label
int64
0
1
func
stringlengths
21
96.3k
1
static void decode_array_0000(APEContext *ctx, GetBitContext *gb, int32_t *out, APERice *rice, int blockstodecode){ int i; int ksummax, ksummin; rice->ksum = 0; for (i = 0; i < 5; i++) { out[i] = get_rice_ook(&ctx->gb, 10); rice->ksum += out[i]; } rice->k = av_log2(rice->ksum / 10) + 1; for (; i < 64; i++) { out[i] = g...
0
static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { int i, d; const int index_a = qp + h->slice_alpha_c0_offset; const int alpha = (alpha_table+52)[index_a]; const int beta = (beta_table+52)[qp + h->slice_beta_offset]; const int pix_next = stride; if( bS[0] < 4 ) { int8_t tc...
1
int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg){ struct kvm_msi msi; KVMMSIRoute *route; if (s->direct_msi) { msi.address_lo = (uint32_t)msg.address; msi.address_hi = msg.address >> 32; msi.data = le32_to_cpu(msg.data); msi.flags = 0; memset(msi.pad, 0, sizeof(msi.pad)); return kvm_vm_ioctl(s, KVM_SIGNAL_MSI, &ms...
1
void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert){ sd->readonly_cb = readonly; sd->inserted_cb = insert; qemu_set_irq(readonly, bdrv_is_read_only(sd->bdrv)); qemu_set_irq(insert, bdrv_is_inserted(sd->bdrv));}
1
static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags){ MOVStreamContext *sc = st->priv_data; int sample, time_sample; int i; sample = av_index_search_timestamp(st, timestamp, flags); av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample)...
1
static int advanced_decode_i_mbs(VC9Context *v){ MpegEncContext *s = &v->s; GetBitContext *gb = &v->s.gb; int mqdiff, mquant, current_mb = 0, over_flags_mb = 0; for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++) { for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++) { if (v->ac_pred_plane.is_raw) s->ac_pred = get_bits(gb, 1);...
1
static int altivec_uyvy_rgb32 (SwsContext *c, unsigned char **in, int *instrides, int srcSliceY,int srcSliceH, unsigned char **oplanes, int *outstrides){ int w = c->srcW; int h = srcSliceH; int i,j; vector unsigned char uyvy; vector signed short Y,U,V; vector signed short R0,G0,B0,R1,G1,B1; vector unsigned char R,G,B; ...
1
static void test_primitives(gconstpointer opaque){ TestArgs *args = (TestArgs *) opaque; const SerializeOps *ops = args->ops; PrimitiveType *pt = args->test_data; PrimitiveType *pt_copy = g_malloc0(sizeof(*pt_copy)); Error *err = NULL; void *serialize_data; char *double1, *double2; pt_copy->type = pt->type; ops->serial...
1
static int qcow_write_snapshots(BlockDriverState *bs){ BDRVQcowState *s = bs->opaque; QCowSnapshot *sn; QCowSnapshotHeader h; int i, name_size, id_str_size, snapshots_size; uint64_t data64; uint32_t data32; int64_t offset, snapshots_offset; /* compute the size of the snapshots */ offset = 0; for(i = 0; i < s->nb_snapsh...
1
void sigaction_invoke(struct sigaction *action, struct qemu_signalfd_siginfo *info){ siginfo_t si = { 0 }; si.si_signo = info->ssi_signo; si.si_errno = info->ssi_errno; si.si_code = info->ssi_code; /* Convert the minimal set of fields defined by POSIX. * Positive si_code values are reserved for kernel-generated * signa...
1
static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref){ PixdescTestContext *priv = inlink->dst->priv; AVFilterLink *outlink = inlink->dst->outputs[0]; AVFilterBufferRef *outpicref; int i; outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h); outpicref = outlink-...
1
void av_noreturn exit_program(int ret){ int i, j; for (i = 0; i < nb_filtergraphs; i++) { avfilter_graph_free(&filtergraphs[i]->graph); for (j = 0; j < filtergraphs[i]->nb_inputs; j++) av_freep(&filtergraphs[i]->inputs[j]); av_freep(&filtergraphs[i]->inputs); for (j = 0; j < filtergraphs[i]->nb_outputs; j++) av_freep(&...
1
static void openrisc_pic_cpu_handler(void *opaque, int irq, int level){ OpenRISCCPU *cpu = (OpenRISCCPU *)opaque; CPUState *cs = CPU(cpu); uint32_t irq_bit = 1 << irq; if (irq > 31 || irq < 0) { return; } if (level) { cpu->env.picsr |= irq_bit; } else { cpu->env.picsr &= ~irq_bit; } if (cpu->env.picsr & cpu->env.picmr)...
0
static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom){ int ret = 0; int length = 0; uint64_t original_size; if (c->fc->nb_streams >= 1) { AVCodecContext *codec = c->fc->streams[c->fc->nb_streams-1]->codec; if (codec->codec_id == AV_CODEC_ID_H264) return 0; if (atom.size == 16) { original_size = codec->...
0
static av_always_inline void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb, VP8FilterStrength *f ){ int interior_limit, filter_level; if (s->segmentation.enabled) { filter_level = s->segmentation.filter_level[s->segment]; if (!s->segmentation.absolute_vals) filter_level += s->filter.level; } else filter_level = ...
1
void rgb15tobgr16(const uint8_t *src, uint8_t *dst, long src_size){long i;long num_pixels = src_size >> 1;for(i=0; i<num_pixels; i++){ unsigned b,g,r; register uint16_t rgb; rgb = src[2*i]; r = rgb&0x1F; g = (rgb&0x3E0)>>5; b = (rgb&0x7C00)>>10; dst[2*i] = (b&0x1F) | ((g&0x3F)<<5) | ((r&0x1F)<<11);}}
1
static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, int opc){ int addr_reg, data_reg, arg0, arg1, arg2, mem_index, s_bits;#if defined(CONFIG_SOFTMMU) uint32_t *label1_ptr, *label2_ptr; data_reg = *args++; addr_reg = *args++; mem_index = *args; s_bits = opc & 3; arg0 = TCG_REG_O0; arg1 = TCG_REG_O1; arg2 = TC...
1
static int mxf_read_index_table_segment(MXFIndexTableSegment *segment, ByteIOContext *pb, int tag){ switch(tag) { case 0x3F05: dprintf(NULL, "EditUnitByteCount %d\n", get_be32(pb)); break; case 0x3F06: dprintf(NULL, "IndexSID %d\n", get_be32(pb)); break; case 0x3F07: dprintf(NULL, "BodySID %d\n", get_be32(pb)); break; ...
1
static const char *vnc_auth_name(VncDisplay *vd) { switch (vd->auth) { case VNC_AUTH_INVALID: return "invalid"; case VNC_AUTH_NONE: return "none"; case VNC_AUTH_VNC: return "vnc"; case VNC_AUTH_RA2: return "ra2"; case VNC_AUTH_RA2NE: return "ra2ne"; case VNC_AUTH_TIGHT: return "tight"; case VNC_AUTH_ULTRA: return "ultr...
1
static void cpu_x86_register(X86CPU *cpu, const char *name, Error **errp){ CPUX86State *env = &cpu->env; x86_def_t def1, *def = &def1; memset(def, 0, sizeof(*def)); if (cpu_x86_find_by_name(cpu, def, name) < 0) { error_setg(errp, "Unable to find CPU definition: %s", name); return; } if (kvm_enabled()) { def->features[F...
1
int bdrv_pwrite(BlockDriverState *bs, int64_t offset, const void *buf1, int count1){ BlockDriver *drv = bs->drv; if (!drv) return -ENOMEDIUM; if (!drv->bdrv_pwrite) return bdrv_pwrite_em(bs, offset, buf1, count1); return drv->bdrv_pwrite(bs, offset, buf1, count1);}
0
static void yuv2nv12X_c(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, int dstW, int chrDstW){ enum P...
1
static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes, QEMUIOVector *qiov, CoroutineEntry co_entry, BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque){ BlkAioEmAIOCB *acb; Coroutine *co; bdrv_inc_in_flight(blk_bs(blk)); acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); acb->...
1
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2){ MpegEncContext *s = avctx->priv_data; int mb_count, mb_pos, left, start_mb_x; init_get_bits(&s->gb, buf, buf_size*8); if(s->codec_id ==CODEC_ID_RV10) mb_count = rv10_decode_picture_header(s); else mb_count = rv20_deco...
1
static void coroutine_fn add_aio_request(BDRVSheepdogState *s, AIOReq *aio_req, struct iovec *iov, int niov, bool create, enum AIOCBState aiocb_type){ int nr_copies = s->inode.nr_copies; SheepdogObjReq hdr; unsigned int wlen = 0; int ret; uint64_t oid = aio_req->oid; unsigned int datalen = aio_req->data_len; uint64_t o...
1
static void init_proc_750gx (CPUPPCState *env){ gen_spr_ne_601(env); gen_spr_7xx(env); /* XXX : not implemented (XXX: different from 750fx) */ spr_register(env, SPR_L2CR, "L2CR", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, NULL, 0x00000000); /* Time base */ gen_tbl(env); /* Thermal management */ gen_spr_thrm(env); /...
1
static int cloop_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVCloopState *s = bs->opaque; uint32_t offsets_size, max_compressed_block_size = 1, i; int ret; bs->read_only = 1; /* read header */ ret = bdrv_pread(bs->file, 128, &s->block_size, 4); if (ret < 0) { return ret; } s->block_size = be...
1
static void spapr_tce_table_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); dc->vmsd = &vmstate_spapr_tce_table; dc->init = spapr_tce_table_realize; dc->reset = spapr_tce_reset; QLIST_INIT(&spapr_tce_tables); /* hcall-tce */ spapr_register_hypercall(H_PUT_TCE, h_put_tce);}
1
static void gmc1_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture){ uint8_t *ptr; int src_x, src_y, motion_x, motion_y; ptrdiff_t offset, linesize, uvlinesize; int emu = 0; motion_x = s->sprite_offset[0][0]; motion_y = s->sprite_offset[0][1]; src_x = s->mb_x * 16 + (m...
0
static void gxf_write_padding(ByteIOContext *pb, offset_t to_pad){ while (to_pad--) { put_byte(pb, 0); }}
0
static int aea_read_header(AVFormatContext *s){ AVStream *st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); /* Parse the amount of channels and skip to pos 2048(0x800) */ avio_skip(s->pb, 264); st->codec->channels = avio_r8(s->pb); avio_skip(s->pb, 1783); st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st...
0
static void spr_write_ibatl (void *opaque, int sprn){ DisasContext *ctx = opaque; gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2); RET_STOP(ctx);}
0
static void gen_eob_inhibit_irq(DisasContext *s, bool inhibit){ gen_update_cc_op(s); /* If several instructions disable interrupts, only the first does it. */ if (inhibit && !(s->flags & HF_INHIBIT_IRQ_MASK)) { gen_set_hflag(s, HF_INHIBIT_IRQ_MASK); } else { gen_reset_hflag(s, HF_INHIBIT_IRQ_MASK); } if (s->tb->flags &...
0
void tb_invalidate_page_range(target_ulong start, target_ulong end){ /* XXX: cannot enable it yet because it yields to MMU exception where NIP != read address on PowerPC */#if 0 target_ulong phys_addr; phys_addr = get_phys_addr_code(env, start); tb_invalidate_phys_page_range(phys_addr, phys_addr + end - start, 0);#endi...
0
static bool kvmppc_is_pr(KVMState *ks){ /* Assume KVM-PR if the GET_PVINFO capability is available */ return kvm_check_extension(ks, KVM_CAP_PPC_GET_PVINFO) != 0;}
0
void aio_set_fd_handler(AioContext *ctx, int fd, IOHandler *io_read, IOHandler *io_write, AioFlushHandler *io_flush, void *opaque){ AioHandler *node; node = find_aio_handler(ctx, fd); /* Are we deleting the fd handler? */ if (!io_read && !io_write) { if (node) { /* If the lock is held, just mark the node as deleted */ ...
0
static uint64_t gic_do_cpu_read(void *opaque, target_phys_addr_t addr, unsigned size){ GICState **backref = (GICState **)opaque; GICState *s = *backref; int id = (backref - s->backref); return gic_cpu_read(s, id, addr);}
0
void bdrv_io_unplug(BlockDriverState *bs){ BlockDriver *drv = bs->drv; if (drv && drv->bdrv_io_unplug) { drv->bdrv_io_unplug(bs); } else if (bs->file) { bdrv_io_unplug(bs->file->bs); }}
0
static void ehci_advance_async_state(EHCIState *ehci){ const int async = 1; switch(ehci_get_state(ehci, async)) { case EST_INACTIVE: if (!ehci_async_enabled(ehci)) { break; } ehci_set_state(ehci, async, EST_ACTIVE); // No break, fall through to ACTIVE case EST_ACTIVE: if (!ehci_async_enabled(ehci)) { ehci_queues_rip_al...
0
static int rpl_read_header(AVFormatContext *s, AVFormatParameters *ap){ AVIOContext *pb = s->pb; RPLContext *rpl = s->priv_data; AVStream *vst = NULL, *ast = NULL; int total_audio_size; int error = 0; uint32_t i; int32_t audio_format, chunk_catalog_offset, number_of_chunks; AVRational fps; char line[RPL_LINE_LENGTH]; /...
0
static QDict *monitor_parse_arguments(Monitor *mon, const char **endp, const mon_cmd_t *cmd){ const char *typestr; char *key; int c; const char *p = *endp; char buf[1024]; QDict *qdict = qdict_new(); /* parse the parameters */ typestr = cmd->args_type; for(;;) { typestr = key_get_info(typestr, &key); if (!typestr) brea...
0
static void visitor_input_teardown(TestInputVisitorData *data, const void *unused){ qobject_decref(data->obj); data->obj = NULL; if (data->qiv) { visit_free(data->qiv); data->qiv = NULL; }}
0
MigrationState *migrate_get_current(void){ static bool once; static MigrationState current_migration = { .state = MIGRATION_STATUS_NONE, .xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE, .mbps = -1, .parameters = { .compress_level = DEFAULT_MIGRATE_COMPRESS_LEVEL, .compress_threads = DEFAULT_MIGRATE_COMPRESS_THREAD_COUN...
0
static int coroutine_fn qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len){ QEDAIOCB *acb = opaque; BDRVQEDState *s = acb_to_s(acb); BlockDriverState *bs = acb->bs; /* Adjust offset into cluster */ offset += qed_offset_into_cluster(s, acb->cur_pos); trace_qed_aio_read_data(s, acb, ret, offset, len); ...
0
static void portio_list_add_1(PortioList *piolist, const MemoryRegionPortio *pio_init, unsigned count, unsigned start, unsigned off_low, unsigned off_high){ MemoryRegionPortio *pio; MemoryRegionOps *ops; MemoryRegion *region, *alias; unsigned i; /* Copy the sub-list and null-terminate it. */ pio = g_new(MemoryRegionPor...
0
static int bochs_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors){ int ret; while (nb_sectors > 0) { int64_t block_offset = seek_to_sector(bs, sector_num); if (block_offset >= 0) { ret = bdrv_pread(bs->file, block_offset, buf, 512); if (ret != 512) { return -1; } } else memset(buf, 0, 512); ...
0
static void visit_nested_struct_list(Visitor *v, void **native, Error **errp){ visit_type_UserDefNestedList(v, (UserDefNestedList **)native, NULL, errp);}
0
int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Context *h0){ unsigned int first_mb_in_slice; unsigned int pps_id; int ret; unsigned int slice_type, tmp, i, j; int default_ref_list_done = 0; int last_pic_structure, last_pic_droppable; int needs_reinit = 0; int field_pic_flag, bottom_field_flag...
1
Object *qio_task_get_source(QIOTask *task){ object_ref(task->source); return task->source;}
1
static void gen_ldx(DisasContext *dc, uint32_t code, uint32_t flags){ I_TYPE(instr, code); TCGv addr = tcg_temp_new(); TCGv data; /* * WARNING: Loads into R_ZERO are ignored, but we must generate the * memory access itself to emulate the CPU precisely. Load * from a protected page to R_ZERO will cause SIGSEGV on * the ...
0
static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit){ MpegTSContext *ts = s->priv_data; int64_t pos; int pos47 = ts->pos47_full % ts->raw_packet_size; pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47; ff_read_frame_flu...
1
static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m){ BDRVQcowState *s = bs->opaque; int l2_index; uint64_t *l2_table; uint64_t entry; unsigned int nb_clusters; int ret; uint64_t alloc_cluster_offset; trace_qcow2_handle_alloc(qemu_coroutine_self(),...
1
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *data_size, UINT8 *buf, int buf_size){ MpegEncContext *s = avctx->priv_data; int i, mb_count, mb_pos, left; DCTELEM block[6][64]; AVPicture *pict = data; #ifdef DEBUG printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);#endif /* no supplem...
0
static int http_open(URLContext *h, const char *uri, int flags){ HTTPContext *s = h->priv_data; h->is_streamed = 1; s->filesize = -1; av_strlcpy(s->location, uri, sizeof(s->location)); if (s->headers) { int len = strlen(s->headers); if (len < 2 || strcmp("\r\n", s->headers + len - 2)) av_log(h, AV_LOG_WARNING, "No trai...
1
static inline void softusb_read_pmem(MilkymistSoftUsbState *s, uint32_t offset, uint8_t *buf, uint32_t len){ if (offset + len >= s->pmem_size) { error_report("milkymist_softusb: read pmem out of bounds " "at offset 0x%x, len %d", offset, len); return; } memcpy(buf, s->pmem_ptr + offset, len);}
1
int attribute_align_arg sws_scale(struct SwsContext *c, const uint8_t * const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[]){ int i, ret; const uint8_t *src2[4] = { srcSlice[0], srcSlice[1], srcSlice[2], srcSlice[3] }; uint8_t *dst2[4] = { dst[0], dst[1], d...
1
static av_cold int MPA_encode_init(AVCodecContext *avctx){ MpegAudioContext *s = avctx->priv_data; int freq = avctx->sample_rate; int bitrate = avctx->bit_rate; int channels = avctx->channels; int i, v, table; float a; if (channels <= 0 || channels > 2){ av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowe...
1
static av_cold int vc1_decode_init(AVCodecContext *avctx){ VC1Context *v = avctx->priv_data; MpegEncContext *s = &v->s; GetBitContext gb; int ret; /* save the container output size for WMImage */ v->output_width = avctx->width; v->output_height = avctx->height; if (!avctx->extradata_size || !avctx->extradata) return -1...
1
int ff_h264_fill_default_ref_list(H264Context *h){ int i, len; if (h->slice_type_nos == AV_PICTURE_TYPE_B) { Picture *sorted[32]; int cur_poc, list; int lens[2]; if (FIELD_PICTURE(h)) cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; else cur_poc = h->cur_pic_ptr->poc; for (list = 0; list ...
1
static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref){ AVFilterContext *ctx = link->dst; CropContext *crop = ctx->priv; AVFilterBufferRef *ref2; int i; picref->video->w = crop->w; picref->video->h = crop->h; ref2 = avfilter_ref_buffer(picref, ~0); crop->var_values[VAR_T] = picref->pts == AV_NOPTS_VALUE...
1
static void gen_tlbsx_440(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else TCGv t0; if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } t0 = tcg_temp_new(); gen_addr_reg_index(ctx, t0); gen_helper_440_tlbsx(cpu_gpr[rD(ctx->opcode)], c...
1
static void blockdev_backup_prepare(BlkActionState *common, Error **errp){ BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common); BlockdevBackup *backup; BlockDriverState *bs, *target; Error *local_err = NULL; assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP); backup = common...
1
static int guest_get_network_stats(const char *name, GuestNetworkInterfaceStat *stats){ DWORD if_index = 0; MIB_IFROW a_mid_ifrow; memset(&a_mid_ifrow, 0, sizeof(a_mid_ifrow)); if_index = get_interface_index(name); a_mid_ifrow.dwIndex = if_index; if (NO_ERROR == GetIfEntry(&a_mid_ifrow)) { stats->rx_bytes = a_mid_ifrow...
0
void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info){ CPUARMState *env = &cpu->env; int kernel_size; int initrd_size; int n; int is_linux = 0; uint64_t elf_entry; target_phys_addr_t entry; int big_endian; QemuOpts *machine_opts; /* Load the kernel. */ if (!info->kernel_filename) { fprintf(stderr, "Kernel image...
0
static CharDriverState *qemu_chr_open_null(void){ CharDriverState *chr; chr = g_malloc0(sizeof(CharDriverState)); chr->chr_write = null_chr_write; chr->explicit_be_open = true; return chr;}
0
static bool nvic_rettobase(NVICState *s){ int irq, nhand = 0; for (irq = ARMV7M_EXCP_RESET; irq < s->num_irq; irq++) { if (s->vectors[irq].active) { nhand++; if (nhand == 2) { return 0; } } } return 1;}
0
void ioinst_handle_xsch(S390CPU *cpu, uint64_t reg1){ int cssid, ssid, schid, m; SubchDev *sch; int ret = -ENODEV; int cc; if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) { program_interrupt(&cpu->env, PGM_OPERAND, 2); return; } trace_ioinst_sch_id("xsch", cssid, ssid, schid); sch = css_find_subch(m,...
0
static int vtd_dev_to_context_entry(IntelIOMMUState *s, uint8_t bus_num, uint8_t devfn, VTDContextEntry *ce){ VTDRootEntry re; int ret_fr; X86IOMMUState *x86_iommu = X86_IOMMU_DEVICE(s); ret_fr = vtd_get_root_entry(s, bus_num, &re); if (ret_fr) { return ret_fr; } if (!vtd_root_entry_present(&re)) { /* Not error - it's ...
0
static void do_interrupt_real(int intno, int is_int, int error_code, unsigned int next_eip){ SegmentCache *dt; uint8_t *ptr, *ssp; int selector; uint32_t offset, esp; uint32_t old_cs, old_eip; /* real mode (simpler !) */ dt = &env->idt; if (intno * 4 + 3 > dt->limit) raise_exception_err(EXCP0D_GPF, intno * 8 + 2); ptr ...
0
void ff_ass_init(AVSubtitle *sub){ memset(sub, 0, sizeof(*sub));}
0
uint64_t helper_stl_c_raw(uint64_t t0, uint64_t t1){ uint64_t ret; if (t1 == env->lock) { stl_raw(t1, t0); ret = 0; } else ret = 1; env->lock = 1; return ret;}
0
int AUD_read (SWVoiceIn *sw, void *buf, int size){ int bytes; if (!sw) { /* XXX: Consider options */ return size; } if (!sw->hw->enabled) { dolog ("Reading from disabled voice %s\n", SW_NAME (sw)); return 0; } bytes = sw->hw->pcm_ops->read (sw, buf, size); return bytes;}
0
QEMUFile *qemu_fopen_ops_buffered(void *opaque, size_t bytes_per_sec, BufferedPutFunc *put_buffer, BufferedPutReadyFunc *put_ready, BufferedWaitForUnfreezeFunc *wait_for_unfreeze, BufferedCloseFunc *close){ QEMUFileBuffered *s; s = qemu_mallocz(sizeof(*s)); s->opaque = opaque; s->xfer_limit = bytes_per_sec / 10; s->put...
0
int keysym2scancode(void *kbd_layout, int keysym){ kbd_layout_t *k = kbd_layout; if (keysym < MAX_NORMAL_KEYCODE) { if (k->keysym2keycode[keysym] == 0) { trace_keymap_unmapped(keysym); fprintf(stderr, "Warning: no scancode found for keysym %d\n", keysym); } return k->keysym2keycode[keysym]; } else { int i;#ifdef XK_ISO...
0
gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUM68KState *env = &cpu->env; DisasContext dc1, *dc = &dc1; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj; target_ulong pc_start; int pc_offset; int num_insns; int max_insns; /* generate intermediate code...
0
static CCPrepare gen_prepare_eflags_c(DisasContext *s, TCGv reg){ TCGv t0, t1; int size, shift; switch (s->cc_op) { case CC_OP_SUBB ... CC_OP_SUBQ: /* (DATA_TYPE)(CC_DST + CC_SRC) < (DATA_TYPE)CC_SRC */ size = s->cc_op - CC_OP_SUBB; t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false); /* If no temporary was used, be car...
0
static void pflash_cfi01_realize(DeviceState *dev, Error **errp){ pflash_t *pfl = CFI_PFLASH01(dev); uint64_t total_len; int ret; uint64_t blocks_per_device, device_len; int num_devices; Error *local_err = NULL; total_len = pfl->sector_len * pfl->nb_blocs; /* These are only used to expose the parameters of each device ...
0
static long do_rt_sigreturn_v2(CPUARMState *env){ abi_ulong frame_addr; struct rt_sigframe_v2 *frame = NULL; /* * Since we stacked the signal on a 64-bit boundary, * then 'sp' should be word aligned here. If it's * not, then the user is trying to mess with us. */ frame_addr = env->regs[13]; trace_user_do_rt_sigreturn(e...
0
void bdrv_drain_all_begin(void){ /* Always run first iteration so any pending completion BHs run */ bool waited = true; BlockDriverState *bs; BdrvNextIterator it; GSList *aio_ctxs = NULL, *ctx; block_job_pause_all(); for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { AioContext *aio_context = bdrv_get_aio_context(bs...
1
static size_t qemu_rdma_save_page(QEMUFile *f, void *opaque, ram_addr_t block_offset, ram_addr_t offset, size_t size, int *bytes_sent){ QEMUFileRDMA *rfile = opaque; RDMAContext *rdma = rfile->rdma; int ret; CHECK_ERROR_STATE(); qemu_fflush(f); if (size > 0) { /* * Add this page to the current 'chunk'. If the chunk * i...
1
int xen_be_init(void){ xenstore = xs_daemon_open(); if (!xenstore) { xen_be_printf(NULL, 0, "can't connect to xenstored\n"); return -1; } if (qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL) < 0) { goto err; } if (xen_xc == XC_HANDLER_INITIAL_VALUE) { /* Check if xen_init() have been called */ goto...
1
static void guess_palette(DVDSubContext* ctx, uint32_t *rgba_palette, uint32_t subtitle_color){ static const uint8_t level_map[4][4] = { // this configuration (full range, lowest to highest) in tests // seemed most common, so assume this {0xff}, {0x00, 0xff}, {0x00, 0x80, 0xff}, {0x00, 0x55, 0xaa, 0xff}, }; uint8_t col...
1
int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice){ MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp; int mmco_index = 0, i; assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); if (h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.re...
1
ImgReSampleContext *img_resample_full_init(int owidth, int oheight, int iwidth, int iheight, int topBand, int bottomBand, int leftBand, int rightBand, int padtop, int padbottom, int padleft, int padright){ ImgReSampleContext *s; s = av_mallocz(sizeof(ImgReSampleContext)); if (!s) s->line_buf = av_mallocz(owidth * (LINE...
1
static abi_long do_socketcall(int num, abi_ulong vptr){ static const unsigned ac[] = { /* number of arguments per call */ [SOCKOP_socket] = 3, /* domain, type, protocol */ [SOCKOP_bind] = 3, /* sockfd, addr, addrlen */ [SOCKOP_connect] = 3, /* sockfd, addr, addrlen */ [SOCKOP_listen] = 2, /* sockfd, backlog */ [SOCKOP_...
1
static MemTxResult address_space_write_continue(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, const uint8_t *buf, int len, hwaddr addr1, hwaddr l, MemoryRegion *mr){ uint8_t *ptr; uint64_t val; MemTxResult result = MEMTX_OK; bool release_lock = false; for (;;) { if (!memory_access_is_direct(mr, true)) { release_lock...
1
void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp){ if (!error_is_set(errp)) { if (v->type_int64) { v->type_int64(v, obj, name, errp); } else { v->type_int(v, obj, name, errp); } }}
1
static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col){ int c0, c1, c2, c3, a0, a1, a2, a3; const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; a0 = col[8*0]; a1 = col[8*1]; a2 = col[8*2]; a3 = col[8*3]; c0 = (a0 + a2)*C3 + (1 << (C_SHIFT - 1)); c2 = (a0 - a2)*C3 + (1 << (C_SHIFT - 1)); c1 = a1 * ...
1
void bdrv_detach_aio_context(BlockDriverState *bs){ BdrvAioNotifier *baf; BdrvChild *child; if (!bs->drv) { return; } QLIST_FOREACH(baf, &bs->aio_notifiers, list) { baf->detach_aio_context(baf->opaque); } if (bs->drv->bdrv_detach_aio_context) { bs->drv->bdrv_detach_aio_context(bs); } QLIST_FOREACH(child, &bs->children,...
0
void cpu_ppc_reset (void *opaque){ CPUPPCState *env; target_ulong msr; env = opaque; msr = (target_ulong)0; if (0) { /* XXX: find a suitable condition to enable the hypervisor mode */ msr |= (target_ulong)MSR_HVB; } msr |= (target_ulong)0 << MSR_AP; /* TO BE CHECKED */ msr |= (target_ulong)0 << MSR_SA; /* TO BE CHECKED...
0
static void omap_sti_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ struct omap_sti_s *s = (struct omap_sti_s *) opaque; if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } switch (addr) { case 0x00:/* STI_REVISION */ case 0x14:/* STI_SYSSTATUS / STI_RX_STATUS / XTI_SYSST...
0
static void gdb_chr_event(void *opaque, int event){ switch (event) { case CHR_EVENT_RESET: vm_stop(EXCP_INTERRUPT); gdb_syscall_state = opaque; gdb_has_xml = 0; break; default: break; }}
0
static void release_keys(void *opaque){ int keycode; while (nb_pending_keycodes > 0) { nb_pending_keycodes--; keycode = keycodes[nb_pending_keycodes]; if (keycode & 0x80) kbd_put_keycode(0xe0); kbd_put_keycode(keycode | 0x80); }}
0
static int virtio_scsi_parse_req(VirtIOSCSIReq *req, unsigned req_size, unsigned resp_size){ VirtIODevice *vdev = (VirtIODevice *) req->dev; size_t in_size, out_size; if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, &req->req, req_size) < req_size) { return -EINVAL; } if (qemu_iovec_concat_iov(&req->resp_iov, req...
0
void pc_dimm_memory_unplug(DeviceState *dev, MemoryHotplugState *hpms, MemoryRegion *mr){ PCDIMMDevice *dimm = PC_DIMM(dev); numa_unset_mem_node_id(dimm->addr, memory_region_size(mr), dimm->node); memory_region_del_subregion(&hpms->mr, mr); vmstate_unregister_ram(mr, dev);}
0
static void kvm_handle_internal_error(CPUState *env, struct kvm_run *run){ if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) { int i; fprintf(stderr, "KVM internal error. Suberror: %d\n", run->internal.suberror); for (i = 0; i < run->internal.ndata; ++i) { fprintf(stderr, "extra data[%d]: %"PRIx64"\n", i...
0
void ff_slice_buffer_init(slice_buffer *buf, int line_count, int max_allocated_lines, int line_width, IDWTELEM *base_buffer){ int i; buf->base_buffer = base_buffer; buf->line_count = line_count; buf->line_width = line_width; buf->data_count = max_allocated_lines; buf->line = av_mallocz(sizeof(IDWTELEM *) * line_count);...
0
static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src, InputEvent *evt){ struct XenInput *xenfb = (struct XenInput *)dev; InputBtnEvent *btn; InputMoveEvent *move; QemuConsole *con; DisplaySurface *surface; int scale; switch (evt->type) { case INPUT_EVENT_KIND_BTN: btn = evt->u.btn.data; switch (btn->button)...
0
static CharDriverState *qemu_chr_open_socket_fd(int fd, bool do_nodelay, bool is_listen, bool is_telnet, bool is_waitconnect, Error **errp){ CharDriverState *chr = NULL; TCPCharDriver *s = NULL; char host[NI_MAXHOST], serv[NI_MAXSERV]; const char *left = "", *right = ""; struct sockaddr_storage ss; socklen_t ss_len = s...
0
static void dhcp_decode(const struct bootp_t *bp, int *pmsg_type, const struct in_addr **preq_addr){ const uint8_t *p, *p_end; int len, tag; *pmsg_type = 0; *preq_addr = NULL; p = bp->bp_vend; p_end = p + DHCP_OPT_LEN; if (memcmp(p, rfc1533_cookie, 4) != 0) return; p += 4; while (p < p_end) { tag = p[0]; if (tag == RFC...