label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void check_suspend_mode(GuestSuspendMode mode, Error **errp){ SYSTEM_POWER_CAPABILITIES sys_pwr_caps; Error *local_err = NULL; if (error_is_set(errp)) { return; } ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps)); if (!GetPwrCapabilities(&sys_pwr_caps)) { error_set(&local_err, QERR_QGA_COMMAND_FAILED, "failed to d... |
1 | static gint range_compare(gconstpointer a, gconstpointer b){ Range *ra = (Range *)a, *rb = (Range *)b; if (ra->begin == rb->begin && ra->end == rb->end) { return 0; } else if (range_get_last(ra->begin, ra->end) < range_get_last(rb->begin, rb->end)) { return -1; } else { return 1; }} |
1 | static void report_unsupported_feature(BlockDriverState *bs, Error **errp, Qcow2Feature *table, uint64_t mask){ while (table && table->name[0] != '\0') { if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) { if (mask & (1 << table->bit)) { report_unsupported(bs, errp, "%.46s", table->name); mask &= ~(1 << table->bit); } }... |
1 | void qemu_ram_free(ram_addr_t addr){ RAMBlock *block; QLIST_FOREACH(block, &ram_list.blocks, next) { if (addr == block->offset) { QLIST_REMOVE(block, next); if (block->flags & RAM_PREALLOC_MASK) { ; } else if (mem_path) {#if defined (__linux__) && !defined(TARGET_S390X) if (block->fd) { munmap(block->host, block->lengt... |
1 | static int rocker_msix_init(Rocker *r){ PCIDevice *dev = PCI_DEVICE(r); int err; err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports), &r->msix_bar, ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET, &r->msix_bar, ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET, 0); if (err) { return err; } err = rocker_msix... |
0 | static void avc_wgt_4width_msa(uint8_t *data, int32_t stride, int32_t height, int32_t log2_denom, int32_t src_weight, int32_t offset_in){ if (2 == height) { avc_wgt_4x2_msa(data, stride, log2_denom, src_weight, offset_in); } else { avc_wgt_4x4multiple_msa(data, stride, height, log2_denom, src_weight, offset_in); }} |
0 | static void do_apply_filter(APEContext *ctx, int version, APEFilter *f, int32_t *data, int count, int order, int fracbits){ int res; int absres; while (count--) { /* round fixedpoint scalar product */ res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs, f->delay - order, f->adaptcoeffs - order, order, APESIGN(*data)... |
1 | static int ffm2_read_header(AVFormatContext *s){ FFMContext *ffm = s->priv_data; AVStream *st; AVIOContext *pb = s->pb; AVCodecContext *codec; const AVCodecDescriptor *codec_desc; int ret, i; int f_main = 0, f_cprv = -1, f_stvi = -1, f_stau = -1; AVCodec *enc; char *buffer; ffm->packet_size = avio_rb32(pb); if (ffm->pa... |
1 | static int h263p_decode_umotion(MpegEncContext * s, int pred){ int code = 0, sign; if (get_bits1(&s->gb)) /* Motion difference = 0 */ return pred; code = 2 + get_bits1(&s->gb); while (get_bits1(&s->gb)) { code <<= 1; code += get_bits1(&s->gb); if (code >= 32768) { avpriv_request_sample(s->avctx, "Huge DMV"); return AVE... |
1 | static void stream_pause(VideoState *is){ is->paused = !is->paused; if (!is->paused) { if(is->read_pause_return != AVERROR(ENOSYS)){ is->video_current_pts = get_video_clock(is); } is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0; is->video_current_pts_time= av_gettime(); }} |
1 | static void gen_tlbia(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; } gen_helper_tlbia(cpu_env);#endif} |
1 | int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet){ MpegEncContext *s = avctx->priv_data; int i, stuffing_count, ret; int context_count = s->slice_context_count; s->picture_in_gop_number++; if (load_input_picture(s, pic_arg) < 0) return -1; if (select_input_picture(... |
0 | static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size){const uint8_t *s = src;const uint8_t *end;#ifdef HAVE_MMXconst uint8_t *mm_end;#endifuint16_t *d = (uint16_t *)dst;end = s + src_size;#ifdef HAVE_MMX__asm __volatile(PREFETCH"%0"::"m"(*src):"memory");__asm __volatile( "movq%0, ... |
0 | static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride, ptrdiff_t _ystride, int *_tc, uint8_t *_no_p, uint8_t *_no_q){ int d, j, no_p, no_q; pixel *pix = (pixel *)_pix; ptrdiff_t xstride = _xstride / sizeof(pixel); ptrdiff_t ystride = _ystride / sizeof(pixel); for (j = 0; j < 2; j++) { const int tc... |
0 | static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple, int pixel_shift){ MpegEncContext * const s = &h->s; int deblock_left; int deblock_top; int top_idx = 1; uint8_t *top_border_m1; uint8_t *top_border; if(!simple && FRAME... |
0 | static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt){ int ret; HEVCContext *s = avctx->priv_data; if (!avpkt->size) { ret = ff_hevc_output_frame(s, data, 1); if (ret < 0) return ret; *got_output = ret; return 0; } s->ref = NULL; ret = decode_nal_units(s, avpkt->data, avpkt->... |
1 | static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req){ uint32_t dw10 = le32_to_cpu(cmd->cdw10); uint32_t result; switch (dw10) { case NVME_VOLATILE_WRITE_CACHE: result = blk_enable_write_cache(n->conf.blk); break; case NVME_NUMBER_OF_QUEUES: result = cpu_to_le32((n->num_queues - 1) | ((n->num_qu... |
1 | static int decode_subframe(TAKDecContext *s, int32_t *decoded, int subframe_size, int prev_subframe_size){ GetBitContext *gb = &s->gb; int x, y, i, j, ret = 0; int dshift, size, filter_quant, filter_order, filter_order16; int tfilter[MAX_PREDICTORS]; if (!get_bits1(gb)) return decode_residues(s, decoded, subframe_size)... |
1 | iscsi_allocmap_update(IscsiLun *iscsilun, int64_t sector_num, int nb_sectors, bool allocated, bool valid){ int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk; if (iscsilun->allocmap == NULL) { return; } /* expand to entirely contain all affected clusters */ cl_num_expanded = sector_num / iscsilun->c... |
1 | static int dca_decode_frame(AVCodecContext * avctx, void *data, int *data_size, const uint8_t * buf, int buf_size){ int i, j, k; int16_t *samples = data; DCAContext *s = avctx->priv_data; int channels; s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE); if (s->dca_buffer_size =... |
0 | static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt){ TeletextContext *ctx = avctx->priv_data; AVSubtitle *sub = data; int ret = 0; if (!ctx->vbi) { if (!(ctx->vbi = vbi_decoder_new())) return AVERROR(ENOMEM); if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler... |
1 | static void pc_init_pci_1_5(QEMUMachineInitArgs *args){ has_pci_info = false; pc_init_pci(args);} |
1 | static int usbnet_can_receive(NetClientState *nc){ USBNetState *s = qemu_get_nic_opaque(nc); if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) { return 1; return !s->in_len; |
1 | static inline int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, uint8_t *src, int field_based, int field_select, int src_x, int src_y, int width, int height, int stride, int h_edge_pos, int v_edge_pos, int w, int h, h264_chroma_mc_func *pix_op, int motion_x, int motion_y){ const int lowres = s->avctx->lowres; co... |
1 | int qemu_devtree_add_subnode(void *fdt, const char *name){ int offset; char *dupname = g_strdup(name); char *basename = strrchr(dupname, '/'); int retval; if (!basename) { return -1; } basename[0] = '\0'; basename++; offset = fdt_path_offset(fdt, dupname); if (offset < 0) { return offset; } retval = fdt_add_subnode(fdt... |
1 | av_cold void ff_mlz_init_dict(void* context, MLZ *mlz) { mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict)); mlz->flush_code = FLUSH_CODE; mlz->current_dic_index_max = DIC_INDEX_INIT; mlz->dic_code_bit = CODE_BIT_INIT; mlz->bump_code = (DIC_INDEX_INIT - 1); mlz->next_code = FIRST_CODE; mlz->freeze_flag = 0; ml... |
1 | static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb){ ProresContext *ctx = avctx->priv_data; LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]); int16_t *block; GetBitContext gb; int i, j, b... |
0 | static int mxf_write_footer(AVFormatContext *s){ MXFContext *mxf = s->priv_data; AVIOContext *pb = s->pb; mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count; mxf_write_klv_fill(s); mxf->footer_partition_offset = avio_tell(pb); if (mxf->edit_unit_byte_count) { // no need to repeat index mxf_write_partit... |
1 | static void pxa2xx_pcmcia_initfn(Object *obj){ SysBusDevice *sbd = SYS_BUS_DEVICE(obj); PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj); memory_region_init(&s->container_mem, obj, "container", 0x10000000); sysbus_init_mmio(sbd, &s->container_mem); /* Socket I/O Memory Space */ memory_region_init_io(&s->iomem, NULL, &pxa2xx_p... |
1 | static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset, uint64_t *bytes){ bool need_cow; int ret = 0; int64_t align_offset = *offset; unsigned int align_bytes = *bytes; int max_bytes = s->granularity * s->max_iov; assert(*bytes < INT_MAX); need_cow = !test_bit(*offset / s->granularity, s->cow_bitmap); need_cow ... |
1 | static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb, const char *fmt, ...){ va_list ap; va_start(ap, fmt); fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ", acb->is_write ? "write" : "read", acb->sector_num, acb->nb_sectors); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap)... |
0 | static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt){ MatroskaMuxContext *mkv = s->priv_data; int codec_type = s->streams[pkt->stream_index]->codec->codec_type; int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY); int cluster_size; int cluster_size_limit; int64_t cluster_time; int64_t cluster_time_limit; AVIOCont... |
0 | static int64_t getutime(void){#ifdef HAVE_GETRUSAGE struct rusage rusage; getrusage(RUSAGE_SELF, &rusage); return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;#elif defined(__MINGW32__) return av_gettime();#endif} |
0 | static void colored_fputs(int level, const char *str){ if (!*str) return; if (use_color < 0) {#if HAVE_SETCONSOLETEXTATTRIBUTE CONSOLE_SCREEN_BUFFER_INFO con_info; con = GetStdHandle(STD_ERROR_HANDLE); use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR"); if (use_color) { ... |
1 | static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask){ int i, count, err; struct pollfd *pfds; count = snd_pcm_poll_descriptors_count (handle); if (count <= 0) { dolog ("Could not initialize poll mode\n" "Invalid number of poll descriptors %d\n", count); return -1; } pfds = audio_calloc ("alsa_... |
0 | AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms, enum AVSampleFormat sample_fmt, int size, int64_t channel_layout, int planar){ AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer)); AVFilterBufferRef *ref = NULL; int i, sample_size, chans_nb, bufsize, per_channel_size, step_si... |
1 | static MigrationState *migrate_init(const MigrationParams *params){ MigrationState *s = migrate_get_current(); int64_t bandwidth_limit = s->bandwidth_limit; bool enabled_capabilities[MIGRATION_CAPABILITY_MAX]; int64_t xbzrle_cache_size = s->xbzrle_cache_size; memcpy(enabled_capabilities, s->enabled_capabilities, sizeof... |
1 | static void chr_read(void *opaque, const uint8_t *buf, int size){ TestServer *s = opaque; CharDriverState *chr = s->chr; VhostUserMsg msg; uint8_t *p = (uint8_t *) &msg; int fd; if (size != VHOST_USER_HDR_SIZE) { g_test_message("Wrong message size received %d\n", size); return; g_mutex_lock(&s->data_mutex); memcpy(p, b... |
1 | static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno, uint8_t *expn, int numgbits){ int bandno, empty = 1; // init bitstream *s->buf = 0; s->bit_index = 0; // header // is the packet empty? for (bandno = 0; bandno < rlevel->nbands; bandno++){ if (rlevel->band[bandno].coord[0][0] < rl... |
1 | static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile, int p, int b, int t_height, int t_width){ int x, y; IVITile *tile = band->tiles; for (y = 0; y < band->height; y += t_height) { for (x = 0; x < band->width; x += t_width) { tile->xpos = x; tile->ypos = y; tile->mb_size = band->mb_size; tile->width = FFMIN(... |
1 | static av_cold int common_end(AVCodecContext *avctx){ FFV1Context *s = avctx->priv_data; int i, j; for(j=0; j<s->slice_count; j++){ FFV1Context *fs= s->slice_context[j]; for(i=0; i<s->plane_count; i++){ PlaneContext *p= &fs->plane[i]; av_freep(&p->state); av_freep(&p->vlc_state); av_freep(&fs->sample_buffer); av_freep(... |
1 | unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx, const AVDXVAContext *ctx, const AVFrame *frame){ void *surface = ff_dxva2_get_surface(frame); unsigned i; for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++) if (DXVA_CONTEXT_SURFACE(avctx, ctx, i) == surface) return i; assert(0); return 0;} |
1 | CpuInfoList *qmp_query_cpus(Error **errp){ MachineState *ms = MACHINE(qdev_get_machine()); MachineClass *mc = MACHINE_GET_CLASS(ms); CpuInfoList *head = NULL, *cur_item = NULL; CPUState *cpu; CPU_FOREACH(cpu) { CpuInfoList *info;#if defined(TARGET_I386) X86CPU *x86_cpu = X86_CPU(cpu); CPUX86State *env = &x86_cpu->env;#... |
1 | static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu, ppc_slb_t *slb, target_ulong eaddr, ppc_hash_pte64_t *pte){ CPUPPCState *env = &cpu->env; hwaddr pte_offset; hwaddr hash; uint64_t vsid, epnmask, epn, ptem; /* The SLB store path should prevent any bad page size encodings * getting in there, so: */ assert(slb->sps);... |
1 | static always_inline void gen_op_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check){ int l1, l2; l1 = gen_new_label(); l2 = gen_new_label();#if defined(TARGET_PPC64) if (ctx->sf_mode) { tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, l1); } else { TCGv t0 = tcg_temp_new(TCG_TYPE_TL);tcg_gen_ext32s_tl(t0, arg1)... |
1 | static int tx_consume(Rocker *r, DescInfo *info){ PCIDevice *dev = PCI_DEVICE(r); char *buf = desc_get_buf(info, true); RockerTlv *tlv_frag; RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1]; struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, }; uint32_t pport; uint32_t port; uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE; uint16_t ... |
1 | static void gen_neon_dup_low16(TCGv var){ TCGv tmp = new_tmp(); tcg_gen_ext16u_i32(var, var); tcg_gen_shli_i32(tmp, var, 16); tcg_gen_or_i32(var, var, tmp); dead_tmp(tmp);} |
0 | static void audio_print_settings (audsettings_t *as){ dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels); switch (as->fmt) { case AUD_FMT_S8: AUD_log (NULL, "S8"); break; case AUD_FMT_U8: AUD_log (NULL, "U8"); break; case AUD_FMT_S16: AUD_log (NULL, "S16"); break; case AUD_FMT_U16: AUD_log (NULL, "U16");... |
0 | static void vnc_refresh(void *opaque){ VncDisplay *vd = opaque; VncState *vs, *vn; int has_dirty, rects = 0; vga_hw_update(); if (vnc_trylock_display(vd)) { vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval); return; } has_dirty = vnc_refresh_server_... |
0 | static void set_pointer(Object *obj, Visitor *v, Property *prop, int (*parse)(DeviceState *dev, const char *str, void **ptr), const char *name, Error **errp){ DeviceState *dev = DEVICE(obj); Error *local_err = NULL; void **ptr = qdev_get_prop_ptr(dev, prop); char *str; int ret; if (dev->state != DEV_STATE_CREATED) { er... |
0 | static int scsi_hd_initfn(SCSIDevice *dev){ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); s->qdev.blocksize = s->qdev.conf.logical_block_size; s->qdev.type = TYPE_DISK; if (!s->product) { s->product = g_strdup("QEMU HARDDISK"); } return scsi_initfn(&s->qdev);} |
0 | static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse){ const char *sec_model = qemu_opt_get(opts, "security_model"); const char *path = qemu_opt_get(opts, "path"); if (!sec_model) { fprintf(stderr, "security model not specified, " "local fs needs security model\nvalid options are:" "\tsecurity_model=[p... |
0 | static void spr_write_dbatl_h (void *opaque, int sprn){ DisasContext *ctx = opaque; gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2); RET_STOP(ctx);} |
0 | static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn, TCGv r_cond, TCGv r_reg){ unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29)); target_ulong target = dc->pc + offset; flush_cond(dc, r_cond); gen_cond_reg(r_cond, cond, r_reg); if (a) { gen_branch_a(dc, target, dc->npc, r_cond... |
0 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start){ int b, prefixes, aflag, dflag; int shift, ot; int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val; target_ulong next_eip, tval; int rex_w, rex_r; if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) { tcg_gen_debug_insn_s... |
0 | static void rpza_decode_stream(RpzaContext *s){ int width = s->avctx->width; int stride = s->frame.linesize[0] / 2; int row_inc = stride - 4; int stream_ptr = 0; int chunk_size; unsigned char opcode; int n_blocks; unsigned short colorA = 0, colorB; unsigned short color4[4]; unsigned char index, idx; unsigned short ta, ... |
0 | int usb_device_attach(USBDevice *dev){ USBBus *bus = usb_bus_from_device(dev); if (bus->nfree == 1 && dev->port_path == NULL) { /* Create a new hub and chain it on (unless a physical port location is specified). */ usb_create_simple(bus, "usb-hub"); } return do_attach(dev);} |
0 | static void cpu_debug_handler(CPUState *env){ gdb_set_stop_cpu(env); qemu_system_debug_request();} |
0 | static uint16_t qpci_spapr_io_readw(QPCIBus *bus, void *addr){ QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus); uint64_t port = (uintptr_t)addr; uint16_t v; if (port < s->pio.size) { v = readw(s->pio_cpu_base + port); } else { v = readw(s->mmio_cpu_base + port); } return bswap16(v);} |
0 | static int ast_read_header(AVFormatContext *s){ int codec; AVStream *st; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); avio_skip(s->pb, 8); codec = avio_rb16(s->pb); switch (codec) { case 1: st->codec->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR; break; default: av_log(s, AV_LOG_ERROR, "unsupported co... |
0 | static av_cold int vsink_init(AVFilterContext *ctx, void *opaque){ BufferSinkContext *buf = ctx->priv; AVBufferSinkParams *params = opaque; if (params && params->pixel_fmts) { const int *pixel_fmts = params->pixel_fmts; buf->pixel_fmts = ff_copy_int_list(pixel_fmts); if (!buf->pixel_fmts) return AVERROR(ENOMEM); } retu... |
1 | 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... |
1 | static void init_proc_book3s_64(CPUPPCState *env, int version){ gen_spr_ne_601(env); gen_tbl(env); gen_spr_book3s_altivec(env); gen_spr_book3s_pmu_sup(env); gen_spr_book3s_pmu_user(env); gen_spr_book3s_common(env); switch (version) { case BOOK3S_CPU_970: case BOOK3S_CPU_POWER5PLUS: gen_spr_970_hid(env); gen_spr_970_hio... |
1 | static void virtio_host_initfn(Object *obj){ VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj); virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_INPUT_HOST);} |
1 | int qcow2_update_snapshot_refcount(BlockDriverState *bs, int64_t l1_table_offset, int l1_size, int addend){ BDRVQcowState *s = bs->opaque; uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated; int64_t old_offset, old_l2_offset; int i, j, l1_modified = 0, nb_csectors, refcount; int ret; l2_table = NU... |
1 | int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs){ int i, b, c_idx = 0; int32_t *dst = (int32_t *)_dst; DiracGolombLUT *future[4], *l = &lut_ctx[2*LUT_SIZE + buf[0]]; INIT_RESIDUE(res); for (b = 1; b <= bytes; b++) { future[0] = &lut_ctx[buf[b]]; future[1]... |
1 | static uint32_t syborg_virtio_readl(void *opaque, target_phys_addr_t offset){ SyborgVirtIOProxy *s = opaque; VirtIODevice *vdev = s->vdev; uint32_t ret; DPRINTF("readl 0x%x\n", (int)offset); if (offset >= SYBORG_VIRTIO_CONFIG) { return virtio_config_readl(vdev, offset - SYBORG_VIRTIO_CONFIG); } switch(offset >> 2) { ca... |
1 | static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp){ int ret = 0; int64_t total_size = 0; NFSClient *client = g_new0(NFSClient, 1); QDict *options = NULL; client->aio_context = qemu_get_aio_context(); /* Read out options */ total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), BDRV... |
1 | int setenv(const char *name, const char *value, int overwrite){ int result = 0; if (overwrite || !getenv(name)) { size_t length = strlen(name) + strlen(value) + 2; char *string = g_malloc(length); snprintf(string, length, "%s=%s", name, value); result = putenv(string); } return result;} |
1 | static void clone_tables(H264Context *dst, H264Context *src){ dst->intra4x4_pred_mode = src->intra4x4_pred_mode; dst->non_zero_count = src->non_zero_count; dst->slice_table = src->slice_table; dst->cbp_table = src->cbp_table; dst->mb2b_xy = src->mb2b_xy; dst->mb2b8_xy = src->mb2b8_xy; dst->chroma_pred_mode_table = src-... |
1 | static void adb_kbd_reset(DeviceState *dev){ ADBDevice *d = ADB_DEVICE(dev); KBDState *s = ADB_KEYBOARD(dev); d->handler = 1; d->devaddr = ADB_DEVID_KEYBOARD; memset(s->data, 0, sizeof(s->data)); s->rptr = 0; s->wptr = 0; s->count = 0;} |
1 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference){ int i, mb_x, mb_y; uint8_t* data[MAX_COMPONENTS]; const uint8_t *reference_data[MAX_COMPONENTS]; int linesize[MAX_COMPONENTS]; GetBitContext mb_bitmask_gb; if (mb_bitmask) { init_... |
0 | static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, int64_t dts, int64_t next){ AVIOContext *pb = s->pb; AVStream *st = NULL; char buf[20]; int ret = AVERROR_INVALIDDATA; int i, length = -1; switch (avio_r8(pb)) { case AMF_DATA_TYPE_MIXEDARRAY: avio_seek(pb, 4, SEEK_CUR); case AMF_DATA_TYPE_OBJECT: break; def... |
0 | void ff_h264_write_back_intra_pred_mode(H264Context *h){ int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy]; AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4); mode[4]= h->intra4x4_pred_mode_cache[7+8*3]; mode[5]= h->intra4x4_pred_mode_cache[7+8*2]; mode[6]= h->intra4x4_pred_mode_cache[7+8*1];} |
1 | static int noise(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe){ unsigned int *state= bsfc->priv_data; int amount= args ? atoi(args) : (*state % 10001+1); int i; *poutbuf= av_malloc(buf_size + FF_INPUT_BUFFER... |
0 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference){ int i, mb_x, mb_y; uint8_t* data[MAX_COMPONENTS]; const uint8_t *reference_data[MAX_COMPONENTS]; int linesize[MAX_COMPONENTS]; GetBitContext mb_bitmask_gb; if (mb_bitmask) { init_... |
1 | static void qcow2_invalidate_cache(BlockDriverState *bs){ BDRVQcowState *s = bs->opaque; int flags = s->flags; AES_KEY aes_encrypt_key; AES_KEY aes_decrypt_key; uint32_t crypt_method = 0; QDict *options; /* * Backing files are read-only which makes all of their metadata immutable, * that means we don't have to worry ab... |
1 | static av_cold int avui_encode_init(AVCodecContext *avctx){ avctx->coded_frame = av_frame_alloc(); if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) { av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n"); return AVERROR(EINVAL); } if (!avctx->coded_frame) { av_log(avctx, AV_LO... |
1 | void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val){ uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar, ar->tmr.overflow_time); if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) { /* if TMRSTS is reset, then compute the new overflow time */ acpi_pm_tmr_calc_overflow_time(ar); } ar->pm1.evt.sts &= ~val;} |
0 | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPADecodeContext *s = avctx->priv_data; uint32_t header; int ret; if (buf_size < HEADER_SIZE) return AVERROR_INVALIDDATA; header = AV_RB32(buf); if (ff_mpa_chec... |
0 | int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options){ int ret = 0; AVDictionary *tmp = NULL; if (avcodec_is_open(avctx)) return 0; if ((!codec && !avctx->codec)) { av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n"); return AVERROR(EINVAL); } if ((codec... |
0 | static int get_transform_coeffs1(uint8_t *exps, uint8_t *bap, float chcoeff, float *coeffs, int start, int end, int dith_flag, GetBitContext *gb, dither_state *state){ int16_t mantissa; int i; int gcode; mant_group l3_grp, l5_grp, l11_grp; for (i = 0; i < 3; i++) l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i] ... |
0 | static int usb_host_update_interfaces(USBHostDevice *dev, int configuration){ int dev_descr_len, config_descr_len; int interface, nb_interfaces, nb_configurations; int ret, i; if (configuration == 0) /* address state - ignore */ return 1; i = 0; dev_descr_len = dev->descr[0]; if (dev_descr_len > dev->descr_len) goto fa... |
0 | static int get_block_status(BlockDriverState *bs, int64_t offset, int64_t bytes, MapEntry *e){ int64_t ret; int depth; BlockDriverState *file; bool has_offset; int nb_sectors = bytes >> BDRV_SECTOR_BITS; assert(bytes < INT_MAX); /* As an optimization, we could cache the current range of unallocated * clusters in each f... |
0 | static void *colo_compare_thread(void *opaque){ CompareState *s = opaque; GSource *timeout_source; s->worker_context = g_main_context_new(); qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read, compare_pri_chr_in, NULL, NULL, s, s->worker_context, true); qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_ca... |
0 | static int find_image_format(BlockDriverState *bs, const char *filename, BlockDriver **pdrv, Error **errp){ BlockDriver *drv; uint8_t buf[BLOCK_PROBE_BUF_SIZE]; int ret = 0; /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) { *pdrv... |
0 | static int fits_write_packet(AVFormatContext *s, AVPacket *pkt){ write_image_header(s); avio_write(s->pb, pkt->data, pkt->size); return 0;} |
0 | static void uart_parameters_setup(UartState *s){ QEMUSerialSetParams ssp; unsigned int baud_rate, packet_size; baud_rate = (s->r[R_MR] & UART_MR_CLKS) ? UART_INPUT_CLK / 8 : UART_INPUT_CLK; ssp.speed = baud_rate / (s->r[R_BRGR] * (s->r[R_BDIV] + 1)); packet_size = 1; switch (s->r[R_MR] & UART_MR_PAR) { case UART_PARITY... |
0 | eth_read(void *opaque, target_phys_addr_t addr, unsigned int size){struct fs_eth *eth = opaque;uint32_t r = 0;addr >>= 2;switch (addr) {case R_STAT:r = eth->mdio_bus.mdio & 1;break;default:r = eth->regs[addr];D(printf ("%s %x\n", __func__, addr * 4));break;}return r;} |
0 | int vnc_display_open(DisplayState *ds, const char *display){ VncState *vs = ds ? (VncState *)ds->opaque : vnc_state; const char *options; int password = 0; int reverse = 0; int to_port = 0;#ifdef CONFIG_VNC_TLS int tls = 0, x509 = 0;#endif vnc_display_close(ds); if (strcmp(display, "none") == 0)return 0; if (!(vs->disp... |
0 | static void nabm_writeb (void *opaque, uint32_t addr, uint32_t val){ PCIAC97LinkState *d = opaque; AC97LinkState *s = &d->ac97; AC97BusMasterRegs *r = NULL; uint32_t index = addr - s->base[1]; switch (index) { case PI_LVI: case PO_LVI: case MC_LVI: r = &s->bm_regs[GET_BM (index)]; if ((r->cr & CR_RPBM) && (r->sr & SR_D... |
0 | void helper_xssubqp(CPUPPCState *env, uint32_t opcode){ ppc_vsr_t xt, xa, xb; float_status tstat; getVSR(rA(opcode) + 32, &xa, env); getVSR(rB(opcode) + 32, &xb, env); getVSR(rD(opcode) + 32, &xt, env); helper_reset_fpstatus(env); if (unlikely(Rc(opcode) != 0)) { /* TODO: Support xssubqp after round-to-odd is implement... |
0 | void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent){ ar->wakeup.notify = acpi_notify_wakeup; qemu_register_wakeup_notifier(&ar->wakeup); memory_region_init_io(&ar->pm1.cnt.io, &acpi_pm_cnt_ops, ar, "acpi-cnt", 2); memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);} |
0 | static void vfio_probe_nvidia_bar0_quirk(VFIOPCIDevice *vdev, int nr){ VFIOQuirk *quirk; VFIOConfigMirrorQuirk *mirror; if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) || !vfio_is_vga(vdev) || nr != 0) { return; } quirk = g_malloc0(sizeof(*quirk)); mirror = quirk->data = g_malloc0(sizeof(*mirror)); mirror->mem... |
0 | static int mkv_write_tag_targets(AVFormatContext *s, unsigned int elementid, unsigned int uid, ebml_master *tags, ebml_master* tag){ AVIOContext *pb; MatroskaMuxContext *mkv = s->priv_data; ebml_master targets; int ret; if (!tags->pos) { ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(s->pb... |
0 | static int v9fs_synth_symlink(FsContext *fs_ctx, const char *oldpath, V9fsPath *newpath, const char *buf, FsCred *credp){ errno = EPERM; return -1;} |
0 | static uint32_t virtio_ioport_read(void *opaque, uint32_t addr){ VirtIODevice *vdev = to_virtio_device(opaque); uint32_t ret = 0xFFFFFFFF; addr -= vdev->addr; switch (addr) { case VIRTIO_PCI_HOST_FEATURES: ret = vdev->get_features(vdev); ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY); break; case VIRTIO_PCI_GUEST_FEATURES: ret... |
1 | static void sb16_realizefn (DeviceState *dev, Error **errp){ ISADevice *isadev = ISA_DEVICE (dev); SB16State *s = SB16 (dev); IsaDmaClass *k; isa_init_irq (isadev, &s->pic, s->irq); s->mixer_regs[0x80] = magic_of_irq (s->irq); s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma); s->mixer_regs[0x82] = 2 << 5; s->csp_re... |
1 | static int slavio_misc_init1(SysBusDevice *sbd){ DeviceState *dev = DEVICE(sbd); MiscState *s = SLAVIO_MISC(dev); sysbus_init_irq(sbd, &s->irq); sysbus_init_irq(sbd, &s->fdc_tc); /* 8 bit registers */ /* Slavio control */ memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_cfg_mem_ops, s, "configuration", MISC_SIZE... |
1 | static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr, Error **errp){ QIOChannelSocket *sioc; Error *local_err = NULL; sioc = qio_channel_socket_new(); qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client"); qio_channel_socket_connect_sync(sioc, saddr, &local_err); if (local_err) { error_propagate(errp,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.