label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void ioreq_release(struct ioreq *ioreq){ struct XenBlkDev *blkdev = ioreq->blkdev; LIST_REMOVE(ioreq, list); memset(ioreq, 0, sizeof(*ioreq)); ioreq->blkdev = blkdev; LIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); blkdev->requests_finished--;} |
0 | static void static_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){#ifdef SPY printf("%s: value %08lx written at " PA_FMT "\n", __FUNCTION__, value, offset);#endif} |
0 | static inline void set_fsr(CPUSPARCState *env){ int rnd_mode; switch (env->fsr & FSR_RD_MASK) { case FSR_RD_NEAREST: rnd_mode = float_round_nearest_even; break; default: case FSR_RD_ZERO: rnd_mode = float_round_to_zero; break; case FSR_RD_POS: rnd_mode = float_round_up; break; case FSR_RD_NEG: rnd_mode = float_round_do... |
0 | static void *kvm_cpu_thread_fn(void *arg){ CPUState *env = arg; int r; qemu_mutex_lock(&qemu_global_mutex); qemu_thread_self(env->thread); r = kvm_init_vcpu(env); if (r < 0) { fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r)); exit(1); } qemu_kvm_init_cpu_signals(env); /* signal CPU creation */ env->created =... |
0 | void HELPER(stfl)(CPUS390XState *env){ uint64_t words[MAX_STFL_WORDS]; LowCore *lowcore; lowcore = cpu_map_lowcore(env); do_stfle(env, words); lowcore->stfl_fac_list = cpu_to_be32(words[0] >> 32); cpu_unmap_lowcore(lowcore);} |
0 | static int nbd_can_accept(void *opaque){ return nb_fds < shared;} |
0 | static void pci_update_mappings(PCIDevice *d){ PCIIORegion *r; int i; pcibus_t new_addr; for(i = 0; i < PCI_NUM_REGIONS; i++) { r = &d->io_regions[i]; /* this region isn't registered */ if (!r->size) continue; new_addr = pci_bar_address(d, i, r->type, r->size); /* This bar isn't changed */ if (new_addr == r->addr) cont... |
0 | static QObject* bdrv_info_stats_bs(BlockDriverState *bs){ QObject *res; QDict *dict; res = qobject_from_jsonf("{ 'stats': {" "'rd_bytes': %" PRId64 "," "'wr_bytes': %" PRId64 "," "'rd_operations': %" PRId64 "," "'wr_operations': %" PRId64 "," "'wr_highest_offset': %" PRId64 "," "'flush_operations': %" PRId64 "} }", bs-... |
0 | static void sun4m_common_init(int ram_size, int boot_device, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model, unsigned int machine){ sun4m_hw_init(&hwdefs[machine], ram_size, ds, cpu_model); sun4m_load_kernel(hwdefs[machine].vram_size, ram_si... |
1 | static int pmp_packet(AVFormatContext *s, AVPacket *pkt){ PMPContext *pmp = s->priv_data; AVIOContext *pb = s->pb; int ret = 0; int i; if (url_feof(pb)) return AVERROR_EOF; if (pmp->cur_stream == 0) { int num_packets; pmp->audio_packets = avio_r8(pb); num_packets = (pmp->num_streams - 1) * pmp->audio_packets + 1; avio_... |
1 | void virtio_queue_notify(VirtIODevice *vdev, int n){ if (n < VIRTIO_PCI_QUEUE_MAX) { virtio_queue_notify_vq(&vdev->vq[n]); }} |
0 | int av_picture_crop(AVPicture *dst, const AVPicture *src, enum PixelFormat pix_fmt, int top_band, int left_band){ int y_shift; int x_shift; if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB) return -1; y_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h; x_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_w; if (is_yuv_pl... |
0 | void ff_put_h264_qpel16_mc30_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride){ avc_luma_hz_qrt_16w_msa(src - 2, stride, dst, stride, 16, 1);} |
0 | static int wv_read_packet(AVFormatContext *s, AVPacket *pkt){ WVContext *wc = s->priv_data; int ret, samples; if (url_feof(&s->pb)) return -EIO; if(wc->block_parsed){ if(wv_read_block_header(s, &s->pb) < 0) return -1; } samples = LE_32(wc->extra); /* should not happen but who knows */ if(samples * 2 * wc->chan > AVCODE... |
0 | static void calc_masking(DCAEncContext *c, const int32_t *input){ int i, k, band, ch, ssf; int32_t data[512]; for (i = 0; i < 256; i++) for (ssf = 0; ssf < SUBSUBFRAMES; ssf++) c->masking_curve_cb[ssf][i] = -2047; for (ssf = 0; ssf < SUBSUBFRAMES; ssf++) for (ch = 0; ch < c->fullband_channels; ch++) { const int chi = c... |
1 | static coroutine_fn void nbd_trip(void *opaque){ NBDClient *client = opaque; NBDExport *exp = client->exp; NBDRequestData *req; NBDRequest request = { 0 }; /* GCC thinks it can be used uninitialized */ int ret; int flags; int reply_data_len = 0; Error *local_err = NULL; char *msg = NULL; trace_nbd_trip(); if (client->c... |
1 | static void quantize_mantissas_blk_ch(AC3EncodeContext *s, int32_t *fixed_coef, int8_t exp_shift, uint8_t *exp, uint8_t *bap, uint16_t *qmant, int n){ int i; for (i = 0; i < n; i++) { int v; int c = fixed_coef[i]; int e = exp[i] - exp_shift; int b = bap[i]; switch (b) { case 0: v = 0; break; case 1: v = sym_quant(c, e,... |
1 | static inline void tb_alloc_page(TranslationBlock *tb, unsigned int n, tb_page_addr_t page_addr){ PageDesc *p;#ifndef CONFIG_USER_ONLY bool page_already_protected;#endif assert_memory_lock(); tb->page_addr[n] = page_addr; p = page_find_alloc(page_addr >> TARGET_PAGE_BITS, 1); tb->page_next[n] = p->first_tb;#ifndef CONF... |
1 | void address_space_destroy(AddressSpace *as){ /* Flush out anything from MemoryListeners listening in on this */ memory_region_transaction_begin(); as->root = NULL; memory_region_transaction_commit(); QTAILQ_REMOVE(&address_spaces, as, address_spaces_link); address_space_destroy_dispatch(as); flatview_destroy(as->curre... |
1 | static void test_submit(void){ WorkerTestData data = { .n = 0 }; thread_pool_submit(pool, worker_cb, &data); qemu_aio_wait_all(); g_assert_cmpint(data.n, ==, 1);} |
1 | static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, uint8_t *data_start, unsigned int data_size){ WebPContext *s = avctx->priv_data; AVPacket pkt; int ret; if (!s->initialized) { ff_vp8_decode_init(avctx); s->initialized = 1; if (s->has_alpha) avctx->pix_fmt = AV_PIX_FMT_YUVA420P; } s->... |
1 | static void vfio_calxeda_xgmac_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); VFIOCalxedaXgmacDeviceClass *vcxc = VFIO_CALXEDA_XGMAC_DEVICE_CLASS(klass); vcxc->parent_realize = dc->realize; dc->realize = calxeda_xgmac_realize; dc->desc = "VFIO Calxeda XGMAC"; dc->vmsd = &vfio_platfor... |
1 | static void ppcuic_set_irq (void *opaque, int irq_num, int level){ ppcuic_t *uic; uint32_t mask, sr; uic = opaque; mask = 1 << (31-irq_num); LOG_UIC("%s: irq %d level %d uicsr %08" PRIx32 " mask %08" PRIx32 " => %08" PRIx32 " %08" PRIx32 "\n", __func__, irq_num, level, uic->uicsr, mask, uic->uicsr & mask, level << irq_... |
1 | static int avi_sync(AVFormatContext *s, int exit_early){ AVIContext *avi = s->priv_data; AVIOContext *pb = s->pb; int n; unsigned int d[8]; unsigned int size; int64_t i, sync;start_sync: memset(d, -1, sizeof(d)); for(i=sync=avio_tell(pb); !url_feof(pb); i++) { int j; for(j=0; j<7; j++) d[j]= d[j+1]; d[7]= avio_r8(pb); ... |
1 | static void ide_atapi_cmd(IDEState *s){ const uint8_t *packet; uint8_t *buf; int max_len; packet = s->io_buffer; buf = s->io_buffer;#ifdef DEBUG_IDE_ATAPI { int i; printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8)); for(i = 0; i < ATAPI_PACKET_SIZE; i++) { printf(" %02x", packet[i]); printf("\n");#endif /* If... |
1 | void rgb16tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size){unsigned i;unsigned num_pixels = src_size >> 1;for(i=0; i<num_pixels; i++){ unsigned b,g,r; register uint16_t rgb; rgb = src[2*i]; r = rgb&0x1F; g = (rgb&0x7E0)>>5; b = (rgb&0xF800)>>11; dst[2*i] = (b&0x1F) | ((g&0x1F)<<5) | ((r&0x1F)<<10);}} |
1 | static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun, int evpd, int pc, void **inq, Error **errp){ int full_size; struct scsi_task *task = NULL; task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64); if (task == NULL || task->status != SCSI_STATUS_GOOD) { goto fail; } full_size = scsi_datain_get... |
1 | int kvm_arch_handle_exit(CPUPPCState *env, struct kvm_run *run){ int ret; switch (run->exit_reason) { case KVM_EXIT_DCR: if (run->dcr.is_write) { dprintf("handle dcr write\n"); ret = kvmppc_handle_dcr_write(env, run->dcr.dcrn, run->dcr.data); } else { dprintf("handle dcr read\n"); ret = kvmppc_handle_dcr_read(env, run-... |
1 | static void tgen_andi(TCGContext *s, TCGType type, TCGReg dest, uint64_t val){ static const S390Opcode ni_insns[4] = { RI_NILL, RI_NILH, RI_NIHL, RI_NIHH }; static const S390Opcode nif_insns[2] = { RIL_NILF, RIL_NIHF }; uint64_t valid = (type == TCG_TYPE_I32 ? 0xffffffffull : -1ull); int i; /* Look for the zero-extensi... |
1 | static inline void RENAME(rgb16to24)(const uint8_t *src, uint8_t *dst, unsigned src_size){const uint16_t *end;#ifdef HAVE_MMXconst uint16_t *mm_end;#endifuint8_t *d = (uint8_t *)dst;const uint16_t *s = (const uint16_t *)src;end = s + src_size/2;#ifdef HAVE_MMX__asm __volatile(PREFETCH"%0"::"m"(*s):"memory");mm_end = en... |
1 | static void gen_tlbsx_40x(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else TCGv t0; if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } t0 = tcg_temp_new(); gen_addr_reg_index(ctx, t0); gen_helper_4xx_tlbsx(cpu_gpr[rD(ctx->opcode)], c... |
1 | static int sdp_parse_fmtp_config_h264(AVFormatContext *s, AVStream *stream, PayloadContext *h264_data, const char *attr, const char *value){ AVCodecParameters *par = stream->codecpar; if (!strcmp(attr, "packetization-mode")) { av_log(s, AV_LOG_DEBUG, "RTP Packetization Mode: %d\n", atoi(value)); h264_data->packetizatio... |
1 | int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase){ if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold && s->slice_context_count == 1 && s->pb.buf == s->avctx->internal->byte_buffer) { int lastgob_pos = s->ptr_lastgob - s->pb.buf; int vbv_pos = s->vbv_del... |
1 | int64_t object_property_get_int(Object *obj, const char *name, Error **errp){ QObject *ret = object_property_get_qobject(obj, name, errp); QInt *qint; int64_t retval; if (!ret) { return -1; } qint = qobject_to_qint(ret); if (!qint) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int"); retval = -1; } else { retv... |
1 | void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout){ int i; if (nb_channels <= 0) nb_channels = av_get_channel_layout_nb_channels(channel_layout); for (i = 0; channel_layout_map[i].name; i++) if (nb_channels == channel_layout_map[i].nb_channels && channel_layout == chann... |
1 | int qemu_read_password(char *buf, int buf_size){ uint8_t ch; int i, ret; printf("password: "); fflush(stdout); term_init(); i = 0; for (;;) { ret = read(0, &ch, 1); if (ret == -1) { if (errno == EAGAIN || errno == EINTR) { continue; } else { break; } } else if (ret == 0) { ret = -1; break; } else { if (ch == '\r' || ch... |
0 | static void smbios_build_type_1_fields(const char *t){ char buf[1024]; if (get_param_value(buf, sizeof(buf), "manufacturer", t)) smbios_add_field(1, offsetof(struct smbios_type_1, manufacturer_str), strlen(buf) + 1, buf); if (get_param_value(buf, sizeof(buf), "product", t)) smbios_add_field(1, offsetof(struct smbios_ty... |
0 | int css_do_tsch_get_irb(SubchDev *sch, IRB *target_irb, int *irb_len){ SCSW *s = &sch->curr_status.scsw; PMCW *p = &sch->curr_status.pmcw; uint16_t stctl; IRB irb; if (!(p->flags & (PMCW_FLAGS_MASK_DNV | PMCW_FLAGS_MASK_ENA))) { return 3; } stctl = s->ctrl & SCSW_CTRL_MASK_STCTL; /* Prepare the irb for the guest. */ me... |
0 | void helper_ldq_kernel(uint64_t t0, uint64_t t1){ ldq_kernel(t1, t0);} |
0 | static void lm32_uclinux_init(MachineState *machine){ const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; LM32CPU *cpu; CPULM32State *env; DriveInfo *dinfo; Memor... |
0 | static inline int retry_transfer_wrapper(URLContext *h, unsigned char *buf, int size, int size_min, int (*transfer_func)(URLContext *h, unsigned char *buf, int size)){ int ret, len; int fast_retries = 5; int64_t wait_since = 0; len = 0; while (len < size_min) { ret = transfer_func(h, buf+len, size-len); if (ret == AVER... |
0 | static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp){ VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); DeviceState *vdev = DEVICE(&dev->vdev); DeviceState *qdev = DEVICE(ccw_dev); Error *err = NULL; char *bus_name; /* * For command line compatibility, this sets the virtio-scsi-device bus * name as ... |
0 | static void mpc8544_guts_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ addr &= MPC8544_GUTS_MMIO_SIZE - 1; switch (addr) { case MPC8544_GUTS_ADDR_RSTCR: if (value & MPC8544_GUTS_RSTCR_RESET) { qemu_system_reset_request(); } break; default: fprintf(stderr, "guts: Unknown register write: %x... |
0 | static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid){ return s->ops->chown(&s->ctx, path->data, uid, gid);} |
0 | static int check_host_key_knownhosts(BDRVSSHState *s, const char *host, int port){ const char *home; char *knh_file = NULL; LIBSSH2_KNOWNHOSTS *knh = NULL; struct libssh2_knownhost *found; int ret, r; const char *hostkey; size_t len; int type; hostkey = libssh2_session_hostkey(s->session, &len, &type); if (!hostkey) { ... |
0 | static void numa_add(const char *optarg){ char option[128]; char *endptr; unsigned long long value, endvalue; int nodenr; optarg = get_opt_name(option, 128, optarg, ',') + 1; if (!strcmp(option, "node")) { if (get_param_value(option, 128, "nodeid", optarg) == 0) { nodenr = nb_numa_nodes; } else { nodenr = strtoull(opti... |
0 | static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state){ sPAPRDRConnector *drc = spapr_drc_by_index(idx); if (!drc) { return RTAS_OUT_PARAM_ERROR; } trace_spapr_drc_set_dr_indicator(idx, state); drc->dr_indicator = state; return RTAS_OUT_SUCCESS;} |
0 | static void unplug_disks(PCIBus *b, PCIDevice *d, void *o){ /* We have to ignore passthrough devices */ if (!strcmp(d->name, "xen-pci-passthrough")) { return; } switch (pci_get_word(d->config + PCI_CLASS_DEVICE)) { case PCI_CLASS_STORAGE_IDE: pci_piix3_xen_ide_unplug(DEVICE(d)); break; case PCI_CLASS_STORAGE_SCSI: case... |
0 | static void monitor_start_input(void){ readline_start("(qemu) ", 0, monitor_handle_command1, NULL);} |
0 | MKSCALE16(scale16be, AV_RB16, AV_WB16)MKSCALE16(scale16le, AV_RL16, AV_WL16)static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const AVPixFmtDescriptor *desc; RawVideoContext *context = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int linesize_a... |
0 | static void opt_qmin(const char *arg){ video_qmin = atoi(arg); if (video_qmin < 0 || video_qmin > 31) { fprintf(stderr, "qmin must be >= 1 and <= 31\n"); exit(1); }} |
0 | void migrate_decompress_threads_join(void){ int i, thread_count; quit_decomp_thread = true; thread_count = migrate_decompress_threads(); for (i = 0; i < thread_count; i++) { qemu_mutex_lock(&decomp_param[i].mutex); qemu_cond_signal(&decomp_param[i].cond); qemu_mutex_unlock(&decomp_param[i].mutex); } for (i = 0; i < thr... |
0 | ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs){ BlockDriver *drv = bs->drv; if (drv && drv->bdrv_get_specific_info) { return drv->bdrv_get_specific_info(bs); } return NULL;} |
0 | do_gen_eob_worker(DisasContext *s, bool inhibit, bool recheck_tf, TCGv jr){ gen_update_cc_op(s); /* If several instructions disable interrupts, only the first does it. */ if (inhibit && !(s->flags & HF_INHIBIT_IRQ_MASK)) { gen_set_hflag(s, HF_INHIBIT_IRQ_MASK); } else { gen_reset_hflag(s, HF_INHIBIT_IRQ_MASK); } if (s-... |
0 | SocketAddressLegacy *socket_local_address(int fd, Error **errp){ struct sockaddr_storage ss; socklen_t sslen = sizeof(ss); if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) { error_setg_errno(errp, errno, "%s", "Unable to query local socket address"); return NULL; } return socket_sockaddr_to_address(&ss, sslen, ... |
0 | static void machine_numa_finish_init(MachineState *machine){ int i; bool default_mapping; GString *s = g_string_new(NULL); MachineClass *mc = MACHINE_GET_CLASS(machine); const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(machine); assert(nb_numa_nodes); for (i = 0; i < possible_cpus->len; i++) { if (possibl... |
0 | void qmp_block_dirty_bitmap_clear(const char *node, const char *name, Error **errp){ AioContext *aio_context; BdrvDirtyBitmap *bitmap; BlockDriverState *bs; bitmap = block_dirty_bitmap_lookup(node, name, &bs, &aio_context, errp); if (!bitmap || !bs) { return; } if (bdrv_dirty_bitmap_frozen(bitmap)) { error_setg(errp, "... |
0 | FWCfgState *fw_cfg_init(uint32_t ctl_port, uint32_t data_port, target_phys_addr_t ctl_addr, target_phys_addr_t data_addr){ DeviceState *dev; SysBusDevice *d; FWCfgState *s; dev = qdev_create(NULL, "fw_cfg"); qdev_prop_set_uint32(dev, "ctl_iobase", ctl_port); qdev_prop_set_uint32(dev, "data_iobase", data_port); qdev_ini... |
1 | static void boston_flash_write(void *opaque, hwaddr addr, uint64_t val, unsigned size){} |
1 | static void revert_cdlms(WmallDecodeCtx *s, int ch, int coef_begin, int coef_end){ int icoef, pred, ilms, num_lms, residue, input; num_lms = s->cdlms_ttl[ch]; for (ilms = num_lms - 1; ilms >= 0; ilms--) { for (icoef = coef_begin; icoef < coef_end; icoef++) { pred = 1 << (s->cdlms[ch][ilms].scaling - 1); residue = s->ch... |
1 | static void utf8_string(void){ /* * FIXME Current behavior for invalid UTF-8 sequences is * incorrect. This test expects current, incorrect results. * They're all marked "bug:" below, and are to be replaced by * correct ones as the bugs get fixed. * * The JSON parser rejects some invalid sequences, but accepts * others... |
1 | static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts){ AVFrame *decoded_frame, *filtered_frame = NULL; void *buffer_to_free = NULL; int i, ret = 0; float quality = 0;#if CONFIG_AVFILTER int frame_available = 1;#endif int duration=0; int64_t *best_effort_timesta... |
1 | SubchDev *css_create_sch(CssDevId bus_id, bool is_virtual, bool squash_mcss, Error **errp){ uint16_t schid = 0; SubchDev *sch; if (bus_id.valid) { if (is_virtual != (bus_id.cssid == VIRTUAL_CSSID)) { error_setg(errp, "cssid %hhx not valid for %s devices", bus_id.cssid, (is_virtual ? "virtual" : "non-virtual")); return ... |
1 | static int vdi_create(const char *filename, QemuOpts *opts, Error **errp){ int ret = 0; uint64_t bytes = 0; uint32_t blocks; size_t block_size = DEFAULT_CLUSTER_SIZE; uint32_t image_type = VDI_TYPE_DYNAMIC; VdiHeader header; size_t i; size_t bmap_size; int64_t offset = 0; Error *local_err = NULL; BlockDriverState *bs =... |
1 | static int brpix_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ BRPixContext *s = avctx->priv_data; AVFrame *frame_out = data; int ret; GetByteContext gb; unsigned int bytes_pp; unsigned int magic[4]; unsigned int chunk_type; unsigned int data_len; BRPixHeader hdr; bytestream2_init(&g... |
1 | static void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile){ int i, csize = 1; int32_t *src[3], i0, i1, i2; float *srcf[3], i0f, i1f, i2f; for (i = 0; i < 3; i++) if (tile->codsty[0].transform == FF_DWT97) srcf[i] = tile->comp[i].f_data; else src [i] = tile->comp[i].i_data; for (i = 0; i < 2; i++) csize *= ti... |
1 | static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = st->priv_data; int entries, i, j; get_be32(pb); // version + flags entries = get_be32(pb); if (entries >= UINT_MAX / sizeof(*sc->drefs)) return -1; sc->drefs_count = en... |
1 | int usb_handle_packet(USBDevice *dev, USBPacket *p){ int ret; if (dev == NULL) { return USB_RET_NODEV; } assert(dev->addr == p->devaddr); assert(dev->state == USB_STATE_DEFAULT); assert(p->owner == NULL); if (p->devep == 0) { /* control pipe */ switch (p->pid) { case USB_TOKEN_SETUP: ret = do_token_setup(dev, p); break... |
1 | static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw){ char *filename; MemoryRegion *bios, *isa_bios; int bios_size, isa_bios_size; int ret; /* BIOS load */ if (bios_name == NULL) { bios_name = BIOS_FILENAME; } filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); if (filename) { bios_siz... |
1 | static int kvm_handle_debug(PowerPCCPU *cpu, struct kvm_run *run){ CPUState *cs = CPU(cpu); CPUPPCState *env = &cpu->env; struct kvm_debug_exit_arch *arch_info = &run->debug.arch; int handle = 0; if (kvm_find_sw_breakpoint(cs, arch_info->address)) { handle = 1; } else { /* QEMU is not able to handle debug exception, so... |
1 | void helper_ldda_asi(target_ulong addr, int asi, int rd){ if ((asi < 0x80 && (env->pstate & PS_PRIV) == 0) || ((env->def->features & CPU_FEATURE_HYPV) && asi >= 0x30 && asi < 0x80 && !(env->hpstate & HS_PRIV))) raise_exception(TT_PRIV_ACT); switch (asi) { case 0x24: // Nucleus quad LDD 128 bit atomic case 0x2c: // Nucl... |
1 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; VBDecContext * const c = avctx->priv_data; uint8_t *outptr, *srcptr; int i, j; int flags; uint32_t size; int rest = buf_size; int offset = 0; if(c->pic.data[0]) avct... |
1 | static inline void RENAME(bgr32ToY)(uint8_t *dst, uint8_t *src, int width){int i;for(i=0; i<width; i++){int b= ((uint32_t*)src)[i]&0xFF;int g= (((uint32_t*)src)[i]>>8)&0xFF;int r= (((uint32_t*)src)[i]>>16)&0xFF;dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)) )>>RGB2YUV_SHIFT);}} |
1 | static void gen_read_xer(TCGv dst){ TCGv t0 = tcg_temp_new(); TCGv t1 = tcg_temp_new(); TCGv t2 = tcg_temp_new(); tcg_gen_mov_tl(dst, cpu_xer); tcg_gen_shli_tl(t0, cpu_so, XER_SO); tcg_gen_shli_tl(t1, cpu_ov, XER_OV); tcg_gen_shli_tl(t2, cpu_ca, XER_CA); tcg_gen_or_tl(t0, t0, t1); tcg_gen_or_tl(dst, dst, t2); tcg_gen_o... |
1 | Object *object_dynamic_cast(Object *obj, const char *typename){ if (object_class_dynamic_cast(object_get_class(obj), typename)) { return obj; } return NULL;} |
0 | static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta){ h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);} |
1 | static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ SVQ1Context * const s = avctx->priv_data; AVFrame *pict = data; AVFrame * const p= (AVFrame*)&s->picture; AVFrame temp; int i; if(avctx->pix_fmt != PIX_FMT_YUV410P){ av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n... |
1 | static void xics_common_class_init(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); dc->reset = xics_common_reset;} |
1 | static BlockJob *test_block_job_start(unsigned int iterations, bool use_timer, int rc, int *result){ BlockDriverState *bs; TestBlockJob *s; TestBlockJobCBData *data; data = g_new0(TestBlockJobCBData, 1); bs = bdrv_new(); s = block_job_create(&test_block_job_driver, bs, 0, test_block_job_cb, data, &error_abort); s->iter... |
1 | static int cook_decode_init(AVCodecContext *avctx){ COOKextradata *e = avctx->extradata; COOKContext *q = avctx->priv_data; /* Take care of the codec specific extradata. */ if (avctx->extradata_size <= 0) { av_log(NULL,AV_LOG_ERROR,"Necessary extradata missing!\n"); } else { /* 8 for mono, 16 for stereo, ? for multicha... |
1 | static int check_for_block_signature(BlockDriverState *bs, const uint8_t *buf){ static const uint8_t signatures[][4] = { { 'Q', 'F', 'I', 0xfb }, /* qcow/qcow2 */ { 'C', 'O', 'W', 'D' }, /* VMDK3 */ { 'V', 'M', 'D', 'K' }, /* VMDK4 */ { 'O', 'O', 'O', 'M' }, /* UML COW */ {} }; int i; for (i = 0; signatures[i][0] != 0;... |
1 | static int parallels_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVParallelsState *s = bs->opaque; ParallelsHeader ph; int ret, size, i; QemuOpts *opts = NULL; Error *local_err = NULL; char *buf; bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false, errp); if (!bs->file) {... |
1 | static void __attribute__((constructor)) st_init(void){ atexit(st_flush_trace_buffer);} |
1 | static void test_qemu_strtoull_full_max(void){ const char *str = g_strdup_printf("%lld", ULLONG_MAX); uint64_t res = 999; int err; err = qemu_strtoull(str, NULL, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, ULLONG_MAX);} |
1 | static av_cold int mss1_decode_init(AVCodecContext *avctx){ MSS1Context * const c = avctx->priv_data; int ret; c->ctx.avctx = avctx; c->pic = av_frame_alloc(); if (!c->pic) return AVERROR(ENOMEM); ret = ff_mss12_decode_init(&c->ctx, 0, &c->sc, NULL); avctx->pix_fmt = AV_PIX_FMT_PAL8; return ret;} |
1 | static int ioreq_map(struct ioreq *ioreq){ XenGnttab gnt = ioreq->blkdev->xendev.gnttabdev; uint32_t domids[BLKIF_MAX_SEGMENTS_PER_REQUEST]; uint32_t refs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; void *page[BLKIF_MAX_SEGMENTS_PER_REQUEST]; int i, j, new_maps = 0; PersistentGrant *grant; /* domids and refs variables will contai... |
1 | static void *aio_thread(void *unused){ sigset_t set; /* block all signals */ sigfillset(&set); sigprocmask(SIG_BLOCK, &set, NULL); while (1) { struct qemu_paiocb *aiocb; size_t offset; int ret = 0; pthread_mutex_lock(&lock); while (TAILQ_EMPTY(&request_list) && !(ret == ETIMEDOUT)) { struct timespec ts = { 0 }; qemu_ti... |
1 | int ff_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst, int max_size){ uint32_t mrk; int i, tmp; const uint16_t *ssrc = (const uint16_t *) src; uint16_t *sdst = (uint16_t *) dst; PutBitContext pb; if ((unsigned) src_size > (unsigned) max_size) src_size = max_size; mrk = AV_RB32(src); switch (mrk) {... |
0 | av_cold void ff_vp8dsp_init_arm(VP8DSPContext *dsp){ int cpu_flags = av_get_cpu_flags(); if (have_armv6(cpu_flags)) ff_vp8dsp_init_armv6(dsp); if (have_neon(cpu_flags)) ff_vp8dsp_init_neon(dsp);} |
0 | static int g723_1_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ G723_1_Context *p = avctx->priv_data; int16_t unq_lpc[LPC_ORDER * SUBFRAMES]; int16_t qnt_lpc[LPC_ORDER * SUBFRAMES]; int16_t cur_lsp[LPC_ORDER]; int16_t weighted_lpc[LPC_ORDER * SUBFRAMES << 1]; int16_t v... |
1 | void ff_wmv2_idct_c(short * block){ int i; for(i=0;i<64;i+=8){ wmv2_idct_row(block+i); } for(i=0;i<8;i++){ wmv2_idct_col(block+i); }} |
1 | type_init(parallel_register_types)static bool parallel_init(ISABus *bus, int index, CharDriverState *chr){ DeviceState *dev; ISADevice *isadev; isadev = isa_try_create(bus, "isa-parallel"); if (!isadev) { return false; } dev = DEVICE(isadev); qdev_prop_set_uint32(dev, "index", index); qdev_prop_set_chr(dev, "chardev", ... |
1 | static void ehci_execute_complete(EHCIQueue *q){ EHCIPacket *p = QTAILQ_FIRST(&q->packets); assert(p != NULL); assert(p->qtdaddr == q->qtdaddr); assert(p->async != EHCI_ASYNC_INFLIGHT); p->async = EHCI_ASYNC_NONE; DPRINTF("execute_complete: qhaddr 0x%x, next %x, qtdaddr 0x%x, status %d\n", q->qhaddr, q->qh.next, q->qtd... |
1 | static void vector_fmul_reverse_vfp(float *dst, const float *src0, const float *src1, int len) { src1 += len; asm volatile( "fldmdbs %[src1]!, {s0-s3}\n\t" "fldmias %[src0]!, {s8-s11}\n\t" "fldmdbs %[src1]!, {s4-s7}\n\t" "fldmias %[src0]!, {s12-s15}\n\t" "fmuls s8, s3, s8\n\t" "fmuls s9, s2, s9\n\t" "fmuls s10, s1, s10... |
1 | static int64_t alloc_clusters_noref(BlockDriverState *bs, int64_t size){ BDRVQcowState *s = bs->opaque; int i, nb_clusters, refcount; nb_clusters = size_to_clusters(s, size);retry: for(i = 0; i < nb_clusters; i++) { int64_t next_cluster_index = s->free_cluster_index++; refcount = get_refcount(bs, next_cluster_index); i... |
1 | double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max){ char *tail; const char *error; double d = av_strtod(numstr, &tail); if (*tail) error = "Expected number for %s but found: %s\n"; else if (d < min || d > max) error = "The value for %s was %s which is not within %f - %... |
1 | static int qemu_rbd_snap_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_tab){ BDRVRBDState *s = bs->opaque; QEMUSnapshotInfo *sn_info, *sn_tab = NULL; int i, snap_count; rbd_snap_info_t *snaps; int max_snaps = RBD_MAX_SNAPS; do { snaps = g_malloc(sizeof(*snaps) * max_snaps); snap_count = rbd_snap_list(s->image, snap... |
1 | static void init_fps(int bf, int audio_preroll, int fps){ AVStream *st; ctx = avformat_alloc_context(); if (!ctx) exit(1); ctx->oformat = av_guess_format(format, NULL, NULL); if (!ctx->oformat) exit(1); ctx->pb = avio_alloc_context(iobuf, sizeof(iobuf), AVIO_FLAG_WRITE, NULL, NULL, io_write, NULL); if (!ctx->pb) exit(1... |
1 | GList *g_list_insert_sorted_merged(GList *list, gpointer data, GCompareFunc func){ GList *l, *next = NULL; Range *r, *nextr; if (!list) { list = g_list_insert_sorted(list, data, func); return list; } nextr = data; l = list; while (l && l != next && nextr) { r = l->data; if (ranges_can_merge(r, nextr)) { range_merge(r, ... |
1 | static int matroska_parse_laces(MatroskaDemuxContext *matroska, uint8_t **buf, int* buf_size, int type, uint32_t **lace_buf, int *laces){ int res = 0, n, size = *buf_size; uint8_t *data = *buf; uint32_t *lace_size; if (!type) { *laces = 1; *lace_buf = av_mallocz(sizeof(int)); if (!*lace_buf) return AVERROR(ENOMEM); *la... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.