instruction stringclasses 1
value | output stringclasses 2
values | input stringlengths 21 96.3k |
|---|---|---|
negative | int rom_add_option(const char *file){ if (!rom_enable_driver_roms) return 0; return rom_add_file(file, "genroms", file, 0);} | |
negative | static target_ulong h_client_architecture_support(PowerPCCPU *cpu_, sPAPRMachineState *spapr, target_ulong opcode, target_ulong *args){ target_ulong list = ppc64_phys_to_real(args[0]); target_ulong ov_table; PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu_); CPUState *cs; bool cpu_match = false, cpu_update = true; uns... | |
negative | static void rtas_ibm_configure_connector(PowerPCCPU *cpu, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint64_t wa_addr; uint64_t wa_offset; uint32_t drc_index; sPAPRDRConnector *drc; sPAPRDRConnectorClass *drck; sPAPRConfigureConnectorState *ccs; sPAPR... | |
negative | static void term_show_prompt2(void){ term_printf("(qemu) "); fflush(stdout); term_last_cmd_buf_index = 0; term_last_cmd_buf_size = 0; term_esc_state = IS_NORM;} | |
negative | static void pxa2xx_lcdc_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){ PXA2xxLCDState *s = (PXA2xxLCDState *) opaque; int ch; switch (offset) { case LCCR0: /* ACK Quick Disable done */ if ((s->control[0] & LCCR0_ENB) && !(value & LCCR0_ENB)) s->status[0] |= LCSR0_QD; if (!(s->control[0] & LCCR0_LCDT... | |
negative | static void v9fs_clunk(void *opaque){ int err; int32_t fid; size_t offset = 7; V9fsFidState *fidp; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "d", &fid); trace_v9fs_clunk(pdu->tag, pdu->id, fid); fidp = clunk_fid(s, fid); if (fidp == NULL) { err = -ENOENT; goto out_nofid; } /* * Bump the r... | |
negative | static void pcie_aer_update_log(PCIDevice *dev, const PCIEAERErr *err){ uint8_t *aer_cap = dev->config + dev->exp.aer_cap; uint8_t first_bit = ffs(err->status) - 1; uint32_t errcap = pci_get_long(aer_cap + PCI_ERR_CAP); int i; assert(err->status); assert(!(err->status & (err->status - 1))); errcap &= ~(PCI_ERR_CAP_FEP_... | |
negative | static int hdev_create(const char *filename, QEMUOptionParameter *options){ int fd; int ret = 0; struct stat stat_buf; int64_t total_size = 0; /* Read out options */ while (options && options->name) { if (!strcmp(options->name, "size")) { total_size = options->value.n / 512; } options++; } fd = open(filename, O_WRONLY ... | |
negative | void net_rx_pkt_set_protocols(struct NetRxPkt *pkt, const void *data, size_t len){ assert(pkt); eth_get_protocols(data, len, &pkt->isip4, &pkt->isip6, &pkt->isudp, &pkt->istcp);} | |
negative | static int 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; int buf_size = avpkt->size; DPXContext *const s = avctx->priv_data; AVFrame *picture = data; AVFrame *const p = &s->picture; uint8_t *ptr; in... | |
negative | static int hls_write_trailer(struct AVFormatContext *s){ HLSContext *hls = s->priv_data; AVFormatContext *oc = hls->avf; av_write_trailer(oc); avio_closep(&oc->pb); avformat_free_context(oc); av_free(hls->basename); append_entry(hls, hls->duration); hls_window(s, 1); free_entries(hls); return 0;} | |
negative | static int g726_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; G726Context *c = avctx->priv_data; int16_t *samples = data; GetBitContext gb; init_get_bits(&gb, buf, buf_size * 8); while (get_bits_count(&gb) + c->code_size <... | |
negative | static inline void downmix_mono_to_stereo(float *samples){ int i; for (i = 0; i < 256; i++) samples[i + 256] = samples[i];} | |
negative | dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum, enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype, IBaseFilter **pfilter){ struct dshow_ctx *ctx = avctx->priv_data; IBaseFilter *device_filter = NULL; IEnumMoniker *classenum = NULL; IMoniker *m = NULL; const char *device_name = ctx... | |
negative | static void rgb24_to_yuvj444p(AVPicture *dst, AVPicture *src, int width, int height){ int src_wrap, x, y; int r, g, b; uint8_t *lum, *cb, *cr; const uint8_t *p; lum = dst->data[0]; cb = dst->data[1]; cr = dst->data[2]; src_wrap = src->linesize[0] - width * BPP; p = src->data[0]; for(y=0;y<height;y++) { for(x=0;x<width;... | |
negative | static int vf_open(vf_instance_t *vf, char *args){ vf->config=config; vf->put_image=put_image; vf->get_image=get_image; vf->query_format=query_format; vf->uninit=uninit; vf->control= control; vf->priv=malloc(sizeof(struct vf_priv_s)); memset(vf->priv, 0, sizeof(struct vf_priv_s)); if (args) sscanf(args, "%d:%d", &vf->p... | |
negative | static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta){ int isv34, tlen, unsync; char tag[5]; int64_t next, end = avio_tell(s->pb) + len; int taghdrlen; const char *reason = NULL; AVIOContext pb; AVIOContext *pbx; unsigned char *buffer = NULL; int buffer_siz... | |
negative | static int eval_refl(int *refl, const int16_t *coefs, RA144Context *ractx){ int b, c, i; unsigned int u; int buffer1[10]; int buffer2[10]; int *bp1 = buffer1; int *bp2 = buffer2; for (i=0; i < 10; i++) buffer2[i] = coefs[i]; refl[9] = bp2[9]; if ((unsigned) bp2[9] + 0x1000 > 0x1fff) { av_log(ractx, AV_LOG_ERROR, "Overf... | |
negative | static char *sdp_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type){ char *config = NULL; switch (c->codec_id) { case CODEC_ID_MPEG4: if (c->flags & CODEC_FLAG_GLOBAL_HEADER) { config = extradata2config(c->extradata, c->extradata_size); } av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n" ... | |
negative | static int mpegvideo_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size){ ParseContext1 *pc1 = s->priv_data; ParseContext *pc= &pc1->pc; int next; if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){ next= buf_size; }else{ next= ff_mpeg1_find_frame_... | |
negative | int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ int i, av_uninit(j); int current_ref_assigned = 0, err = 0; H264Picture *av_uninit(pic); if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0) av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n"); for (i = 0; i < mmco_count; i++) { int av_... | |
negative | static int libschroedinger_encode_close(AVCodecContext *avctx){ SchroEncoderParams *p_schro_params = avctx->priv_data; /* Close the encoder. */ schro_encoder_free(p_schro_params->encoder); /* Free data in the output frame queue. */ ff_schro_queue_free(&p_schro_params->enc_frame_queue, libschroedinger_free_frame); /* Fr... | |
negative | static void apply_window_mp3(float *in, float *win, int *unused, float *out, int incr){ LOCAL_ALIGNED_16(float, suma, [17]); LOCAL_ALIGNED_16(float, sumb, [17]); LOCAL_ALIGNED_16(float, sumc, [17]); LOCAL_ALIGNED_16(float, sumd, [17]); float sum; /* copy to avoid wrap */ memcpy(in + 512, in, 32 * sizeof(*in)); apply_wi... | |
negative | static int mp_user_removexattr(FsContext *ctx, const char *path, const char *name){ char buffer[PATH_MAX]; if (strncmp(name, "user.virtfs.", 12) == 0) { /* * Don't allow fetch of user.virtfs namesapce * in case of mapped security */ errno = EACCES; return -1; } return lremovexattr(rpath(ctx, path, buffer), name);} | |
negative | static void sdhci_data_transfer(SDHCIState *s){ SDHCIClass *k = SDHCI_GET_CLASS(s); if (s->trnmod & SDHC_TRNS_DMA) { switch (SDHC_DMA_TYPE(s->hostctl)) { case SDHC_CTRL_SDMA: if ((s->trnmod & SDHC_TRNS_MULTI) && (!(s->trnmod & SDHC_TRNS_BLK_CNT_EN) || s->blkcnt == 0)) { break; } if ((s->blkcnt == 1) || !(s->trnmod & SD... | |
negative | static void disas_cc(DisasContext *s, uint32_t insn){ unsigned int sf, op, y, cond, rn, nzcv, is_imm; int label_continue = -1; TCGv_i64 tcg_tmp, tcg_y, tcg_rn; if (!extract32(insn, 29, 1)) { unallocated_encoding(s); return; } if (insn & (1 << 10 | 1 << 4)) { unallocated_encoding(s); return; } sf = extract32(insn, 31, 1... | |
negative | static void xenfb_handle_events(struct XenFB *xenfb){ uint32_t prod, cons, out_cons; struct xenfb_page *page = xenfb->c.page; prod = page->out_prod; out_cons = page->out_cons; if (prod - out_cons >= XENFB_OUT_RING_LEN) { return; } xen_rmb();/* ensure we see ring contents up to prod */ for (cons = out_cons; cons != prod... | |
negative | static always_inline void gen_ext_l(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1), int ra, int rb, int rc, int islit, uint8_t lit){ if (unlikely(rc == 31)) return; if (ra != 31) { if (islit) { tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], (lit & 7) * 8); } else { TCGv tmp = tcg_temp_new(TCG_TYPE_I64); tcg_gen_andi_i64(tmp, cpu_... | |
negative | eth_calc_pseudo_hdr_csum(struct ip_header *iphdr, uint16_t csl){ struct ip_pseudo_header ipph; ipph.ip_src = iphdr->ip_src; ipph.ip_dst = iphdr->ip_dst; ipph.ip_payload = cpu_to_be16(csl); ipph.ip_proto = iphdr->ip_p; ipph.zeros = 0; return net_checksum_add(sizeof(ipph), (uint8_t *) &ipph);} | |
negative | static int ftp_auth(FTPContext *s, char *auth){ const char *user = NULL, *pass = NULL; char *end = NULL, buf[CONTROL_BUFFER_SIZE]; int err; av_assert2(auth); user = av_strtok(auth, ":", &end); pass = av_strtok(end, ":", &end); if (user) { snprintf(buf, sizeof(buf), "USER %s\r\n", user); if ((err = ffurl_write(s->conn_c... | |
negative | static void omap_l4_io_writew(void *opaque, target_phys_addr_t addr, uint32_t value){ unsigned int i = (addr - OMAP2_L4_BASE) >> TARGET_PAGE_BITS; return omap_l4_io_writew_fn[i](omap_l4_io_opaque[i], addr, value);} | |
negative | static void pl050_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){ pl050_state *s = (pl050_state *)opaque; switch (offset >> 2) { case 0: /* KMICR */ s->cr = value; pl050_update(s, s->pending); /* ??? Need to implement the enable/disable bit. */ break; case 2: /* KMIDATA */ /* ??? This should toggle t... | |
negative | static int eject_device(Monitor *mon, BlockDriverState *bs, int force){ if (!bdrv_is_removable(bs)) { qerror_report(QERR_DEVICE_NOT_REMOVABLE, bdrv_get_device_name(bs)); return -1; } if (!force && bdrv_dev_is_medium_locked(bs)) { qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs)); return -1; } bdrv_close(bs); ... | |
negative | static int load_dtb(target_phys_addr_t addr, const struct arm_boot_info *binfo){#ifdef CONFIG_FDT uint32_t *mem_reg_property; uint32_t mem_reg_propsize; void *fdt = NULL; char *filename; int size, rc; uint32_t acells, scells, hival; filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, binfo->dtb_filename); if (!filename) { f... | |
negative | static void flush_compressed_data(QEMUFile *f){ int idx, len, thread_count; if (!migrate_use_compression()) { return; } thread_count = migrate_compress_threads(); for (idx = 0; idx < thread_count; idx++) { if (!comp_param[idx].done) { qemu_mutex_lock(comp_done_lock); while (!comp_param[idx].done && !quit_comp_thread) {... | |
negative | sPAPRDRConnector *spapr_dr_connector_new(Object *owner, sPAPRDRConnectorType type, uint32_t id){ sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(object_new(TYPE_SPAPR_DR_CONNECTOR)); g_assert(type); drc->type = type; drc->id = id; drc->owner = owner; object_property_add_child(owner, "dr-connector[*]", OBJECT(drc), NULL); ob... | |
negative | int bdrv_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info){ BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; if (drv->bdrv_snapshot_create) return drv->bdrv_snapshot_create(bs, sn_info); if (bs->file) return bdrv_snapshot_create(bs->file, sn_info); return -ENOTSUP;} | |
negative | static char *tcg_get_arg_str_idx(TCGContext *s, char *buf, int buf_size, int idx){ assert(idx >= 0 && idx < s->nb_temps); return tcg_get_arg_str_ptr(s, buf, buf_size, &s->temps[idx]);} | |
negative | static inline int mpeg4_is_resync(MpegEncContext *s){ const int bits_count= get_bits_count(&s->gb); if(s->workaround_bugs&FF_BUG_NO_PADDING){ return 0; } if(bits_count + 8 >= s->gb.size*8){ int v= show_bits(&s->gb, 8); v|= 0x7F >> (7-(bits_count&7)); if(v==0x7F) return 1; }else{ if(show_bits(&s->gb, 16) == ff_mpeg4_res... | |
positive | ssize_t v9fs_list_xattr(FsContext *ctx, const char *path, void *value, size_t vsize){ ssize_t size = 0; char *buffer; void *ovalue = value; XattrOperations *xops; char *orig_value, *orig_value_start; ssize_t xattr_len, parsed_len = 0, attr_len; /* Get the actual len */ buffer = rpath(ctx, path); xattr_len = llistxattr(... | |
positive | static int mov_write_udta_tag(ByteIOContext *pb, MOVContext* mov, AVFormatContext *s){ int pos = url_ftell(pb); int i; put_be32(pb, 0); /* size */ put_tag(pb, "udta"); /* iTunes meta data */ mov_write_meta_tag(pb, mov, s); /* Requirements */ for (i=0; i<MAX_STREAMS; i++) { if(mov->tracks[i].entry <= 0) continue; if (mo... | |
positive | static void bochs_bios_write(void *opaque, uint32_t addr, uint32_t val){ static const char shutdown_str[8] = "Shutdown"; static int shutdown_index = 0; switch(addr) { /* Bochs BIOS messages */ case 0x400: case 0x401: /* used to be panic, now unused */ break; case 0x402: case 0x403:#ifdef DEBUG_BIOS fprintf(stderr, "%c"... | |
positive | void error_propagate(Error **dst_err, Error *local_err){ if (dst_err) { *dst_err = local_err; } else if (local_err) { error_free(local_err); }} | |
positive | static int macio_newworld_initfn(PCIDevice *d){ MacIOState *s = MACIO(d); NewWorldMacIOState *ns = NEWWORLD_MACIO(d); SysBusDevice *sysbus_dev; MemoryRegion *timer_memory = g_new(MemoryRegion, 1); int i; int cur_irq = 0; int ret = macio_common_initfn(d); if (ret < 0) { return ret; } sysbus_dev = SYS_BUS_DEVICE(&s->cuda... | |
positive | static void cpu_openrisc_load_kernel(ram_addr_t ram_size, const char *kernel_filename, OpenRISCCPU *cpu){ long kernel_size; uint64_t elf_entry; hwaddr entry; if (kernel_filename && !qtest_enabled()) { kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry, NULL, NULL, 1, ELF_MACHINE, 1); entry = elf_entry; if (... | |
positive | void qmp_migrate(const char *uri, bool has_blk, bool blk, bool has_inc, bool inc, bool has_detach, bool detach, Error **errp){ Error *local_err = NULL; MigrationState *s = migrate_get_current(); MigrationParams params; const char *p; params.blk = has_blk && blk; params.shared = has_inc && inc; if (migration_is_setup_or... | |
negative | static void avc_luma_hv_qrt_and_aver_dst_16x16_msa(const uint8_t *src_x, const uint8_t *src_y, int32_t src_stride, uint8_t *dst, int32_t dst_stride){ uint32_t multiple8_cnt; for (multiple8_cnt = 2; multiple8_cnt--;) { avc_luma_hv_qrt_and_aver_dst_8x8_msa(src_x, src_y, src_stride, dst, dst_stride); src_x += 8; src_y += ... | |
negative | uint32_t net_checksum_add(int len, uint8_t *buf){ uint32_t sum = 0; int i; for (i = 0; i < len; i++) {if (i & 1) sum += (uint32_t)buf[i];else sum += (uint32_t)buf[i] << 8; } return sum;} | |
negative | static uint32_t hpet_ram_readl(void *opaque, target_phys_addr_t addr){ HPETState *s = opaque; uint64_t cur_tick, index; DPRINTF("qemu: Enter hpet_ram_readl at %" PRIx64 "\n", addr); index = addr; /*address range of all TN regs*/ if (index >= 0x100 && index <= 0x3ff) { uint8_t timer_id = (addr - 0x100) / 0x20; HPETTimer... | |
negative | static void gen_jump(DisasContext *dc, uint32_t imm, uint32_t reg, uint32_t op0){ target_ulong tmp_pc; /* N26, 26bits imm */ tmp_pc = sign_extend((imm<<2), 26) + dc->pc; switch (op0) { case 0x00: /* l.j */ tcg_gen_movi_tl(jmp_pc, tmp_pc); break; case 0x01: /* l.jal */ tcg_gen_movi_tl(cpu_R[9], (dc->pc + 8)); tcg_gen_mo... | |
negative | static int net_init_nic(const NetClientOptions *opts, const char *name, NetClientState *peer, Error **errp){ int idx; NICInfo *nd; const NetLegacyNicOptions *nic; assert(opts->type == NET_CLIENT_OPTIONS_KIND_NIC); nic = opts->u.nic; idx = nic_get_free_idx(); if (idx == -1 || nb_nics >= MAX_NICS) { error_setg(errp, "too... | |
negative | static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic, const uint8_t *src, int src_size){ GetByteContext gb; GetBitContext gb2; int nslices, slice, slice_height, ref_slice_height; int cur_y, next_y; uint32_t off, slice_size; uint8_t *Y, *U, *V; int ret; bytestream2_init(&gb, src, src_size); nslices = byte... | |
negative | int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg){ struct kvm_irq_routing_entry kroute; if (!kvm_irqchip_in_kernel()) { return -ENOSYS; } kroute.gsi = virq; kroute.type = KVM_IRQ_ROUTING_MSI; kroute.flags = 0; kroute.u.msi.address_lo = (uint32_t)msg.address; kroute.u.msi.address_hi = msg.address >... | |
negative | type_init(pflash_cfi01_register_types)pflash_t *pflash_cfi01_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, BlockDriverState *bs, uint32_t sector_len, int nb_blocs, int bank_width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, int be){ DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFL... | |
negative | static void vnc_write_u16(VncState *vs, uint16_t value){ uint8_t buf[2]; buf[0] = (value >> 8) & 0xFF; buf[1] = value & 0xFF; vnc_write(vs, buf, 2);} | |
negative | type_init(assign_register_types)static void assigned_dev_load_option_rom(AssignedDevice *dev){ int size = 0; pci_assign_dev_load_option_rom(&dev->dev, OBJECT(dev), &size, dev->host.domain, dev->host.bus, dev->host.slot, dev->host.function); if (!size) { error_report("pci-assign: Invalid ROM."); }} | |
negative | static void ide_issue_trim_cb(void *opaque, int ret){ TrimAIOCB *iocb = opaque; if (ret >= 0) { while (iocb->j < iocb->qiov->niov) { int j = iocb->j; while (++iocb->i < iocb->qiov->iov[j].iov_len / 8) { int i = iocb->i; uint64_t *buffer = iocb->qiov->iov[j].iov_base; /* 6-byte LBA + 2-byte range per entry */ uint64_t e... | |
negative | static void usbredir_device_disconnect(void *priv){ USBRedirDevice *dev = priv; int i; /* Stop any pending attaches */ qemu_del_timer(dev->attach_timer); if (dev->dev.attached) { usb_device_detach(&dev->dev); /* * Delay next usb device attach to give the guest a chance to see * see the detach / attach in case of quick ... | |
negative | static void pm_write_config(PCIDevice *d, uint32_t address, uint32_t val, int len){ DPRINTF("pm_write_config address 0x%x val 0x%x len 0x%x \n", address, val, len); pci_default_write_config(d, address, val, len);} | |
negative | static int rv20_decode_picture_header(MpegEncContext *s){ int seq, mb_pos, i; i= get_bits(&s->gb, 2); switch(i){ case 0: s->pict_type= I_TYPE; break; case 1: s->pict_type= I_TYPE; break; //hmm ... case 2: s->pict_type= P_TYPE; break; case 3: s->pict_type= B_TYPE; break; default: av_log(s->avctx, AV_LOG_ERROR, "unknown ... | |
negative | static void test_visitor_in_union_flat(TestInputVisitorData *data, const void *unused){ Visitor *v; Error *err = NULL; UserDefFlatUnion *tmp; UserDefUnionBase *base; v = visitor_input_test_init(data, "{ 'enum1': 'value1', " "'integer': 41, " "'string': 'str', " "'boolean': true }"); visit_type_UserDefFlatUnion(v, &tmp,... | |
negative | static void s390_pcihost_hot_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ PCIDevice *pci_dev = NULL; PCIBus *bus; int32_t devfn; S390PCIBusDevice *pbdev = NULL; S390pciState *s = s390_get_phb(); if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_BRIDGE)) { error_setg(errp, "PCI bridge hot unplug curr... | |
positive | static int parse_presentation_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int64_t pts){ PGSSubContext *ctx = avctx->priv_data; int i, state, ret; // Video descriptor int w = bytestream_get_be16(&buf); int h = bytestream_get_be16(&buf); uint16_t object_index; ctx->presentation.pts = pts; av_dlog(avc... | |
positive | static int crypto_close(URLContext *h){ CryptoContext *c = h->priv_data; if (c->hd) ffurl_close(c->hd); av_freep(&c->aes); av_freep(&c->key); av_freep(&c->iv); return 0;} | |
positive | static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int swap_buf_size = buf_size - MIMIC_HEADER_SIZE; MimicContext *ctx = avctx->priv_data; GetByteContext gb; int is_pframe; int width, height; int quality, num_c... | |
positive | static void vmgenid_set_guid_auto_test(void){ const char *cmd; QemuUUID measured; cmd = "-machine accel=tcg -device vmgenid,id=testvgid," "guid=auto"; qtest_start(cmd); read_guid_from_memory(&measured); /* Just check that the GUID is non-null */ g_assert(!qemu_uuid_is_null(&measured)); qtest_quit(global_qtest);} | |
positive | static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base){ uint32_t offset; uint16_t ext; TCGv add; TCGv tmp; uint32_t bd, od; offset = s->pc; ext = cpu_lduw_code(env, s->pc); s->pc += 2; if ((ext & 0x800) == 0 && !m68k_feature(s->env, M68K_FEATURE_WORD_INDEX)) return NULL_QREG; if (ext & 0x100) { /* f... | |
positive | int swr_convert_frame(SwrContext *s, AVFrame *out, const AVFrame *in){ int ret, setup = 0; if (!swr_is_initialized(s)) { if ((ret = swr_config_frame(s, out, in)) < 0) return ret; if ((ret = swr_init(s)) < 0) return ret; setup = 1; } else { // return as is or reconfigure for input changes? if ((ret = config_changed(s, o... | |
negative | av_cold static int fbdev_read_header(AVFormatContext *avctx, AVFormatParameters *ap){ FBDevContext *fbdev = avctx->priv_data; AVStream *st = NULL; enum PixelFormat pix_fmt; int ret, flags = O_RDONLY; ret = av_parse_video_rate(&fbdev->framerate_q, fbdev->framerate); if (ret < 0) { av_log(avctx, AV_LOG_ERROR, "Couldn't p... | |
positive | static abi_long target_to_host_data_route(struct nlmsghdr *nlh){ struct ifinfomsg *ifi; struct ifaddrmsg *ifa; struct rtmsg *rtm; switch (nlh->nlmsg_type) { case RTM_GETLINK: break; case RTM_NEWLINK: case RTM_DELLINK: ifi = NLMSG_DATA(nlh); ifi->ifi_type = tswap16(ifi->ifi_type); ifi->ifi_index = tswap32(ifi->ifi_index... | |
positive | PPC_OP(cmp){ if (Ts0 < Ts1) { T0 = 0x08; } else if (Ts0 > Ts1) { T0 = 0x04; } else { T0 = 0x02; } RETURN();} | |
positive | static int parse_channel_expressions(AVFilterContext *ctx, int expected_nb_channels){ EvalContext *eval = ctx->priv; char *args1 = av_strdup(eval->exprs); char *expr, *last_expr, *buf; double (* const *func1)(void *, double) = NULL; const char * const *func1_names = NULL; int i, ret = 0; if (!args1) return AVERROR(ENOM... | |
positive | static int sdp_probe(AVProbeData *p1){ const char *p = p1->buf, *p_end = p1->buf + p1->buf_size; /* we look for a line beginning "c=IN IP" */ while (p < p_end && *p != '\0') { if (p + sizeof("c=IN IP") - 1 < p_end && av_strstart(p, "c=IN IP", NULL)) return AVPROBE_SCORE_EXTENSION; while (p < p_end - 1 && *p != '\n') p+... | |
negative | int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, uint8_t *buf, int buf_size){ int ret; *frame_size_ptr= 0; ret = avctx->codec->decode(avctx, samples, frame_size_ptr, buf, buf_size); avctx->frame_number++; return ret;} | |
negative | static int mpeg4_unpack_bframes_filter(AVBSFContext *ctx, AVPacket *out){ UnpackBFramesBSFContext *s = ctx->priv_data; int pos_p = -1, nb_vop = 0, pos_vop2 = -1, ret = 0; AVPacket *in; ret = ff_bsf_get_packet(ctx, &in); if (ret < 0) return ret; scan_buffer(in->data, in->size, &pos_p, &nb_vop, &pos_vop2); av_log(ctx, AV... | |
positive | static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst){ int ret = 0; int num, den; char c; if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) { if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0) return ret; ret = 0; } for (;;) { int i = 0; char buf[256]; int c... | |
positive | static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp){ StackObject *tos = &qiv->stack[qiv->nb_stack - 1]; assert(qiv->nb_stack > 0); if (qiv->strict) { GHashTable *const top_ht = tos->h; if (top_ht) { GHashTableIter iter; const char *key; g_hash_table_iter_init(&iter, top_ht); if (g_hash_table_iter_next(&iter, ... | |
positive | static void large_dict(void){ GString *gstr = g_string_new(""); QObject *obj; gen_test_json(gstr, 10, 100); obj = qobject_from_json(gstr->str, NULL); g_assert(obj != NULL); qobject_decref(obj); g_string_free(gstr, true);} | |
positive | static uint32_t m25p80_transfer8(SSISlave *ss, uint32_t tx){ Flash *s = M25P80(ss); uint32_t r = 0; switch (s->state) { case STATE_PAGE_PROGRAM: DB_PRINT_L(1, "page program cur_addr=%#" PRIx64 " data=%" PRIx8 "\n", s->cur_addr, (uint8_t)tx); flash_write8(s, s->cur_addr, (uint8_t)tx); s->cur_addr++; break; case STATE_RE... | |
positive | static void dec_scall(DisasContext *dc){ if (dc->imm5 == 7) { LOG_DIS("scall\n"); } else if (dc->imm5 == 2) { LOG_DIS("break\n"); } else { cpu_abort(dc->env, "invalid opcode\n"); } if (dc->imm5 == 7) { tcg_gen_movi_tl(cpu_pc, dc->pc); t_gen_raise_exception(dc, EXCP_SYSTEMCALL); } else { tcg_gen_movi_tl(cpu_pc, dc->pc);... | |
positive | static int ohci_service_iso_td(OHCIState *ohci, struct ohci_ed *ed, int completion){ int dir; size_t len = 0;#ifdef DEBUG_ISOCH const char *str = NULL;#endif int pid; int ret; int i; USBDevice *dev; struct ohci_iso_td iso_td; uint32_t addr; uint16_t starting_frame; int16_t relative_frame_number; int frame_count; uint32... | |
positive | int spapr_vio_send_crq(VIOsPAPRDevice *dev, uint8_t *crq){ int rc; uint8_t byte; if (!dev->crq.qsize) { fprintf(stderr, "spapr_vio_send_creq on uninitialized queue\n"); return -1; } /* Maybe do a fast path for KVM just writing to the pages */ rc = spapr_tce_dma_read(dev, dev->crq.qladdr + dev->crq.qnext, &byte, 1); if ... | |
positive | static void vhost_log_put(struct vhost_dev *dev, bool sync){ struct vhost_log *log = dev->log; if (!log) { return; } dev->log = NULL; dev->log_size = 0; --log->refcnt; if (log->refcnt == 0) { /* Sync only the range covered by the old log */ if (dev->log_size && sync) { vhost_log_sync_range(dev, 0, dev->log_size * VHOST... | |
positive | static void mirror_set_speed(BlockJob *job, int64_t speed, Error **errp){ MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); if (speed < 0) { error_setg(errp, QERR_INVALID_PARAMETER, "speed"); return; } ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);} | |
positive | static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1, uint64_t prp2, uint32_t len, NvmeCtrl *n){ hwaddr trans_len = n->page_size - (prp1 % n->page_size); trans_len = MIN(len, trans_len); int num_prps = (len >> n->page_bits) + 1; if (!prp1) { return NVME_INVALID_FIELD | NVME_DNR; } else if (n->... | |
positive | static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options){ int ret; AVProbeData pd = {filename, NULL, 0}; if(s->iformat && !strlen(filename)) return 0; if (s->pb) { s->flags |= AVFMT_FLAG_CUSTOM_IO; if (!s->iformat) return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0); else ... | |
positive | static GuestPCIAddress *get_pci_info(char *guid, Error **errp){ HDEVINFO dev_info; SP_DEVINFO_DATA dev_info_data; DWORD size = 0; int i; char dev_name[MAX_PATH]; char *buffer = NULL; GuestPCIAddress *pci = NULL; char *name = g_strdup(&guid[4]); if (!QueryDosDevice(name, dev_name, ARRAY_SIZE(dev_name))) { error_setg_win... | |
positive | int target_get_monitor_def(CPUState *cs, const char *name, uint64_t *pval){ int i, regnum; PowerPCCPU *cpu = POWERPC_CPU(cs); CPUPPCState *env = &cpu->env; /* General purpose registers */ if ((tolower(name[0]) == 'r') && ppc_cpu_get_reg_num(name + 1, ARRAY_SIZE(env->gpr), ®num)) { *pval = env->gpr[regnum]; return 0;... | |
positive | PPC_OP(update_nip){ env->nip = PARAM(1); RETURN();} | |
positive | static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size){ Mpeg1Context *s1 = avctx->priv_data; MpegEncContext *s = &s1->mpeg_enc_ctx; int width, height; int i, v, j; init_get_bits(&s->gb, buf, buf_size * 8); width = get_bits(&s->gb, 12); height = get_bits(&s->gb, 12); if (width == 0 || ... | |
positive | static void vnc_async_encoding_end(VncState *orig, VncState *local){ orig->tight = local->tight; orig->zlib = local->zlib; orig->hextile = local->hextile; orig->zrle = local->zrle; orig->lossy_rect = local->lossy_rect;} | |
positive | static int s302m_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ S302Context *s = avctx->priv_data; AVFrame *frame = data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int block_size, ret; int i; int non_pcm_data_type = -1; int frame_size = s302m_parse_frame_header... | |
negative | static gboolean tcp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque){ CharDriverState *chr = opaque; TCPCharDriver *s = chr->opaque; uint8_t buf[READ_BUF_LEN]; int len, size; if (!s->connected || s->max_size <= 0) { return FALSE; } len = sizeof(buf); if (len > s->max_size) len = s->max_size; size = tcp_chr_r... | |
negative | static void ivshmem_realize(PCIDevice *dev, Error **errp){ IVShmemState *s = IVSHMEM_COMMON(dev); if (!qtest_enabled()) { error_report("ivshmem is deprecated, please use ivshmem-plain" " or ivshmem-doorbell instead"); } if (!!qemu_chr_fe_get_driver(&s->server_chr) + !!s->shmobj != 1) { error_setg(errp, "You must specif... | |
negative | void css_conditional_io_interrupt(SubchDev *sch){ /* * If the subchannel is not currently status pending, make it pending * with alert status. */ if (!(sch->curr_status.scsw.ctrl & SCSW_STCTL_STATUS_PEND)) { S390CPU *cpu = s390_cpu_addr2state(0); uint8_t isc = (sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ISC) >> 11; ... | |
negative | int load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz){ uint8_t *compressed_data = NULL; uint8_t *data = NULL; gsize len; ssize_t bytes; int ret = -1; if (!g_file_get_contents(filename, (char **) &compressed_data, &len, NULL)) { goto out; } /* Is it a gzip-compressed file? */ if (len < 2 || compress... | |
negative | static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu){ ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu); if (req->state != STATE_IOREQ_READY) { DPRINTF("I/O request not ready: " "%x, ptr: %x, port: %"PRIx64", " "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", re... | |
negative | static void vfio_pci_write_config(PCIDevice *pdev, uint32_t addr, uint32_t val, int len){ VFIODevice *vdev = DO_UPCAST(VFIODevice, pdev, pdev); uint32_t val_le = cpu_to_le32(val); DPRINTF("%s(%04x:%02x:%02x.%x, @0x%x, 0x%x, len=0x%x)\n", __func__, vdev->host.domain, vdev->host.bus, vdev->host.slot, vdev->host.function,... | |
negative | static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix, uint16_t **refcount_table, int64_t *nb_clusters){ BDRVQcowState *s = bs->opaque; int64_t i; for(i = 0; i < s->refcount_table_size; i++) { uint64_t offset, cluster; offset = s->refcount_table[i]; cluster = offset >> s->cluster_bits... | |
negative | static void gen_lwarx(DisasContext *ctx){ TCGv t0; gen_set_access_type(ctx, ACCESS_RES); t0 = tcg_temp_local_new(); gen_addr_reg_index(ctx, t0); gen_check_align(ctx, t0, 0x03); gen_qemu_ld32u(ctx, cpu_gpr[rD(ctx->opcode)], t0); tcg_gen_mov_tl(cpu_reserve, t0); tcg_temp_free(t0);} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.