project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | 64263dd526ec25ede1591fc1144715a20cc7bc4e | 1 | static const unsigned char *seq_decode_op1(SeqVideoContext *seq, const unsigned char *src, unsigned char *dst)
{
const unsigned char *color_table;
int b, i, len, bits;
GetBitContext gb;
unsigned char block[8 * 8];
len = *src++;
if (len & 0x80) {
switch (len & 3) {
case... | 12,591 |
qemu | e4fc8781db7c49b0c5ac5d24762e17c59dfe0871 | 1 | static void qed_commit_l2_update(void *opaque, int ret)
{
QEDAIOCB *acb = opaque;
BDRVQEDState *s = acb_to_s(acb);
CachedL2Table *l2_table = acb->request.l2_table;
qed_commit_l2_cache_entry(&s->l2_cache, l2_table);
/* This is guaranteed to succeed because we just committed the entry to the... | 12,592 |
qemu | 3936161f1fd72d1dfa577aaba910819c5e873260 | 1 | static void pci_qdev_unrealize(DeviceState *dev, Error **errp)
{
PCIDevice *pci_dev = PCI_DEVICE(dev);
PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);
pci_unregister_io_regions(pci_dev);
pci_del_option_rom(pci_dev);
if (pc->exit) {
pc->exit(pci_dev);
}
do_pci_unre... | 12,593 |
FFmpeg | bb6c67bb36b136de10256f0999128df4a42f9ffc | 1 | static int start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
{
SliceContext *slice = link->dst->priv;
if (slice->use_random_h) {
slice->lcg_state = slice->lcg_state * 1664525 + 1013904223;
slice->h = 8 + (uint64_t)slice->lcg_state * 25 / UINT32_MAX;
}
/* ensure that s... | 12,594 |
qemu | 6d0ee85040e4d238e2483191fe6e74aebbecd5d5 | 1 | static void virtio_balloon_save(QEMUFile *f, void *opaque)
{
VirtIOBalloon *s = opaque;
virtio_save(&s->vdev, f);
qemu_put_be32(f, s->num_pages);
qemu_put_be32(f, s->actual);
qemu_put_buffer(f, (uint8_t *)&s->stats_vq_elem, sizeof(VirtQueueElement));
qemu_put_buffer(f, (uint8_t *)&s->... | 12,595 |
qemu | e5c67ab552fb056827b5b40356c0ef235e975e7e | 1 | static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)
{
BDRVBlkdebugState *s = bs->opaque;
int error = rule->options.inject.error;
bool immediately = rule->options.inject.immediately;
if (rule->options.inject.once) {
QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, activ... | 12,597 |
FFmpeg | 1cfde7abd0008e58fcd10f8804812e72a1a5295a | 0 | static void output_segment_list(OutputStream *os, AVIOContext *out, DASHContext *c,
int representation_id, int final)
{
int i, start_index = 0, start_number = 1;
if (c->window_size) {
start_index = FFMAX(os->nb_segments - c->window_size, 0);
start_number ... | 12,598 |
FFmpeg | 2b53e696c864c4ade3c38707f8595e17a998bedc | 0 | static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) {
const uint8_t *buf = avpkt->data;
const uint8_t *buf_end = avpkt->data + avpkt->size;
PTXContext * const s = avctx->priv_data;
AVFrame *picture = data;
AVFrame * const ... | 12,599 |
FFmpeg | 4a30f08505a4e85718896ff233c97be41a9754ca | 0 | static int alloc_sequence_buffers(DiracContext *s)
{
int sbwidth = DIVRNDUP(s->source.width, 4);
int sbheight = DIVRNDUP(s->source.height, 4);
int i, w, h, top_padding;
/* todo: think more about this / use or set Plane here */
for (i = 0; i < 3; i++) {
int max_xblen = MAX_BLOCKSIZ... | 12,600 |
FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | 0 | static av_cold int vpx_init(AVCodecContext *avctx,
const struct vpx_codec_iface *iface)
{
VP8Context *ctx = avctx->priv_data;
struct vpx_codec_enc_cfg enccfg = { 0 };
int res;
av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
av_log(avctx, AV_LOG_VERBO... | 12,601 |
qemu | b36e391441906c36ed0856b69de84001860402bf | 1 | static int virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
{
int n, r;
if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) ||
proxy->ioeventfd_disabled ||
proxy->ioeventfd_started) {
return 0;
}
for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
if (!virtio_queue... | 12,602 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static void block_set_params(const MigrationParams *params, void *opaque)
{
block_mig_state.blk_enable = params->blk;
block_mig_state.shared_base = params->shared;
/* shared base means that blk_enable = 1 */
block_mig_state.blk_enable |= params->shared;
}
| 12,603 |
FFmpeg | 7328c2fc2184476235ebc9a9b9247a986bdea1cf | 1 | static void show_packets(WriterContext *w, AVFormatContext *fmt_ctx)
{
AVPacket pkt;
AVFrame frame;
int i = 0;
av_init_packet(&pkt);
while (!av_read_frame(fmt_ctx, &pkt)) {
if (do_show_packets)
show_packet(w, fmt_ctx, &pkt, i++);
if (do_show_frames &&
... | 12,604 |
qemu | dc8764f06155a7b3e635e02281b747a9e292127e | 1 | static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
const char *sysfile_str, Error **err)
{
pid_t pid;
ssize_t ret;
char *pmutils_path;
int status, pipefds[2];
if (pipe(pipefds) < 0) {
error_set(err, QERR_UNDEFINED_ERROR);... | 12,605 |
qemu | b0706b716769494f321a0d2bfd9fa9893992f995 | 1 | void tlb_reset_dirty_range(CPUTLBEntry *tlb_entry, uintptr_t start,
uintptr_t length)
{
uintptr_t addr;
if (tlb_is_dirty_ram(tlb_entry)) {
addr = (tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend;
if ((addr - start) < length) {
tlb_ent... | 12,606 |
qemu | 5e30a07d6d70d3073ff61e6db79d61c2b688502f | 1 | static const char *scsi_command_name(uint8_t cmd)
{
static const char *names[] = {
[ TEST_UNIT_READY ] = "TEST_UNIT_READY",
[ REQUEST_SENSE ] = "REQUEST_SENSE",
[ FORMAT_UNIT ] = "FORMAT_UNIT",
[ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS",... | 12,608 |
FFmpeg | 5c4e97282f52d4045bd4498805f508ca50b313dd | 1 | X264_close(AVCodecContext *avctx)
{
X264Context *x4 = avctx->priv_data;
if(x4->enc)
x264_encoder_close(x4->enc);
return 0;
} | 12,609 |
FFmpeg | 7d74aaf6985e0f286e10c851e4d7e80fd687a774 | 0 | static void synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
{
int sb, j, k, n, ch, run, channels;
int joined_stereo, zero_encoding, chs;
int type34_first;
float type34_div = 0;
float type34_predictor;
float samples[10], sign_bits[16];
... | 12,610 |
FFmpeg | d1991f51f3298e91f9e4cca1f581b486fbd29ec3 | 0 | static void opt_target(const char *arg)
{
enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
if(!strncmp(arg, "pal-", 4)) {
norm = PAL;
arg += 4;
} else if(!strncmp(arg, "ntsc-", 5)) {
norm = NT... | 12,611 |
FFmpeg | c31b81216619e6b3d986ce63c82357993e10e8e9 | 1 | static int decode_init(AVCodecContext *avctx)
{
LclContext * const c = (LclContext *)avctx->priv_data;
int basesize = avctx->width * avctx->height;
int zret; // Zlib return code
c->avctx = avctx;
avctx->has_b_frames = 0;
c->pic.data[0] = NULL;
#ifdef CONFIG_ZLIB
// Needed if z... | 12,612 |
qemu | 3c55fe2a13353b3ddf1db51c34ada23d161ee428 | 1 | static void lsi_do_command(LSIState *s)
{
SCSIDevice *dev;
uint8_t buf[16];
uint32_t id;
int n;
DPRINTF("Send command len=%d\n", s->dbc);
if (s->dbc > 16)
s->dbc = 16;
pci_dma_read(PCI_DEVICE(s), s->dnad, buf, s->dbc);
s->sfbr = buf[0];
s->command_complete = 0;
... | 12,613 |
FFmpeg | 6cf31ef263d36f6b89d9b64f15ca81cef4f24901 | 1 | static void use_high_update_speed(WmallDecodeCtx *s, int ich)
{
int ilms, recent, icoef;
s->update_speed[ich] = 16;
for (ilms = s->cdlms_ttl[ich]; ilms >= 0; ilms--) {
recent = s->cdlms[ich][ilms].recent;
if (s->bV3RTM) {
for (icoef = 0; icoef < s->cdlms[ich][ilms].order; ... | 12,615 |
qemu | 911ee36d411ee9b3540855642b53219b6a974992 | 1 | static void dump_json_image_check(ImageCheck *check, bool quiet)
{
Error *local_err = NULL;
QString *str;
QmpOutputVisitor *ov = qmp_output_visitor_new();
QObject *obj;
visit_type_ImageCheck(qmp_output_get_visitor(ov), NULL, &check,
&local_err);
obj = qmp_output... | 12,617 |
qemu | e0dadc1e9ef1f35208e5d2af9c7740c18a0b769f | 1 | static bool aux_bus_is_bridge(AUXBus *bus, DeviceState *dev)
{
return (dev == DEVICE(bus->bridge));
}
| 12,618 |
FFmpeg | 5b4da8a38a5ed211df9504c85ce401c30af86b97 | 0 | void ff_estimate_b_frame_motion(MpegEncContext * s,
int mb_x, int mb_y)
{
MotionEstContext * const c= &s->me;
const int penalty_factor= c->mb_penalty_factor;
int fmin, bmin, dmin, fbmin, bimin, fimin;
int type=0;
const int xy = mb_y*s->mb_stride + mb_x;
init_... | 12,619 |
FFmpeg | 6d71b3820759235c02493ac73ef5949b653ad29b | 0 | static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
{
int level, pred, code;
uint16_t *dc_val;
if (n < 4)
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
else
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
if (code < 0 || code > 9 /... | 12,620 |
FFmpeg | 515b69f8f8e9a24cfaee95d8c1f63f265d8582fe | 0 | static void check_pred8x8(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
int codec, int chroma_format, int bit_depth)
{
int pred_mode;
for (pred_mode = 0; pred_mode < 11; pred_mode++) {
if (check_pred_func(h->pred8x8[pred_mode], (chroma_format == 2) ? "8x16" : "8x8",
... | 12,621 |
qemu | b9bec74bcb16519a876ec21cd5277c526a9b512d | 0 | int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
{
uint8_t int3;
if (cpu_memory_rw_debug(env, bp->pc, &int3, 1, 0) || int3 != 0xcc ||
cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1))
return -EINVAL;
return 0;
}
| 12,622 |
qemu | 210b580b106fa798149e28aa13c66b325a43204e | 0 | static void rtas_nvram_fetch(sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
sPAPRNVRAM *nvram = spapr->nvram;
hwaddr offset, buffer, len;
int alen;
... | 12,623 |
qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | 0 | int socket_connect(SocketAddressLegacy *addr, NonBlockingConnectHandler *callback,
void *opaque, Error **errp)
{
int fd;
switch (addr->type) {
case SOCKET_ADDRESS_LEGACY_KIND_INET:
fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp);
break;
c... | 12,625 |
qemu | ec78f8114bc4c133fc56fefa7f2af99725e42857 | 0 | static void validate_numa_cpus(void)
{
int i;
unsigned long *seen_cpus = bitmap_new(max_cpus);
for (i = 0; i < nb_numa_nodes; i++) {
if (bitmap_intersects(seen_cpus, numa_info[i].node_cpu, max_cpus)) {
bitmap_and(seen_cpus, seen_cpus,
numa_info[i].node_cpu... | 12,626 |
qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | 0 | void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
{
const char *uri = qdict_get_str(qdict, "uri");
bool writable = qdict_get_try_bool(qdict, "writable", false);
bool all = qdict_get_try_bool(qdict, "all", false);
Error *local_err = NULL;
BlockInfoList *block_list, *info;
SocketA... | 12,627 |
FFmpeg | 13a099799e89a76eb921ca452e1b04a7a28a9855 | 0 | static void RENAME(yuv2bgr24_2)(SwsContext *c, const uint16_t *buf0,
const uint16_t *buf1, const uint16_t *ubuf0,
const uint16_t *ubuf1, const uint16_t *vbuf0,
const uint16_t *vbuf1, const uint16_t *abuf0,
... | 12,629 |
qemu | 9a78eead0c74333a394c0f7bbfc4423ac746fcd5 | 0 | void cpu_dump_statistics (CPUState *env, FILE*f,
int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
int flags)
{
#if defined(DO_PPC_STATISTICS)
opc_handler_t **t1, **t2, **t3, *handler;
int op1, op2, op3;
t1 = env->opcodes;
for (op1 = 0; op1 ... | 12,630 |
qemu | 65cdadd2e2de76f7db3bf6b7d8dd8c67abff9659 | 0 | static Suite *qint_suite(void)
{
Suite *s;
TCase *qint_public_tcase;
s = suite_create("QInt test-suite");
qint_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qint_public_tcase);
tcase_add_test(qint_public_tcase, qint_from_int_test);
tcase_add_test(qint_public... | 12,631 |
qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | 0 | static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, true, errp);
QInt *qint;
if (!qobj) {
return;
}
qint = qobject_to_qin... | 12,632 |
qemu | 03ae4133ab8675d4c67e6fdc8032de7c53a89514 | 0 | static gint ppc_cpu_compare_class_pvr_mask(gconstpointer a, gconstpointer b)
{
ObjectClass *oc = (ObjectClass *)a;
uint32_t pvr = *(uint32_t *)b;
PowerPCCPUClass *pcc = (PowerPCCPUClass *)a;
gint ret;
/* -cpu host does a PVR lookup during construction */
if (unlikely(strcmp(object_class... | 12,633 |
qemu | 6886b98036a8f8f5bce8b10756ce080084cef11b | 0 | void cpu_resume_from_signal(CPUState *cpu, void *puc)
{
/* XXX: restore cpu registers saved in host registers */
cpu->exception_index = -1;
siglongjmp(cpu->jmp_env, 1);
}
| 12,634 |
qemu | 234ac1a9025bcfcc532449f72a97b3d4754d466c | 0 | void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new)
{
assert(!bdrv_requests_pending(old));
assert(!bdrv_requests_pending(new));
bdrv_ref(old);
change_parent_backing_link(old, new);
bdrv_unref(old);
}
| 12,636 |
qemu | abd696e4f74a9d30801c6ae2693efe4e5979c2f2 | 0 | unsigned long virtio_load_direct(ulong rec_list1, ulong rec_list2,
ulong subchan_id, void *load_addr)
{
u8 status;
int sec = rec_list1;
int sec_num = ((rec_list2 >> 32) & 0xffff) + 1;
int sec_len = rec_list2 >> 48;
ulong addr = (ulong)load_addr;
if (sec_len != SECTOR_SIZE) {
... | 12,637 |
qemu | 2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5 | 0 | void xen_init_display(int domid)
{
struct XenDevice *xfb, *xin;
struct XenFB *fb;
struct XenInput *in;
int i = 0;
wait_more:
i++;
main_loop_wait(true);
xfb = xen_be_find_xendev("vfb", domid, 0);
xin = xen_be_find_xendev("vkbd", domid, 0);
if (!xfb || !xin) {
if ... | 12,638 |
qemu | 2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5 | 0 | static int musicpal_lcd_init(SysBusDevice *dev)
{
musicpal_lcd_state *s = FROM_SYSBUS(musicpal_lcd_state, dev);
s->brightness = 7;
memory_region_init_io(&s->iomem, &musicpal_lcd_ops, s,
"musicpal-lcd", MP_LCD_SIZE);
sysbus_init_mmio(dev, &s->iomem);
s->con = gr... | 12,639 |
FFmpeg | ea60a11e8e2d818e8e56da4da3ff38e23a12bdff | 0 | static int mov_write_gmhd_tag(AVIOContext *pb)
{
avio_wb32(pb, 0x20); /* size */
ffio_wfourcc(pb, "gmhd");
avio_wb32(pb, 0x18); /* gmin size */
ffio_wfourcc(pb, "gmin");/* generic media info */
avio_wb32(pb, 0); /* version & flags */
avio_wb16(pb, 0x40); /* graphics mode = */
... | 12,640 |
qemu | f090c9d4ad5812fb92843d6470a1111c15190c4c | 0 | int float64_le( float64 a, float64 b STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) {
float_raise( float_flag_invalid STATUS_VAR);
retu... | 12,641 |
qemu | 891fb2cd4592b6fe76106a69e0ca40efbf82726a | 0 | static int usb_qdev_init(DeviceState *qdev, DeviceInfo *base)
{
USBDevice *dev = DO_UPCAST(USBDevice, qdev, qdev);
USBDeviceInfo *info = DO_UPCAST(USBDeviceInfo, qdev, base);
int rc;
pstrcpy(dev->product_desc, sizeof(dev->product_desc), info->product_desc);
dev->info = info;
dev->auto_a... | 12,643 |
qemu | c3d8688470a33feb0ea78c006b4399d50c13185e | 0 | static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs,
int64_t sector_num,
int nb_sectors, int *pnum)
{
int64_t length;
int64_t n;
int64_t ret, ret2;
length = bdrv_getle... | 12,644 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | void *qemu_try_blockalign(BlockDriverState *bs, size_t size)
{
size_t align = bdrv_opt_mem_align(bs);
/* Ensure that NULL is never returned on success */
assert(align > 0);
if (size == 0) {
size = align;
}
return qemu_try_memalign(align, size);
}
| 12,646 |
qemu | 7385aed20db5d83979f683b9d0048674411e963c | 0 | float32 helper_fxtos(CPUSPARCState *env, int64_t src)
{
float32 ret;
clear_float_exceptions(env);
ret = int64_to_float32(src, &env->fp_status);
check_ieee_exceptions(env);
return ret;
}
| 12,647 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | VirtIOSCSIReq *virtio_scsi_pop_req_vring(VirtIOSCSI *s,
VirtIOSCSIVring *vring)
{
VirtIOSCSIReq *req = virtio_scsi_init_req(s, NULL);
int r;
req->vring = vring;
r = vring_pop((VirtIODevice *)s, &vring->vring, &req->elem);
if (r < 0) {
virtio... | 12,649 |
qemu | 185698715dfb18c82ad2a5dbc169908602d43e81 | 0 | uint64_t helper_fctiwz (uint64_t arg)
{
CPU_DoubleU farg;
farg.ll = arg;
if (unlikely(float64_is_signaling_nan(farg.d))) {
/* sNaN conversion */
farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
} else if (unlikely(float64_is_nan(farg.d) || float64... | 12,650 |
qemu | 9a78eead0c74333a394c0f7bbfc4423ac746fcd5 | 0 | void list_cpus(FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
const char *optarg)
{
/* XXX: implement xxx_cpu_list for targets that still miss it */
#if defined(cpu_list_id)
cpu_list_id(f, cpu_fprintf, optarg);
#elif defined(cpu_list)
cpu_list(f, cpu_fprintf); /* deprecate... | 12,652 |
qemu | 3b098d56979d2f7fd707c5be85555d114353a28d | 0 | static void qmp_deserialize(void **native_out, void *datap,
VisitorFunc visit, Error **errp)
{
QmpSerializeData *d = datap;
QString *output_json;
QObject *obj_orig, *obj;
obj_orig = qmp_output_get_qobject(d->qov);
output_json = qobject_to_json(obj_orig);
obj... | 12,653 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void scsi_read_complete(void * opaque, int ret)
{
SCSIGenericReq *r = (SCSIGenericReq *)opaque;
SCSIDevice *s = r->req.dev;
int len;
r->req.aiocb = NULL;
if (ret || r->req.io_canceled) {
scsi_command_complete(r, ret);
return;
}
len = r->io_header.dxfer_len ... | 12,654 |
FFmpeg | 19fe8b4100dfe0323e351e474c54293bb4ae576e | 0 | static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr) {
MpegEncContext * const s = &h->s;
const int mb_xy= mb_x + mb_y*s->mb_stride;
int linesize, uvlinesize;
int dir;
/* FIXME Implement deblocking filter for field MB */
if( h->sps.m... | 12,655 |
FFmpeg | a1335149fd610b16459d9281b611282cac51c950 | 0 | int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
AVPacket *pkt, const AVFrame *frame, int *got_packet)
{
int ret;
ret = encode_frame(avctx, q, frame);
if (ret < 0)
return ret;
if (!av_fifo_space(q->async_fifo) ||
(!frame && av_fifo_size(q->async_fi... | 12,656 |
FFmpeg | e53c9065ca08a9153ecc73a6a8940bcc6d667e58 | 0 | static int test_vector_dmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
const double *v1, double scale)
{
LOCAL_ALIGNED(32, double, cdst, [LEN]);
LOCAL_ALIGNED(32, double, odst, [LEN]);
int ret;
cdsp->vector_dmul_scalar(cdst, v1, scale, LEN);
... | 12,657 |
FFmpeg | e56cfad04b73be35ea8dcb5fd5e8451f6924aff1 | 0 | static int mpegps_read_pes_header(AVFormatContext *s,
int64_t *ppos, int *pstart_code,
int64_t *ppts, int64_t *pdts)
{
MpegDemuxContext *m = s->priv_data;
int len, size, startcode, c, flags, header_len;
int64_t pts, dts, last_pos;
... | 12,658 |
FFmpeg | f1e173049ecc9de03817385ba8962d14cba779db | 0 | static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
int bpno, int bandno,
int vert_causal_ctx_csty_symbol)
{
int mask = 3 << (bpno - 1), y0, x, y;
for (y0 = 0; y0 < height; y0 += 4)
for (x = 0; x < width; x++)
... | 12,659 |
FFmpeg | d584533cf38141172e20bae5436629ee17c8ce50 | 0 | static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
AVPacketList **plast_pktl)
{
AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
if (!pktl)
return NULL;
if (*packet_buffer)
(*plast_pktl)->next = pktl;
else
*... | 12,660 |
FFmpeg | 3176217c60ca7828712985092d9102d331ea4f3d | 0 | static av_always_inline void h264_filter_mb_fast_internal(const H264Context *h,
H264SliceContext *sl,
int mb_x, int mb_y,
uint8_t *img_y,
... | 12,661 |
FFmpeg | b7280cff9a7683395d7f899517b4aea8b52f12a4 | 0 | static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
ASFContext *asf = s->priv_data;
ASFStream *asfst;
int rsize = 1;
int num = avio_r8(pb);
int i;
int64_t ts0, ts1 av_unused;
asf->packet_segments--;
asf->packet_key_frame = num >> 7;
asf->stream_index = a... | 12,662 |
qemu | 39ea3d4eaf1ff300ee55946108394729bc053dfa | 0 | void HELPER(set_r13_banked)(CPUState *env, uint32_t mode, uint32_t val)
{
env->banked_r13[bank_number(mode)] = val;
}
| 12,665 |
FFmpeg | a0560d0477549eaaa7d002e013bd8376e80873e4 | 0 | static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_GRAY8,
AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUV... | 12,669 |
qemu | 25b422eb4051b9b7473feea1ae848f1e3b4f799f | 0 | static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
const QDict *params)
{
QObject *data = NULL;
cmd->mhandler.cmd_new(mon, params, &data);
if (data)
cmd->user_print(mon, data);
qobject_decref(data);
}
| 12,670 |
qemu | 45876e913e169bf156a3fc36f21eb0adf6ec3671 | 0 | static void m5206_mbar_update(m5206_mbar_state *s)
{
int irq;
int vector;
int level;
irq = m5206_find_pending_irq(s);
if (irq) {
int tmp;
tmp = s->icr[irq];
level = (tmp >> 2) & 7;
if (tmp & 0x80) {
/* Autovector. */
vector = 24 ... | 12,673 |
qemu | 5b8bb3595a2941e9408021f1080e60ce86d677d2 | 0 | aio_ctx_check(GSource *source)
{
AioContext *ctx = (AioContext *) source;
QEMUBH *bh;
atomic_and(&ctx->notify_me, ~1);
aio_notify_accept(ctx);
for (bh = ctx->first_bh; bh; bh = bh->next) {
if (!bh->deleted && bh->scheduled) {
return true;
}
}
return... | 12,675 |
qemu | d6085e3ace20bc9b0fa625d8d79b22668710e217 | 0 | static bool vmxnet3_peer_has_vnet_hdr(VMXNET3State *s)
{
NetClientState *nc = qemu_get_queue(s->nic);
if (qemu_peer_has_vnet_hdr(nc)) {
return true;
}
VMW_WRPRN("Peer has no virtio extension. Task offloads will be emulated.");
return false;
}
| 12,676 |
qemu | 524089bce43fd1cd3daaca979872451efa2cf7c6 | 0 | static int get_cluster_offset(BlockDriverState *bs,
VmdkExtent *extent,
VmdkMetaData *m_data,
uint64_t offset,
bool allocate,
uint64_t *cluster_offset,
... | 12,677 |
qemu | fae2afb10e3fdceab612c62a2b1e8b944ff578d9 | 0 | static void qxl_log_image(PCIQXLDevice *qxl, QXLPHYSICAL addr, int group_id)
{
QXLImage *image;
QXLImageDescriptor *desc;
image = qxl_phys2virt(qxl, addr, group_id);
desc = &image->descriptor;
fprintf(stderr, " (id %" PRIx64 " type %d flags %d width %d height %d",
desc->id, desc... | 12,678 |
qemu | 0928a95ffe91862938cee997c9e30602fa7884ab | 0 | static BOOTPClient *get_new_addr(struct in_addr *paddr)
{
BOOTPClient *bc;
int i;
for(i = 0; i < NB_ADDR; i++) {
if (!bootp_clients[i].allocated)
goto found;
}
return NULL;
found:
bc = &bootp_clients[i];
bc->allocated = 1;
paddr->s_addr = htonl(ntohl(sp... | 12,679 |
qemu | 678421650dc166cd6cb35bb2bc0baf1b481b40ca | 0 | static uint64_t cchip_read(void *opaque, hwaddr addr, unsigned size)
{
CPUState *cpu = current_cpu;
TyphoonState *s = opaque;
uint64_t ret = 0;
if (addr & 4) {
return s->latch_tmp;
}
switch (addr) {
case 0x0000:
/* CSC: Cchip System Configuration Register. */
... | 12,681 |
qemu | ad7171394f2fe3f9b5fe02f0c62496291a859a92 | 0 | static int blk_init(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
int index, qflags, have_barriers, info = 0;
char *h;
/* read xenstore entries */
if (blkdev->params == NULL) {
blkdev->params = xenstore_read_be_str(&blkdev->xendev, "... | 12,682 |
qemu | 53cb28cbfea038f8ad50132dc8a684e638c7d48b | 0 | static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *section)
{
subpage_t *subpage;
hwaddr base = section->offset_within_address_space
& TARGET_PAGE_MASK;
MemoryRegionSection *existing = phys_page_find(d->phys_map, base,
... | 12,683 |
qemu | 9c5ce8db2e5c2769ed2fd3d91928dd1853b5ce7c | 0 | static void smbios_encode_uuid(struct smbios_uuid *uuid, const uint8_t *buf)
{
memcpy(uuid, buf, 16);
if (smbios_uuid_encoded) {
uuid->time_low = bswap32(uuid->time_low);
uuid->time_mid = bswap16(uuid->time_mid);
uuid->time_hi_and_version = bswap16(uuid->time_hi_and_version);
... | 12,684 |
qemu | bd5c51ee6c4f1c79cae5ad2516d711a27b4ea8ec | 0 | static gboolean qemu_chr_be_generic_open_bh(gpointer opaque)
{
CharDriverState *s = opaque;
qemu_chr_be_event(s, CHR_EVENT_OPENED);
s->idle_tag = 0;
return FALSE;
}
| 12,687 |
qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | 0 | static void smc91c111_receive(void *opaque, const uint8_t *buf, size_t size)
{
smc91c111_state *s = (smc91c111_state *)opaque;
int status;
int packetsize;
uint32_t crc;
int packetnum;
uint8_t *p;
if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST))
return;
/* Shor... | 12,688 |
qemu | 4678124bb9bfb49e93b83f95c4d2feeb443ea38b | 0 | void acpi_add_table(GArray *table_offsets, GArray *table_data)
{
uint32_t offset = cpu_to_le32(table_data->len);
g_array_append_val(table_offsets, offset);
}
| 12,689 |
qemu | 6cb2996cef5e273ef370e690e84b5e1403f5c391 | 0 | int cpu_is_bsp(CPUState *env)
{
return env->cpuid_apic_id == 0;
}
| 12,690 |
FFmpeg | 8622613d9f74e0ce5e248905f3f554d26f6d6c06 | 0 | static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
int64_t total_size = 0;
MOV_atom_t a;
int i;
int err = 0;
a.offset = atom.offset;
if (atom.size < 0)
atom.size = INT64_MAX;
while(((total_size + 8) < atom.size) && !url_feof(pb) && !err) {
... | 12,691 |
qemu | 3ddcd2edc8ca708ccd808a78424b9aadebd4f7c4 | 0 | static int hyperv_handle_properties(CPUState *cs)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
if (cpu->hyperv_relaxed_timing) {
env->features[FEAT_HYPERV_EAX] |= HV_X64_MSR_HYPERCALL_AVAILABLE;
}
if (cpu->hyperv_vapic) {
env->features[FEAT_HYPERV_EAX] |= HV_X... | 12,692 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static void network_to_compress(RDMACompress *comp)
{
comp->value = ntohl(comp->value);
comp->block_idx = ntohl(comp->block_idx);
comp->offset = ntohll(comp->offset);
comp->length = ntohll(comp->length);
}
| 12,693 |
qemu | 82a93a1d307064f35c363f79b04b0a0149ac53d9 | 1 | void spapr_drc_attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt,
int fdt_start_offset, Error **errp)
{
trace_spapr_drc_attach(spapr_drc_index(drc));
if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
error_setg(errp, "an attached device is still awaiting... | 12,694 |
FFmpeg | 55d53cb59380bebea79ae8f99d4e119b2b006629 | 1 | int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
{
int i;
if(!graph)
return 0;
for (i = 0; i < graph->nb_filters; i++) {
AVFilterContext *filter = graph->filters[i];
if(filter && (!strcmp(target, "a... | 12,695 |
FFmpeg | c8cfbc6629c1fe5755b59a3bcfd95ad08b843a07 | 1 | static av_cold int hevc_decode_init(AVCodecContext *avctx)
{
HEVCContext *s = avctx->priv_data;
int ret;
avctx->internal->allocate_progress = 1;
ret = hevc_init_context(avctx);
if (ret < 0)
return ret;
s->enable_parallel_tiles = 0;
s->sei.picture_timing.picture_struct ... | 12,696 |
FFmpeg | 6ad1fa5a49320c101a62d24aa0e7df14c10d7612 | 1 | void dsputil_init_armv4l(DSPContext* c, AVCodecContext *avctx)
{
const int idct_algo= avctx->idct_algo;
ff_put_pixels_clamped = c->put_pixels_clamped;
ff_add_pixels_clamped = c->add_pixels_clamped;
if(idct_algo==FF_IDCT_ARM){
if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_ARM){
c->idct_put... | 12,697 |
qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | 0 | static void test_qemu_strtoull_underflow(void)
{
const char *str = "-99999999999999999999999999999999999999999999";
char f = 'X';
const char *endptr = &f;
uint64_t res = 999;
int err;
err = qemu_strtoull(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
g_assert_cm... | 12,698 |
qemu | ede9c94acf6cd1968de4188c0228b714ab871a86 | 0 | static int vtd_remap_irq_get(IntelIOMMUState *iommu, uint16_t index, VTDIrq *irq)
{
VTD_IRTE irte = {};
int ret = 0;
ret = vtd_irte_get(iommu, index, &irte);
if (ret) {
return ret;
}
irq->trigger_mode = irte.trigger_mode;
irq->vector = irte.vector;
irq->delivery_mod... | 12,699 |
qemu | 37ad223c515da2fe9f1c679768cb5ccaa42e57e1 | 0 | static void nvdimm_build_ssdt(GSList *device_list, GArray *table_offsets,
GArray *table_data, GArray *linker)
{
Aml *ssdt, *sb_scope, *dev;
acpi_add_table(table_offsets, table_data);
ssdt = init_aml_allocator();
acpi_data_push(ssdt->buf, sizeof(AcpiTableHeader));
... | 12,700 |
qemu | 20fdef58a0daa8da21438b79663f7ada2c59ebbc | 0 | static void nvdimm_build_structure_dcr(GArray *structures, DeviceState *dev)
{
NvdimmNfitControlRegion *nfit_dcr;
int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
NULL);
uint32_t sn = nvdimm_slot_to_sn(slot);
nfit_dcr = acpi_data_push(stru... | 12,703 |
qemu | 10ee2aaa417d8d8978cdb2bbed55ebb152df5f6b | 0 | static void nam_writew (void *opaque, uint32_t addr, uint32_t val)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
uint32_t index = addr - s->base[0];
s->cas = 0;
switch (index) {
case AC97_Reset:
mixer_reset (s);
break;
case AC97_Powerdown_Ctrl_Stat:
... | 12,705 |
qemu | 269fe4c3ab0cf29329317eb868f8ec90ac761b41 | 0 | pvscsi_cleanup_msi(PVSCSIState *s)
{
PCIDevice *d = PCI_DEVICE(s);
if (s->msi_used) {
msi_uninit(d);
}
}
| 12,706 |
FFmpeg | bc2d2757bb532fa260c373adb00f4e47766e3449 | 0 | static void exponents_from_scale_factors(MPADecodeContext *s,
GranuleDef *g,
int16_t *exponents)
{
const uint8_t *bstab, *pretab;
int len, i, j, k, l, v0, shift, gain, gains[3];
int16_t *exp_ptr;
exp_ptr = exponen... | 12,707 |
qemu | 7385ac0ba2456159a52b9b2cbb5f6c71921d0c23 | 0 | static always_inline void check_cp1_3d(CPUState *env, DisasContext *ctx)
{
if (unlikely(!(env->fpu->fcr0 & (1 << FCR0_3D))))
generate_exception(ctx, EXCP_RI);
}
| 12,708 |
qemu | 54bf36ed351c526cde0c853079f9ff1ab7e2ff89 | 0 | static bool linked_bp_matches(ARMCPU *cpu, int lbn)
{
CPUARMState *env = &cpu->env;
uint64_t bcr = env->cp15.dbgbcr[lbn];
int brps = extract32(cpu->dbgdidr, 24, 4);
int ctx_cmps = extract32(cpu->dbgdidr, 20, 4);
int bt;
uint32_t contextidr;
/* Links to unimplemented or non-context ... | 12,709 |
qemu | cf864569cd9134ee503ad9eb6be2881001c0ed80 | 0 | static int vnc_display_disable_login(DisplayState *ds)
{
VncDisplay *vs = vnc_display;
if (!vs) {
return -1;
}
if (vs->password) {
g_free(vs->password);
}
vs->password = NULL;
if (vs->auth == VNC_AUTH_NONE) {
vs->auth = VNC_AUTH_VNC;
}
ret... | 12,711 |
qemu | 77e4743c94d2a926623e280913e05ad6c840791e | 0 | int scsi_build_sense(uint8_t *in_buf, int in_len,
uint8_t *buf, int len, bool fixed)
{
bool fixed_in;
SCSISense sense;
if (!fixed && len < 8) {
return 0;
}
if (in_len == 0) {
sense.key = NO_SENSE;
sense.asc = 0;
sense.ascq = 0;
}... | 12,712 |
qemu | dc61cd3b144151024a247a109f360d2e2cab0f81 | 0 | static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
int *pnum)
{
bool res;
int i;
if (n <= 0) {
*pnum = 0;
return 0;
}
res = !!memcmp(buf1, buf2, 512);
for(i = 1; i < n; i++) {
buf1 += 512;
buf2 += 512;
if (!!... | 12,713 |
qemu | 67a0fd2a9bca204d2b39f910a97c7137636a0715 | 0 | static void coroutine_fn bdrv_get_block_status_above_co_entry(void *opaque)
{
BdrvCoGetBlockStatusData *data = opaque;
data->ret = bdrv_co_get_block_status_above(data->bs, data->base,
data->sector_num,
data->nb_... | 12,714 |
qemu | 7ccb84a91618eda626b12ce83d62cfe678cfc58f | 0 | static inline int target_rt_restore_ucontext(CPUM68KState *env,
struct target_ucontext *uc,
int *pd0)
{
int temp;
target_greg_t *gregs = uc->tuc_mcontext.gregs;
__get_user(temp, &uc->tuc_mcontext.version);
... | 12,715 |
qemu | 26a83ad0e793465b74a8b06a65f2f6fdc5615413 | 0 | void memory_region_init_ram_ptr(MemoryRegion *mr,
const char *name,
uint64_t size,
void *ptr)
{
memory_region_init(mr, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_regio... | 12,716 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.