label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | PCIDevice *pci_try_create(PCIBus *bus, int devfn, const char *name){ return pci_try_create_multifunction(bus, devfn, false, name);} |
0 | int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset, int nb_sectors, enum qcow2_discard_type type, bool full_discard){ BDRVQcow2State *s = bs->opaque; uint64_t end_offset; unsigned int nb_clusters; int ret; end_offset = offset + (nb_sectors << BDRV_SECTOR_BITS); /* Round start up and end down */ offset = a... |
0 | int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes){ uint8_t buf[4096]; target_phys_addr_t dst_begin = dst_addr; size_t want, did; while (nbytes) {want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;did = read(fd, buf, want);if (did != want) break;cpu_physical_memory_write_rom(dst_addr, buf, did);dst_a... |
0 | static int gxf_probe(AVProbeData *p) { static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2}; if (p->buf_size < 16) return 0; if (!memcmp(p->buf, startcode, sizeof(startcode)) && !memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof... |
0 | uint32_t cpu_inl(CPUState *env, pio_addr_t addr){ uint32_t val; val = ioport_read(2, addr); LOG_IOPORT("inl : %04"FMT_pioaddr" %08"PRIx32"\n", addr, val);#ifdef CONFIG_KQEMU if (env) env->last_io_time = cpu_get_time_fast();#endif return val;} |
0 | e1000_receive(void *opaque, const uint8_t *buf, size_t size){ E1000State *s = opaque; struct e1000_rx_desc desc; target_phys_addr_t base; unsigned int n, rdt; uint32_t rdh_start; uint16_t vlan_special = 0; uint8_t vlan_status = 0, vlan_offset = 0; if (!(s->mac_reg[RCTL] & E1000_RCTL_EN)) return; if (size > s->rxbuf_siz... |
0 | static uint64_t omap_mcbsp_read(void *opaque, target_phys_addr_t addr, unsigned size){ struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; int offset = addr & OMAP_MPUI_REG_MASK; uint16_t ret; if (size != 2) { return omap_badwidth_read16(opaque, addr); } switch (offset) { case 0x00:/* DRR2 */ if (((s->rcr[0] >> 5)... |
0 | static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req){ int status = VIRTIO_BLK_S_OK; struct virtio_scsi_inhdr *scsi = NULL; VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); VirtQueueElement *elem = &req->elem; VirtIOBlock *blk = req->dev;#ifdef __linux__ int i; VirtIOBlockIoctlReq *ioctl_req;#endif /* * We require at... |
0 | static int targa_decode_rle(AVCodecContext *avctx, TargaContext *s, const uint8_t *src, int src_size, uint8_t *dst, int w, int h, int stride, int bpp){ int i, x, y; int depth = (bpp + 1) >> 3; int type, count; int diff; const uint8_t *src_end = src + src_size; diff = stride - w * depth; x = y = 0; while(y < h){ CHECK_B... |
1 | uint32_t pci_default_read_config(PCIDevice *d, uint32_t address, int len){ uint32_t val = 0; assert(len == 1 || len == 2 || len == 4); len = MIN(len, pci_config_size(d) - address); memcpy(&val, d->config + address, len); return le32_to_cpu(val);} |
1 | static void gen_rfci_40x(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } /* Restore CPU state */ gen_helper_40x_rfci(cpu_env); gen_sync_exception(ctx);#endif} |
0 | static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, uint8_t *buf, int buf_size){ RTSPState *rt = s->priv_data; RTSPStream *rtsp_st; fd_set rfds; int fd, fd_max, n, i, ret, tcp_fd, timeout_cnt = 0; struct timeval tv; for (;;) { if (url_interrupt_cb()) return AVERROR(EINTR); FD_ZERO(&rfds); if (rt->rtsp... |
0 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) { AVCodecContext *acodec, *vcodec; ByteIOContext *ioc; AMFDataType amf_type; char str_val[256]; double num_val; num_val = 0; ioc = s->pb; amf_type = get_byte(ioc); switch(amf_type) { case A... |
0 | static void mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t){ uint8_t *key = av_strdup(t->key); uint8_t *p = key; const uint8_t *lang = NULL; ebml_master tag; if ((p = strrchr(p, '-')) && (lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL))) *p = 0; p = key; while (*p) { if (*p == ' ') *p = '_'; else if ... |
0 | static inline int decode_hrd_parameters(H264Context *h, SPS *sps){ int cpb_count, i; cpb_count = get_ue_golomb_31(&h->gb) + 1; if (cpb_count > 32U) { av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count); return AVERROR_INVALIDDATA; } get_bits(&h->gb, 4); /* bit_rate_scale */ get_bits(&h->gb, 4); /* cpb_s... |
0 | int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt) { int i, j, t, rconpointer = 0; uint8_t tk[8][4]; int KC= key_bits>>5; int rounds= KC + 6; uint8_t log8[256]; uint8_t alog8[512]; if(!enc_multbl[4][1023]){ j=1; for(i=0; i<255; i++){ alog8[i]= alog8[i+255]= j; log8[j]= i; j^= j+j; if(j>255) j^= 0x... |
0 | static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap){ VideoData *s = s1->priv_data; AVStream *st; int video_fd; int desired_palette, desired_depth; struct video_tuner tuner; struct video_audio audio; struct video_picture pict; int j; int vformat_num = FF_ARRAY_ELEMS(video_formats); av_log(s1, AV_LOG... |
0 | int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s){ put_be32(pb, 0x14 ); /* size */ put_tag(pb, "ftyp"); if (!strcmp("3gp", s->oformat->name)) put_tag(pb, "3gp4"); else put_tag(pb, "isom"); put_be32(pb, 0x200 ); if (!strcmp("3gp", s->oformat->name)) put_tag(pb, "3gp4"); else put_tag(pb, "mp41"); return 0x14;... |
1 | int qemu_strtoul(const char *nptr, const char **endptr, int base, unsigned long *result){ char *p; int err = 0; if (!nptr) { if (endptr) { *endptr = nptr; } err = -EINVAL; } else { errno = 0; *result = strtoul(nptr, &p, base); err = check_strtox_error(endptr, p, errno); } return err;} |
1 | static void virtio_9p_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); dc->props = virtio_9p_properties; set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); vdc->realize = virtio_9p_device_realize; vdc->get_features = virtio_9p_get_fea... |
1 | static void stereo_processing(PSContext *ps, float (*l)[32][2], float (*r)[32][2], int is34){ int e, b, k; float (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11; float (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12; float (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21; float (*H22)[PS_MAX_NUM_ENV+1][PS... |
1 | static void openpic_gbl_write(void *opaque, hwaddr addr, uint64_t val, unsigned len){ OpenPICState *opp = opaque; IRQ_dst_t *dst; int idx; DPRINTF("%s: addr " TARGET_FMT_plx " <= %08x\n", __func__, addr, val); if (addr & 0xF) return; switch (addr) { case 0x00: /* Block Revision Register1 (BRR1) is Readonly */ break; ca... |
1 | static int decode_header(MPADecodeContext *s, uint32_t header){ int sample_rate, frame_size, mpeg25, padding; int sample_rate_index, bitrate_index; if (header & (1<<20)) { s->lsf = (header & (1<<19)) ? 0 : 1; mpeg25 = 0; } else { s->lsf = 1; mpeg25 = 1; } s->layer = 4 - ((header >> 17) & 3); /* extract frequency */ sam... |
1 | void HELPER(divs)(CPUM68KState *env, uint32_t word){ int32_t num; int32_t den; int32_t quot; int32_t rem; num = env->div1; den = env->div2; if (den == 0) { raise_exception(env, EXCP_DIV0); } quot = num / den; rem = num % den; env->cc_v = (word && quot != (int16_t)quot ? -1 : 0); env->cc_z = quot; env->cc_n = quot; env-... |
1 | static void dma_bdrv_cb(void *opaque, int ret){ DMAAIOCB *dbs = (DMAAIOCB *)opaque; target_phys_addr_t cur_addr, cur_len; void *mem; dbs->acb = NULL; dbs->sector_num += dbs->iov.size / 512; dma_bdrv_unmap(dbs); qemu_iovec_reset(&dbs->iov); if (dbs->sg_cur_index == dbs->sg->nsg || ret < 0) { dbs->common.cb(dbs->common.o... |
1 | static uint64_t fw_cfg_data_mem_read(void *opaque, hwaddr addr, unsigned size){ FWCfgState *s = opaque; uint8_t buf[8]; unsigned i; for (i = 0; i < size; ++i) { buf[i] = fw_cfg_read(s); } switch (size) { case 1: return buf[0]; case 2: return lduw_he_p(buf); case 4: return (uint32_t)ldl_he_p(buf); case 8: return ldq_he_... |
1 | static void test_redirector_rx(void){#ifndef _WIN32/* socketpair(PF_UNIX) which does not exist on windows */ int backend_sock[2], send_sock; char *cmdline; uint32_t ret = 0, len = 0; char send_buf[] = "Hello!!"; char sock_path0[] = "filter-redirector0.XXXXXX"; char sock_path1[] = "filter-redirector1.XXXXXX"; char *recv... |
1 | int tlb_set_page_exec(CPUState *env, target_ulong vaddr, target_phys_addr_t paddr, int prot, int is_user, int is_softmmu){ PhysPageDesc *p; unsigned long pd; unsigned int index; target_ulong address; target_phys_addr_t addend; int ret; CPUTLBEntry *te; int i; p = phys_page_find(paddr >> TARGET_PAGE_BITS); if (!p) { pd ... |
1 | static void qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len){ /* Allocate buffer for zero writes */ if (acb->flags & QED_AIOCB_ZERO) { struct iovec *iov = acb->qiov->iov; if (!iov->iov_base) { iov->iov_base = qemu_blockalign(acb->common.bs, iov->iov_len); memset(iov->iov_base, 0, iov->iov_len); } } /* ... |
1 | static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame, int line, int left, uint8_t lru[3][8]){ int x, y; int width = frame->width; int stride = frame->linesize[0]; uint8_t *dst = frame->data[0] + stride * line; for (y = 0; y < left && get_bits_left(gb) > 16; y++) { for (x = 0; x < width; x++) { dst[x * 3 + ... |
0 | static int mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ MJpegDecodeContext *s = avctx->priv_data; uint8_t *buf_end, *buf_ptr; int i, start_code; AVPicture *picture = data; *data_size = 0; /* no supplementary picture */ if (buf_size == 0) return 0; buf_ptr = buf; buf... |
1 | static void do_ext_interrupt(CPUS390XState *env){ S390CPU *cpu = s390_env_get_cpu(env); uint64_t mask, addr; LowCore *lowcore; ExtQueue *q; if (!(env->psw.mask & PSW_MASK_EXT)) { cpu_abort(CPU(cpu), "Ext int w/o ext mask\n"); } if (env->ext_index < 0 || env->ext_index > MAX_EXT_QUEUE) { cpu_abort(CPU(cpu), "Ext queue o... |
1 | static struct omap_rtc_s *omap_rtc_init(MemoryRegion *system_memory, hwaddr base, qemu_irq timerirq, qemu_irq alarmirq, omap_clk clk){ struct omap_rtc_s *s = (struct omap_rtc_s *) g_malloc0(sizeof(struct omap_rtc_s)); s->irq = timerirq; s->alarm = alarmirq; s->clk = timer_new_ms(rtc_clock, omap_rtc_tick, s); omap_rtc_r... |
1 | static void gen_mtmsrd(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG); return; } if (ctx->opcode & 0x00010000) { /* Special form that does not need any synchronisation */ TCGv t0 = tcg_temp_n... |
1 | static av_cold int svq3_decode_init(AVCodecContext *avctx){ SVQ3Context *svq3 = avctx->priv_data; H264Context *h = &svq3->h; MpegEncContext *s = &h->s; int m; unsigned char *extradata; unsigned char *extradata_end; unsigned int size; int marker_found = 0; if (ff_h264_decode_init(avctx) < 0) return -1; s->flags = avctx-... |
0 | int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; VP56Context *s = avctx->priv_data; AVFrame *const p = s->framep[VP56_FRAME_CURRENT]; int remaining_buf_size = avpkt->size; int is_alpha, av_uninit(alpha_offset); if (s->has_alpha) { if (remain... |
0 | static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOVAtom atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; int tag, len; get_be32(pb); /* version + flags */ len = mp4_read_descr(c, pb, &tag); if (tag == MP4ESDescrTag) { get_be16(pb); /* ID */ get_byte(pb); /* priority */ } else get_be16(pb); /* ID */... |
0 | av_cold int ff_nvenc_encode_close(AVCodecContext *avctx){ NVENCContext *ctx = avctx->priv_data; NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs; int i; av_frame_free(&avctx->coded_frame); if (ctx->in) { for (i = 0; i < ctx->nb_surfaces; ++i) { nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[i].in); nv->nvE... |
0 | static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list, int type){ while (list != NULL && list->packet != NULL) { if (list->packet->type == type) return list; list = list->next; } return NULL;} |
0 | static int segment_end(AVFormatContext *s, int write_trailer, int is_last){ SegmentContext *seg = s->priv_data; AVFormatContext *oc = seg->avf; int ret = 0; av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */ if (write_trailer) ret = av_write_trailer(oc); if (ret < 0) av_log(s, AV_LOG_ERROR, "Failu... |
1 | static void get_default_channel_layouts(OutputStream *ost, InputStream *ist){ char layout_name[256]; AVCodecContext *enc = ost->st->codec; AVCodecContext *dec = ist->st->codec; if (dec->channel_layout && av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) { av_get_channel_layout_string(layout_name,... |
1 | int cache_insert(PageCache *cache, uint64_t addr, const uint8_t *pdata){ CacheItem *it = NULL; g_assert(cache); g_assert(cache->page_cache); /* actual update of entry */ it = cache_get_by_addr(cache, addr); /* allocate page */ if (!it->it_data) { it->it_data = g_try_malloc(cache->page_size); if (!it->it_data) { DPRINTF... |
1 | static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps){ #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL) enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts; switch (sps->pix_fmt) { case AV_PIX_FMT_YUV420P: ... |
1 | static int sd_open(BlockDriverState *bs, const char *filename, int flags){ int ret, fd; uint32_t vid = 0; BDRVSheepdogState *s = bs->opaque; char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN]; uint32_t snapid; char *buf = NULL; strstart(filename, "sheepdog:", (const char **)&filename); QLIST_INIT(&s->inflight_aio_head);... |
1 | static void qvirtio_9p_pci_stop(QVirtIO9P *v9p){ qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc); qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev)); g_free(v9p->dev); qvirtio_9p_stop(v9p);} |
0 | static av_cold int pnm_encode_init(AVCodecContext *avctx){ avctx->coded_frame = av_frame_alloc(); if (!avctx->coded_frame) return AVERROR(ENOMEM); avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; avctx->coded_frame->key_frame = 1; return 0;} |
0 | static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform, int nb_components){ int i, mb_x, mb_y, mask; int bits= (s->bits+7)&~7; int resync_mb_y = 0; int resync_mb_x = 0; point_transform += bits - s->bits; mask = ((1 << s->bits) - 1) << point_transform; av_assert0(nb_components>=1 && n... |
0 | static void virtio_blk_dma_restart_cb(void *opaque, int running, RunState state){ VirtIOBlock *s = opaque; if (!running) { return; } if (!s->bh) { s->bh = qemu_bh_new(virtio_blk_dma_restart_bh, s); qemu_bh_schedule(s->bh); }} |
0 | int parse_debug_env(const char *name, int max, int initial){ char *debug_env = getenv(name); char *inv = NULL; int debug; if (!debug_env) { return initial; } debug = strtol(debug_env, &inv, 10); if (inv == debug_env) { return initial; } if (debug < 0 || debug > max) { fprintf(stderr, "warning: %s not in [0, %d]", name,... |
0 | static void vfio_listener_region_del(MemoryListener *listener, MemoryRegionSection *section){ VFIOContainer *container = container_of(listener, VFIOContainer, listener); hwaddr iova, end; Int128 llend, llsize; int ret; if (vfio_listener_skipped_section(section)) { trace_vfio_listener_region_del_skip( section->offset_wi... |
0 | VirtIOSCSIReq *virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq){ VirtIOSCSIReq *req; VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s; const size_t zero_skip = offsetof(VirtIOSCSIReq, vring); req = g_malloc(sizeof(*req) + vs->cdb_size); req->vq = vq; req->dev = s; qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space... |
0 | static void qemu_cpu_kick_thread(CPUState *cpu){#ifndef _WIN32 int err; err = pthread_kill(cpu->thread->thread, SIG_IPI); if (err) { fprintf(stderr, "qemu:%s: %s", __func__, strerror(err)); exit(1); }#else /* _WIN32 */ if (!qemu_cpu_is_self(cpu)) { SuspendThread(cpu->hThread); cpu_signal(0); ResumeThread(cpu->hThread);... |
0 | bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs){ BlockDriverInfo bdi; if (bs->backing_hd) { return false; } if (bdrv_get_info(bs, &bdi) == 0) { return bdi.unallocated_blocks_are_zero; } return false;} |
0 | static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features, Error **errp){ VirtIONet *n = VIRTIO_NET(vdev); NetClientState *nc = qemu_get_queue(n->nic); /* Firstly sync all virtio-net possible supported features */ features |= n->host_features; virtio_add_feature(&features, VIRTIO_NET_F_MAC); if (!pe... |
0 | PXA2xxState *pxa270_init(MemoryRegion *address_space, unsigned int sdram_size, const char *revision){ PXA2xxState *s; int i; DriveInfo *dinfo; s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState)); if (revision && strncmp(revision, "pxa27", 5)) { fprintf(stderr, "Machine requires a PXA27x processor.\n"); exit(1); } if (!r... |
0 | static gboolean pty_chr_timer(gpointer opaque){ struct CharDriverState *chr = opaque; PtyCharDriver *s = chr->opaque; if (s->connected) { goto out; } if (s->polling) { /* If we arrive here without polling being cleared due * read returning -EIO, then we are (re-)connected */ pty_chr_state(chr, 1); goto out; } /* Next p... |
0 | static void virtio_scsi_reset(VirtIODevice *vdev){ VirtIOSCSI *s = VIRTIO_SCSI(vdev); VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); if (s->ctx) { virtio_scsi_dataplane_stop(s); } s->resetting++; qbus_reset_all(&s->bus.qbus); s->resetting--; vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE; vs->cdb_size = VIRTIO_SCSI_... |
0 | int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data){ BlockDriverState *bs; int force = qdict_get_int(qdict, "force"); const char *filename = qdict_get_str(qdict, "device"); bs = bdrv_find(filename); if (!bs) { qerror_report(QERR_DEVICE_NOT_FOUND, filename); return -1; } return eject_device(mon, bs, force... |
0 | static int qxl_post_load(void *opaque, int version){ PCIQXLDevice* d = opaque; uint8_t *ram_start = d->vga.vram_ptr; QXLCommandExt *cmds; int in, out, i, newmode; dprint(d, 1, "%s: start\n", __FUNCTION__); assert(d->last_release_offset < d->vga.vram_size); if (d->last_release_offset == 0) { d->last_release = NULL; } el... |
0 | static void musicpal_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; ARMCPU *cpu; qemu_irq pic[32]; DeviceState *dev; DeviceState... |
0 | static int read_table(AVFormatContext *avctx, AVStream *st, int (*parse)(AVFormatContext *avctx, AVStream *st, const char *name, int size)){ int count, i; AVIOContext *pb = avctx->pb; avio_skip(pb, 4); count = avio_rb32(pb); avio_skip(pb, 4); for (i = 0; i < count; i++) { char name[17]; int size; avio_read(pb, name, 16... |
0 | int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f){ uint8_t buf[4096]; target_phys_addr_t dst_begin = dst_addr; size_t want, did; while (nbytes) {want = nbytes > sizeof(buf) ? sizeof(buf) : nbytes;did = fread(buf, 1, want, f);cpu_physical_memory_write_rom(dst_addr, buf, did);dst_addr += did;nbytes ... |
1 | void avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state){ int dist; elbg_data elbg_d; elbg_data *elbg = &elbg_d; int i, j, k, last_error, steps=0; int *dist_cb = av_malloc(numpoints*sizeof(int)); int *size_part = av_malloc(numCB*sizeof(int)); ... |
1 | void qmp_blockdev_change_medium(const char *device, const char *filename, bool has_format, const char *format, bool has_read_only, BlockdevChangeReadOnlyMode read_only, Error **errp){ BlockBackend *blk; BlockDriverState *medium_bs = NULL; int bdrv_flags, ret; QDict *options = NULL; Error *err = NULL; blk = blk_by_name(... |
1 | static void v9fs_link(void *opaque){ V9fsPDU *pdu = opaque; int32_t dfid, oldfid; V9fsFidState *dfidp, *oldfidp; V9fsString name; size_t offset = 7; int err = 0; v9fs_string_init(&name); err = pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name); if (err < 0) { trace_v9fs_link(pdu->tag, pdu->id, dfid, oldfid, name.... |
1 | static PCIDevice *nic_init(PCIBus * bus, NICInfo * nd, uint32_t device){ PCIEEPRO100State *d; EEPRO100State *s; logout("\n"); d = (PCIEEPRO100State *) pci_register_device(bus, nd->model, sizeof(PCIEEPRO100State), -1, NULL, NULL); s = &d->eepro100; s->device = device; s->pci_dev = &d->dev; pci_reset(s); /* Add 64 * 2 EE... |
1 | void coroutine_fn co_aio_sleep_ns(AioContext *ctx, QEMUClockType type, int64_t ns){ CoSleepCB sleep_cb = { .co = qemu_coroutine_self(), }; sleep_cb.ts = aio_timer_new(ctx, type, SCALE_NS, co_sleep_cb, &sleep_cb); timer_mod(sleep_cb.ts, qemu_clock_get_ns(type) + ns); qemu_coroutine_yield(); timer_del(sleep_cb.ts); timer... |
1 | void cpu_set_log(int log_flags){ loglevel = log_flags; if (loglevel && !logfile) { logfile = fopen(logfilename, log_append ? "a" : "w"); if (!logfile) { perror(logfilename); _exit(1); }#if !defined(CONFIG_SOFTMMU) /* must avoid mmap() usage of glibc by setting a buffer "by hand" */ { static char logfile_buf[4096]; setv... |
1 | void helper_ocbi(CPUSH4State *env, uint32_t address){ memory_content **current = &(env->movcal_backup); while (*current) {uint32_t a = (*current)->address;if ((a & ~0x1F) == (address & ~0x1F)){ memory_content *next = (*current)->next; cpu_stl_data(env, a, (*current)->value); if (next == NULL) {env->movcal_backup_tail =... |
0 | static int xmv_read_packet(AVFormatContext *s, AVPacket *pkt){ XMVDemuxContext *xmv = s->priv_data; int result; if (xmv->video.current_frame == xmv->video.frame_count) { /* No frames left in this packet, so we fetch a new one */ result = xmv_fetch_new_packet(s); if (result) return result; } if (xmv->current_stream == 0... |
1 | static void render_memory_region(FlatView *view, MemoryRegion *mr, target_phys_addr_t base, AddrRange clip){ MemoryRegion *subregion; unsigned i; target_phys_addr_t offset_in_region; uint64_t remain; uint64_t now; FlatRange fr; AddrRange tmp; base += mr->addr; tmp = addrrange_make(base, mr->size); if (!addrrange_inters... |
1 | void fw_cfg_add_i32(FWCfgState *s, uint16_t key, uint32_t value){ uint32_t *copy; copy = g_malloc(sizeof(value)); *copy = cpu_to_le32(value); fw_cfg_add_bytes(s, key, (uint8_t *)copy, sizeof(value));} |
1 | struct omap_lcd_panel_s *omap_lcdc_init(MemoryRegion *sysmem, hwaddr base, qemu_irq irq, struct omap_dma_lcd_channel_s *dma, omap_clk clk){ struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *) g_malloc0(sizeof(struct omap_lcd_panel_s)); s->irq = irq; s->dma = dma; s->sysmem = sysmem; omap_lcdc_reset(s); memory_regi... |
1 | static void virtio_crypto_free_request(VirtIOCryptoReq *req){ if (req) { if (req->flags == CRYPTODEV_BACKEND_ALG_SYM) { g_free(req->u.sym_op_info); } g_free(req); }} |
1 | void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec, int unused, int size){ if (is_exec) helper_raise_exception(EXCP_IBE); else helper_raise_exception(EXCP_DBE);} |
1 | static void qemu_aio_complete(void *opaque, int ret){ struct ioreq *ioreq = opaque; if (ret != 0) { xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n", ioreq->req.operation == BLKIF_OP_READ ? "read" : "write"); ioreq->aio_errors++; } ioreq->aio_inflight--; if (ioreq->presync) { ioreq->presync = 0; ioreq_runio_qe... |
1 | static void spapr_msi_setmsg(PCIDevice *pdev, hwaddr addr, bool msix, unsigned first_irq, unsigned req_num){ unsigned i; MSIMessage msg = { .address = addr, .data = first_irq }; if (!msix) { msi_set_message(pdev, msg); trace_spapr_pci_msi_setup(pdev->name, 0, msg.address); return; } for (i = 0; i < req_num; ++i, ++msg.... |
1 | static void spapr_reset_htab(sPAPRMachineState *spapr){ long shift; int index; shift = kvmppc_reset_htab(spapr->htab_shift); if (shift > 0) { if (shift != spapr->htab_shift) { error_setg(&error_abort, "Requested HTAB allocation failed during reset"); } /* Tell readers to update their file descriptor */ if (spapr->htab_... |
1 | void raise_irq_cpu_hotplug(void){ qemu_irq_raise(irq_cpu_hotplug);} |
1 | static void uhci_queue_free(UHCIQueue *queue){ UHCIState *s = queue->uhci; UHCIAsync *async; while (!QTAILQ_EMPTY(&queue->asyncs)) { async = QTAILQ_FIRST(&queue->asyncs); uhci_async_cancel(async); } trace_usb_uhci_queue_del(queue->token); QTAILQ_REMOVE(&s->queues, queue, next); g_free(queue);} |
0 | static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr, SBRData *ch_data, int e_a[2]){ int e, i, m; memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1])); for (e = 0; e < ch_data->bs_num_env; e++) { const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]]; uint16_t *table = ch_dat... |
1 | static void draw_mandelbrot(AVFilterContext *ctx, uint32_t *color, int linesize, int64_t pts){ MBContext *mb = ctx->priv; int x,y,i, in_cidx=0, next_cidx=0, tmp_cidx; double scale= mb->start_scale*pow(mb->end_scale/mb->start_scale, pts/mb->end_pts); int use_zyklus=0; fill_from_cache(ctx, NULL, &in_cidx, NULL, mb->start... |
1 | static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb, RMDemuxContext *rm, RMStream *vst, AVPacket *pkt, int len, int *pseq, int64_t *timestamp){ int hdr, seq, pic_num, len2, pos; int type; hdr = avio_r8(pb); len--; type = hdr >> 6; if(type != 3){ // not frame as a part of packet seq = avio_r8(pb); len... |
1 | aio_write_f(int argc, char **argv){int nr_iov, c;int pattern = 0xcd;struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));BlockDriverAIOCB *acb;while ((c = getopt(argc, argv, "CqP:")) != EOF) {switch (c) {case 'C':ctx->Cflag = 1;break;case 'q':ctx->qflag = 1;break;case 'P':pattern = atoi(optarg);break;default:return ... |
1 | static void debugcon_ioport_write(void *opaque, hwaddr addr, uint64_t val, unsigned width){ DebugconState *s = opaque; unsigned char ch = val;#ifdef DEBUG_DEBUGCON printf(" [debugcon: write addr=0x%04" HWADDR_PRIx " val=0x%02" PRIx64 "]\n", addr, val);#endif qemu_chr_fe_write(s->chr, &ch, 1);} |
1 | static void nal_send(AVFormatContext *s1, const uint8_t *buf, int size, int last){ RTPMuxContext *s = s1->priv_data; av_log(s1, AV_LOG_DEBUG, "Sending NAL %x of len %d M=%d\n", buf[0] & 0x1F, size, last); if (size <= s->max_payload_size) { int buffered_size = s->buf_ptr - s->buf; // Flush buffered NAL units if the curr... |
1 | static av_always_inline int vmnc_get_pixel(const uint8_t *buf, int bpp, int be){ switch (bpp * 2 + be) { case 2: case 3: return *buf; case 4: return AV_RL16(buf); case 5: return AV_RB16(buf); case 8: return AV_RL32(buf); case 9: return AV_RB32(buf); default: return 0; }} |
1 | static void test_wait_event_notifier(void){ EventNotifierTestData data = { .n = 0, .active = 1 }; event_notifier_init(&data.e, false); aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb); g_assert(aio_poll(ctx, false)); g_assert_cmpint(data.n, ==, 0); g_assert_cmpint(data.active, ==, 1); event_notifie... |
1 | target_ulong helper_rdhwr_synci_step(CPUMIPSState *env){ check_hwrena(env, 1); return env->SYNCI_Step;} |
1 | static int get_moov_size(AVFormatContext *s){ int ret; AVIOContext *moov_buf; MOVMuxContext *mov = s->priv_data; if ((ret = ffio_open_null_buf(&moov_buf)) < 0) return ret; mov_write_moov_tag(moov_buf, mov, s); return ffio_close_null_buf(moov_buf);} |
1 | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg){ MpegEncContext *s = &v->s; uint8_t *srcY; int dxy, mx, my, src_x, src_y; int off; int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0; int v_edge_pos = s->v_edge_pos >> v->field_mode; uint8_t (*luty)[256]; int use_ic; if ((!v... |
1 | static int recover(WtvContext *wtv, uint64_t broken_pos){ AVIOContext *pb = wtv->pb; int i; for (i = 0; i < wtv->nb_index_entries; i++) { if (wtv->index_entries[i].pos > broken_pos) { int ret = avio_seek(pb, wtv->index_entries[i].pos, SEEK_SET); if (ret < 0) return ret; wtv->pts = wtv->index_entries[i].timestamp; retur... |
1 | static always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h){ uint8_t *ptr_y, *ptr_cb, *ptr_cr; int mx, my, src_x, src_y, uv... |
1 | static void qxl_reset_state(PCIQXLDevice *d){ QXLRam *ram = d->ram; QXLRom *rom = d->rom; assert(SPICE_RING_IS_EMPTY(&ram->cmd_ring)); assert(SPICE_RING_IS_EMPTY(&ram->cursor_ring)); d->shadow_rom.update_id = cpu_to_le32(0); *rom = d->shadow_rom; qxl_rom_set_dirty(d); init_qxl_ram(d); d->num_free_res = 0; d->last_relea... |
1 | static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){ int i, si, di; uint8_t *dst; int bufidx;// src[0]&0x80; //forbidden bit h->nal_ref_idc= src[0]>>5; h->nal_unit_type= src[0]&0x1F; src++; length--;#if 0 for(i=0; i<length; i++) printf("%2X ", src[i]);#endif ... |
1 | static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp){ CPUState *cs = CPU(cpu); CPUPPCState *env = &cpu->env; target_ulong msr, new_msr, vector; int srr0, srr1, asrr0, asrr1; int lpes0, lpes1, lev, ail; if (0) { /* XXX: find a suitable condition to enable the hypervisor mode */ lpes0 = (env->spr[SP... |
1 | static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp, uint64_t off, uint32_t count, struct iovec *sg, int cnt){ int i, to_copy; ssize_t err = 0; int write_count; int64_t xattr_len; size_t offset = 7; xattr_len = fidp->fs.xattr.len; write_count = xattr_len - off; if (write_count > count) { write_co... |
1 | static void test_retry_flush(const char *machine){ QPCIDevice *dev; void *bmdma_base, *ide_base; uint8_t data; const char *s; prepare_blkdebug_script(debug_path, "flush_to_disk"); ide_test_start( "-vnc none " "-drive file=blkdebug:%s:%s,if=ide,cache=writeback,format=raw," "rerror=stop,werror=stop", debug_path, tmp_path... |
1 | static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ GetBitContext gb; HuffContext h[4]; VLC vlc[4]; int16_t *samples = data; int val; int i, res; int unp_size; int bits, stereo; int pred[2] = {0, 0}; unp_size = AV_RL32(buf); init_get_bits(&gb, buf + 4, (buf_size ... |
1 | void do_brinc (void){ uint32_t a, b, d, mask; mask = (uint32_t)(-1UL) >> MASKBITS; b = T1_64 & mask; a = T0_64 & mask; d = word_reverse(1 + word_reverse(a | ~mask)); T0_64 = (T0_64 & ~mask) | (d & mask);} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.