label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static av_always_inline void h264_filter_mb_fast_internal(H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int pixel_shift){ int chroma = !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY)); int chroma444 = CHROMA444(h);... |
0 | static void pxb_pcie_dev_realize(PCIDevice *dev, Error **errp){ if (!pci_bus_is_express(dev->bus)) { error_setg(errp, "pxb-pcie devices cannot reside on a PCI bus"); return; } pxb_dev_realize_common(dev, true, errp);} |
0 | static int float64_is_unordered(int sig, float64 a, float64 b STATUS_PARAM){ if (float64_is_signaling_nan(a) || float64_is_signaling_nan(b) || (sig && (float64_is_nan(a) || float64_is_nan(b)))) { float_raise(float_flag_invalid, status); return 1; } else if (float64_is_nan(a) || float64_is_nan(b)) { return 1; } else { r... |
0 | static void qmp_input_type_str(Visitor *v, const char *name, char **obj, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true, errp); QString *qstr; *obj = NULL; if (!qobj) { return; } qstr = qobject_to_qstring(qobj); if (!qstr) { error_setg(errp, QERR_INVALID_PARAMETER_... |
0 | static int curl_open(BlockDriverState *bs, const char *filename, int flags){ BDRVCURLState *s = bs->opaque; CURLState *state = NULL; double d; #define RA_OPTSTR ":readahead=" char *file; char *ra; const char *ra_val; int parse_state = 0; static int inited = 0; file = strdup(filename); s->readahead_size = READ_AHEAD_SIZ... |
0 | static void gen_ldarx(DisasContext *ctx){ TCGv t0; gen_set_access_type(ctx, ACCESS_RES); t0 = tcg_temp_local_new(); gen_addr_reg_index(ctx, t0); gen_check_align(ctx, t0, 0x07); gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], t0); tcg_gen_mov_tl(cpu_reserve, t0); tcg_temp_free(t0);} |
0 | static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq){ VirtIOSCSI *s = (VirtIOSCSI *)vdev; VirtIOSCSIReq *req; while ((req = virtio_scsi_pop_req(s, vq))) { int type; if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, &type, sizeof(type)) < sizeof(type)) { virtio_scsi_bad_req(); continue; } tswap32s... |
1 | void arm_cpu_realize(ARMCPU *cpu){ /* This function is called by cpu_arm_init() because it * needs to do common actions based on feature bits, etc * that have been set by the subclass init functions. * When we have QOM realize support it should become * a true realize function instead. */ CPUARMState *env = &cpu->env; ... |
1 | static int mpc7_decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPCContext *c = avctx->priv_data; GetBitContext gb; uint8_t *bits; int i, ch; int mb = -1; Band *bands = c->bands; int off, ret; int bits_used, bits_avail;... |
1 | static void replication_start(ReplicationState *rs, ReplicationMode mode, Error **errp){ BlockDriverState *bs = rs->opaque; BDRVReplicationState *s; BlockDriverState *top_bs; int64_t active_length, hidden_length, disk_length; AioContext *aio_context; Error *local_err = NULL; BlockJob *job; aio_context = bdrv_get_aio_co... |
1 | uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size){ uint8_t *ret = NULL; JNIEnv *env = NULL; jobject buffer = NULL; JNI_GET_ENV_OR_RETURN(env, codec, NULL); if (codec->has_get_i_o_buffer) { buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id... |
1 | int cpu_get_dump_info(ArchDumpInfo *info, const struct GuestPhysBlockList *guest_phys_blocks){ PowerPCCPU *cpu = POWERPC_CPU(first_cpu); PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu); info->d_machine = EM_PPC64; info->d_class = ELFCLASS64; if ((*pcc->interrupts_big_endian)(cpu)) { info->d_endian = ELFDATA2MSB; } el... |
1 | static int try_decode_video_frame(AVCodecContext *codec_ctx, AVPacket *pkt, int decode){ int ret = 0; int got_frame = 0; AVFrame *frame = NULL; int skip_frame = codec_ctx->skip_frame; if (!avcodec_is_open(codec_ctx)) { const AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id); ret = avcodec_open2(codec_ctx, code... |
0 | static int tiff_decode_tag(TiffContext *s, AVFrame *frame){ unsigned tag, type, count, off, value = 0, value2 = 0; int i, start; int pos; int ret; double *dp; ret = ff_tread_tag(&s->gb, s->le, &tag, &type, &count, &start); if (ret < 0) { goto end; } off = bytestream2_tell(&s->gb); if (count == 1) { switch (type) { case... |
1 | static int reap_filters(void){ AVFilterBufferRef *picref; AVFrame *filtered_frame = NULL; int i; int64_t frame_pts; /* Reap all buffers present in the buffer sinks */ 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->f... |
1 | static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass, int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p){ MpegEncContext * const s = &h->s; void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride); void (*idct_dc_add)(... |
1 | static int adx_read_packet(AVFormatContext *s, AVPacket *pkt){ ADXDemuxerContext *c = s->priv_data; AVCodecContext *avctx = s->streams[0]->codec; int ret, size; size = BLOCK_SIZE * avctx->channels; pkt->pos = avio_tell(s->pb); pkt->stream_index = 0; ret = av_get_packet(s->pb, pkt, size); if (ret != size) { av_free_pack... |
1 | static int execute_command(BlockDriverState *bdrv, SCSIGenericReq *r, int direction, BlockDriverCompletionFunc *complete){ SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, r->req.dev); r->io_header.interface_id = 'S'; r->io_header.dxfer_direction = direction; r->io_header.dxferp = r->buf; r->io_header.dxfer_len ... |
1 | static int get_int8(QEMUFile *f, void *pv, size_t size){ int8_t *v = pv; qemu_get_s8s(f, v); return 0;} |
0 | static void handle_msr(DisasContext *s, uint32_t insn, unsigned int op0, unsigned int op1, unsigned int op2, unsigned int crn, unsigned int crm, unsigned int rt){ unsupported_encoding(s, insn);} |
0 | static void validate_teardown(TestInputVisitorData *data, const void *unused){ qobject_decref(data->obj); data->obj = NULL; if (data->qiv) { visit_free(data->qiv); data->qiv = NULL; }} |
0 | int kvm_arch_remove_hw_breakpoint(target_ulong addr, target_ulong len, int type){ int n; n = find_hw_breakpoint(addr, (type == GDB_BREAKPOINT_HW) ? 1 : len, type); if (n < 0) return -ENOENT; nb_hw_breakpoint--; hw_breakpoint[n] = hw_breakpoint[nb_hw_breakpoint]; return 0;} |
0 | void HELPER(cas2l)(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); uint32_t c1 = env->dregs[Dc1]; uint32_t c2 = env->dregs[Dc2]; uint32_t u1 = env->dregs[D... |
0 | static inline hwaddr booke206_page_size_to_tlb(uint64_t size){ return (ffs(size >> 10) - 1) >> 1;} |
0 | sofcantrcvmore(struct socket *so){if ((so->so_state & SS_NOFDREF) == 0) {shutdown(so->s,0);if(global_writefds) { FD_CLR(so->s,global_writefds);}}so->so_state &= ~(SS_ISFCONNECTING);if (so->so_state & SS_FCANTSENDMORE) { so->so_state &= SS_PERSISTENT_MASK; so->so_state |= SS_NOFDREF; /* Don't select it */} else { so->so... |
0 | void cpu_breakpoint_remove_all(CPUState *env, int mask){#if defined(TARGET_HAS_ICE) CPUBreakpoint *bp, *next; TAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { if (bp->flags & mask) cpu_breakpoint_remove_by_ref(env, bp); }#endif} |
0 | static void scsi_destroy(SCSIDevice *d){ SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, d); SCSIGenericReq *r; while (!QTAILQ_EMPTY(&s->qdev.requests)) { r = DO_UPCAST(SCSIGenericReq, req, QTAILQ_FIRST(&s->qdev.requests)); scsi_remove_request(r); } blockdev_mark_auto_del(s->qdev.conf.dinfo->bdrv);} |
0 | static inline void kqemu_save_seg(SegmentCache *sc, const struct kqemu_segment_cache *ksc){ sc->selector = ksc->selector; sc->flags = ksc->flags; sc->limit = ksc->limit; sc->base = ksc->base;} |
0 | static void omap_mpu_timer_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque; if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } switch (addr) { case 0x00:/* CNTL_TIMER */ omap_timer_sync(s); s->enable = (value... |
0 | bool qemu_peer_has_vnet_hdr(NetClientState *nc){ if (!nc->peer || !nc->peer->info->has_vnet_hdr) { return false; } return nc->peer->info->has_vnet_hdr(nc->peer);} |
0 | static void vmxnet3_cleanup(NetClientState *nc){ VMXNET3State *s = qemu_get_nic_opaque(nc); s->nic = NULL;} |
0 | void op_cp1_enabled(void){ if (!(env->CP0_Status & (1 << CP0St_CU1))) { CALL_FROM_TB2(do_raise_exception_err, EXCP_CpU, 1); } RETURN();} |
0 | static int put_flac_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec){ // if the extradata_size is greater than FLAC_STREAMINFO_SIZE, // assume that it's in Matroska format already if (codec->extradata_size < FLAC_STREAMINFO_SIZE) { av_log(s, AV_LOG_ERROR, "Invalid FLAC extradata\n"); return -1; }... |
0 | static void core_region_add(MemoryListener *listener, MemoryRegionSection *section){ cpu_register_physical_memory_log(section, section->readonly);} |
0 | static void kvm_mce_inj_srao_memscrub(CPUState *env, target_phys_addr_t paddr){ struct kvm_x86_mce mce = { .bank = 9, .status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN | MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S | 0xc0, .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV, .addr = paddr, .misc = (MCM_ADDR_PH... |
0 | int avcodec_open(AVCodecContext *avctx, AVCodec *codec){ int ret; if(avctx->codec) return -1; avctx->codec = codec; avctx->codec_id = codec->id; avctx->frame_number = 0; if (codec->priv_data_size > 0) { avctx->priv_data = av_mallocz(codec->priv_data_size); if (!avctx->priv_data) return -ENOMEM; } else { avctx->priv_dat... |
0 | static inline void RENAME(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, long width, long height, long lumStride, long chromStride, long dstStride){ //FIXME interpolate chroma RENAME(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);} |
1 | static int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS - 1], int i, uint8_t *token_prob, int16_t qmul[2]){ VP56RangeCoder c = *r; goto skip_eob; do { int coeff; if (!vp56_rac_get_prob_branchy(&c, token_prob[0])) // DCT_EOB break;skip_eob: if (!vp56_rac_get_prob... |
1 | static int img_check(int argc, char **argv){ int c, ret; OutputFormat output_format = OFORMAT_HUMAN; const char *filename, *fmt, *output, *cache; BlockBackend *blk; BlockDriverState *bs; int fix = 0; int flags = BDRV_O_FLAGS | BDRV_O_CHECK; ImageCheck *check; bool quiet = false; fmt = NULL; output = NULL; cache = BDRV_... |
1 | static void imdct12(INTFLOAT *out, INTFLOAT *in){ INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2; in0 = in[0*3]; in1 = in[1*3] + in[0*3]; in2 = in[2*3] + in[1*3]; in3 = in[3*3] + in[2*3]; in4 = in[4*3] + in[3*3]; in5 = in[5*3] + in[4*3]; in5 += in3; in3 += in1; in2 = MULH3(in2, C3, 2); in3 = MULH3(in3, C3, 4); t1 = in0 ... |
1 | int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_id, const char *name, Error **errp){ int i, snapshot_index; BDRVQcowState *s = bs->opaque; QCowSnapshot *sn; uint64_t *new_l1_table; int new_l1_bytes; int ret; assert(bs->read_only); /* Search the snapshot */ snapshot_index = find_snapshot_by_id_and... |
1 | static int vdi_create(const char *filename, QEMUOptionParameter *options, Error **errp){ int fd; int result = 0; uint64_t bytes = 0; uint32_t blocks; size_t block_size = DEFAULT_CLUSTER_SIZE; uint32_t image_type = VDI_TYPE_DYNAMIC; VdiHeader header; size_t i; size_t bmap_size; logout("\n"); /* Read out options. */ whil... |
1 | static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap){ AVIOContext *pb = s->pb; DXAContext *c = s->priv_data; AVStream *st, *ast; uint32_t tag; int32_t fps; int w, h; int num, den; int flags; tag = avio_rl32(pb); if (tag != MKTAG('D', 'E', 'X', 'A')) return -1; flags = avio_r8(pb); c->frames = avio_rb1... |
0 | static int get_cv_color_primaries(AVCodecContext *avctx, CFStringRef *primaries){ enum AVColorPrimaries pri = avctx->color_primaries; switch (pri) { case AVCOL_PRI_UNSPECIFIED: *primaries = NULL; break; case AVCOL_PRI_BT709: *primaries = kCVImageBufferColorPrimaries_ITU_R_709_2; break; case AVCOL_PRI_BT2020: *primaries... |
0 | static void avc_wgt_4x4multiple_msa(uint8_t *data, int32_t stride, int32_t height, int32_t log2_denom, int32_t src_weight, int32_t offset_in){ uint8_t cnt; uint32_t data0, data1, data2, data3; v16u8 zero = { 0 }; v16u8 src0, src1, src2, src3; v8u16 temp0, temp1, temp2, temp3; v8i16 wgt, denom, offset; offset_in <<= (lo... |
0 | static void FUNC(flac_decorrelate_indep_c)(uint8_t **out, int32_t **in, int channels, int len, int shift){ sample *samples = (sample *) OUT(out); int i, j; for (j = 0; j < len; j++) for (i = 0; i < channels; i++) S(samples, i, j) = in[i][j] << shift;} |
1 | void object_property_add_link(Object *obj, const char *name, const char *type, Object **child, void (*check)(Object *, const char *, Object *, Error **), ObjectPropertyLinkFlags flags, Error **errp){ Error *local_err = NULL; LinkProperty *prop = g_malloc(sizeof(*prop)); gchar *full_type; ObjectProperty *op; prop->child... |
1 | static int alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index, uint16_t **refcount_block){ BDRVQcowState *s = bs->opaque; unsigned int refcount_table_index; int ret; BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); /* Find the refcount block for the given cluster */ refcount_table_index = cluster_index >> (... |
1 | PPC_OP(test_ctrz){ T0 = (regs->ctr == 0); RETURN();} |
1 | static void usb_net_handle_dataout(USBNetState *s, USBPacket *p){ int sz = sizeof(s->out_buf) - s->out_ptr; struct rndis_packet_msg_type *msg = (struct rndis_packet_msg_type *) s->out_buf; uint32_t len;#ifdef TRAFFIC_DEBUG fprintf(stderr, "usbnet: data out len %zu\n", p->iov.size); iov_hexdump(p->iov.iov, p->iov.niov, ... |
1 | static void quiesce_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); SCLPEventClass *k = SCLP_EVENT_CLASS(klass); dc->reset = quiesce_reset; dc->vmsd = &vmstate_sclpquiesce; set_bit(DEVICE_CATEGORY_MISC, dc->categories); k->init = quiesce_init; k->get_send_mask = send_mask; k->get_rece... |
0 | static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref, AVIOInterruptCB *int_cb){ AVOpenCallback open_func = c->fc->open_cb; if (!open_func) open_func = ffio_open2_wrapper; /* try relative path, we do not try the absolute because it can leak information about our system to an attacker *... |
0 | static void filter_mb_edgev( 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]; if( bS[0] < 4 ) { int8_t tc[4]; for(i=0; i<4; i++) tc[i]... |
0 | int qemu_file_rate_limit(QEMUFile *f){ if (f->ops->rate_limit) return f->ops->rate_limit(f->opaque); return 0;} |
0 | qcrypto_block_luks_create(QCryptoBlock *block, QCryptoBlockCreateOptions *options, const char *optprefix, QCryptoBlockInitFunc initfunc, QCryptoBlockWriteFunc writefunc, void *opaque, Error **errp){ QCryptoBlockLUKS *luks; QCryptoBlockCreateOptionsLUKS luks_opts; Error *local_err = NULL; uint8_t *masterkey = NULL; uint... |
0 | static void pc_cmos_init_late(void *opaque){ pc_cmos_init_late_arg *arg = opaque; ISADevice *s = arg->rtc_state; int16_t cylinders; int8_t heads, sectors; int val; int i, trans; Object *container; CheckFdcState state = { 0 }; val = 0; if (ide_get_geometry(arg->idebus[0], 0, &cylinders, &heads, §ors) >= 0) { cmos_in... |
0 | static void kvm_mce_broadcast_rest(CPUState *env){ CPUState *cenv; int family, model, cpuver = env->cpuid_version; family = (cpuver >> 8) & 0xf; model = ((cpuver >> 12) & 0xf0) + ((cpuver >> 4) & 0xf); /* Broadcast MCA signal for processor version 06H_EH and above */ if ((family == 6 && model >= 14) || family > 6) { fo... |
0 | static struct omap_lpg_s *omap_lpg_init(MemoryRegion *system_memory, target_phys_addr_t base, omap_clk clk){ struct omap_lpg_s *s = (struct omap_lpg_s *) g_malloc0(sizeof(struct omap_lpg_s)); s->tm = qemu_new_timer_ms(vm_clock, omap_lpg_tick, s); omap_lpg_reset(s); memory_region_init_io(&s->iomem, &omap_lpg_ops, s, "om... |
0 | static int vapic_enable(VAPICROMState *s, CPUX86State *env){ int cpu_number = get_kpcr_number(env); target_phys_addr_t vapic_paddr; static const uint8_t enabled = 1; if (cpu_number < 0) { return -1; } vapic_paddr = s->vapic_paddr + (((target_phys_addr_t)cpu_number) << VAPIC_CPU_SHIFT); cpu_physical_memory_rw(vapic_padd... |
0 | static void omap_id_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } OMAP_BAD_REG(addr);} |
0 | static void scsi_unmap_complete(void *opaque, int ret){ UnmapCBData *data = opaque; SCSIDiskReq *r = data->r; SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); uint64_t sector_num; uint32_t nb_sectors; r->req.aiocb = NULL; if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); goto done; } if (ret < ... |
0 | static void selfTest(uint8_t *src[4], int stride[4], int w, int h){ enum PixelFormat srcFormat, dstFormat; int srcW, srcH, dstW, dstH; int flags; for (srcFormat = 0; srcFormat < PIX_FMT_NB; srcFormat++) { for (dstFormat = 0; dstFormat < PIX_FMT_NB; dstFormat++) { printf("%s -> %s\n", sws_format_name(srcFormat), sws_for... |
0 | int qemu_strtoi64(const char *nptr, const char **endptr, int base, int64_t *result){ char *ep; int err = 0; if (!nptr) { if (endptr) { *endptr = nptr; } err = -EINVAL; } else { errno = 0; /* FIXME This assumes int64_t is long long */ *result = strtoll(nptr, &ep, base); err = check_strtox_error(nptr, ep, endptr, errno);... |
0 | static int qemu_rdma_exchange_get_response(RDMAContext *rdma, RDMAControlHeader *head, int expecting, int idx){ int ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RECV_CONTROL + idx); if (ret < 0) { fprintf(stderr, "rdma migration: recv polling control error!\n"); return ret; } network_to_control((void *) rdma->wr_data... |
0 | static void omap_tcmi_init(MemoryRegion *memory, target_phys_addr_t base, struct omap_mpu_state_s *mpu){ memory_region_init_io(&mpu->tcmi_iomem, &omap_tcmi_ops, mpu, "omap-tcmi", 0x100); memory_region_add_subregion(memory, base, &mpu->tcmi_iomem); omap_tcmi_reset(mpu);} |
0 | static void spapr_machine_2_5_class_options(MachineClass *mc){ sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); mc->alias = "pseries"; mc->is_default = 1; smc->dr_lmb_enabled = true;} |
1 | static int disas_thumb2_insn(CPUState *env, DisasContext *s, uint16_t insn_hw1){ uint32_t insn, imm, shift, offset; uint32_t rd, rn, rm, rs; TCGv tmp; TCGv tmp2; TCGv tmp3; TCGv addr; TCGv_i64 tmp64; int op; int shiftop; int conds; int logic_cc; if (!(arm_feature(env, ARM_FEATURE_THUMB2) || arm_feature (env, ARM_FEATUR... |
1 | static void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size, ram_addr_t phys_offset, bool log_dirty){ KVMState *s = kvm_state; ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK; KVMSlot *mem, old; int err; void *ram = NULL; /* kvm works in page size chunks, but the function may be called with sub-page ... |
1 | static void v9fs_xattrwalk(void *opaque){ int64_t size; V9fsString name; ssize_t err = 0; size_t offset = 7; int32_t fid, newfid; V9fsFidState *file_fidp; V9fsFidState *xattr_fidp = NULL; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name); file_fidp = get_fid(pdu, fid)... |
1 | void ff_eac3_apply_spectral_extension(AC3DecodeContext *s){ int bin, bnd, ch, i; uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS]; float rms_energy[SPX_MAX_BANDS]; /* Set copy index mapping table. Set wrap flags to apply a notch filter at wrap points later on. */ bin = s->spx_dst_sta... |
1 | static int add_crc_to_array(uint32_t crc, int64_t pts){ if (size_of_array <= number_of_elements) { if (size_of_array == 0) size_of_array = 10; size_of_array *= 2; crc_array = av_realloc(crc_array, size_of_array * sizeof(uint32_t)); pts_array = av_realloc(pts_array, size_of_array * sizeof(int64_t)); if ((crc_array == NU... |
1 | static void vfio_listener_region_del(MemoryListener *listener, MemoryRegionSection *section){ VFIOContainer *container = container_of(listener, VFIOContainer, iommu_data.listener); hwaddr iova, end; int ret; if (vfio_listener_skipped_section(section)) { DPRINTF("SKIPPING region_del %"HWADDR_PRIx" - %"PRIx64"\n", sectio... |
0 | static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s){ int f_code; int mv; for(f_code=1; f_code<=MAX_FCODE; f_code++){ for(mv=-MAX_MV; mv<=MAX_MV; mv++){ int len; if(mv==0) len= ff_mvtab[0][1]; else{ int val, bit_size, code; bit_size = f_code - 1; val=mv; if (val < 0) val = -val; val--; code = (val >> bit_si... |
0 | static av_always_inline int setup_classifs(vorbis_context *vc, vorbis_residue *vr, uint8_t *do_not_decode, unsigned ch_used, int partition_count){ int p, j, i; unsigned c_p_c = vc->codebooks[vr->classbook].dimensions; unsigned inverse_class = ff_inverse[vr->classifications]; unsigned temp, temp2; for (p = 0, j = 0; j <... |
0 | static int qemu_laio_process_requests(void *opaque){ struct qemu_laio_state *s = opaque; struct qemu_laiocb *laiocb, *next; int res = 0; QLIST_FOREACH_SAFE (laiocb, &s->completed_reqs, node, next) { if (laiocb->async_context_id == get_async_context_id()) { qemu_laio_process_completion(s, laiocb); QLIST_REMOVE(laiocb, n... |
0 | static void event_scan(PowerPCCPU *cpu, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t mask, buf, len, event_len; sPAPREventLogEntry *event; struct rtas_error_log *hdr; if (nargs != 4 || nret != 1) { rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); return... |
0 | static void sysbus_esp_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned int size){ SysBusESPState *sysbus = opaque; uint32_t saddr; saddr = addr >> sysbus->it_shift; esp_reg_write(&sysbus->esp, saddr, val);} |
0 | static uint32_t adler32(uint32_t adler, const uint8_t *buf, unsigned int len){ unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; int k; if (buf == NULL) return 1L; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); k -= 16; } if (k != 0) do { DO1(buf); } wh... |
0 | static int wm8750_tx(I2CSlave *i2c, uint8_t data){ WM8750State *s = WM8750(i2c); uint8_t cmd; uint16_t value; if (s->i2c_len >= 2) {#ifdef VERBOSE printf("%s: long message (%i bytes)\n", __func__, s->i2c_len);#endif return 1; } s->i2c_data[s->i2c_len ++] = data; if (s->i2c_len != 2) return 0; cmd = s->i2c_data[0] >> 1;... |
0 | static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len){ int i; uint16_t limit; VncDisplay *vd = vs->vd; if (data[0] > 3) { vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval)) qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock... |
0 | void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...)){ int i, max; max = ARRAY_SIZE(ppc_defs); for (i = 0; i < max; i++) { (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n", ppc_defs[i].name, ppc_defs[i].pvr); }} |
0 | static void gic_update(gic_state *s){ int best_irq; int best_prio; int irq; int level; int cpu; int cm; for (cpu = 0; cpu < NUM_CPU(s); cpu++) { cm = 1 << cpu; s->current_pending[cpu] = 1023; if (!s->enabled || !s->cpu_enabled[cpu]) { qemu_irq_lower(s->parent_irq[cpu]); return; } best_prio = 0x100; best_irq = 1023; for... |
0 | static void *kqemu_vmalloc(size_t size){ static int phys_ram_fd = -1; static int phys_ram_size = 0; void *ptr;/* no need (?) for a dummy file on OpenBSD/FreeBSD */#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) int map_anon = MAP_ANON;#else int map_anon = 0; const char *tmpdir; char phys_ram_... |
0 | static uint32_t virtio_console_get_features(VirtIODevice *vdev){ return 0;} |
0 | void event_loop(void){ SDL_Event event; double incr, pos, frac; for(;;) { SDL_WaitEvent(&event); switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_ESCAPE: case SDLK_q: do_exit(); break; case SDLK_f: toggle_full_screen(); break; case SDLK_p: case SDLK_SPACE: toggle_pause(); break; case SDLK... |
0 | static inline void IRQ_setbit(IRQQueue *q, int n_IRQ){ set_bit(q->queue, n_IRQ);} |
0 | static void sdl_callback (void *opaque, Uint8 *buf, int len){ SDLVoiceOut *sdl = opaque; SDLAudioState *s = &glob_sdl; HWVoiceOut *hw = &sdl->hw; int samples = len >> hw->info.shift; if (s->exit) { return; } while (samples) { int to_mix, decr; /* dolog ("in callback samples=%d\n", samples); */ sdl_wait (s, "sdl_callbac... |
0 | static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s){ int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ilst"); mov_write_string_metadata(s, pb, "\251nam", "title" , 1); mov_write_string_metadata(s, pb, "\251ART", "artist" , 1); mov_write_string_metadata(s, pb... |
1 | static int gif_read_close(AVFormatContext *s1){ GifState *s = s1->priv_data; av_free(s->image_buf); return 0;} |
1 | void qemu_thread_get_self(QemuThread *thread){ if (!thread->thread) { /* In the main thread of the process. Initialize the QemuThread pointer in TLS, and use the dummy GetCurrentThread handle as the identifier for qemu_thread_is_self. */ qemu_thread_init(); TlsSetValue(qemu_thread_tls_index, thread); thread->thread = G... |
1 | static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex){ Coroutine *self = qemu_coroutine_self(); CoWaitRecord w; unsigned old_handoff; trace_qemu_co_mutex_lock_entry(mutex, self); w.co = self; push_waiter(mutex, &w); /* This is the "Responsibility Hand-Off" protocol; a lock() picks from * a concurrent unl... |
1 | static int pnm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; PNMContext * const s = avctx->priv_data; AVFrame * const p = data; int i, j, n, linesize, h, upgrade = 0, is_mono = 0; unsigned char *ptr; int components, sample... |
0 | static ssize_t block_crypto_write_func(QCryptoBlock *block, void *opaque, size_t offset, const uint8_t *buf, size_t buflen, Error **errp){ struct BlockCryptoCreateData *data = opaque; ssize_t ret; ret = blk_pwrite(data->blk, offset, buf, buflen, 0); if (ret < 0) { error_setg_errno(errp, -ret, "Could not write encryptio... |
0 | static int qemu_calculate_timeout(void){#ifndef CONFIG_IOTHREAD int timeout; if (!vm_running) timeout = 5000; else if (tcg_has_work()) timeout = 0; else { /* XXX: use timeout computed from timers */ int64_t add; int64_t delta; /* Advance virtual time to the next event. */delta = qemu_icount_delta(); if (delta > 0) { /*... |
0 | static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len){ SpiceCharDriver *s = chr->opaque; vmc_register_interface(s); assert(s->datalen == 0); if (s->bufsize < len) { s->bufsize = len; s->buffer = g_realloc(s->buffer, s->bufsize); } memcpy(s->buffer, buf, len); s->datapos = s->buffer; s->datalen =... |
0 | static int net_slirp_init(NetClientState *peer, const char *model, const char *name, int restricted, const char *vnetwork, const char *vhost, const char *vhostname, const char *tftp_export, const char *bootfile, const char *vdhcp_start, const char *vnameserver, const char *smb_export, const char *vsmbserver, const char... |
0 | static int ppce500_load_device_tree(CPUPPCState *env, PPCE500Params *params, hwaddr addr, hwaddr initrd_base, hwaddr initrd_size){ int ret = -1; uint64_t mem_reg_property[] = { 0, cpu_to_be64(params->ram_size) }; int fdt_size; void *fdt; uint8_t hypercall[16]; uint32_t clock_freq = 400000000; uint32_t tb_freq = 4000000... |
0 | int ff_audio_mix_get_matrix(AudioMix *am, double *matrix, int stride){ int i, o; if ( am->in_channels <= 0 || am->in_channels > AVRESAMPLE_MAX_CHANNELS || am->out_channels <= 0 || am->out_channels > AVRESAMPLE_MAX_CHANNELS) { av_log(am, AV_LOG_ERROR, "Invalid channel counts\n"); return AVERROR(EINVAL); }#define GET_MAT... |
0 | DriveInfo *drive_get_by_blockdev(BlockDriverState *bs){ return bs->blk ? blk_legacy_dinfo(bs->blk) : NULL;} |
0 | int kvm_arch_put_registers(CPUState *env, int level){ int ret; assert(cpu_is_stopped(env) || qemu_cpu_self(env)); ret = kvm_getput_regs(env, 1); if (ret < 0) { return ret; } ret = kvm_put_xsave(env); if (ret < 0) { return ret; } ret = kvm_put_xcrs(env); if (ret < 0) { return ret; } ret = kvm_put_sregs(env); if (ret < 0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.