label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | QEMUClock *qemu_clock_ptr(QEMUClockType type){ return &qemu_clocks[type];} |
0 | int do_subchannel_work_passthrough(SubchDev *sch){ int ret; SCSW *s = &sch->curr_status.scsw; if (s->ctrl & SCSW_FCTL_CLEAR_FUNC) { /* TODO: Clear handling */ sch_handle_clear_func(sch); ret = 0; } else if (s->ctrl & SCSW_FCTL_HALT_FUNC) { /* TODO: Halt handling */ sch_handle_halt_func(sch); ret = 0; } else if (s->ctrl... |
0 | void ff_h264_v_lpf_luma_inter_msa(uint8_t *data, int img_width, int alpha, int beta, int8_t *tc){ uint8_t bs0 = 1; uint8_t bs1 = 1; uint8_t bs2 = 1; uint8_t bs3 = 1; if (tc[0] < 0) bs0 = 0; if (tc[1] < 0) bs1 = 0; if (tc[2] < 0) bs2 = 0; if (tc[3] < 0) bs3 = 0; avc_loopfilter_luma_inter_edge_hor_msa(data, bs0, bs1, bs2... |
0 | static av_always_inline void FUNC(row_fdct)(int16_t *data){ int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; int tmp10, tmp11, tmp12, tmp13; int z1, z2, z3, z4, z5; int16_t *dataptr; int ctr; /* Pass 1: process rows. */ /* Note results are scaled up by sqrt(8) compared to a true DCT; */ /* furthermore, we scale the ... |
0 | static int decode_type2(GetByteContext *gb, PutByteContext *pb){ unsigned repeat = 0, first = 1, opcode; int i, len, pos; while (bytestream2_get_bytes_left(gb) > 0) { GetByteContext gbc; while (bytestream2_get_bytes_left(gb) > 0) { if (first) { first = 0; if (bytestream2_peek_byte(gb) > 17) { len = bytestream2_get_byte... |
0 | static int device_open(AVFormatContext *ctx, uint32_t *capabilities){ struct v4l2_capability cap; int fd; int res, err; int flags = O_RDWR; if (ctx->flags & AVFMT_FLAG_NONBLOCK) { flags |= O_NONBLOCK; } fd = open(ctx->filename, flags, 0); if (fd < 0) { av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s : %s\n", ctx... |
0 | static void get_default_channel_layouts(OutputStream *ost, InputStream *ist){ char layout_name[256]; AVCodecContext *enc = ost->st->codec; AVCodecContext *dec = ist->st->codec; if (!dec->channel_layout) { if (enc->channel_layout && dec->channels == enc->channels) { dec->channel_layout = enc->channel_layout; } else { de... |
0 | static int roq_dpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ int i, stereo, data_size, ret; const int16_t *in = frame ? (const int16_t *)frame->data[0] : NULL; uint8_t *out; ROQDPCMContext *context = avctx->priv_data; stereo = (avctx->channels == 2); if (!in && co... |
0 | static int twin_decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; TwinContext *tctx = avctx->priv_data; GetBitContext gb; const ModeTab *mtab = tctx->mtab; float *out = data; enum FrameType ftype; int window_type; static cons... |
0 | matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size, int64_t pos, uint64_t cluster_time, int is_keyframe, int is_bframe, int *ptrack, AVPacket **ppkt){ int res = 0; int track; AVPacket *pkt; uint8_t *origdata = data; int16_t block_time; uint32_t *lace_size = NULL; int n, flags, laces = 0; uint6... |
0 | static void clipper_init(MachineState *machine){ ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; AlphaCPU *cpus[4]; P... |
0 | void ff_thread_flush(AVCodecContext *avctx){ FrameThreadContext *fctx = avctx->thread_opaque; if (!avctx->thread_opaque) return; park_frame_worker_threads(fctx, avctx->thread_count); if (fctx->prev_thread) { if (fctx->prev_thread != &fctx->threads[0]) update_context_from_thread(fctx->threads[0].avctx, fctx->prev_thread... |
0 | static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, int l1_size, int64_t *visited_l1_entries, int64_t l1_entries, BlockDriverAmendStatusCB *status_cb, void *cb_opaque){ BDRVQcow2State *s = bs->opaque; bool is_active_l1 = (l1_table == s->l1_table); uint64_t *l2_table = NULL; int ret; int i, j... |
0 | static void wait_for_aio(void){ while (aio_poll(ctx, true)) { /* Do nothing */ }} |
0 | static VTDIOTLBEntry *vtd_lookup_iotlb(IntelIOMMUState *s, uint16_t source_id, hwaddr addr){ uint64_t key; key = (addr >> VTD_PAGE_SHIFT_4K) | ((uint64_t)(source_id) << VTD_IOTLB_SID_SHIFT); return g_hash_table_lookup(s->iotlb, &key);} |
0 | BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error){ BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error; switch (on_err) { case BLOCKDEV_ON_ERROR_ENOSPC: return (error == ENOSPC) ? BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; case BLOCKDEV_ON_ERROR_STOP: ... |
0 | gboolean qcrypto_hash_supports(QCryptoHashAlgorithm alg G_GNUC_UNUSED){ return false;} |
0 | static void xen_io_add(MemoryListener *listener, MemoryRegionSection *section){ XenIOState *state = container_of(listener, XenIOState, io_listener); memory_region_ref(section->mr); xen_map_io_section(xen_xc, xen_domid, state->ioservid, section);} |
0 | static void opt_mb_qmin(const char *arg){ video_mb_qmin = atoi(arg); if (video_mb_qmin < 0 || video_mb_qmin > 31) { fprintf(stderr, "qmin must be >= 1 and <= 31\n"); exit(1); }} |
0 | static void handle_windowevent(SDL_Event *ev){ struct sdl2_console *scon = get_scon_from_window(ev->window.windowID); if (!scon) { return; } switch (ev->window.event) { case SDL_WINDOWEVENT_RESIZED: { QemuUIInfo info; memset(&info, 0, sizeof(info)); info.width = ev->window.data1; info.height = ev->window.data2; dpy_set... |
0 | static void kvm_supported_msrs(CPUState *env){ static int kvm_supported_msrs; int ret; /* first time */ if (kvm_supported_msrs == 0) { struct kvm_msr_list msr_list, *kvm_msr_list; kvm_supported_msrs = -1; /* Obtain MSR list from KVM. These are the MSRs that we must * save/restore */ msr_list.nmsrs = 0; ret = kvm_ioctl(... |
0 | static void spapr_lmb_release(DeviceState *dev, void *opaque){ HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev); sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_ctrl); sPAPRDIMMState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev)); if (--ds->nr_lmbs) { return; } spapr_pending_dimm_unplugs_remove... |
0 | static void monitor_readline_printf(void *opaque, const char *fmt, ...){ va_list ap; va_start(ap, fmt); monitor_vprintf(opaque, fmt, ap); va_end(ap);} |
0 | static int op_to_mov(int op){ switch (op_bits(op)) { case 32: return INDEX_op_mov_i32;#if TCG_TARGET_REG_BITS == 64 case 64: return INDEX_op_mov_i64;#endif default: fprintf(stderr, "op_to_mov: unexpected return value of " "function op_bits.\n"); tcg_abort(); }} |
0 | void object_property_get_uint16List(Object *obj, const char *name, uint16List **list, Error **errp){ Error *err = NULL; StringOutputVisitor *ov; Visitor *v; char *str; ov = string_output_visitor_new(false); object_property_get(obj, string_output_get_visitor(ov), name, &err); if (err) { error_propagate(errp, err); goto ... |
0 | static void chroma_4mv_motion(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture, op_pixels_func *pix_op, int mx, int my){ uint8_t *ptr; int src_x, src_y, dxy, emu = 0; ptrdiff_t offset; /* In case of 8X8, we construct a single chroma motion vector * with a special rounding */ mx = ff_h263_rou... |
0 | static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, const int *const_args){ int c; switch (opc) { case INDEX_op_exit_tb: { uint8_t *ld_ptr = s->code_ptr; if (args[0] >> 8) tcg_out_ld32_12(s, COND_AL, TCG_REG_R0, TCG_REG_PC, 0); else tcg_out_dat_imm(s, COND_AL, ARITH_MOV, TCG_REG_R0, 0, args[... |
0 | void hmp_info_vnc(Monitor *mon, const QDict *qdict){ VncInfo *info; Error *err = NULL; VncClientInfoList *client; info = qmp_query_vnc(&err); if (err) { monitor_printf(mon, "%s\n", error_get_pretty(err)); error_free(err); return; } if (!info->enabled) { monitor_printf(mon, "Server: disabled\n"); goto out; } monitor_pri... |
0 | static void cmos_init(int ram_size, const char *boot_device, BlockDriverState **hd_table){ RTCState *s = rtc_state; int val; int fd0, fd1, nb; int i; /* various important CMOS locations needed by PC/Bochs bios */ /* memory size */ val = 640; /* base memory in K */ rtc_set_memory(s, 0x15, val); rtc_set_memory(s, 0x16, v... |
0 | static int nbd_parse_uri(const char *filename, QDict *options){ URI *uri; const char *p; QueryParams *qp = NULL; int ret = 0; bool is_unix; uri = uri_parse(filename); if (!uri) { return -EINVAL; } /* transport */ if (!strcmp(uri->scheme, "nbd")) { is_unix = false; } else if (!strcmp(uri->scheme, "nbd+tcp")) { is_unix =... |
0 | static void disas_ldst_excl(DisasContext *s, uint32_t insn){ int rt = extract32(insn, 0, 5); int rn = extract32(insn, 5, 5); int rt2 = extract32(insn, 10, 5); int is_lasr = extract32(insn, 15, 1); int rs = extract32(insn, 16, 5); int is_pair = extract32(insn, 21, 1); int is_store = !extract32(insn, 22, 1); int is_excl ... |
0 | static void do_info_uuid(Monitor *mon){ monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1], qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5], qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], qemu_uuid[14], qemu_uuid[15]);} |
0 | void kvm_setup_guest_memory(void *start, size_t size){#ifdef CONFIG_VALGRIND_H VALGRIND_MAKE_MEM_DEFINED(start, size);#endif if (!kvm_has_sync_mmu()) { int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK); if (ret) { perror("qemu_madvise"); fprintf(stderr, "Need MADV_DONTFORK in absence of synchronous KVM MMU\n"); e... |
0 | build_facs(GArray *table_data, GArray *linker){ AcpiFacsDescriptorRev1 *facs = acpi_data_push(table_data, sizeof *facs); memcpy(&facs->signature, "FACS", 4); facs->length = cpu_to_le32(sizeof(*facs));} |
0 | bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag){ while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { bs = bs->file; } if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { return bs->drv->bdrv_debug_is_suspended(bs, tag); } return false;} |
1 | AioContext *aio_context_new(void){ AioContext *ctx; ctx = (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext)); ctx->pollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD)); ctx->thread_pool = NULL; qemu_mutex_init(&ctx->bh_lock); rfifolock_init(&ctx->lock, aio_rfifolock_cb, ctx); event_notifier_init(&ctx->n... |
1 | void bdrv_query_info(BlockDriverState *bs, BlockInfo **p_info, Error **errp){ BlockInfo *info = g_malloc0(sizeof(*info)); BlockDriverState *bs0; ImageInfo **p_image_info; Error *local_err = NULL; info->device = g_strdup(bs->device_name); info->type = g_strdup("unknown"); info->locked = bdrv_dev_is_medium_locked(bs); in... |
1 | 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){ CPUState *env = NULL; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); ram_addr_t kernel_size = 0; r... |
1 | static int do_break(CPUMIPSState *env, target_siginfo_t *info, unsigned int code){ int ret = -1; switch (code) { case BRK_OVERFLOW: case BRK_DIVZERO: info->si_signo = TARGET_SIGFPE; info->si_code = (code == BRK_OVERFLOW) ? FPE_INTOVF : FPE_INTDIV; break; default: break; } return ret;} |
1 | static uint16_t qpci_pc_config_readw(QPCIBus *bus, int devfn, uint8_t offset){ outl(0xcf8, (1 << 31) | (devfn << 8) | offset); return inw(0xcfc);} |
1 | int kvm_arch_put_registers(CPUState *env, int level){ int ret; assert(cpu_is_stopped(env) || qemu_cpu_is_self(env)); ret = kvm_getput_regs(env, 1); ret = kvm_put_xsave(env); ret = kvm_put_xcrs(env); ret = kvm_put_sregs(env); ret = kvm_put_msrs(env, level); if (level >= KVM_PUT_RESET_STATE) { ret = kvm_put_mp_state(env)... |
1 | static QObject *get_stats_qobject(VirtIOBalloon *dev){ QDict *dict = qdict_new(); uint32_t actual = ram_size - (dev->actual << VIRTIO_BALLOON_PFN_SHIFT); stat_put(dict, "actual", actual); stat_put(dict, "mem_swapped_in", dev->stats[VIRTIO_BALLOON_S_SWAP_IN]); stat_put(dict, "mem_swapped_out", dev->stats[VIRTIO_BALLOON_... |
1 | static int twolame_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ TWOLAMEContext *s = avctx->priv_data; int ret; if ((ret = ff_alloc_packet(avpkt, MPA_MAX_CODED_FRAME_SIZE)) < 0) return ret; if (frame) { switch (avctx->sample_fmt) { case AV_SAMPLE_FMT_FLT: ret = twolame... |
1 | yuv2rgb_full_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 AVPixelFormat target, int hasAlpha){ int i; int step =... |
1 | int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MpegEncContext *s = avctx->priv_data; int ret; AVFrame *pict = data; s->flags = avctx->flags; s->flags2 = avctx->flags2; /* no supplementary picture */ if (buf_size... |
1 | void sm501_init(MemoryRegion *address_space_mem, uint32_t base, uint32_t local_mem_bytes, qemu_irq irq, CharDriverState *chr){ SM501State * s; DeviceState *dev; MemoryRegion *sm501_system_config = g_new(MemoryRegion, 1); MemoryRegion *sm501_disp_ctrl = g_new(MemoryRegion, 1); MemoryRegion *sm501_2d_engine = g_new(Memor... |
1 | static void nbd_parse_filename(const char *filename, QDict *options, Error **errp){ char *file; char *export_name; const char *host_spec; const char *unixpath; if (qdict_haskey(options, "host") || qdict_haskey(options, "port") || qdict_haskey(options, "path")) { error_setg(errp, "host/port/path and a file name may not ... |
1 | static int64_t get_pts(const char **buf, int *duration, int32_t *x1, int32_t *y1, int32_t *x2, int32_t *y2){ int i; for (i=0; i<2; i++) { int hh1, mm1, ss1, ms1; int hh2, mm2, ss2, ms2; if (sscanf(*buf, "%d:%2d:%2d%*1[,.]%3d --> %d:%2d:%2d%*1[,.]%3d" "%*[ ]X1:%u X2:%u Y1:%u Y2:%u", &hh1, &mm1, &ss1, &ms1, &hh2, &mm2, &... |
1 | static int handle_hypercall(CPUState *env, struct kvm_run *run){ int r; cpu_synchronize_state(env); r = s390_virtio_hypercall(env); kvm_arch_put_registers(env); return r;} |
1 | static void disas_ldst_reg_imm9(DisasContext *s, uint32_t insn, int opc, int size, int rt, bool is_vector){ int rn = extract32(insn, 5, 5); int imm9 = sextract32(insn, 12, 9); int idx = extract32(insn, 10, 2); bool is_signed = false; bool is_store = false; bool is_extended = false; bool is_unpriv = (idx == 2); bool iss... |
1 | static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf, int buf_size){ HEVCParserContext *ctx = s->priv_data; ParseContext *pc = &ctx->pc; int i; for (i = 0; i < buf_size; i++) { int nut; pc->state64 = (pc->state64 << 8) | buf[i]; if (((pc->state64 >> 3 * 8) & 0xFFFFFF) != START_CODE) continue; nut ... |
1 | static void vnc_debug_gnutls_log(int level, const char* str) { VNC_DEBUG("%d %s", level, str);} |
0 | static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack* track){ int pos = url_ftell(pb); put_be32(pb, 0); /* size */ if(track->enc->codec_id == CODEC_ID_PCM_MULAW) put_tag(pb, "ulaw"); else if(track->enc->codec_id == CODEC_ID_PCM_ALAW) put_tag(pb, "alaw"); else if(track->enc->codec_id == CODEC_ID_ADPCM_IMA_QT) put_... |
1 | static void usbredir_alt_setting_status(void *priv, uint32_t id, struct usb_redir_alt_setting_status_header *alt_setting_status){ USBRedirDevice *dev = priv; AsyncURB *aurb; int len = 0; DPRINTF("alt status %d intf %d alt %d id: %u\n", alt_setting_status->status, alt_setting_status->interface, alt_setting_status->alt, ... |
1 | PPC_OP(setcrfbit){ T1 = (T1 & PARAM(1)) | (T0 << PARAM(2)); RETURN();} |
1 | PPC_OP(test_ctr_false){ T0 = (regs->ctr != 0 && (T0 & PARAM(1)) == 0); RETURN();} |
1 | void blk_io_limits_disable(BlockBackend *blk){ assert(blk->public.throttle_group_member.throttle_state); bdrv_drained_begin(blk_bs(blk)); throttle_group_unregister_tgm(&blk->public.throttle_group_member); bdrv_drained_end(blk_bs(blk));} |
1 | void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base){ FFFrameBucket *b; size_t bytes; int planar, planes, i; check_consistency(fq); av_assert1(fq->queued); b = bucket(fq, 0); av_assert1(samples < b->frame->nb_samples); planar = av_sample_fmt_is_planar(b->frame->format); planes = plana... |
1 | static void tcg_out_qemu_st(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; arg0 = TCG_REG_O0; arg1 = TCG_REG_O1; arg2 = TCG_RE... |
1 | void vnc_jobs_consume_buffer(VncState *vs){ bool flush; vnc_lock_output(vs); if (vs->jobs_buffer.offset) { if (vs->ioc != NULL && buffer_empty(&vs->output)) { if (vs->ioc_tag) { g_source_remove(vs->ioc_tag); vs->ioc_tag = qio_channel_add_watch( vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL); buffer_move(&vs->out... |
1 | ssize_t qsb_write_at(QEMUSizedBuffer *qsb, const uint8_t *source, off_t pos, size_t count){ ssize_t rc = qsb_grow(qsb, pos + count); size_t to_copy; size_t all_copy = count; const struct iovec *iov; ssize_t index; char *dest; off_t d_off, s_off = 0; if (rc < 0) { return rc; } if (pos + count > qsb->used) { qsb->used = ... |
1 | av_cold int ff_psy_init(FFPsyContext *ctx, AVCodecContext *avctx, int num_lens, const uint8_t **bands, const int* num_bands, int num_groups, const uint8_t *group_map){ int i, j, k = 0; ctx->avctx = avctx; ctx->ch = av_mallocz_array(sizeof(ctx->ch[0]), avctx->channels * 2); ctx->group = av_mallocz_array(sizeof(ctx->grou... |
1 | static int vpc_open(BlockDriverState *bs, int flags){ BDRVVPCState *s = bs->opaque; int i; struct vhd_footer* footer; struct vhd_dyndisk_header* dyndisk_header; uint8_t buf[HEADER_SIZE]; uint32_t checksum; int err = -1; int disk_type = VHD_DYNAMIC; if (bdrv_pread(bs->file, 0, s->footer_buf, HEADER_SIZE) != HEADER_SIZE)... |
1 | static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, SBRData *ch_data){ int i; ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env[1]]; ch_data->bs_num_env[0] = ch_data->bs_num_env[1]; ch_data->bs_amp_res = sbr->bs_amp_res_header; switch (ch_data->bs_frame_class = get... |
1 | static void extract_exponents(AC3EncodeContext *s){ int blk, ch, i; for (ch = 0; ch < s->channels; ch++) { for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { AC3Block *block = &s->blocks[blk]; uint8_t *exp = block->exp[ch]; int32_t *coef = block->fixed_coef[ch]; int exp_shift = block->exp_shift[ch]; for (i = 0; i < AC3_MAX_C... |
1 | static float32 roundAndPackFloat32( flag zSign, int16 zExp, uint32_t zSig STATUS_PARAM){ int8 roundingMode; flag roundNearestEven; int8 roundIncrement, roundBits; flag isTiny; roundingMode = STATUS(float_rounding_mode); roundNearestEven = ( roundingMode == float_round_nearest_even ); roundIncrement = 0x40; if ( ! round... |
1 | static av_cold int oggvorbis_encode_close(AVCodecContext *avctx){ OggVorbisContext *s = avctx->priv_data; /* notify vorbisenc this is EOF */ vorbis_analysis_wrote(&s->vd, 0); vorbis_block_clear(&s->vb); vorbis_dsp_clear(&s->vd); vorbis_info_clear(&s->vi); av_freep(&avctx->coded_frame); av_freep(&avctx->extradata); retu... |
1 | int av_parse_time(int64_t *timeval, const char *timestr, int duration){ const char *p; int64_t t; struct tm dt = { 0 }; int i; static const char * const date_fmt[] = { "%Y-%m-%d", "%Y%m%d", }; static const char * const time_fmt[] = { "%H:%M:%S", "%H%M%S", }; const char *q; int is_utc, len; char lastch; int negative = 0... |
0 | void *qemu_get_virtqueue_element(QEMUFile *f, size_t sz){ VirtQueueElement *elem; VirtQueueElementOld data; int i; qemu_get_buffer(f, (uint8_t *)&data, sizeof(VirtQueueElementOld)); elem = virtqueue_alloc_element(sz, data.out_num, data.in_num); elem->index = data.index; for (i = 0; i < elem->in_num; i++) { elem->in_add... |
0 | void qdev_property_add_child(DeviceState *dev, const char *name, DeviceState *child, Error **errp){ gchar *type; type = g_strdup_printf("child<%s>", child->info->name); qdev_property_add(dev, name, type, qdev_get_child_property, NULL, NULL, child, errp); qdev_ref(child); g_assert(child->parent == NULL); child->parent =... |
0 | static int copy_sectors(BlockDriverState *bs, uint64_t start_sect, uint64_t cluster_offset, int n_start, int n_end){ BDRVQcowState *s = bs->opaque; int n, ret; n = n_end - n_start; if (n <= 0) return 0; ret = qcow_read(bs, start_sect + n_start, s->cluster_data, n); if (ret < 0) return ret; if (s->crypt_method) { qcow2_... |
0 | static uint8_t send_read_command(void){ uint8_t drive = 0; uint8_t head = 0; uint8_t cyl = 0; uint8_t sect_addr = 1; uint8_t sect_size = 2; uint8_t eot = 1; uint8_t gap = 0x1b; uint8_t gpl = 0xff; uint8_t msr = 0; uint8_t st0; uint8_t ret = 0; floppy_send(CMD_READ); floppy_send(head << 2 | drive); g_assert(!get_irq(FLO... |
0 | static void unassigned_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){#ifdef DEBUG_UNASSIGNED printf("Unassigned mem write " TARGET_FMT_plx " = 0x%"PRIx64"\n", addr, val);#endif#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE) cpu_unassigned_access(cpu_singl... |
0 | static void tcg_out_insn_3405(TCGContext *s, AArch64Insn insn, TCGType ext, TCGReg rd, uint16_t half, unsigned shift){ assert((shift & ~0x30) == 0); tcg_out32(s, insn | ext << 31 | shift << (21 - 4) | half << 5 | rd);} |
0 | static inline int handle_cpu_signal(unsigned long pc, unsigned long address, int is_write, sigset_t *old_set, void *puc){ TranslationBlock *tb; int ret; if (cpu_single_env) env = cpu_single_env; /* XXX: find a correct solution for multithread */#if defined(DEBUG_SIGNAL) qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08... |
0 | static void coroutine_fn v9fs_xattrcreate(void *opaque){ int flags; int32_t fid; int64_t size; ssize_t err = 0; V9fsString name; size_t offset = 7; V9fsFidState *file_fidp; V9fsFidState *xattr_fidp; V9fsPDU *pdu = opaque; v9fs_string_init(&name); err = pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags); if ... |
0 | static void omap_sysctl_write(void *opaque, target_phys_addr_t addr, uint32_t value){ struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; switch (addr) { case 0x000:/* CONTROL_REVISION */ case 0x2a4:/* CONTROL_MSUSPENDMUX_5 */ case 0x2c0:/* CONTROL_PSA_VALUE */ case 0x2f8:/* CONTROL_STATUS */ case 0x2fc:/* CONTR... |
0 | ssize_t qemu_paio_return(struct qemu_paiocb *aiocb){ ssize_t ret; pthread_mutex_lock(&lock); ret = aiocb->ret; pthread_mutex_unlock(&lock); return ret;} |
0 | block_crypto_create_opts_init(QCryptoBlockFormat format, QemuOpts *opts, Error **errp){ Visitor *v; QCryptoBlockCreateOptions *ret = NULL; Error *local_err = NULL; ret = g_new0(QCryptoBlockCreateOptions, 1); ret->format = format; v = opts_visitor_new(opts); visit_start_struct(v, NULL, NULL, 0, &local_err); if (local_er... |
0 | static void cris_evaluate_flags(DisasContext *dc){if (!dc->flags_uptodate) {cris_flush_cc_state(dc);switch (dc->cc_op){case CC_OP_MCP:gen_helper_evaluate_flags_mcp();break;case CC_OP_MULS:gen_helper_evaluate_flags_muls();break;case CC_OP_MULU:gen_helper_evaluate_flags_mulu();break;case CC_OP_MOVE:case CC_OP_AND:case CC... |
0 | int nbd_disconnect(int fd){ errno = ENOTSUP; return -1;} |
0 | static void pl061_write(void *opaque, target_phys_addr_t offset, uint32_t value){ pl061_state *s = (pl061_state *)opaque; uint8_t mask; if (offset < 0x400) { mask = (offset >> 2) & s->dir; s->data = (s->data & ~mask) | (value & mask); pl061_update(s); return; } switch (offset) { case 0x400: /* Direction */ s->dir = val... |
0 | static int nvdec_vp8_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size){ VP8Context *h = avctx->priv_data; NVDECContext *ctx = avctx->internal->hwaccel_priv_data; CUVIDPICPARAMS *pp = &ctx->pic_params; FrameDecodeData *fdd; NVDECFrame *cf; AVFrame *cur_frame = h->framep[VP56_FRAME_CURRENT]->tf.f; ... |
0 | AVFilterBufferRef *avfilter_default_get_video_buffer(AVFilterLink *link, int perms, int w, int h){ AVFilterBuffer *pic = av_mallocz(sizeof(AVFilterBuffer)); AVFilterBufferRef *ref = av_mallocz(sizeof(AVFilterBufferRef)); int i, tempsize; char *buf; ref->buf = pic; ref->video = av_mallocz(sizeof(AVFilterBufferRefVideoPr... |
0 | static void blk_disconnect(struct XenDevice *xendev){ struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); if (blkdev->bs) { bdrv_detach_dev(blkdev->bs, blkdev); if (!blkdev->dinfo) { blk_unref(blk_by_name(blkdev->dev)); } blkdev->bs = NULL; } xen_be_unbind_evtchn(&blkdev->xendev); if (blkdev->sri... |
0 | static void raw_aio_remove(RawAIOCB *acb){ RawAIOCB **pacb; /* remove the callback from the queue */ pacb = &posix_aio_state->first_aio; for(;;) { if (*pacb == NULL) { fprintf(stderr, "raw_aio_remove: aio request not found!\n"); break; } else if (*pacb == acb) { *pacb = acb->next; qemu_aio_release(acb); break; } pacb =... |
0 | static void nvic_writel(NVICState *s, uint32_t offset, uint32_t value){ ARMCPU *cpu = s->cpu; switch (offset) { case 0xd04: /* Interrupt Control State. */ if (value & (1 << 31)) { armv7m_nvic_set_pending(s, ARMV7M_EXCP_NMI); } if (value & (1 << 28)) { armv7m_nvic_set_pending(s, ARMV7M_EXCP_PENDSV); } else if (value & (... |
0 | static void virtio_blk_handle_write(BlockRequest *blkreq, int *num_writes, VirtIOBlockReq *req){ if (req->out->sector & req->dev->sector_mask) { virtio_blk_rw_complete(req, -EIO); return; } if (*num_writes == 32) { do_multiwrite(req->dev->bs, blkreq, *num_writes); *num_writes = 0; } blkreq[*num_writes].sector = req->ou... |
0 | static void nbd_restart_write(void *opaque){ NbdClientSession *s = opaque; qemu_coroutine_enter(s->send_coroutine, NULL);} |
0 | static void xen_domain_poll(void *opaque){ struct xc_dominfo info; int rc; rc = xc_domain_getinfo(xen_xc, xen_domid, 1, &info); if ((rc != 1) || (info.domid != xen_domid)) { qemu_log("xen: domain %d is gone\n", xen_domid); goto quit; } if (info.dying) { qemu_log("xen: domain %d is dying (%s%s)\n", xen_domid, info.crash... |
0 | static void v9fs_unlinkat(void *opaque){ int err = 0; V9fsString name; int32_t dfid, flags; size_t offset = 7; V9fsPath path; V9fsFidState *dfidp; V9fsPDU *pdu = opaque; pdu_unmarshal(pdu, offset, "dsd", &dfid, &name, &flags); dfidp = get_fid(pdu, dfid); if (dfidp == NULL) { err = -EINVAL; goto out_nofid; } /* * IF the... |
0 | void load_seg(int seg_reg, int selector, unsigned int cur_eip){ uint32_t e1, e2; int cpl, dpl, rpl; SegmentCache *dt; int index; uint8_t *ptr; if ((selector & 0xfffc) == 0) { /* null selector case */ if (seg_reg == R_SS) { EIP = cur_eip; raise_exception_err(EXCP0D_GPF, 0); } else { cpu_x86_load_seg_cache(env, seg_reg, ... |
0 | static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, uint8_t absexp, int8_t *dexps){ int i, j, grp, group_size; int dexp[256]; int expacc, prevexp; /* unpack groups */ group_size = exp_strategy + (exp_strategy == EXP_D45); for(grp=0,i=0; grp<ngrps; grp++) { expacc = get_bits(gbc, 7); dexp[i++] =... |
0 | static void unix_accept_incoming_migration(void *opaque){ struct sockaddr_un addr; socklen_t addrlen = sizeof(addr); int s = (unsigned long)opaque; QEMUFile *f; int c, ret; do { c = qemu_accept(s, (struct sockaddr *)&addr, &addrlen); } while (c == -1 && socket_error() == EINTR); DPRINTF("accepted migration\n"); if (c =... |
0 | static int protocol_version(VncState *vs, uint8_t *version, size_t len){ char local[13]; memcpy(local, version, 12); local[12] = 0; if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {VNC_DEBUG("Malformed protocol version %s\n", local);vnc_client_error(vs);return 0; } VNC_DEBUG("Client request protocol ... |
0 | static void data_plane_set_up_op_blockers(VirtIOBlockDataPlane *s){ assert(!s->blocker); error_setg(&s->blocker, "block device is in use by data plane"); blk_op_block_all(s->conf->conf.blk, s->blocker); blk_op_unblock(s->conf->conf.blk, BLOCK_OP_TYPE_RESIZE, s->blocker); blk_op_unblock(s->conf->conf.blk, BLOCK_OP_TYPE_... |
0 | static inline void scoop_gpio_handler_update(ScoopInfo *s) { uint32_t level, diff; int bit; level = s->gpio_level & s->gpio_dir; for (diff = s->prev_level ^ level; diff; diff ^= 1 << bit) { bit = ffs(diff) - 1; qemu_set_irq(s->handler[bit], (level >> bit) & 1); } s->prev_level = level;} |
0 | static void disas_simd_zip_trn(DisasContext *s, uint32_t insn){ unsupported_encoding(s, insn);} |
0 | static int run_ccw(struct subchannel_id schid, int cmd, void *ptr, int len){ struct ccw1 ccw = {}; struct cmd_orb orb = {}; struct schib schib; int r; /* start command processing */ stsch_err(schid, &schib); schib.scsw.ctrl = SCSW_FCTL_START_FUNC; msch(schid, &schib); /* start subchannel command */ orb.fmt = 1; orb.cpa... |
0 | static struct omap_lpg_s *omap_lpg_init(target_phys_addr_t base, omap_clk clk){ int iomemtype; struct omap_lpg_s *s = (struct omap_lpg_s *) qemu_mallocz(sizeof(struct omap_lpg_s)); s->tm = qemu_new_timer(rt_clock, omap_lpg_tick, s); omap_lpg_reset(s); iomemtype = cpu_register_io_memory(omap_lpg_readfn, omap_lpg_writefn... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.