label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void parse_presentation_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size){ PGSSubContext *ctx = avctx->priv_data; int x, y; int w = bytestream_get_be16(&buf); int h = bytestream_get_be16(&buf); av_dlog(avctx, "Video Dimensions %dx%d\n", w, h); if (av_image_check_size(w, h, 0, avctx) >= 0) avcodec_... |
1 | void virtio_init(VirtIODevice *vdev, const char *name, uint16_t device_id, size_t config_size){ BusState *qbus = qdev_get_parent_bus(DEVICE(vdev)); VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus); int i; int nvectors = k->query_nvectors ? k->query_nvectors(qbus->parent) : 0; if (nvectors) { vdev->vector_queues = g_mallo... |
1 | static int mon_init_func(QemuOpts *opts, void *opaque){ CharDriverState *chr; const char *chardev; const char *mode; int flags; mode = qemu_opt_get(opts, "mode"); if (mode == NULL) { mode = "readline"; } if (strcmp(mode, "readline") == 0) { flags = MONITOR_USE_READLINE; } else if (strcmp(mode, "control") == 0) { flags ... |
1 | void ga_unset_frozen(GAState *s){ if (!ga_is_frozen(s)) { return; } /* if we delayed creation/opening of pid/log files due to being * in a frozen state at start up, do it now */ if (s->deferred_options.log_filepath) { s->log_file = fopen(s->deferred_options.log_filepath, "a"); if (!s->log_file) { s->log_file = stderr; ... |
1 | static int local_remove(FsContext *ctx, const char *path){ int err; struct stat stbuf; char *buffer; if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { buffer = rpath(ctx, path); err = lstat(buffer, &stbuf); g_free(buffer); if (err) { goto err_out; } /* * If directory remove .virtfs_metadata contained in the * directory */... |
1 | static int t37(InterplayACMContext *s, unsigned ind, unsigned col){ GetBitContext *gb = &s->gb; unsigned i, b; int n1, n2; for (i = 0; i < s->rows; i++) { /* b = (x1) + (x2 * 11) */ b = get_bits(gb, 7); n1 = (mul_2x11[b] & 0x0F) - 5; n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5; set_pos(s, i++, col, n1); if (i >= s->rows) brea... |
1 | static inline void RENAME(rgb24to32)(const uint8_t *src,uint8_t *dst,long src_size){ uint8_t *dest = dst; const uint8_t *s = src; const uint8_t *end;#ifdef HAVE_MMX const uint8_t *mm_end;#endif end = s + src_size;#ifdef HAVE_MMX __asm __volatile(PREFETCH"%0"::"m"(*s):"memory"); mm_end = end - 23; __asm __volatile("movq... |
1 | void do_subfmeo (void){ T1 = T0; T0 = ~T0 + xer_ca - 1; if (likely(!((uint32_t)~T1 & ((uint32_t)~T1 ^ (uint32_t)T0) & (1UL << 31)))) { xer_ov = 0; } else { xer_so = 1; xer_ov = 1; } if (likely((uint32_t)T1 != UINT32_MAX)) xer_ca = 1;} |
1 | static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ PCDIMMDevice *dimm = PC_DIMM(dev); PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); MemoryRegion *mr = ddc->get_memory_region(dimm); uint64_t size = memory_region_size(mr); char *mem_dev; if (size % SPAPR_MEMORY_BLOCK_SIZE)... |
0 | static inline void RENAME(rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, long width, long height, long lumStride, long chromStride, long srcStride){ long y; const x86_reg chromWidth= width>>1;#if COMPILE_TEMPLATE_MMX for (y=0; y<height-2; y+=2) { long i; for (i=0; i<2; i++) { __asm__ vola... |
0 | static int aarch64_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cpu, int max_insns){ DisasContext *dc = container_of(dcbase, DisasContext, base); CPUARMState *env = cpu->env_ptr; ARMCPU *arm_cpu = arm_env_get_cpu(env); dc->pc = dc->base.pc_first; dc->condjmp = 0; dc->aarch64 = 1; /* If we are coming from s... |
0 | static void monitor_print_error(Monitor *mon){ qerror_print(mon->error); QDECREF(mon->error); mon->error = NULL;} |
0 | void nvdimm_build_acpi(GArray *table_offsets, GArray *table_data, GArray *linker){ GSList *device_list; /* no NVDIMM device is plugged. */ device_list = nvdimm_get_plugged_device_list(); if (!device_list) { return; } nvdimm_build_nfit(device_list, table_offsets, table_data, linker); nvdimm_build_ssdt(device_list, table... |
0 | static void qio_channel_websock_handshake_process(QIOChannelWebsock *ioc, char *buffer, Error **errp){ QIOChannelWebsockHTTPHeader hdrs[32]; size_t nhdrs = G_N_ELEMENTS(hdrs); const char *protocols = NULL, *version = NULL, *key = NULL, *host = NULL, *connection = NULL, *upgrade = NULL; nhdrs = qio_channel_websock_extra... |
0 | uint16_t css_build_subchannel_id(SubchDev *sch){ if (channel_subsys.max_cssid > 0) { return (sch->cssid << 8) | (1 << 3) | (sch->ssid << 1) | 1; } return (sch->ssid << 1) | 1;} |
0 | void aio_bh_call(QEMUBH *bh){ bh->cb(bh->opaque);} |
0 | static void gd_connect_signals(GtkDisplayState *s){ g_signal_connect(s->show_tabs_item, "activate", G_CALLBACK(gd_menu_show_tabs), s); g_signal_connect(s->window, "key-press-event", G_CALLBACK(gd_window_key_event), s); g_signal_connect(s->window, "delete-event", G_CALLBACK(gd_window_close), s);#if GTK_CHECK_VERSION(3, ... |
0 | int ff_v4l2_context_set_status(V4L2Context* ctx, int cmd){ int type = ctx->type; int ret; ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type); if (ret < 0) return AVERROR(errno); ctx->streamon = (cmd == VIDIOC_STREAMON); return 0;} |
0 | static void scoop_writeb(void *opaque, target_phys_addr_t addr, uint32_t value){ ScoopInfo *s = (ScoopInfo *) opaque; value &= 0xffff; switch (addr) { case SCOOP_MCR: s->mcr = value; break; case SCOOP_CDR: s->cdr = value; break; case SCOOP_CPR: s->power = value; if (value & 0x80) s->power |= 0x8040; break; case SCOOP_C... |
0 | static int proxy_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name, void *value, size_t size, int flags){ int retval; V9fsString xname, xvalue; v9fs_string_init(&xname); v9fs_string_sprintf(&xname, "%s", name); v9fs_string_init(&xvalue); xvalue.size = size; xvalue.data = g_malloc(size); memcpy(xvalue.data, ... |
0 | static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration){ int dev_descr_len, config_descr_len; int interface, nb_interfaces; int ret, i; if (configuration == 0) /* address state - ignore */ return 1; DPRINTF("husb: claiming interfaces. config %d\n", configuration); i = 0; dev_descr_len = dev->descr[0... |
0 | static void rtas_nvram_store(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ sPAPRNVRAM *nvram = spapr->nvram; hwaddr offset, buffer, len; int alen; void *membuf; if ((nargs != 3) || (nret != 2)) { rtas_st(rets, 0, -3); return; } if (!nvram) { rtas_st(rets,... |
0 | static bool sd_get_inserted(SDState *sd){ return blk_is_inserted(sd->blk);} |
0 | uint32_t helper_efdctsi (uint64_t val){ CPU_DoubleU u; u.ll = val; /* NaN are not treated the same way IEEE 754 does */ if (unlikely(float64_is_nan(u.d))) return 0; return float64_to_int32(u.d, &env->vec_status);} |
0 | target_ulong helper_yield(target_ulong arg1){ if (arg1 < 0) { /* No scheduling policy implemented. */ if (arg1 != -2) { if (env->CP0_VPEControl & (1 << CP0VPECo_YSI) && env->active_tc.CP0_TCStatus & (1 << CP0TCSt_DT)) { env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT); env->CP0_VPEControl |= 4 << CP0VPECo_EXCPT; helper_... |
0 | static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb){ int i, j, scale_factor; unsigned prob, cumulative_target; unsigned cumul_prob = 0; unsigned scaled_cumul_prob = 0; rac->prob[0] = 0; rac->prob[257] = UINT_MAX; /* Read probabilities from bitstream */ for (i = 1; i < 257; i++) { if (lag_decode_prob(gb, &r... |
1 | MemTxResult gicv3_redist_read(void *opaque, hwaddr offset, uint64_t *data, unsigned size, MemTxAttrs attrs){ GICv3State *s = opaque; GICv3CPUState *cs; MemTxResult r; int cpuidx; /* This region covers all the redistributor pages; there are * (for GICv3) two 64K pages per CPU. At the moment they are * all contiguous (ie... |
1 | uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length){ const uint8_t *end= buffer+length;#if !CONFIG_SMALL if(!ctx[256]) while(buffer<end-3){ crc ^= le2me_32(*(const uint32_t*)buffer); buffer+=4; crc = ctx[3*256 + ( crc &0xFF)] ^ctx[2*256 + ((crc>>8 )&0xFF)] ^ctx[1*256 + ((crc>>16)&0xFF)... |
1 | void migrate_add_blocker(Error *reason){ migration_blockers = g_slist_prepend(migration_blockers, reason);} |
1 | static int encode_superframe(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ WMACodecContext *s = avctx->priv_data; const short *samples = data; int i, total_gain; s->block_len_bits= s->frame_len_bits; //required by non variable block len s->block_len = 1 << s->block_len_bits; apply_window_and_mdc... |
1 | static int encode_residual_ch(FlacEncodeContext *s, int ch){ int i, n; int min_order, max_order, opt_order, omethod; FlacFrame *frame; FlacSubframe *sub; int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; int shift[MAX_LPC_ORDER]; int32_t *res, *smp; frame = &s->frame; sub = &frame->subframes[ch]; res = sub->residual; smp = ... |
1 | static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary *opts, AVDictionary *opts2, int *is_http){ HLSContext *c = s->priv_data; AVDictionary *tmp = NULL; const char *proto_name = NULL; int ret; av_dict_copy(&tmp, opts, 0); av_dict_copy(&tmp, opts2, 0); if (av_strstart(url, "crypto", NUL... |
1 | static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp, abi_ulong parent_tidptr, target_ulong newtls, abi_ulong child_tidptr){ CPUState *cpu = ENV_GET_CPU(env); int ret; TaskState *ts; CPUState *new_cpu; CPUArchState *new_env; sigset_t sigmask; /* Emulate vfork() with fork() */ if (flags & CLONE_VFOR... |
1 | static AVFilterContext *create_filter(AVFilterGraph *ctx, int index, const char *name, const char *args, AVClass *log_ctx){ AVFilterContext *filt; AVFilter *filterdef; char inst_name[30]; snprintf(inst_name, sizeof(inst_name), "Parsed filter %d", index); filterdef = avfilter_get_by_name(name); if(!filterdef) { av_log(l... |
1 | static int find_tag(ByteIOContext *pb, uint32_t tag1){ unsigned int tag; int size; for(;;) { if (url_feof(pb)) return -1; tag = get_le32(pb); size = get_le32(pb); if (tag == tag1) break; url_fseek(pb, size, SEEK_CUR); } if (size < 0) size = 0x7fffffff; return size;} |
0 | static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx, RowContext *row, int n, int index_bits, int level_bias, int level_shift){ int i, j, index1, index2, len, flags; int level, component, sign; const int *scale; const uint8_t *weight_matrix; const uint8_t *ac_level = ctx->cid_table->ac_level; cons... |
0 | static int read_data(void *opaque, uint8_t *buf, int buf_size){ struct playlist *v = opaque; HLSContext *c = v->parent->priv_data; int ret, i; int just_opened = 0; if (!v->needed) return AVERROR_EOF;restart: if (!v->input) { /* If this is a live stream and the reload interval has elapsed since * the last playlist reloa... |
0 | static int decode_header(SnowContext *s){ int plane_index, tmp; uint8_t kstate[32]; memset(kstate, MID_STATE, sizeof(kstate)); s->keyframe= get_rac(&s->c, kstate); if(s->keyframe || s->always_reset){ reset_contexts(s); s->spatial_decomposition_type= s->qlog= s->qbias= s->mv_scale= s->block_max_depth= 0; } if(s->keyfram... |
0 | static av_cold void x8_vlc_init(void){ int i; int offset = 0; int sizeidx = 0; static const uint16_t sizes[8*4 + 8*2 + 2 + 4] = { 576, 548, 582, 618, 546, 616, 560, 642, 584, 582, 704, 664, 512, 544, 656, 640, 512, 648, 582, 566, 532, 614, 596, 648, 586, 552, 584, 590, 544, 578, 584, 624, 528, 528, 526, 528, 536, 528, ... |
0 | static int ass_split(ASSSplitContext *ctx, const char *buf){ char c, section[16]; int i; if (ctx->current_section >= 0) buf = ass_split_section(ctx, buf); while (buf && *buf) { if (sscanf(buf, "[%15[0-9A-Za-z+ ]]%c", section, &c) == 2) { buf += strcspn(buf, "\n") + 1; for (i=0; i<FF_ARRAY_ELEMS(ass_sections); i++) if (... |
0 | static int aac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AACContext *ac = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; GetBitContext gb; int buf_consumed; int buf_offset; int err; int new_extradata_size; const uint8_t *new_extradata = av_pac... |
0 | static inline void t_gen_swapw(TCGv d, TCGv s){TCGv t;/* d and s refer the same object. */t = tcg_temp_new(TCG_TYPE_TL);tcg_gen_mov_tl(t, s);tcg_gen_shli_tl(d, t, 16);tcg_gen_shri_tl(t, t, 16);tcg_gen_or_tl(d, d, t);tcg_temp_free(t);} |
0 | static int get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, MapEntry *e){ int64_t ret; int depth; /* As an optimization, we could cache the current range of unallocated * clusters in each file of the chain, and avoid querying the same * range repeatedly. */ depth = 0; for (;;) { ret = bdrv_get... |
0 | void HELPER(cas2w)(CPUM68KState *env, uint32_t regs, uint32_t a1, uint32_t a2){ uint32_t Dc1 = extract32(regs, 9, 3); uint32_t Dc2 = extract32(regs, 6, 3); uint32_t Du1 = extract32(regs, 3, 3); uint32_t Du2 = extract32(regs, 0, 3); int16_t c1 = env->dregs[Dc1]; int16_t c2 = env->dregs[Dc2]; int16_t u1 = env->dregs[Du1]... |
0 | static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds, fd_set *xfds, struct timeval *tv){ GMainContext *context = g_main_context_default(); int i; int timeout = 0, cur_timeout; g_main_context_prepare(context, &max_priority); n_poll_fds = g_main_context_query(context, max_priority, &timeout, poll_fds, ARR... |
0 | void bdrv_info(Monitor *mon, QObject **ret_data){ QList *bs_list; BlockDriverState *bs; bs_list = qlist_new(); QTAILQ_FOREACH(bs, &bdrv_states, list) { QObject *bs_obj; bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': 'unknown', " "'removable': %i, 'locked': %i }", bs->device_name, bs->removable, bdrv_dev_is_medium... |
0 | static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags, abi_ulong target_addr, abi_ulong target_addrlen){ socklen_t addrlen; void *addr; void *host_msg; abi_long ret; host_msg = lock_user(VERIFY_WRITE, msg, len, 0); if (!host_msg) return -TARGET_EFAULT; if (target_addr) { if (get_user_u32(addrlen, tar... |
0 | static PageDesc *page_find_alloc(tb_page_addr_t index, int alloc){ PageDesc *pd; void **lp; int i;#if defined(CONFIG_USER_ONLY) /* We can't use g_malloc because it may recurse into a locked mutex. */# define ALLOC(P, SIZE) \ do { \ P = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, \ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \ } ... |
0 | static void pointer_event(VncState *vs, int button_mask, int x, int y){ static uint32_t bmap[INPUT_BUTTON__MAX] = { [INPUT_BUTTON_LEFT] = 0x01, [INPUT_BUTTON_MIDDLE] = 0x02, [INPUT_BUTTON_RIGHT] = 0x04, [INPUT_BUTTON_WHEEL_UP] = 0x08, [INPUT_BUTTON_WHEEL_DOWN] = 0x10, }; QemuConsole *con = vs->vd->dcl.con; int width = ... |
0 | static bool is_zero_cluster(BlockDriverState *bs, int64_t start){ BDRVQcow2State *s = bs->opaque; int nr; BlockDriverState *file; int64_t res = bdrv_get_block_status_above(bs, NULL, start, s->cluster_sectors, &nr, &file); return res >= 0 && (res & BDRV_BLOCK_ZERO);} |
0 | static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, BdrvRequestFlags flags){ if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) { return -EINVAL; } return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS, nb_sectors << BDRV_SECTOR_BI... |
0 | void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict){ const char *param = qdict_get_str(qdict, "parameter"); const char *valuestr = qdict_get_str(qdict, "value"); int64_t valuebw = 0; long valueint = 0; Error *err = NULL; bool use_int_value = false; int i; for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) { if... |
0 | static void mcf5208evb_init(MachineState *machine){ ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; M68kCPU *cpu; CPUM68KState *env; int kernel_size; uint64_t elf_entry; hwaddr entry; qemu_irq *pic; MemoryRegion *address_space_... |
0 | static CharDriverState *qemu_chr_open_tty_fd(int fd){ CharDriverState *chr; tty_serial_init(fd, 115200, 'N', 8, 1); chr = qemu_chr_open_fd(fd, fd); chr->chr_ioctl = tty_serial_ioctl; chr->chr_close = qemu_chr_close_tty; return chr;} |
0 | void qdev_property_add_static(DeviceState *dev, Property *prop, Error **errp){ Error *local_err = NULL; Object *obj = OBJECT(dev); /* * TODO qdev_prop_ptr does not have getters or setters. It must * go now that it can be replaced with links. The test should be * removed along with it: all static properties are read/wri... |
0 | static uint16_t shpc_get_status(SHPCDevice *shpc, int slot, uint16_t msk){ uint8_t *status = shpc->config + SHPC_SLOT_STATUS(slot); return (pci_get_word(status) & msk) >> (ffs(msk) - 1);} |
0 | static int hls_start(AVFormatContext *s, VariantStream *vs){ HLSContext *c = s->priv_data; AVFormatContext *oc = vs->avf; AVFormatContext *vtt_oc = vs->vtt_avf; AVDictionary *options = NULL; char *filename, iv_string[KEYSIZE*2 + 1]; int err = 0; if (c->flags & HLS_SINGLE_FILE) { av_strlcpy(oc->filename, vs->basename, s... |
0 | void virtio_submit_multiwrite(BlockDriverState *bs, MultiReqBuffer *mrb){ int i, ret; if (!mrb->num_writes) { return; } ret = bdrv_aio_multiwrite(bs, mrb->blkreq, mrb->num_writes); if (ret != 0) { for (i = 0; i < mrb->num_writes; i++) { if (mrb->blkreq[i].error) { virtio_blk_rw_complete(mrb->blkreq[i].opaque, -EIO); } ... |
0 | DeviceState *pc_vga_init(ISABus *isa_bus, PCIBus *pci_bus){ DeviceState *dev = NULL; if (cirrus_vga_enabled) { if (pci_bus) { dev = pci_cirrus_vga_init(pci_bus); } else { dev = isa_cirrus_vga_init(get_system_memory()); } } else if (vmsvga_enabled) { if (pci_bus) { dev = pci_vmsvga_init(pci_bus); if (!dev) { fprintf(std... |
0 | static void v9fs_version(void *opaque){ V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; V9fsString version; size_t offset = 7; pdu_unmarshal(pdu, offset, "ds", &s->msize, &version); trace_v9fs_version(pdu->tag, pdu->id, s->msize, version.data); virtfs_reset(pdu); if (!strcmp(version.data, "9P2000.u")) { s->proto_version ... |
0 | static void openpic_irq_raise(openpic_t *opp, int n_CPU, IRQ_src_t *src){ int n_ci = IDR_CI0 - n_CPU; if ((opp->flags & OPENPIC_FLAG_IDE_CRIT) && test_bit(&src->ide, n_ci)) { qemu_irq_raise(opp->dst[n_CPU].irqs[OPENPIC_OUTPUT_CINT]); } else { qemu_irq_raise(opp->dst[n_CPU].irqs[OPENPIC_OUTPUT_INT]); }} |
0 | void vm_stop(int reason){ QemuThread me; qemu_thread_self(&me); if (!qemu_thread_equal(&me, &io_thread)) { qemu_system_vmstop_request(reason); /* * FIXME: should not return to device code in case * vm_stop() has been requested. */ cpu_stop_current(); return; } do_vm_stop(reason);} |
0 | int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset, const void *buf, int count){ int ret; ret = bdrv_pwrite(bs, offset, buf, count); if (ret < 0) { return ret; } /* No flush needed for cache modes that already do it */ if (bs->enable_write_cache) { bdrv_flush(bs); } return 0;} |
0 | static uint64_t mv88w8618_pit_read(void *opaque, target_phys_addr_t offset, unsigned size){ mv88w8618_pit_state *s = opaque; mv88w8618_timer_state *t; switch (offset) { case MP_PIT_TIMER1_VALUE ... MP_PIT_TIMER4_VALUE: t = &s->timer[(offset-MP_PIT_TIMER1_VALUE) >> 2]; return ptimer_get_count(t->ptimer); default: return... |
1 | static int amrwb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AMRWBContext *ctx = avctx->priv_data; AMRWBFrame *cf = &ctx->frame; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int expected_fr_size, header_size; float *buf_out; float spare_vector[AMRWB_SFR_SIZE]; ... |
1 | static ssize_t mcf_fec_receive(NetClientState *nc, const uint8_t *buf, size_t size){ mcf_fec_state *s = qemu_get_nic_opaque(nc); mcf_fec_bd bd; uint32_t flags = 0; uint32_t addr; uint32_t crc; uint32_t buf_addr; uint8_t *crc_ptr; unsigned int buf_len; size_t retsize; DPRINTF("do_rx len %d\n", size); if (!s->rx_enabled)... |
1 | static int openfile(char *name, int flags, int growable){if (bs) {fprintf(stderr, "file open already, try 'help close'\n");return 1;}bs = bdrv_new("hda");if (!bs)return 1;if (bdrv_open(bs, name, flags) == -1) {fprintf(stderr, "%s: can't open device %s\n", progname, name);bs = NULL;return 1;}if (growable) {if (!bs->drv ... |
1 | static BlockDriverAIOCB *rbd_aio_rw_vector(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int write){ RBDAIOCB *acb; RADOSCB *rcb; rbd_completion_t c; int64_t off, size; char *buf; BDRVRBDState *s = bs->opaque; acb = qemu_aio_get(&rbd_aio_pool,... |
1 | static int plot_cqt(AVFilterContext *ctx){ AVFilterLink *outlink = ctx->outputs[0]; ShowCQTContext *s = ctx->priv; int ret; memcpy(s->fft_result, s->fft_data, s->fft_len * sizeof(*s->fft_data)); av_fft_permute(s->fft_ctx, s->fft_result); av_fft_calc(s->fft_ctx, s->fft_result); s->fft_result[s->fft_len] = s->fft_result[... |
1 | static inline void vring_used_idx_set(VirtQueue *vq, uint16_t val){ VRingMemoryRegionCaches *caches = atomic_rcu_read(&vq->vring.caches); hwaddr pa = offsetof(VRingUsed, idx); virtio_stw_phys_cached(vq->vdev, &caches->used, pa, val); address_space_cache_invalidate(&caches->used, pa, sizeof(val)); vq->used_idx = val;} |
1 | static void usbredir_interrupt_packet(void *priv, uint64_t id, struct usb_redir_interrupt_packet_header *interrupt_packet, uint8_t *data, int data_len){ USBRedirDevice *dev = priv; uint8_t ep = interrupt_packet->endpoint; DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64"\n", interrupt_packet->status, ep, data... |
1 | static int decode_band(IVI45DecContext *ctx, IVIBandDesc *band, AVCodecContext *avctx){ int result, i, t, idx1, idx2, pos; IVITile *tile; band->buf = band->bufs[ctx->dst_buf]; if (!band->buf) { av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n"); return AVERROR_INVALIDDATA; } band->ref_buf = band->bufs[ctx-... |
1 | int e820_add_entry(uint64_t address, uint64_t length, uint32_t type){ int index = le32_to_cpu(e820_reserve.count); struct e820_entry *entry; if (type != E820_RAM) { /* old FW_CFG_E820_TABLE entry -- reservations only */ if (index >= E820_NR_ENTRIES) { return -EBUSY; } entry = &e820_reserve.entry[index++]; entry->addres... |
1 | static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom){ uint32_t count; uint32_t i; if (atom.size < 8) return 0; avio_skip(pb, 4); count = avio_rb32(pb); if (count > UINT_MAX / sizeof(*c->meta_keys)) { av_log(c->fc, AV_LOG_ERROR, "The 'keys' atom with the invalid key count: %d\n", count); return AVERROR... |
1 | static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom){ AVStream *st; uint32_t type; uint32_t av_unused ctype; int64_t title_size; char *title_str; if (c->fc->nb_streams < 1) // meta before first trak return 0; st = c->fc->streams[c->fc->nb_streams-1]; avio_r8(pb); /* version */ avio_rb24(pb); /* flags ... |
1 | static void chomp6(ChannelData *ctx, int16_t *output, uint8_t val, const uint16_t tab1[], const int16_t *tab2, int tab2_stride, uint32_t numChannels){ int16_t current; current = tab2[((ctx->index & 0x7f0) >> 4)*tab2_stride + val]; if ((ctx->previous ^ current) >= 0) { ctx->factor = FFMIN(ctx->factor + 506, 32767); } el... |
1 | aio_read_done(void *opaque, int ret){struct aio_ctx *ctx = opaque;struct timeval t2;gettimeofday(&t2, NULL);if (ret < 0) {printf("readv failed: %s\n", strerror(-ret));return;}if (ctx->Pflag) {void *cmp_buf = malloc(ctx->qiov.size);memset(cmp_buf, ctx->pattern, ctx->qiov.size);if (memcmp(ctx->buf, cmp_buf, ctx->qiov.siz... |
1 | void helper_retry(void){ env->pc = env->tsptr->tpc; env->npc = env->tsptr->tnpc; PUT_CCR(env, env->tsptr->tstate >> 32); env->asi = (env->tsptr->tstate >> 24) & 0xff; change_pstate((env->tsptr->tstate >> 8) & 0xf3f); PUT_CWP64(env, env->tsptr->tstate & 0xff); env->tl--; env->tsptr = &env->ts[env->tl & MAXTL_MASK];} |
1 | static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str, int legacy_format){ struct in_addr host_addr = { .s_addr = INADDR_ANY }; struct in_addr guest_addr = { .s_addr = 0 }; int host_port, guest_port; const char *p; char buf[256]; int is_udp; char *end; p = redir_str; if (!p || get_str_sep(buf, si... |
1 | static inline int RENAME(yuv420_rgb24)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]){ int y, h_size; if(c->srcFormat == PIX_FMT_YUV422P){srcStride[1] *= 2;srcStride[2] *= 2; } h_size= (c->dstW+7)&~7; if(h_size*3 > FFABS(dstStride[0])) h_size-=8; __asm__ _... |
1 | static void mux_chr_read(void *opaque, const uint8_t *buf, int size){ CharDriverState *chr = opaque; MuxDriver *d = chr->opaque; int m = chr->focus; int i; mux_chr_accept_input (opaque); for(i = 0; i < size; i++) if (mux_proc_byte(chr, d, buf[i])) { if (d->prod == d->cons && d->chr_can_read[m] && d->chr_can_read[m](d->... |
1 | static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap){ VideoData *s = s1->priv_data; AVStream *st; int width, height; int video_fd, frame_size; int ret, frame_rate, frame_rate_base; int desired_palette, desired_depth; struct video_tuner tuner; struct video_audio audio; struct video_picture pict; int ... |
1 | static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame){ int x, y; unsigned char opcode; int ret; GetBitContext gb; bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */ if (!s->is_16bpp) { /* this is PAL8, so make the palette available */ memcpy(frame->data[1], s->pal, AVPALETTE_SIZE); s->s... |
1 | static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg){ GlusterAIOCB *acb = (GlusterAIOCB *)arg; BlockDriverState *bs = acb->common.bs; BDRVGlusterState *s = bs->opaque; int retval; acb->ret = ret; retval = qemu_write_full(s->fds[GLUSTER_FD_WRITE], &acb, sizeof(acb)); if (retval != sizeof(acb)) { ... |
1 | static void close_htab_fd(sPAPRMachineState *spapr){ if (spapr->htab_fd >= 0) { close(spapr->htab_fd); } spapr->htab_fd = -1;} |
1 | static void intel_hda_update_irq(IntelHDAState *d){ int msi = d->msi && msi_enabled(&d->pci); int level; intel_hda_update_int_sts(d); if (d->int_sts & (1 << 31) && d->int_ctl & (1 << 31)) { level = 1; } else { level = 0; } dprint(d, 2, "%s: level %d [%s]\n", __FUNCTION__, level, msi ? "msi" : "intx"); if (msi) { if (le... |
1 | static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) { int res = 0; uint64_t pos; uint64_t maxlen = 100 * 1024 * 1024; AVStream *st = s->streams[0]; int64_t start_time = s->streams[stream_index]->start_time; int64_t found; int idx; if (timestamp < start_time) timestamp = start_time; i... |
0 | static int iscsi_aio_discard_acb(IscsiAIOCB *acb) { struct iscsi_context *iscsi = acb->iscsilun->iscsi; struct unmap_list list[1]; acb->canceled = 0; acb->bh = NULL; acb->status = -EINPROGRESS; acb->buf = NULL; list[0].lba = sector_qemu2lun(acb->sector_num, acb->iscsilun); list[0].num = acb->nb_sectors * BDRV_SECTOR_SI... |
0 | static void vmsa_tcr_el1_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value){ ARMCPU *cpu = arm_env_get_cpu(env); /* For AArch64 the A1 bit could result in a change of ASID, so TLB flush. */ tlb_flush(CPU(cpu), 1); env->cp15.c2_control = value;} |
0 | cpu_mips_check_sign_extensions (CPUState *env, FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...), int flags){ int i; if (!SIGN_EXT_P(env->active_tc.PC)) cpu_fprintf(f, "BROKEN: pc=0x" TARGET_FMT_lx "\n", env->active_tc.PC); if (!SIGN_EXT_P(env->active_tc.HI[0])) cpu_fprintf(f, "BROKEN: HI=0x" TARGET_FMT_lx "\n... |
0 | void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier){ qemu_clock_register_reset_notifier(clock->type, notifier);} |
0 | static int match_format(const char *name, const char *names){ const char *p; int len, namelen; if (!name || !names) return 0; namelen = strlen(name); while ((p = strchr(names, ','))) { len = FFMAX(p - names, namelen); if (!av_strncasecmp(name, names, len)) return 1; names = p + 1; } return !av_strcasecmp(name, names);} |
0 | static int check_refcounts_l1(BlockDriverState *bs, uint16_t *refcount_table, int refcount_table_size, int64_t l1_table_offset, int l1_size, int check_copied){ BDRVQcowState *s = bs->opaque; uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2; int l2_size, i, j, nb_csectors, refcount; l2_table = NULL; l1_size2 =... |
0 | static void ide_sector_read_cb(void *opaque, int ret){ IDEState *s = opaque; int n; s->pio_aiocb = NULL; s->status &= ~BUSY_STAT; if (ret == -ECANCELED) { return; } block_acct_done(bdrv_get_stats(s->bs), &s->acct); if (ret != 0) { if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO | IDE_RETRY_READ)) { return; } } n = s->ns... |
0 | static void logerr (struct audio_pt *pt, int err, const char *fmt, ...){ va_list ap; va_start (ap, fmt); AUD_vlog (pt->drv, fmt, ap); va_end (ap); AUD_log (NULL, "\n"); AUD_log (pt->drv, "Reason: %s\n", strerror (err));} |
0 | static void slavio_timer_reset(DeviceState *d){ SLAVIO_TIMERState *s = container_of(d, SLAVIO_TIMERState, busdev.qdev); unsigned int i; CPUTimerState *curr_timer; for (i = 0; i <= MAX_CPUS; i++) { curr_timer = &s->cputimer[i]; curr_timer->limit = 0; curr_timer->count = 0; curr_timer->reached = 0; if (i < s->num_cpus) {... |
0 | static void coroutine_delete(Coroutine *co){ if (CONFIG_COROUTINE_POOL) { qemu_mutex_lock(&pool_lock); if (pool_size < pool_max_size) { QSLIST_INSERT_HEAD(&pool, co, pool_next); co->caller = NULL; pool_size++; qemu_mutex_unlock(&pool_lock); return; } qemu_mutex_unlock(&pool_lock); } qemu_coroutine_delete(co);} |
0 | static void arm_post_translate_insn(CPUARMState *env, DisasContext *dc){ if (dc->condjmp && !dc->base.is_jmp) { gen_set_label(dc->condlabel); dc->condjmp = 0; } /* Translation stops when a conditional branch is encountered. * Otherwise the subsequent code could get translated several times. * Also stop translation when... |
0 | static void r2d_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; SuperHCPU *cpu; CPUSH4State *env; ResetData *reset_info; struct S... |
0 | static void gen_compute_eflags_s(DisasContext *s, TCGv reg, bool inv){ switch (s->cc_op) { case CC_OP_DYNAMIC: gen_compute_eflags(s); /* FALLTHRU */ case CC_OP_EFLAGS: tcg_gen_shri_tl(reg, cpu_cc_src, 7); tcg_gen_andi_tl(reg, reg, 1); if (inv) { tcg_gen_xori_tl(reg, reg, 1); } break; default: { int size = (s->cc_op - C... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.