label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static BlockDriverState *get_bs_snapshots(void){ BlockDriverState *bs; DriveInfo *dinfo; if (bs_snapshots) return bs_snapshots; QTAILQ_FOREACH(dinfo, &drives, next) { bs = dinfo->bdrv; if (bdrv_can_snapshot(bs)) goto ok; } return NULL; ok: bs_snapshots = bs; return bs;} |
1 | opts_visitor_new(const QemuOpts *opts){ OptsVisitor *ov; ov = g_malloc0(sizeof *ov); ov->visitor.type = VISITOR_INPUT; ov->visitor.start_struct = &opts_start_struct; ov->visitor.check_struct = &opts_check_struct; ov->visitor.end_struct = &opts_end_struct; ov->visitor.start_list = &opts_start_list; ov->visitor.next_list... |
1 | size_t qcrypto_hash_digest_len(QCryptoHashAlgorithm alg){ if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) { return 0; } return qcrypto_hash_alg_size[alg];} |
1 | int read_targphys(const char *name, int fd, target_phys_addr_t dst_addr, size_t nbytes){ uint8_t *buf; size_t did; buf = g_malloc(nbytes); did = read(fd, buf, nbytes); if (did > 0) rom_add_blob_fixed("read", buf, did, dst_addr); g_free(buf); return did;} |
0 | static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, int width){#ifdef HAVE_MMXFIXME#elseint i;for(i=0; i<width; i++)dst[i]= src[2*i];#endif} |
0 | static av_cold int source_init(AVFilterContext *ctx, const char *args, void *opaque){ Frei0rContext *frei0r = ctx->priv; char dl_name[1024], c; char frame_size[128] = ""; char frame_rate[128] = ""; AVRational frame_rate_q; memset(frei0r->params, 0, sizeof(frei0r->params)); if (args) sscanf(args, "%127[^:]:%127[^:]:%102... |
1 | static void dash_free(AVFormatContext *s){ DASHContext *c = s->priv_data; int i, j; if (c->as) { for (i = 0; i < c->nb_as; i++) av_dict_free(&c->as[i].metadata); av_freep(&c->as); c->nb_as = 0; } if (!c->streams) return; for (i = 0; i < s->nb_streams; i++) { OutputStream *os = &c->streams[i]; if (os->ctx && os->ctx_ini... |
1 | static void decode_bo_addrmode_post_pre_base(CPUTriCoreState *env, DisasContext *ctx){ uint32_t op2; uint32_t off10; int32_t r1, r2; TCGv temp; r1 = MASK_OP_BO_S1D(ctx->opcode); r2 = MASK_OP_BO_S2(ctx->opcode); off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode); op2 = MASK_OP_BO_OP2(ctx->opcode); switch (op2) { case OPC2_32_BO... |
1 | void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p){ if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) { ByteIOContext pb; RTSPState *rt = s->priv_data; int len = strlen(p) * 6 / 8; char *buf = av_mallocz(len); av_base64_decode(buf, p, len); if (rtp_asf_fix_header(buf, len) < 0)... |
1 | static int dtext_prepare_text(AVFilterContext *ctx){ DrawTextContext *dtext = ctx->priv; uint32_t code = 0, prev_code = 0; int x = 0, y = 0, i = 0, ret; int text_height, baseline; char *text = dtext->text; uint8_t *p; int str_w = 0, len; int y_min = 32000, y_max = -32000; FT_Vector delta; Glyph *glyph = NULL, *prev_gly... |
1 | static int vsink_query_formats(AVFilterContext *ctx){ BufferSinkContext *buf = ctx->priv; AVFilterFormats *formats = NULL; unsigned i; int ret; CHECK_LIST_SIZE(pixel_fmts) if (buf->pixel_fmts_size) { for (i = 0; i < NB_ITEMS(buf->pixel_fmts); i++) if ((ret = ff_add_format(&formats, buf->pixel_fmts[i])) < 0) return ret;... |
0 | static int poll_filters(void){ AVFilterBufferRef *picref; AVFrame *filtered_frame = NULL; int i, frame_size; for (i = 0; i < nb_output_streams; i++) { OutputStream *ost = output_streams[i]; OutputFile *of = output_files[ost->file_index]; int ret = 0; if (!ost->filter) continue; if (!ost->filtered_frame && !(ost->filter... |
0 | static int file_read_dir(URLContext *h, AVIODirEntry **next){#if HAVE_DIRENT_H FileContext *c = h->priv_data; struct dirent *dir; char *fullpath = NULL; *next = ff_alloc_dir_entry(); if (!*next) return AVERROR(ENOMEM); do { errno = 0; dir = readdir(c->dir); if (!dir) { av_freep(next); return AVERROR(errno); } } while (... |
1 | static void monitor_qmp_event(void *opaque, int event){ QObject *data; Monitor *mon = opaque; switch (event) { case CHR_EVENT_OPENED: mon->qmp.in_command_mode = false; data = get_qmp_greeting(); monitor_json_emitter(mon, data); qobject_decref(data); mon_refcount++; break; case CHR_EVENT_CLOSED: json_message_parser_dest... |
1 | void add_user_command(char *optarg){ ncmdline++; cmdline = realloc(cmdline, ncmdline * sizeof(char *)); if (!cmdline) { perror("realloc"); exit(1); } cmdline[ncmdline-1] = optarg;} |
0 | static void check_update_timer(RTCState *s){ uint64_t next_update_time; uint64_t guest_nsec; int next_alarm_sec; /* From the data sheet: "Holding the dividers in reset prevents * interrupts from operating, while setting the SET bit allows" * them to occur. However, it will prevent an alarm interrupt * from occurring, b... |
0 | int main(int argc, char **argv){ TestInputVisitorData testdata; g_test_init(&argc, &argv, NULL); validate_test_add("/visitor/input-strict/pass/struct", &testdata, test_validate_struct); validate_test_add("/visitor/input-strict/pass/struct-nested", &testdata, test_validate_struct_nested); validate_test_add("/visitor/inp... |
0 | void slirp_select_fill(int *pnfds, fd_set *readfds, fd_set *writefds, fd_set *xfds){ Slirp *slirp; struct socket *so, *so_next; int nfds; if (QTAILQ_EMPTY(&slirp_instances)) { return; } /* fail safe */ global_readfds = NULL; global_writefds = NULL; global_xfds = NULL; nfds = *pnfds; /* * First, TCP sockets */ do_slowti... |
0 | static void test_validate_qmp_introspect(TestInputVisitorData *data, const void *unused){ do_test_validate_qmp_introspect(data, test_qmp_schema_json); do_test_validate_qmp_introspect(data, qmp_schema_json);} |
0 | static void dump_receive(void *opaque, const uint8_t *buf, size_t size){ DumpState *s = opaque; struct pcap_sf_pkthdr hdr; int64_t ts; int caplen; /* Early return in case of previous error. */ if (s->fd < 0) { return; } ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec); caplen = size > s->pcap_caplen ? s-... |
0 | void OPPROTO op_mov_T0_cc(void){ T0 = cc_table[CC_OP].compute_all();} |
0 | static int alsa_run_in (HWVoiceIn *hw){ ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; int hwshift = hw->info.shift; int i; int live = audio_pcm_hw_get_live_in (hw); int dead = hw->samples - live; int decr; struct { int add; int len; } bufs[2] = { { hw->wpos, 0 }, { 0, 0 } }; snd_pcm_sframes_t avail; snd_pcm_uframes_t read_sa... |
0 | static void do_change(int argc, const char **argv){ BlockDriverState *bs; if (argc != 3) { help_cmd(argv[0]); return; } bs = bdrv_find(argv[1]); if (!bs) { term_printf("device not found\n"); return; } if (eject_device(bs, 0) < 0) return; bdrv_open(bs, argv[2], 0);} |
0 | static void opt_qscale(const char *arg){ video_qscale = atof(arg); if (video_qscale <= 0 || video_qscale > 255) { fprintf(stderr, "qscale must be > 0.0 and <= 255\n"); ffmpeg_exit(1); }} |
0 | static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){ int i, ret= -1; int av_unused mm_flags = av_get_cpu_flags(); int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 && (mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MM... |
0 | static bool run_poll_handlers(AioContext *ctx, int64_t max_ns){ bool progress; int64_t end_time; assert(ctx->notify_me); assert(qemu_lockcnt_count(&ctx->list_lock) > 0); assert(ctx->poll_disable_cnt == 0); trace_run_poll_handlers_begin(ctx, max_ns); end_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + max_ns; do { progr... |
0 | static CharDriverState *qemu_chr_open_win_con(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp){ return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));} |
0 | void qmp_nbd_server_start(SocketAddress *addr, bool has_tls_creds, const char *tls_creds, Error **errp){ if (nbd_server) { error_setg(errp, "NBD server already running"); return; } nbd_server = g_new0(NBDServerData, 1); nbd_server->watch = -1; nbd_server->listen_ioc = qio_channel_socket_new(); qio_channel_set_name(QIO_... |
0 | int v9fs_co_mkdir(V9fsState *s, char *name, mode_t mode, uid_t uid, gid_t gid){ int err; FsCred cred; cred_init(&cred); cred.fc_mode = mode; cred.fc_uid = uid; cred.fc_gid = gid; v9fs_co_run_in_worker( { err = s->ops->mkdir(&s->ctx, name, &cred); if (err < 0) { err = -errno; } }); return err;} |
0 | static uint32_t nam_readw (void *opaque, uint32_t addr){ PCIAC97LinkState *d = opaque; AC97LinkState *s = &d->ac97; uint32_t val = ~0U; uint32_t index = addr - s->base[0]; s->cas = 0; val = mixer_load (s, index); return val;} |
0 | static uint32_t virtio_net_bad_features(VirtIODevice *vdev){ uint32_t features = 0; /* Linux kernel 2.6.25. It understood MAC (as everyone must), * but also these: */ features |= (1 << VIRTIO_NET_F_MAC); features |= (1 << VIRTIO_NET_F_CSUM); features |= (1 << VIRTIO_NET_F_HOST_TSO4); features |= (1 << VIRTIO_NET_F_HOST... |
0 | void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp){ int64_t value; if (v->type_uint16) { v->type_uint16(v, obj, name, errp); } else { value = *obj; v->type_int64(v, &value, name, errp); if (value < 0 || value > UINT16_MAX) { /* FIXME questionable reuse of errp if callback changed value on... |
1 | static int try_decode_frame(AVStream *st, AVPacket *avpkt){ int16_t *samples; AVCodec *codec; int got_picture, data_size, ret=0; AVFrame picture; if(!st->codec->codec){ codec = avcodec_find_decoder(st->codec->codec_id); if (!codec) return -1; ret = avcodec_open(st->codec, codec); if (ret < 0) return ret; } if(!has_code... |
1 | int s390_virtio_hypercall(CPUS390XState *env){ s390_virtio_fn fn = s390_diag500_table[env->regs[1]]; if (!fn) { return -EINVAL; } return fn(&env->regs[2]);} |
1 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt){ int ret; *got_picture_ptr= 0; if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx)) return -1; if((avctx->codec->capabilities &... |
1 | void qemu_thread_create(QemuThread *thread, const char *name, void *(*start_routine)(void*), void *arg, int mode){ sigset_t set, oldset; int err; pthread_attr_t attr; err = pthread_attr_init(&attr); if (err) { error_exit(err, __func__); } if (mode == QEMU_THREAD_DETACHED) { err = pthread_attr_setdetachstate(&attr, PTHR... |
1 | static inline void vmsvga_fill_rect(struct vmsvga_state_s *s, uint32_t c, int x, int y, int w, int h){ DisplaySurface *surface = qemu_console_surface(s->vga.con); int bypl = surface_stride(surface); int width = surface_bytes_per_pixel(surface) * w; int line = h; int column; uint8_t *fst; uint8_t *dst; uint8_t *src; uin... |
1 | static void IMLT(float *pInput, float *pOutput, int odd_band){ int i; if (odd_band) { /** * Reverse the odd bands before IMDCT, this is an effect of the QMF transform * or it gives better compression to do it this way. * FIXME: It should be possible to handle this in ff_imdct_calc * for that to happen a modification of... |
1 | void op_div (void){ if (T1 != 0) { env->LO = (int32_t)((int32_t)T0 / (int32_t)T1); env->HI = (int32_t)((int32_t)T0 % (int32_t)T1); } RETURN();} |
1 | static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size){ AVIOContext *pb = s->pb; mxf_write_generic_desc(s, st, key, size+5+12+8+8); // audio locked mxf_write_local_tag(pb, 1, 0x3D02); avio_w8(pb, 1); // write audio sampling rate mxf_write_local_tag(pb, 8, 0x3D03); avi... |
1 | static void mpeg_decode_quant_matrix_extension(MpegEncContext *s){ int i, v, j; dprintf("matrix extension\n"); if (get_bits1(&s->gb)) { for(i=0;i<64;i++) { v = get_bits(&s->gb, 8); j = zigzag_direct[i]; s->intra_matrix[j] = v; s->chroma_intra_matrix[j] = v; } } if (get_bits1(&s->gb)) { for(i=0;i<64;i++) { v = get_bits(... |
1 | uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b){ uint64_t tmp; uint64_t result; DO_ABD(result, a, b, int8_t); DO_ABD(tmp, a >> 8, b >> 8, int8_t); result |= tmp << 16; DO_ABD(tmp, a >> 16, b >> 16, int8_t); result |= tmp << 32; DO_ABD(tmp, a >> 24, b >> 24, int8_t); result |= tmp << 48; return result;} |
1 | int pcie_cap_v1_init(PCIDevice *dev, uint8_t offset, uint8_t type, uint8_t port){ /* PCIe cap v1 init */ int pos; uint8_t *exp_cap; assert(pci_is_express(dev)); pos = pci_add_capability(dev, PCI_CAP_ID_EXP, offset, PCI_EXP_VER1_SIZEOF); if (pos < 0) { return pos; } dev->exp.exp_cap = pos; exp_cap = dev->config + pos; p... |
0 | static int oggvorbis_encode_frame(AVCodecContext *avctx, unsigned char *packets, int buf_size, void *data){ OggVorbisContext *s = avctx->priv_data; ogg_packet op; float *audio = data; int pkt_size; /* send samples to libvorbis */ if (data) { const int samples = avctx->frame_size; float **buffer; int c, channels = s->vi... |
0 | static void av_always_inline filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) { const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8); const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset; const int alpha = alpha_table[index_a]; const i... |
1 | static void v9fs_getlock(void *opaque){ size_t offset = 7; struct stat stbuf; V9fsFidState *fidp; V9fsGetlock *glock; int32_t fid, err = 0; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; glock = g_malloc(sizeof(*glock)); pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type, &glock->start, &glock->length, &glock->proc... |
1 | static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *out){ BitstreamContext bc; VP9BSFContext *s = ctx->priv_data; AVPacket *in; int res, invisible, profile, marker, uses_superframe_syntax = 0, n; res = ff_bsf_get_packet(ctx, &in); if (res < 0) return res; marker = in->data[in->size - 1]; if ((marker & 0xe0) =... |
1 | static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy, int n, bool assign, bool set_handler){ VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); VirtQueue *vq = virtio_get_queue(vdev, n); EventNotifier *notifier = virtio_queue_get_host_notifier(vq); int r = 0; if (assign) { r = event_notifier_ini... |
0 | static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride){ int x,y; dst[0]= src[0]; // first line for (x=0; x<srcWidth-1; x++) { dst[2*x+1]= (3*src[x] + src[x+1])>>2; dst[2*x+2]= ( src[x] + 3*src[x+1])>>2; } dst[2*srcWidth-1]= src[srcWidth-1]; dst+=... |
0 | int64_t avio_seek(AVIOContext *s, int64_t offset, int whence){ int64_t offset1; int64_t pos; int force = whence & AVSEEK_FORCE; whence &= ~AVSEEK_FORCE; if(!s) return AVERROR(EINVAL); pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); if (whence != SEEK_CUR && whence != SEEK_SET) return AVERROR(EINVAL); if ... |
1 | static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp){ const char *name = opaque; const char *driver, *netdev; const char virtio_name[] = "virtio-net-"; driver = qemu_opt_get(opts, "driver"); netdev = qemu_opt_get(opts, "netdev"); if (!driver || !netdev) { return 0; } if (strcmp(netdev, name) == 0 ... |
1 | static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe){ return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;} |
1 | static int mxf_read_generic_descriptor(MXFDescriptor *descriptor, ByteIOContext *pb, int tag, int size, UID uid){ switch(tag) { case 0x3F01: descriptor->sub_descriptors_count = get_be32(pb); if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID)) return -1; descriptor->sub_descriptors_refs = av_malloc(descript... |
1 | static void spapr_vio_busdev_realize(DeviceState *qdev, Error **errp){ sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev; VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); char *id; if (dev->reg != -1) { /* * Explicitly assigned address, just verify that... |
1 | static int tta_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; TTAContext *s = avctx->priv_data; int i, ret; int cur_chan = 0, framelen = s->frame_length; int32_t *p; init_get_bits(&s->gb, buf, buf_size*8); // FIXME: see... |
1 | uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr){ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); uint32_t val; k->get_config(vdev, vdev->config); if (addr > (vdev->config_len - sizeof(val))) return (uint32_t)-1; val = ldl_p(vdev->config + addr); return val;} |
1 | static uint8_t *disas_insn(DisasContext *s, uint8_t *pc_start){ int b, prefixes, aflag, dflag; int shift, ot; int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val; unsigned int next_eip; s->pc = pc_start; prefixes = 0; aflag = s->code32; dflag = s->code32; s->override = -1; next_byte: b = ldub_code(s->pc); s-... |
1 | static void ogg_write_pages(AVFormatContext *s, int flush){ OGGContext *ogg = s->priv_data; OGGPageList *next, *p; if (!ogg->page_list) return; for (p = ogg->page_list; p; ) { OGGStreamContext *oggstream = s->streams[p->page.stream_index]->priv_data; if (oggstream->page_count < 2 && !flush) break; ogg_write_page(s, &p-... |
1 | static void get_lag(float *buf, const float *new, LongTermPrediction *ltp){ int i, j, lag, max_corr = 0; float max_ratio; for (i = 0; i < 2048; i++) { float corr, s0 = 0.0f, s1 = 0.0f; const int start = FFMAX(0, i - 1024); for (j = start; j < 2048; j++) { const int idx = j - i + 1024; s0 += new[j]*buf[idx]; s1 += buf[i... |
1 | static void memory_region_dispatch_write(MemoryRegion *mr, hwaddr addr, uint64_t data, unsigned size){ if (!memory_region_access_valid(mr, addr, size, true)) { return; /* FIXME: better signalling */ } adjust_endianness(mr, &data, size); if (!mr->ops->write) { mr->ops->old_mmio.write[bitops_ffsl(size)](mr->opaque, addr,... |
1 | int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data){ const char *id = qdict_get_str(qdict, "id"); BlockDriverState *bs; BlockDriverState **ptr; Property *prop; bs = bdrv_find(id); if (!bs) { qerror_report(QERR_DEVICE_NOT_FOUND, id); return -1; } if (bdrv_in_use(bs)) { qerror_report(QERR_DEVICE_IN_USE... |
1 | void error_setg_file_open(Error **errp, int os_errno, const char *filename){ error_setg_errno(errp, os_errno, "Could not open '%s'", filename);} |
1 | int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header){ uint8_t rps_predict = 0; int delta_poc; int k0 = 0; int k1 = 0; int k = 0; int i; if (rps != sps->st_rps && sps->nb_st_rps) rps_predict = get_bits1(gb); if (rps_predict) { const Short... |
1 | static int qcow_check(BlockDriverState *bs){ return qcow2_check_refcounts(bs);} |
0 | static void pl061_save(QEMUFile *f, void *opaque){ pl061_state *s = (pl061_state *)opaque; qemu_put_be32(f, s->locked); qemu_put_be32(f, s->data); qemu_put_be32(f, s->old_data); qemu_put_be32(f, s->dir); qemu_put_be32(f, s->isense); qemu_put_be32(f, s->ibe); qemu_put_be32(f, s->iev); qemu_put_be32(f, s->im); qemu_put_b... |
0 | void cpu_reset(CPUSPARCState *env){ tlb_flush(env, 1); env->cwp = 0; env->wim = 1; env->regwptr = env->regbase + (env->cwp * 16);#if defined(CONFIG_USER_ONLY) env->user_mode_only = 1;#ifdef TARGET_SPARC64 env->cleanwin = env->nwindows - 2; env->cansave = env->nwindows - 2; env->pstate = PS_RMO | PS_PEF | PS_IE; env->as... |
0 | static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds, bool err){ GMainContext *context = g_main_context_default(); if (!err) { int i; for (i = 0; i < n_poll_fds; i++) { GPollFD *p = &poll_fds[i]; if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) { p->revents |= G_IO_IN; } if ((p->events & G_IO_OUT) &... |
0 | static void set_lcd_pixel(musicpal_lcd_state *s, int x, int y, int col){ int dx, dy; for (dy = 0; dy < 3; dy++) for (dx = 0; dx < 3; dx++) { s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 0] = scale_lcd_color(col); s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 1] = scale_lcd_color(col >> 8); s->ds->data[(x*3 + d... |
0 | static inline uint32_t celt_icwrsi(uint32_t N, const int *y){ int i, idx = 0, sum = 0; for (i = N - 1; i >= 0; i--) { const uint32_t i_s = CELT_PVQ_U(N - i, sum + FFABS(y[i]) + 1); idx += CELT_PVQ_U(N - i, sum) + (y[i] < 0)*i_s; sum += FFABS(y[i]); } return idx;} |
0 | static void test_qemu_strtoul_hex(void){ const char *str = "0123"; char f = 'X'; const char *endptr = &f; unsigned long res = 999; int err; err = qemu_strtoul(str, &endptr, 16, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, 0x123); g_assert(endptr == str + strlen(str)); str = "0x123"; res = 999; endptr = ... |
0 | static void mvp_init (CPUMIPSState *env, const mips_def_t *def){ env->mvp = qemu_mallocz(sizeof(CPUMIPSMVPContext)); /* MVPConf1 implemented, TLB sharable, no gating storage support, programmable cache partitioning implemented, number of allocatable and sharable TLB entries, MVP has allocatable TCs, 2 VPEs implemented,... |
0 | static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp){ PCIHostState *h = PCI_HOST_BRIDGE(obj); Range w64; pci_bus_get_w64_range(h->bus, &w64); visit_type_uint64(v, name, &w64.begin, errp);} |
0 | static void spapr_phb_remove_pci_device(sPAPRDRConnector *drc, sPAPRPHBState *phb, PCIDevice *pdev, Error **errp){ sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); drck->detach(drc, DEVICE(pdev), spapr_phb_remove_pci_device_cb, phb, errp);} |
0 | static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, const char *desc_file_path, Error **errp){ int ret; char access[11]; char type[11]; char fname[512]; const char *p = desc; int64_t sectors = 0; int64_t flat_offset; char extent_path[PATH_MAX]; BlockDriverState *extent_file; BDRVVmdkState *s = bs->opa... |
0 | void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs){ bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);} |
0 | int kvmppc_put_books_sregs(PowerPCCPU *cpu){ CPUPPCState *env = &cpu->env; struct kvm_sregs sregs; int i; sregs.pvr = env->spr[SPR_PVR]; sregs.u.s.sdr1 = env->spr[SPR_SDR1]; /* Sync SLB */#ifdef TARGET_PPC64 for (i = 0; i < ARRAY_SIZE(env->slb); i++) { sregs.u.s.ppc64.slb[i].slbe = env->slb[i].esid; if (env->slb[i].esi... |
0 | static void gen_brcond(DisasContext *dc, TCGCond cond, TCGv_i32 t0, TCGv_i32 t1, uint32_t offset){ int label = gen_new_label(); gen_advance_ccount(dc); tcg_gen_brcond_i32(cond, t0, t1, label); gen_jumpi_check_loop_end(dc, 0); gen_set_label(label); gen_jumpi(dc, dc->pc + offset, 1);} |
0 | static bool net_tx_pkt_rebuild_payload(struct NetTxPkt *pkt){ size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len; pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG], pkt->max_payload_frags, pkt->raw, pkt->raw_frags, pkt->hdr_len, payload_len); if (pkt->payload_frags != (uint32_t) -1) ... |
0 | static void omap_pin_cfg_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; uint32_t diff; if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } switch (addr) { case 0x00:/* FUNC_MUX_CTRL_0 */ diff = s->func_mux_c... |
0 | static USBDevice *usb_serial_init(USBBus *bus, const char *filename){ USBDevice *dev; Chardev *cdrv; char label[32]; static int index; while (*filename && *filename != ':') { const char *p; if (strstart(filename, "vendorid=", &p)) { error_report("vendorid is not supported anymore"); return NULL; } else if (strstart(fil... |
0 | static void virtio_ccw_notify(DeviceState *d, uint16_t vector){ VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d); SubchDev *sch = dev->sch; uint64_t indicators; if (vector >= 128) { return; } if (vector < VIRTIO_PCI_QUEUE_MAX) { if (!dev->indicators) { return; } if (sch->thinint_active) { /* * In the adapter interrupt ... |
0 | void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector){ CPUX86State *saved_env; saved_env = env; env = s; if (env->eflags & VM_MASK) { SegmentCache *sc; selector &= 0xffff; sc = &env->seg_cache[seg_reg]; /* NOTE: in VM86 mode, limit and seg_32bit are never reloaded, so we must load them here */ sc->base = (vo... |
0 | static char *sysbus_get_fw_dev_path(DeviceState *dev){ SysBusDevice *s = sysbus_from_qdev(dev); char path[40]; int off; off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev)); if (s->num_mmio) { snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx, s->mmio[0].addr); } else if (s->num_pio) { snprintf(path + o... |
0 | void hmp_info_memory_devices(Monitor *mon, const QDict *qdict){ Error *err = NULL; MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err); MemoryDeviceInfoList *info; MemoryDeviceInfo *value; PCDIMMDeviceInfo *di; for (info = info_list; info; info = info->next) { value = info->value; if (value) { switch (valu... |
0 | static void v9fs_synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off){ V9fsSynthOpenState *synth_open = fs->private; synth_open->offset = off;} |
0 | static struct vm_area_struct *vma_first(const struct mm_struct *mm){ return (TAILQ_FIRST(&mm->mm_mmap));} |
0 | static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr){ DNXHDEncContext *ctx = avctx->priv_data; int mb_y = jobnr, mb_x; ctx = ctx->thread[threadnr]; if (ctx->cid_table->bit_depth == 8) { uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y<<4) * ctx->m.linesize); for (mb_x = 0; mb_x < ctx-... |
0 | static void xan_wc3_decode_frame(XanContext *s) { int width = s->avctx->width; int height = s->avctx->height; int total_pixels = width * height; unsigned char opcode; unsigned char flag = 0; int size = 0; int motion_x, motion_y; int x, y; unsigned char *opcode_buffer = s->buffer1; int opcode_buffer_size = s->buffer1_si... |
0 | static void qmp_input_start_alternate(Visitor *v, const char *name, GenericAlternate **obj, size_t size, bool promote_int, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, false, errp); if (!qobj) { *obj = NULL; return; } *obj = g_malloc0(size); (*obj)->type = qobject_typ... |
0 | static void ac97_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ MilkymistAC97State *s = opaque; trace_milkymist_ac97_memory_write(addr, value); addr >>= 2; switch (addr) { case R_AC97_CTRL: /* always raise an IRQ according to the direction */ if (value & AC97_CTRL_RQEN) { if (value & AC97_... |
0 | static void mch_realize(PCIDevice *d, Error **errp){ int i; MCHPCIState *mch = MCH_PCI_DEVICE(d); /* setup pci memory mapping */ pc_pci_as_mapping_init(OBJECT(mch), mch->system_memory, mch->pci_address_space); /* if *disabled* show SMRAM to all CPUs */ memory_region_init_alias(&mch->smram_region, OBJECT(mch), "smram-re... |
0 | static void arm_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu){ DisasContext *dc = container_of(dcbase, DisasContext, base); CPUARMState *env = cpu->env_ptr;#ifdef CONFIG_USER_ONLY /* Intercept jump to the magic kernel page. */ if (dc->pc >= 0xffff0000) { /* We always get here via a jump, so know we are not... |
0 | void ppc_tlb_invalidate_one(CPUPPCState *env, target_ulong addr){#if !defined(FLUSH_ALL_TLBS) PowerPCCPU *cpu = ppc_env_get_cpu(env); CPUState *cs; addr &= TARGET_PAGE_MASK; switch (env->mmu_model) { case POWERPC_MMU_SOFT_6xx: case POWERPC_MMU_SOFT_74xx: ppc6xx_tlb_invalidate_virt(env, addr, 0); if (env->id_tlbs == 1) ... |
0 | static int scsi_qdev_init(DeviceState *qdev){ SCSIDevice *dev = SCSI_DEVICE(qdev); SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus); SCSIDevice *d; int rc = -1; if (dev->channel > bus->info->max_channel) { error_report("bad scsi channel id: %d", dev->channel); goto err; } if (dev->id != -1 && dev->id > bus... |
0 | static BusState *qbus_find_recursive(BusState *bus, const char *name, const BusInfo *info){ DeviceState *dev; BusState *child, *ret; int match = 1; if (name && (strcmp(bus->name, name) != 0)) { match = 0; } if (info && (bus->info != info)) { match = 0; } if (match) { return bus; } LIST_FOREACH(dev, &bus->children, sibl... |
0 | static void dump_metadata(void *ctx, AVDictionary *m, const char *indent){ if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){ AVDictionaryEntry *tag=NULL; av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent); while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) { if(strcmp("language", tag->key)){ con... |
0 | X86CPU *cpu_x86_create(const char *cpu_model, Error **errp){ X86CPU *cpu = NULL; ObjectClass *oc; CPUClass *cc; gchar **model_pieces; char *name, *features; Error *error = NULL; const char *typename; model_pieces = g_strsplit(cpu_model, ",", 2); if (!model_pieces[0]) { error_setg(&error, "Invalid/empty CPU model name")... |
0 | static QEMUClock *qemu_new_clock(int type){ QEMUClock *clock; clock = g_malloc0(sizeof(QEMUClock)); clock->type = type; clock->enabled = true; clock->last = INT64_MIN; notifier_list_init(&clock->reset_notifiers); return clock;} |
0 | static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing, gpointer opaque){ VirtualConsole *vc = opaque; GtkDisplayState *s = vc->s; if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) { gd_grab_keyboard(vc); } return TRUE;} |
0 | sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum){ BDRVSheepdogState *s = bs->opaque; SheepdogInode *inode = &s->inode; uint32_t object_size = (UINT32_C(1) << inode->block_size_shift); uint64_t offset = sector_num * BDRV_SECTOR_SIZE; unsigned long start = offset / object_size, ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.