label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void test_bh_schedule10(void){ BHTestData data = { .n = 0, .max = 10 }; data.bh = aio_bh_new(ctx, bh_test_cb, &data); qemu_bh_schedule(data.bh); g_assert_cmpint(data.n, ==, 0); g_assert(aio_poll(ctx, false)); g_assert_cmpint(data.n, ==, 1); g_assert(aio_poll(ctx, true)); g_assert_cmpint(data.n, ==, 2); wait_for_... |
0 | static void vexpress_modify_dtb(const struct arm_boot_info *info, void *fdt){ uint32_t acells, scells, intc; const VEDBoardInfo *daughterboard = (const VEDBoardInfo *)info; acells = qemu_fdt_getprop_cell(fdt, "/", "#address-cells", NULL, &error_fatal); scells = qemu_fdt_getprop_cell(fdt, "/", "#size-cells", NULL, &erro... |
0 | static int cpu_gdb_write_register(CPUPPCState *env, uint8_t *mem_buf, int n){ if (n < 32) { /* gprs */ env->gpr[n] = ldtul_p(mem_buf); return sizeof(target_ulong); } else if (n < 64) { /* fprs */ if (gdb_has_xml) return 0; env->fpr[n-32] = ldfq_p(mem_buf); return 8; } else { switch (n) { case 64: env->nip = ldtul_p(mem... |
0 | static void tcg_out_ri(TCGContext *s, int const_arg, TCGArg arg){ if (const_arg) { assert(const_arg == 1); tcg_out8(s, TCG_CONST); tcg_out_i(s, arg); } else { tcg_out_r(s, arg); }} |
0 | static bool get_vt_profile_level(AVCodecContext *avctx, CFStringRef *profile_level_val){ VTEncContext *vtctx = avctx->priv_data; int64_t profile = vtctx->profile; if (profile == H264_PROF_AUTO && vtctx->level) { //Need to pick a profile if level is not auto-selected. profile = vtctx->has_b_frames ? H264_PROF_MAIN : H26... |
0 | void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared){ /* * Note: this always allocates at least one extra page of virtual address * space, even if size is already aligned. */ size_t total = size + align;#if defined(__powerpc64__) && defined(__linux__) /* On ppc64 mappings in the same segment (aka slice) ... |
0 | static void rtas_set_tce_bypass(PowerPCCPU *cpu, sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ VIOsPAPRBus *bus = spapr->vio_bus; VIOsPAPRDevice *dev; uint32_t unit, enable; if (nargs != 2) { rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); return; } unit = rtas_l... |
0 | static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense){ VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); if (((s->vdev.guest_features >> VIRTIO_SCSI_F_CHANGE) & 1) && (s->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) && dev->type != TYPE_ROM) { virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_PARAM_CH... |
0 | static int usb_hid_initfn(USBDevice *dev, int kind){ USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev); usb_desc_init(dev); hid_init(&us->hid, kind, usb_hid_changed); /* Force poll routine to be run and grab input the first time. */ us->changed = 1; return 0;} |
0 | int target_to_host_signal(int sig){ if (sig >= _NSIG) return sig; return target_to_host_signal_table[sig];} |
0 | int net_init_tap(const NetClientOptions *opts, const char *name, NetClientState *peer, Error **errp){ /* FIXME error_setg(errp, ...) on failure */ const NetdevTapOptions *tap; assert(opts->kind == NET_CLIENT_OPTIONS_KIND_TAP); tap = opts->tap; if (!tap->has_ifname) { error_report("tap: no interface name"); return -1; }... |
0 | clk_setup_cb ppc_emb_timers_init (CPUState *env, uint32_t freq){ ppc_tb_t *tb_env; ppcemb_timer_t *ppcemb_timer; tb_env = qemu_mallocz(sizeof(ppc_tb_t)); env->tb_env = tb_env; ppcemb_timer = qemu_mallocz(sizeof(ppcemb_timer_t)); tb_env->tb_freq = freq; tb_env->decr_freq = freq; tb_env->opaque = ppcemb_timer; LOG_TB("%s... |
0 | static int htab_save_iterate(QEMUFile *f, void *opaque){ sPAPRMachineState *spapr = opaque; int fd; int rc = 0; /* Iteration header */ if (!spapr->htab_shift) { qemu_put_be32(f, -1); return 0; } else { qemu_put_be32(f, 0); } if (!spapr->htab) { assert(kvm_enabled()); fd = get_htab_fd(spapr); if (fd < 0) { return fd; } ... |
0 | static int drive_init_func(QemuOpts *opts, void *opaque){ int *use_scsi = opaque; return drive_init(opts, *use_scsi) == NULL;} |
0 | static int adpcm_encode_frame(AVCodecContext *avctx, unsigned char *frame, int buf_size, void *data){ int n, i, st; short *samples; unsigned char *dst; ADPCMContext *c = avctx->priv_data; dst = frame; samples = (short *)data; st= avctx->channels == 2;/* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); *... |
0 | static void migration_bitmap_sync(void){ uint64_t num_dirty_pages_init = ram_list.dirty_pages; trace_migration_bitmap_sync_start(); memory_global_sync_dirty_bitmap(get_system_memory()); trace_migration_bitmap_sync_end(ram_list.dirty_pages - num_dirty_pages_init);} |
0 | static inline int ucf64_exceptbits_from_host(int host_bits){ int target_bits = 0; if (host_bits & float_flag_invalid) { target_bits |= UCF64_FPSCR_FLAG_INVALID; } if (host_bits & float_flag_divbyzero) { target_bits |= UCF64_FPSCR_FLAG_DIVZERO; } if (host_bits & float_flag_overflow) { target_bits |= UCF64_FPSCR_FLAG_OVE... |
0 | static void gen_mtfsf(DisasContext *ctx){ TCGv_i32 t0; int L = ctx->opcode & 0x02000000; if (unlikely(!ctx->fpu_enabled)) { gen_exception(ctx, POWERPC_EXCP_FPU); return; } /* NIP cannot be restored if the memory exception comes from an helper */ gen_update_nip(ctx, ctx->nip - 4); gen_reset_fpstatus(); if (L) t0 = tcg_c... |
0 | static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos){ BDRVQcow2State *s = bs->opaque; int64_t total_sectors = bs->total_sectors; bool zero_beyond_eof = bs->zero_beyond_eof; int ret; BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE); bs->zero_beyond_eof = false; ret = bdrv_pwritev(bs, qcow2_vm_... |
0 | int ioinst_handle_schm(CPUS390XState *env, uint64_t reg1, uint64_t reg2, uint32_t ipb){ uint8_t mbk; int update; int dct; trace_ioinst("schm"); if (SCHM_REG1_RES(reg1)) { program_interrupt(env, PGM_OPERAND, 2); return -EIO; } mbk = SCHM_REG1_MBK(reg1); update = SCHM_REG1_UPD(reg1); dct = SCHM_REG1_DCT(reg1); if (update... |
0 | static int read_ir(AVFilterLink *inlink, AVFrame *frame){ AVFilterContext *ctx = inlink->dst; HeadphoneContext *s = ctx->priv; int ir_len, max_ir_len, input_number; for (input_number = 0; input_number < s->nb_inputs; input_number++) if (inlink == ctx->inputs[input_number]) break; av_audio_fifo_write(s->in[input_number]... |
0 | static inline void RENAME(shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, long src_size){ x86_reg idx = 15 - src_size; const uint8_t *s = src-idx; uint8_t *d = dst-idx;#if COMPILE_TEMPLATE_MMX __asm__ volatile( "test %0, %0 \n\t" "jns 2f \n\t" PREFETCH" (%1, %0) \n\t" "movq %3, %%mm7 \n\t" "pxor %4, %%mm7 \n\t" "... |
0 | static int slice_end(AVCodecContext *avctx, AVFrame *pict){ Mpeg1Context *s1 = avctx->priv_data; MpegEncContext *s = &s1->mpeg_enc_ctx; if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr) return 0; if (s->avctx->hwaccel) { if (s->avctx->hwaccel->end_frame(s->avctx) < 0) av_log(avctx, AV_LOG_ERROR, "hardware acc... |
0 | av_cold void ff_audio_mix_init_x86(AudioMix *am){#if HAVE_YASM int mm_flags = av_get_cpu_flags(); if (mm_flags & AV_CPU_FLAG_SSE && HAVE_SSE) { ff_audio_mix_set_func(am, AV_SAMPLE_FMT_FLTP, AV_MIX_COEFF_TYPE_FLT, 2, 1, 16, 8, "SSE", ff_mix_2_to_1_fltp_flt_sse); ff_audio_mix_set_func(am, AV_SAMPLE_FMT_FLTP, AV_MIX_COEFF... |
0 | static int opt_map(OptionsContext *o, const char *opt, const char *arg){ StreamMap *m = NULL; int i, negative = 0, file_idx; int sync_file_idx = -1, sync_stream_idx; char *p, *sync; char *map; if (*arg == '-') { negative = 1; arg++; } map = av_strdup(arg); /* parse sync stream first, just pick first matching stream */ ... |
0 | MemoryRegion *iotlb_to_region(target_phys_addr_t index){ return phys_sections[index & ~TARGET_PAGE_MASK].mr;} |
0 | static void *do_data_compress(void *opaque){ CompressParam *param = opaque; while (!quit_comp_thread) { qemu_mutex_lock(¶m->mutex); /* Re-check the quit_comp_thread in case of * terminate_compression_threads is called just before * qemu_mutex_lock(¶m->mutex) and after * while(!quit_comp_thread), re-check it her... |
0 | int nbd_client_session_co_readv(NbdClientSession *client, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov){ int offset = 0; int ret; while (nb_sectors > NBD_MAX_SECTORS) { ret = nbd_co_readv_1(client, sector_num, NBD_MAX_SECTORS, qiov, offset); if (ret < 0) { return ret; } offset += NBD_MAX_SECTORS * 512; sector... |
0 | static int find_pte64(CPUPPCState *env, struct mmu_ctx_hash64 *ctx, ppc_slb_t *slb, target_ulong eaddr, int rwx){ hwaddr pteg_off, pte_offset; ppc_hash_pte64_t pte; uint64_t vsid, pageaddr, ptem; hwaddr hash; int segment_bits, target_page_bits; int ret; ret = -1; /* No entry found */ if (slb->vsid & SLB_VSID_B) { vsid ... |
0 | static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args){ int err; const char *p; CmdArgs cmd_args; QemuOptsList *opts_list; if (cmd->args_type == NULL) { return (qdict_size(args) == 0 ? 0 : -1); } err = 0; cmd_args_init(&cmd_args); opts_list = NULL; for (p = cmd->args_type;; p++) { if (*p == ':') { cmd_arg... |
0 | static void dec_bcc(DisasContext *dc){ unsigned int cc; unsigned int dslot; cc = EXTRACT_FIELD(dc->ir, 21, 23); dslot = dc->ir & (1 << 25); LOG_DIS("bcc%s r%d %x\n", dslot ? "d" : "", dc->ra, dc->imm); dc->delayed_branch = 1; if (dslot) { dc->delayed_branch = 2; dc->tb_flags |= D_FLAG; tcg_gen_st_tl(tcg_const_tl(dc->ty... |
0 | static int buffered_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size){ QEMUFileBuffered *s = opaque; ssize_t error; DPRINTF("putting %d bytes at %" PRId64 "\n", size, pos); error = qemu_file_get_error(s->file); if (error) { DPRINTF("flush when error, bailing: %s\n", strerror(-error)); return error; } ... |
0 | static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata, AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta){ int isv34, unsync; unsigned tlen; char tag[5]; int64_t next, end = avio_tell(pb) + len; int taghdrlen; const char *reason = NULL; AVIOContext pb_local; AVIOContext... |
0 | void op_mfc0_ebase (void){ T0 = (int32_t)env->CP0_EBase; RETURN();} |
0 | static void init_blk_migration_it(void *opaque, BlockDriverState *bs){ Monitor *mon = opaque; BlkMigDevState *bmds; int64_t sectors; if (!bdrv_is_read_only(bs)) { sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS; if (sectors <= 0) { return; } bmds = g_malloc0(sizeof(BlkMigDevState)); bmds->bs = bs; bmds->bulk_completed... |
0 | static void pc_q35_init(QEMUMachineInitArgs *args){ ram_addr_t below_4g_mem_size, above_4g_mem_size; Q35PCIHost *q35_host; PCIHostState *phb; PCIBus *host_bus; PCIDevice *lpc; BusState *idebus[MAX_SATA_PORTS]; ISADevice *rtc_state; ISADevice *floppy; MemoryRegion *pci_memory; MemoryRegion *rom_memory; MemoryRegion *ram... |
0 | static void fd_accept_incoming_migration(void *opaque){ QEMUFile *f = opaque; int ret; ret = qemu_loadvm_state(f); if (ret < 0) { fprintf(stderr, "load of migration failed\n"); goto err; } qemu_announce_self(); DPRINTF("successfully loaded vm state\n"); /* we've successfully migrated, close the fd */ qemu_set_fd_handle... |
0 | static coroutine_fn void do_co_req(void *opaque){ int ret; Coroutine *co; SheepdogReqCo *srco = opaque; int sockfd = srco->sockfd; SheepdogReq *hdr = srco->hdr; void *data = srco->data; unsigned int *wlen = srco->wlen; unsigned int *rlen = srco->rlen; co = qemu_coroutine_self(); qemu_aio_set_fd_handler(sockfd, NULL, re... |
1 | void commit_start(const char *job_id, BlockDriverState *bs, BlockDriverState *base, BlockDriverState *top, int64_t speed, BlockdevOnError on_error, BlockCompletionFunc *cb, void *opaque, const char *backing_file_str, Error **errp){ CommitBlockJob *s; BlockReopenQueue *reopen_queue = NULL; int orig_overlay_flags; int or... |
1 | yuv2mono_X_c_template(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, int dstW, int y, enum PixelFormat target){ const uint8_t * const d128=dither_8x8... |
1 | static void virtio_balloon_set_config(VirtIODevice *vdev, const uint8_t *config_data){ VirtIOBalloon *dev = VIRTIO_BALLOON(vdev); struct virtio_balloon_config config; uint32_t oldactual = dev->actual; memcpy(&config, config_data, 8); dev->actual = le32_to_cpu(config.actual); if (dev->actual != oldactual) { qemu_balloon... |
1 | static void avi_read_nikon(AVFormatContext *s, uint64_t end){ while (avio_tell(s->pb) < end) { uint32_t tag = avio_rl32(s->pb); uint32_t size = avio_rl32(s->pb); switch (tag) { case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */ { uint64_t tag_end = avio_tell(s->pb) + size; while (avio_tell(s->pb) < tag_end) { uint16_t ta... |
1 | static ssize_t qio_channel_websock_read_wire(QIOChannelWebsock *ioc, Error **errp){ ssize_t ret; if (ioc->encinput.offset < 4096) { size_t want = 4096 - ioc->encinput.offset; buffer_reserve(&ioc->encinput, want); ret = qio_channel_read(ioc->master, (char *)ioc->encinput.buffer + ioc->encinput.offset, want, errp); if (r... |
1 | static int decode_slice(MpegEncContext *s){ const int part_mask = s->partitioned_frame ? (ER_AC_END | ER_AC_ERROR) : 0x7F; const int mb_size = 16; int ret; s->last_resync_gb = s->gb; s->first_slice_line = 1; s->resync_mb_x = s->mb_x; s->resync_mb_y = s->mb_y; ff_set_qscale(s, s->qscale); if (s->avctx->hwaccel) { const ... |
1 | DVMuxContext* dv_init_mux(AVFormatContext* s){ DVMuxContext *c; AVStream *vst = NULL; int i; /* we support at most 1 video and 2 audio streams */ if (s->nb_streams > 3) return NULL; c = av_mallocz(sizeof(DVMuxContext)); if (!c) return NULL; c->n_ast = 0; c->ast[0] = c->ast[1] = NULL; /* We have to sort out where audio ... |
1 | int qcow2_snapshot_delete(BlockDriverState *bs, const char *snapshot_id){ BDRVQcowState *s = bs->opaque; QCowSnapshot sn; int snapshot_index, ret; /* Search the snapshot */ snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id); if (snapshot_index < 0) { return -ENOENT; } sn = s->snapshots[snapshot_index]; /* Re... |
1 | static void rtas_ibm_read_pci_config(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t val, size, addr; uint64_t buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2); PCIDevice *dev = find_dev(spapr, buid, rtas_ld(args, 0)); if (!dev) { rtas_... |
1 | int ff_rv34_decode_init_thread_copy(AVCodecContext *avctx){ int err; RV34DecContext *r = avctx->priv_data; r->s.avctx = avctx; if (avctx->internal->is_copy) { r->tmp_b_block_base = NULL; if ((err = ff_MPV_common_init(&r->s)) < 0) return err; if ((err = rv34_decoder_alloc(r)) < 0) return err; } return 0;} |
1 | static int64_t get_remaining_dirty(void){ BlkMigDevState *bmds; int64_t dirty = 0; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { dirty += bdrv_get_dirty_count(bmds->bs, bmds->dirty_bitmap); } return dirty << BDRV_SECTOR_BITS;} |
1 | static int shall_we_drop(AVFormatContext *s, int index){ struct dshow_ctx *ctx = s->priv_data; static const uint8_t dropscore[] = {62, 75, 87, 100}; const int ndropscores = FF_ARRAY_ELEMS(dropscore); unsigned int buffer_fullness = (ctx->curbufsize[index]*100)/s->max_picture_buffer; if(dropscore[++ctx->video_frame_num%n... |
1 | int arm_set_cpu_on(uint64_t cpuid, uint64_t entry, uint64_t context_id, uint32_t target_el, bool target_aa64){ CPUState *target_cpu_state; ARMCPU *target_cpu; DPRINTF("cpu %" PRId64 " (EL %d, %s) @ 0x%" PRIx64 " with R0 = 0x%" PRIx64 "\n", cpuid, target_el, target_aa64 ? "aarch64" : "aarch32", entry, context_id); /* re... |
1 | void qtest_init(const char *qtest_chrdev, const char *qtest_log){ CharDriverState *chr; chr = qemu_chr_new("qtest", qtest_chrdev, NULL); qemu_chr_add_handlers(chr, qtest_can_read, qtest_read, qtest_event, chr); qemu_chr_fe_set_echo(chr, true); inbuf = g_string_new(""); if (qtest_log) { if (strcmp(qtest_log, "none") != ... |
1 | static bool bdrv_drain_recurse(BlockDriverState *bs){ BdrvChild *child; bool waited; waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0); if (bs->drv && bs->drv->bdrv_drain) { bs->drv->bdrv_drain(bs); } QLIST_FOREACH(child, &bs->children, next) { waited |= bdrv_drain_recurse(child->bs); } return waited;} |
1 | static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from){ MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data; int i, ret; if (avctx == avctx_from) return 0; dst->cur_index = src->next_cur_index; dst->prev_index = src->next_prev_index; memcpy(dst->flipped_ptr... |
1 | static void do_test_equality(bool expected, int _, ...){ va_list ap_count, ap_extract; QObject **args; int arg_count = 0; int i, j; va_start(ap_count, _); va_copy(ap_extract, ap_count); while (va_arg(ap_count, QObject *) != &test_equality_end_of_arguments) { arg_count++; } va_end(ap_count); args = g_new(QObject *, arg_... |
1 | static int asf_read_stream_properties(AVFormatContext *s, int64_t size){ ASFContext *asf = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; ASFStream *asf_st; ff_asf_guid g; enum AVMediaType type; int type_specific_size, sizeX; uint64_t total_size; unsigned int tag1; int64_t pos1, pos2, start_time; int test_for_ext... |
1 | static int kmvc_decode_intra_8x8(KmvcContext * ctx, const uint8_t * src, int src_size, int w, int h){ BitBuf bb; int res, val; int i, j; int bx, by; int l0x, l1x, l0y, l1y; int mx, my; const uint8_t *src_end = src + src_size; kmvc_init_getbits(bb, src); for (by = 0; by < h; by += 8) for (bx = 0; bx < w; bx += 8) { kmvc... |
1 | static int ff_asf_parse_packet(AVFormatContext *s, ByteIOContext *pb, AVPacket *pkt){ ASFContext *asf = s->priv_data; ASFStream *asf_st = 0; for (;;) { if(url_feof(pb)) return AVERROR_EOF; if (asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1) { //asf->packet_size_left <= asf->packet_padsize) { int ... |
1 | void *g_try_realloc(void *mem, size_t n_bytes){ __coverity_negative_sink__(n_bytes); return realloc(mem, n_bytes == 0 ? 1 : n_bytes);} |
1 | BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity){ int64_t bitmap_size; BdrvDirtyBitmap *bitmap; assert((granularity & (granularity - 1)) == 0); granularity >>= BDRV_SECTOR_BITS; assert(granularity); bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS); bitmap = g_malloc0(sizeof(BdrvDir... |
1 | static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf){ AVFilterContext *ctx = inlink->dst; ASyncContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout); int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts : av_r... |
1 | static int init_output_stream_streamcopy(OutputStream *ost){ OutputFile *of = output_files[ost->file_index]; InputStream *ist = get_input_stream(ost); AVCodecParameters *par_dst = ost->st->codecpar; AVCodecParameters *par_src = ost->ref_par; AVRational sar; int i, ret; uint32_t codec_tag = par_dst->codec_tag; av_assert... |
1 | static unsigned hpte_page_shift(const struct ppc_one_seg_page_size *sps, uint64_t pte0, uint64_t pte1){ int i; if (!(pte0 & HPTE64_V_LARGE)) { if (sps->page_shift != 12) { /* 4kiB page in a non 4kiB segment */ return 0; } /* Normal 4kiB page */ return 12; } for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) { const struct ppc... |
1 | yuv2rgb_full_1_c_template(SwsContext *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha){ const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0]; int i; int step = (target == AV_PIX_FMT_RGB24 || ta... |
1 | static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector){ int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; if (sector < bdrv_nb_sectors(bmds->bs)) { return !!(bmds->aio_bitmap[chunk / (sizeof(unsigned long) * 8)] & (1UL << (chunk % (sizeof(unsigned long) * 8)))); } else { return 0; }} |
1 | static void smc91c111_release_packet(smc91c111_state *s, int packet){ s->allocated &= ~(1 << packet); if (s->tx_alloc == 0x80) smc91c111_tx_alloc(s); qemu_flush_queued_packets(qemu_get_queue(s->nic));} |
1 | static void parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers){ int i; HEVCLocalContext *lc = s->HEVClc; GetBitContext *gb = &lc->gb; decode_profile_tier_level(s, &ptl->general_ptl); ptl->general_ptl.level_idc = get_bits(gb, 8); for (i = 0; i < max_num_sub_layers - 1; i++) { ptl->sub_layer_profile_present_flag... |
0 | void av_blowfish_crypt(AVBlowfish *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt){ uint32_t v0, v1; int i; while (count > 0) { if (decrypt) { v0 = AV_RB32(src); v1 = AV_RB32(src + 4); av_blowfish_crypt_ecb(ctx, &v0, &v1, decrypt); AV_WB32(dst, v0); AV_WB32(dst + 4, v1); if (iv) { for (i = 0... |
0 | void ff_put_h264_qpel16_mc22_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride){ avc_luma_mid_16w_msa(src - (2 * stride) - 2, stride, dst, stride, 16);} |
0 | static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb){ WVContext *wc = ctx->priv_data; int ret; int rate, bpp, chan; uint32_t chmask, flags; wc->pos = avio_tell(pb); /* don't return bogus packets with the ape tag data */ if (wc->apetag_start && wc->pos >= wc->apetag_start) return AVERROR_EOF; ret = avi... |
1 | static void ehci_trace_qh(EHCIQueue *q, target_phys_addr_t addr, EHCIqh *qh){ trace_usb_ehci_qh(q, addr, qh->next, qh->current_qtd, qh->next_qtd, qh->altnext_qtd, get_field(qh->epchar, QH_EPCHAR_RL), get_field(qh->epchar, QH_EPCHAR_MPLEN), get_field(qh->epchar, QH_EPCHAR_EPS), get_field(qh->epchar, QH_EPCHAR_EP), get_f... |
1 | void visit_end_list(Visitor *v, Error **errp){ assert(!error_is_set(errp)); v->end_list(v, errp);} |
1 | static void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size){ av_opt_set_int(s, "server_attached", 1, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(s, "write_index", pos, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(s, "file_size", file_size, AV_OPT_SEARCH_CHILDREN);} |
0 | int ff_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb, dirac_source_params *source){ unsigned version_major; unsigned video_format, picture_coding_mode; version_major = svq3_get_ue_golomb(gb); svq3_get_ue_golomb(gb); /* version_minor */ avctx->profile = svq3_get_ue_golomb(gb); avctx->level = svq3_... |
0 | static int vga_osi_call (CPUState *env){ static int vga_vbl_enabled; int linesize;#if 0 printf("osi_call R5=%016" PRIx64 "\n", ppc_dump_gpr(env, 5));#endif /* same handler as PearPC, coming from the original MOL video driver. */ switch(env->gpr[5]) { case 4: break; case 28: /* set_vmode */ if (env->gpr[6] != 1 || env->... |
0 | static void s390_init(ram_addr_t my_ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUS390XState *env = NULL; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); ram_addr_t kernel_size =... |
0 | static GenericList *qmp_input_next_list(Visitor *v, GenericList **list, size_t size){ QmpInputVisitor *qiv = to_qiv(v); GenericList *entry; StackObject *so = &qiv->stack[qiv->nb_stack - 1]; if (!so->entry) { return NULL; } entry = g_malloc0(size); if (so->first) { *list = entry; so->first = false; } else { (*list)->nex... |
0 | static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom){ int err; err = mov_read_default(c, pb, atom); /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */ /* so we don't parse the whole file if over a network */ c->found_moov=1; if(c->found_mdat) return 1; /* ... |
0 | static ssize_t v9fs_synth_preadv(FsContext *ctx, V9fsFidOpenState *fs, const struct iovec *iov, int iovcnt, off_t offset){ int i, count = 0, rcount; V9fsSynthOpenState *synth_open = fs->private; V9fsSynthNode *node = synth_open->node; if (!node->attr->read) { errno = EPERM; return -1; } for (i = 0; i < iovcnt; i++) { r... |
0 | static void spr_write_601_ubatl (void *opaque, int sprn){ DisasContext *ctx = opaque; gen_op_store_601_batl((sprn - SPR_IBAT0L) / 2); RET_STOP(ctx);} |
0 | static void pci_vpb_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = pci_vpb_realize; dc->reset = pci_vpb_reset; dc->vmsd = &pci_vpb_vmstate; dc->props = pci_vpb_properties; /* Reason: object_unref() hangs */ dc->cannot_destroy_with_object_finalize_yet = true;} |
0 | static void *aio_thread(void *unused){ pid_t pid; sigset_t set; pid = getpid(); /* block all signals */ if (sigfillset(&set)) die("sigfillset"); if (sigprocmask(SIG_BLOCK, &set, NULL)) die("sigprocmask"); while (1) { struct qemu_paiocb *aiocb; size_t ret = 0; qemu_timeval tv; struct timespec ts; qemu_gettimeofday(&tv);... |
0 | static int vnc_start_tls(struct VncState *vs) { static const int cert_type_priority[] = { GNUTLS_CRT_X509, 0 }; static const int protocol_priority[]= { GNUTLS_TLS1_1, GNUTLS_TLS1_0, GNUTLS_SSL3, 0 }; static const int kx_anon[] = {GNUTLS_KX_ANON_DH, 0}; static const int kx_x509[] = {GNUTLS_KX_DHE_DSS, GNUTLS_KX_RSA, GNU... |
0 | void pcspk_init(PITState *pit){ PCSpkState *s = &pcspk_state; s->pit = pit; register_ioport_read(0x61, 1, 1, pcspk_ioport_read, s); register_ioport_write(0x61, 1, 1, pcspk_ioport_write, s);} |
0 | static void s390x_cpu_get_id(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp){ S390CPU *cpu = S390_CPU(obj); int64_t value = cpu->id; visit_type_int(v, name, &value, errp);} |
0 | void xen_invalidate_map_cache_entry(uint8_t *buffer){ MapCacheEntry *entry = NULL, *pentry = NULL; MapCacheRev *reventry; hwaddr paddr_index; hwaddr size; int found = 0; QTAILQ_FOREACH(reventry, &mapcache->locked_entries, next) { if (reventry->vaddr_req == buffer) { paddr_index = reventry->paddr_index; size = reventry-... |
0 | void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req){ VirtIODevice *vdev = (VirtIODevice *)s; int type; int r = 0; if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, &type, sizeof(type)) < sizeof(type)) { virtio_scsi_bad_req(); return; } virtio_tswap32s(vdev, &req->req.tmf.type); if (req->req.tmf.typ... |
0 | void helper_sysenter(void){ if (env->sysenter_cs == 0) { raise_exception_err(EXCP0D_GPF, 0); } env->eflags &= ~(VM_MASK | IF_MASK | RF_MASK); cpu_x86_set_cpl(env, 0); cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc, 0, 0xffffffff, DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK | DESC_R... |
0 | static int xvid_ff_2pass_create(xvid_plg_create_t * param, void ** handle) { struct xvid_ff_pass1 *x = (struct xvid_ff_pass1 *)param->param; char *log = x->context->twopassbuffer; /* Do a quick bounds check */ if( log == NULL ) return XVID_ERR_FAIL; /* We use snprintf() */ /* This is because we can safely prevent a buf... |
0 | static void vga_screen_dump_blank(VGAState *s, const char *filename){ FILE *f; unsigned int y, x, w, h; w = s->last_scr_width * sizeof(uint32_t); h = s->last_scr_height; f = fopen(filename, "wb"); if (!f) return; fprintf(f, "P6\n%d %d\n%d\n", w, h, 255); for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { fputc(0, f); ... |
0 | void qemu_fclose(QEMUFile *f){ if (f->is_writable) qemu_fflush(f); if (f->is_file) { fclose(f->outfile); } qemu_free(f);} |
0 | static int vdi_create(const char *filename, QemuOpts *opts, 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; bool nocow = false; logout("\n"); /* Read out options. *... |
0 | static always_inline void gen_qemu_sts (TCGv t0, TCGv t1, int flags){ TCGv tmp = tcg_temp_new(TCG_TYPE_I32); tcg_gen_helper_1_1(helper_s_to_memory, tmp, t0); tcg_gen_qemu_st32(tmp, t1, flags); tcg_temp_free(tmp);} |
0 | sPAPRDRConnector *spapr_dr_connector_new(Object *owner, const char *type, uint32_t id){ sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(object_new(type)); char *prop_name; drc->id = id; drc->owner = owner; prop_name = g_strdup_printf("dr-connector[%"PRIu32"]", spapr_drc_index(drc)); object_property_add_child(owner, prop_nam... |
0 | int64_t HELPER(nabs_i64)(int64_t val){ if (val < 0) { return val; } else { return -val; }} |
0 | int qcrypto_hash_bytesv(QCryptoHashAlgorithm alg, const struct iovec *iov G_GNUC_UNUSED, size_t niov G_GNUC_UNUSED, uint8_t **result G_GNUC_UNUSED, size_t *resultlen G_GNUC_UNUSED, Error **errp){ error_setg(errp, "Hash algorithm %d not supported without GNUTLS", alg); return -1;} |
0 | static void iommu_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val){ IOMMUState *s = opaque; target_phys_addr_t saddr; saddr = (addr - s->addr) >> 2; DPRINTF("write reg[%d] = %x\n", (int)saddr, val); switch (saddr) { case IOMMU_CTRL: switch (val & IOMMU_CTRL_RNGE) { case IOMMU_RNGE_16MB: s->iostart = 0xff... |
0 | static void pci_reset(EEPRO100State * s){ uint32_t device = s->device; uint8_t *pci_conf = s->pci_dev->config; logout("%p\n", s); /* PCI Vendor ID */ pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL); /* PCI Device ID */ pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82551IT); /* PCI Command */ PCI_CONFIG... |
0 | int ff_mjpeg_find_marker(MJpegDecodeContext *s, const uint8_t **buf_ptr, const uint8_t *buf_end, const uint8_t **unescaped_buf_ptr, int *unescaped_buf_size){ int start_code; start_code = find_marker(buf_ptr, buf_end); av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr); if (!s->buffer) return AVERROR... |
0 | static int yuv4_write_header(AVFormatContext *s){ int *first_pkt = s->priv_data; if (s->nb_streams != 1) return AVERROR(EIO); if (s->streams[0]->codecpar->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME) { av_log(s, AV_LOG_ERROR, "ERROR: Codec not supported.\n"); return AVERROR_INVALIDDATA; } switch (s->streams[0]->codecpar->f... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.