label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void dec_modu(DisasContext *dc){ int l1; LOG_DIS("modu r%d, r%d, %d\n", dc->r2, dc->r0, dc->r1); if (!(dc->env->features & LM32_FEATURE_DIVIDE)) { cpu_abort(dc->env, "hardware divider is not available\n"); } l1 = gen_new_label(); tcg_gen_brcondi_tl(TCG_COND_NE, cpu_R[dc->r1], 0, l1); tcg_gen_movi_tl(cpu_pc, dc->... |
1 | static void rv40_loop_filter(RV34DecContext *r, int row){ MpegEncContext *s = &r->s; int mb_pos, mb_x; int i, j, k; uint8_t *Y, *C; int alpha, beta, betaY, betaC; int q; int mbtype[4]; ///< current macroblock and its neighbours types /** * flags indicating that macroblock can be filtered with strong filter * it is set ... |
1 | static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt){ struct video_data *s = ctx->priv_data; struct v4l2_buffer buf = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .memory = V4L2_MEMORY_MMAP }; int res; pkt->size = 0; /* FIXME: Some special treatment might be needed in case of loss of signal... */ while ((res = v4l... |
1 | static int seg_write_packet(AVFormatContext *s, AVPacket *pkt){ SegmentContext *seg = s->priv_data; AVStream *st = s->streams[pkt->stream_index]; int64_t end_pts = INT64_MAX, offset; int start_frame = INT_MAX; int ret; struct tm ti; int64_t usecs; int64_t wrapped_val; if (!seg->avf) return AVERROR(EINVAL);calc_times: i... |
1 | static int reap_filters(int flush){ AVFrame *filtered_frame = NULL; int i; /* 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]; AVFilterContext *filter; AVCodecContext *enc = ost->enc_ctx; int ... |
1 | static int decode_p_picture_primary_header(VC9Context *v){ /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */ GetBitContext *gb = &v->s.gb; int lowquant, pqindex, status = 0; pqindex = get_bits(gb, 5); if (v->quantizer_mode == QUANT_FRAME_IMPLICIT) v->pq = pquant_table[0][pqindex]; else { v->pq = pquant_table[v->quanti... |
1 | static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){ RMDemuxContext *rm = s->priv_data; ByteIOContext *pb = s->pb; int len, num, res, i; AVStream *st; uint32_t state=0xFFFFFFFF; while(!url_feof(pb)){ *pos= url_ftell(pb) - 3; if(rm->remaining_len > 0){ num= rm->current_st... |
1 | int mpeg4_decode_picture_header(MpegEncContext * s){ int time_incr, startcode, state, v; redo: /* search next start code */ align_get_bits(&s->gb); state = 0xff; for(;;) { v = get_bits(&s->gb, 8); if (state == 0x000001) { state = ((state << 8) | v) & 0xffffff; startcode = state; break; } state = ((state << 8) | v) & 0x... |
1 | static int encode_init(AVCodecContext * avctx){ WMACodecContext *s = avctx->priv_data; int i, flags1, flags2; uint8_t *extradata; s->avctx = avctx; if(avctx->channels > MAX_CHANNELS) { av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer", avctx->channels, MAX_CHANNELS); return AVERROR(EINVAL); } if... |
1 | static int txd_read_header(AVFormatContext *s, AVFormatParameters *ap) { AVStream *st; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_TXD; st->codec->time_base.den = 5; st->codec->time_base.num = 1; /* the parameters will be... |
1 | static int output_frame(AVFilterLink *outlink, int nb_samples){ AVFilterContext *ctx = outlink->src; MixContext *s = ctx->priv; AVFilterBufferRef *out_buf, *in_buf; int i; calculate_scales(s, nb_samples); out_buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples); if (!out_buf) return AVERROR(ENOMEM); in_buf = f... |
1 | MAKE_ACCESSORS(AVVDPAUContext, vdpau_hwaccel, AVVDPAU_Render2, render2)int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile, int level){ VDPAUHWContext *hwctx = avctx->hwaccel_context; VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data; VdpDecoderCreate *create; void *func; VdpStatus status; ... |
1 | static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, int n, int coded, int intra, int rvlc){ int level, i, last, run; int dc_pred_dir; RLTable * rl; RL_VLC_ELEM * rl_vlc; const uint8_t * scan_table; int qmul, qadd; //Note intra & rvlc should be optimized away if this is inlined if(intra) { if(s->us... |
1 | static void check_watchpoint(int offset, int len, int flags){ CPUState *cpu = current_cpu; CPUArchState *env = cpu->env_ptr; target_ulong pc, cs_base; target_ulong vaddr; CPUWatchpoint *wp; int cpu_flags; if (cpu->watchpoint_hit) { /* We re-entered the check after replacing the TB. Now raise * the debug interrupt so th... |
1 | int ff_mov_read_esds(AVFormatContext *fc, ByteIOContext *pb, MOVAtom atom){ AVStream *st; int tag, len; if (fc->nb_streams < 1) return 0; st = fc->streams[fc->nb_streams-1]; get_be32(pb); /* version + flags */ len = mp4_read_descr(fc, pb, &tag); if (tag == MP4ESDescrTag) { get_be16(pb); /* ID */ get_byte(pb); /* priori... |
1 | PPC_OP(neg){ if (T0 != 0x80000000) { T0 = -Ts0; } RETURN();} |
1 | static inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2, bool add_ca, bool compute_ca, bool compute_ov, bool compute_rc0){ TCGv t0 = ret; if (compute_ca || compute_ov) { t0 = tcg_temp_new(); } if (compute_ca) { /* dest = ~arg1 + arg2 [+ ca]. */ if (NARROW_MODE(ctx)) { /* Caution: a non-ob... |
1 | static int64_t coroutine_fn vpc_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file){ BDRVVPCState *s = bs->opaque; VHDFooter *footer = (VHDFooter*) s->footer_buf; int64_t start, offset; bool allocated; int64_t ret; int n; if (be32_to_cpu(footer->type) == VHD... |
1 | struct pxa2xx_mmci_s *pxa2xx_mmci_init(target_phys_addr_t base, qemu_irq irq, void *dma){ int iomemtype; struct pxa2xx_mmci_s *s; s = (struct pxa2xx_mmci_s *) qemu_mallocz(sizeof(struct pxa2xx_mmci_s)); s->base = base; s->irq = irq; s->dma = dma; iomemtype = cpu_register_io_memory(0, pxa2xx_mmci_readfn, pxa2xx_mmci_wri... |
1 | void kvmppc_set_papr(CPUPPCState *env){ struct kvm_enable_cap cap = {}; struct kvm_one_reg reg = {}; struct kvm_sregs sregs = {}; int ret; uint64_t hior = env->spr[SPR_HIOR]; cap.cap = KVM_CAP_PPC_PAPR; ret = kvm_vcpu_ioctl(env, KVM_ENABLE_CAP, &cap); if (ret) { goto fail; } /* * XXX We set HIOR here. It really should ... |
1 | static void send_ext_key_event_ack(VncState *vs){ vnc_lock_output(vs); vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE); vnc_write_u8(vs, 0); vnc_write_u16(vs, 1); vnc_framebuffer_update(vs, 0, 0, surface_width(vs->vd->ds), surface_height(vs->vd->ds), VNC_ENCODING_EXT_KEY_EVENT); vnc_unlock_output(vs); vnc_flush(vs)... |
1 | static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, long src_size){const uint8_t *s = src;const uint8_t *end;#ifdef HAVE_MMXconst uint8_t *mm_end;#endifuint16_t *d = (uint16_t *)dst;end = s + src_size;#ifdef HAVE_MMX__asm __volatile(PREFETCH"%0"::"m"(*src):"memory");__asm __volatile( "movq%0, %%mm7\n... |
1 | void *HELPER(lookup_tb_ptr)(CPUArchState *env){ CPUState *cpu = ENV_GET_CPU(env); TranslationBlock *tb; target_ulong cs_base, pc; uint32_t flags, hash; cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags); hash = tb_jmp_cache_hash_func(pc); tb = atomic_rcu_read(&cpu->tb_jmp_cache[hash]); if (unlikely(!(tb && tb->pc == pc &... |
1 | void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h){ ff_draw_horiz_band(s->avctx, &s->current_picture.f, &s->last_picture.f, y, h, s->picture_structure, s->first_field, s->low_delay);} |
1 | int load_image_targphys(const char *filename,target_phys_addr_t addr, int max_sz){ int size; size = get_image_size(filename); if (size > 0) rom_add_file_fixed(filename, addr, -1); return size;} |
1 | static void ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p){ CCID_Header *ccid_header; if (p->iov.size + s->bulk_out_pos > BULK_OUT_DATA_SIZE) { goto err; } usb_packet_copy(p, s->bulk_out_data + s->bulk_out_pos, p->iov.size); s->bulk_out_pos += p->iov.size; if (s->bulk_out_pos < 10) { DPRINTF(s, 1, "%s: header inco... |
1 | static av_cold int vcr1_decode_init(AVCodecContext *avctx){ avctx->pix_fmt = AV_PIX_FMT_YUV410P; return 0; |
1 | static void *sparc32_dma_init(target_phys_addr_t daddr, qemu_irq parent_irq, void *iommu, qemu_irq *dev_irq){ DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "sparc32_dma"); qdev_prop_set_ptr(dev, "iommu_opaque", iommu); qdev_init(dev); s = sysbus_from_qdev(dev); sysbus_connect_irq(s, 0, parent_irq); *dev_ir... |
1 | int monitor_read_block_device_key(Monitor *mon, const char *device, BlockCompletionFunc *completion_cb, void *opaque){ Error *err = NULL; BlockBackend *blk; blk = blk_by_name(device); if (!blk) { monitor_printf(mon, "Device not found %s\n", device); return -1; } if (!blk_bs(blk)) { monitor_printf(mon, "Device '%s' has ... |
1 | static void migrate_set_state(MigrationState *s, int old_state, int new_state){ if (atomic_cmpxchg(&s->state, old_state, new_state) == new_state) { trace_migrate_set_state(new_state); }} |
1 | static void disas_arm_insn(CPUState * env, DisasContext *s){ unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh; insn = ldl_code(s->pc); s->pc += 4; cond = insn >> 28; if (cond == 0xf){ /* Unconditional instructions. */ if ((insn & 0x0d70f000) == 0x0550f000) return; /* PLD */ else if ((insn & 0x0e000000) =... |
1 | static void print_block_info(Monitor *mon, BlockInfo *info, BlockDeviceInfo *inserted, bool verbose){ ImageInfo *image_info; assert(!info || !info->has_inserted || info->inserted == inserted); if (info) { monitor_printf(mon, "%s", info->device); if (inserted && inserted->has_node_name) { monitor_printf(mon, " (%s)", in... |
1 | int qemu_bh_poll(void){ QEMUBH *bh, **pbh; int ret; ret = 0; for(;;) { pbh = &first_bh; bh = *pbh; if (!bh) break; ret = 1; *pbh = bh->next; bh->scheduled = 0; bh->cb(bh->opaque); } return ret;} |
1 | static int qemu_rdma_write(QEMUFile *f, RDMAContext *rdma, uint64_t block_offset, uint64_t offset, uint64_t len){ uint64_t current_addr = block_offset + offset; uint64_t index = rdma->current_index; uint64_t chunk = rdma->current_chunk; int ret; /* If we cannot merge it, we flush the current buffer first. */ if (!qemu_... |
0 | static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, int pitch){ uint32_t bit_cache; uint8_t *list[63]; uint32_t *dst; const uint32_t *codebook; int entries[6]; int i, j, m, n; int mean, stages; int x, y, width, height, level; uint32_t n1, n2, n3, n4; /* initialize list for breadth first proce... |
0 | static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AC3DecodeContext *s = avctx->priv_data; int blk, ch, err, ret; const uint8_t *channel_map; const float *output[AC3_MAX_CHANNELS]; /* copy input buffer to de... |
1 | static void decode_postinit(H264Context *h, int setup_finished){ H264Picture *out = h->cur_pic_ptr; H264Picture *cur = h->cur_pic_ptr; int i, pics, out_of_order, out_idx; int invalid = 0, cnt = 0; h->cur_pic_ptr->f->pict_type = h->pict_type; if (h->next_output_pic) return; if (cur->field_poc[0] == INT_MAX || cur->field... |
1 | static int str_read_packet(AVFormatContext *s, AVPacket *ret_pkt){ AVIOContext *pb = s->pb; StrDemuxContext *str = s->priv_data; unsigned char sector[RAW_CD_SECTOR_SIZE]; int channel; AVPacket *pkt; AVStream *st; while (1) { if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE) return AVERROR(EIO); chann... |
1 | char *object_property_print(Object *obj, const char *name, bool human, Error **errp){ StringOutputVisitor *mo; char *string; mo = string_output_visitor_new(human); object_property_get(obj, string_output_get_visitor(mo), name, errp); string = string_output_get_string(mo); string_output_visitor_cleanup(mo); return string... |
1 | static void virtio_gpu_resource_create_2d(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd){ pixman_format_code_t pformat; struct virtio_gpu_simple_resource *res; struct virtio_gpu_resource_create_2d c2d; VIRTIO_GPU_FILL_CMD(c2d); trace_virtio_gpu_cmd_res_create_2d(c2d.resource_id, c2d.format, c2d.width, c2d.height); ... |
1 | int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, int nb_clusters){ BDRVQcowState *s = bs->opaque; uint64_t cluster_index; uint64_t old_free_cluster_index; uint64_t i; int refcount, ret; assert(nb_clusters >= 0); if (nb_clusters == 0) { return 0; } /* Check how many clusters there are free */ cluster_i... |
1 | static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size){ Mpeg1Context *s = avctx->priv_data; MpegEncContext *s2 = &s->mpeg_enc_ctx; const uint8_t *buf_ptr = buf; const uint8_t *buf_end = buf + buf_size; int ret, input_size; int last_code = 0, skip_frame = 0; ... |
1 | static int get_video_frame(VideoState *is, AVFrame *frame){ int got_picture; if ((got_picture = decoder_decode_frame(&is->viddec, frame)) < 0) return -1; if (got_picture) { double dpts = NAN; if (frame->pts != AV_NOPTS_VALUE) dpts = av_q2d(is->video_st->time_base) * frame->pts; frame->sample_aspect_ratio = av_guess_sam... |
1 | START_TEST(escaped_string){ int i; struct { const char *encoded; const char *decoded; int skip; } test_cases[] = { { "\"\\\"\"", "\"" }, { "\"hello world \\\"embedded string\\\"\"", "hello world \"embedded string\"" }, { "\"hello world\\nwith new line\"", "hello world\nwith new line" }, { "\"single byte utf-8 \\u0020\"... |
1 | static void pc_dimm_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ HotplugHandlerClass *hhc; Error *local_err = NULL; PCMachineState *pcms = PC_MACHINE(hotplug_dev); if (!pcms->acpi_dev) { error_setg(&local_err, "memory hotplug is not enabled: missing acpi device"); goto out; } if (object_... |
0 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, int unit){ const char *driver; DeviceState *dev; driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk"; dev = qdev_create(&bus->qbus, driver); qdev_prop_set_uint32(dev, "scsi-id", unit); if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) { qde... |
0 | NBDExport *nbd_export_new(BlockBackend *blk, off_t dev_offset, off_t size, uint32_t nbdflags, void (*close)(NBDExport *), Error **errp){ NBDExport *exp = g_malloc0(sizeof(NBDExport)); exp->refcount = 1; QTAILQ_INIT(&exp->clients); exp->blk = blk; exp->dev_offset = dev_offset; exp->nbdflags = nbdflags; exp->size = size ... |
0 | static int bdrv_qed_open(BlockDriverState *bs, int flags){ BDRVQEDState *s = bs->opaque; QEDHeader le_header; int64_t file_size; int ret; s->bs = bs; QSIMPLEQ_INIT(&s->allocating_write_reqs); ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header)); if (ret < 0) { return ret; } qed_header_le_to_cpu(&le_header, &s->... |
0 | static void test_io_channel_unix(bool async){ SocketAddress *listen_addr = g_new0(SocketAddress, 1); SocketAddress *connect_addr = g_new0(SocketAddress, 1);#define TEST_SOCKET "test-io-channel-socket.sock" listen_addr->type = SOCKET_ADDRESS_KIND_UNIX; listen_addr->u.q_unix = g_new0(UnixSocketAddress, 1); listen_addr->u... |
0 | static void test_visitor_in_native_list_bool(TestInputVisitorData *data, const void *unused){ UserDefNativeListUnion *cvalue = NULL; boolList *elem = NULL; Visitor *v; GString *gstr_list = g_string_new(""); GString *gstr_union = g_string_new(""); int i; for (i = 0; i < 32; i++) { g_string_append_printf(gstr_list, "%s",... |
0 | static void init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb, int length){ int i, k, run, level, diff; if (BITS_LEFT(length,gb) < 16) return; level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2); quantized_coeffs[0] = level; for (i = 0; i < 7; ) { if (BITS_LEFT(length,gb) < 16) break; run = qdm2_get_v... |
0 | QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, QEMUTimerCB *cb, void *opaque){ return g_malloc(1);} |
0 | static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof){ /* FMOV: gpr to or from float, double, or top half of quad fp reg, * without conversion. */ if (itof) { TCGv_i64 tcg_rn = cpu_reg(s, rn); switch (type) { case 0: { /* 32 bit */ TCGv_i64 tmp = tcg_temp_new_i64(); tcg_gen_ext32u_i64(tmp, tcg_r... |
0 | static void coroutine_fn bdrv_discard_co_entry(void *opaque){ DiscardCo *rwco = opaque; rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors);} |
0 | static uint64_t escc_mem_read(void *opaque, target_phys_addr_t addr, unsigned size){ SerialState *serial = opaque; ChannelState *s; uint32_t saddr; uint32_t ret; int channel; saddr = (addr >> serial->it_shift) & 1; channel = (addr >> (serial->it_shift + 1)) & 1; s = &serial->chn[channel]; switch (saddr) { case SERIAL_C... |
0 | static int proxy_parse_opts(QemuOpts *opts, struct FsDriverEntry *fs){ const char *socket = qemu_opt_get(opts, "socket"); const char *sock_fd = qemu_opt_get(opts, "sock_fd"); if (!socket && !sock_fd) { fprintf(stderr, "socket and sock_fd none of the option specified\n"); return -1; } if (socket && sock_fd) { fprintf(st... |
0 | static void bdrv_co_io_em_complete(void *opaque, int ret){ CoroutineIOCompletion *co = opaque; co->ret = ret; qemu_coroutine_enter(co->coroutine, NULL);} |
0 | START_TEST(qobject_to_qdict_test){ fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);} |
0 | static int mmu_translate_pte(CPUS390XState *env, target_ulong vaddr, uint64_t asc, uint64_t asce, target_ulong *raddr, int *flags, int rw){ if (asce & _PAGE_INVALID) { DPRINTF("%s: PTE=0x%" PRIx64 " invalid\n", __func__, asce); trigger_page_fault(env, vaddr, PGM_PAGE_TRANS, asc, rw); return -1; } if (asce & _PAGE_RO) {... |
0 | static uint64_t qvirtio_scsi_alloc(QVirtIOSCSI *vs, size_t alloc_size, const void *data){ uint64_t addr; addr = guest_alloc(vs->alloc, alloc_size); if (data) { memwrite(addr, data, alloc_size); } return addr;} |
0 | guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond, GIOFunc func, void *user_data){ GSource *src; guint tag; if (s->chr_add_watch == NULL) { return -ENOSYS; } src = s->chr_add_watch(s, cond); g_source_set_callback(src, (GSourceFunc)func, user_data, NULL); tag = g_source_attach(src, NULL); g_source_unref(... |
0 | static void notdirty_mem_write(void *opaque, target_phys_addr_t ram_addr, uint64_t val, unsigned size){ int dirty_flags; dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr); if (!(dirty_flags & CODE_DIRTY_FLAG)) {#if !defined(CONFIG_USER_ONLY) tb_invalidate_phys_page_fast(ram_addr, size); dirty_flags = cpu_phys... |
0 | 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); trace_v9fs_xattrwalk(pdu->tag... |
0 | void kvm_cpu_synchronize_state(CPUState *env){ if (!env->kvm_vcpu_dirty) run_on_cpu(env, do_kvm_cpu_synchronize_state, env);} |
0 | static void virtio_blk_rw_complete(void *opaque, int ret){ VirtIOBlockReq *req = opaque; trace_virtio_blk_rw_complete(req, ret); if (ret) { int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type); bool is_read = !(p & VIRTIO_BLK_T_OUT); if (virtio_blk_handle_rw_error(req, -ret, is_read)) return; } virtio_blk_req_... |
0 | void qmp_migrate_set_parameters(MigrationParameters *params, Error **errp){ MigrationState *s = migrate_get_current(); if (params->has_compress_level && (params->compress_level < 0 || params->compress_level > 9)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", "is invalid, it should be in the range o... |
0 | uint64_t HELPER(lpq)(CPUS390XState *env, uint64_t addr){ uintptr_t ra = GETPC(); uint64_t hi, lo; if (parallel_cpus) {#ifndef CONFIG_ATOMIC128 cpu_loop_exit_atomic(ENV_GET_CPU(env), ra);#else int mem_idx = cpu_mmu_index(env, false); TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx); Int128 v = helper_atomi... |
0 | void breakpoint_handler(CPUState *cs){ X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; CPUBreakpoint *bp; if (cs->watchpoint_hit) { if (cs->watchpoint_hit->flags & BP_CPU) { cs->watchpoint_hit = NULL; if (check_hw_breakpoints(env, false)) { raise_exception(env, EXCP01_DB); } else { cpu_resume_from_signal(cs, N... |
0 | static void start_output(DBDMA_channel *ch, int key, uint32_t addr, uint16_t req_count, int is_last){ DBDMA_DPRINTF("start_output\n"); /* KEY_REGS, KEY_DEVICE and KEY_STREAM * are not implemented in the mac-io chip */ DBDMA_DPRINTF("addr 0x%x key 0x%x\n", addr, key); if (!addr || key > KEY_STREAM3) { kill_channel(ch); ... |
1 | static void FUNCC(pred8x8_dc)(uint8_t *_src, int stride){ int i; int dc0, dc1, dc2; pixel4 dc0splat, dc1splat, dc2splat, dc3splat; pixel *src = (pixel*)_src; stride /= sizeof(pixel); dc0=dc1=dc2=0; for(i=0;i<4; i++){ dc0+= src[-1+i*stride] + src[i-stride]; dc1+= src[4+i-stride]; dc2+= src[-1+(i+4)*stride]; } dc0splat =... |
1 | static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len){ int32_t *ptr = qdev_get_prop_ptr(dev, prop); return snprintf(dest, len, "%" PRId32, *ptr);} |
1 | int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){ VP56Context *s = avctx->priv_data; AVFrame *const p = s->framep[VP56_FRAME_CURRENT]; int remaining_buf_size = buf_size; int is_alpha, alpha_offset; if (s->has_alpha) { alpha_offset = bytestream_get_be24(&buf); re... |
1 | static inline void RENAME(uyvyToY)(uint8_t *dst, uint8_t *src, int width){#ifdef HAVE_MMXasm volatile("mov %0, %%"REG_a"\n\t""1:\n\t""movq (%1, %%"REG_a",2), %%mm0\n\t""movq 8(%1, %%"REG_a",2), %%mm1\n\t""psrlw $8, %%mm0\n\t""psrlw $8, %%mm1\n\t""packuswb %%mm1, %%mm0\n\t""movq %%mm0, (%2, %%"REG_a")\n\t""add $8, %%"RE... |
1 | static av_cold int wmavoice_decode_init(AVCodecContext *ctx){ int n, flags, pitch_range, lsp16_flag; WMAVoiceContext *s = ctx->priv_data; /** * Extradata layout: * - byte 0-18: WMAPro-in-WMAVoice extradata (see wmaprodec.c), * - byte 19-22: flags field (annoyingly in LE; see below for known * values), * - byte 23-46: v... |
1 | static void ehci_queues_rip_unused(EHCIState *ehci, int async){ EHCIQueueHead *head = async ? &ehci->aqueues : &ehci->pqueues; EHCIQueue *q, *tmp; QTAILQ_FOREACH_SAFE(q, head, next, tmp) { if (q->seen) { q->seen = 0; q->ts = ehci->last_run_ns; continue; } if (ehci->last_run_ns < q->ts + 250000000) { /* allow 0.25 sec i... |
1 | void kvm_arch_pre_run(CPUState *env, struct kvm_run *run){ /* Inject NMI */ if (env->interrupt_request & CPU_INTERRUPT_NMI) { env->interrupt_request &= ~CPU_INTERRUPT_NMI; DPRINTF("injected NMI\n"); kvm_vcpu_ioctl(env, KVM_NMI); } if (!kvm_irqchip_in_kernel()) { /* Force the VCPU out of its inner loop to process the IN... |
1 | static void test_acpi_one(const char *params, test_data *data){ char *args; uint8_t signature_low; uint8_t signature_high; uint16_t signature; int i; const char *device = ""; if (!g_strcmp0(data->machine, MACHINE_Q35)) { device = ",id=hd -device ide-hd,drive=hd"; } args = g_strdup_printf("-net none -display none %s -dr... |
1 | static int ea_read_header(AVFormatContext *s, AVFormatParameters *ap){ EaDemuxContext *ea = s->priv_data; AVStream *st; if (!process_ea_header(s)) return AVERROR(EIO); if (ea->video_codec) { /* initialize the video decoder stream */ st = av_new_stream(s, 0); if (!st) return AVERROR(ENOMEM); ea->video_stream_index = st-... |
1 | PCIBus *pci_get_bus_devfn(int *devfnp, PCIBus *root, const char *devaddr){ int dom, bus; unsigned slot; assert(!root->parent_dev); if (!root) { fprintf(stderr, "No primary PCI bus\n"); return NULL; } if (!devaddr) { *devfnp = -1; return pci_find_bus_nr(root, 0); } if (pci_parse_devaddr(devaddr, &dom, &bus, &slot, NULL)... |
1 | static void destroy_page_desc(uint16_t section_index){ MemoryRegionSection *section = &phys_sections[section_index]; MemoryRegion *mr = section->mr; if (mr->subpage) { subpage_t *subpage = container_of(mr, subpage_t, iomem); memory_region_destroy(&subpage->iomem); g_free(subpage); }} |
1 | static void opt_output_file(const char *filename){ AVFormatContext *oc; int err, use_video, use_audio, use_subtitle; int input_has_video, input_has_audio, input_has_subtitle; AVFormatParameters params, *ap = ¶ms; AVOutputFormat *file_oformat; if (!strcmp(filename, "-")) filename = "pipe:"; oc = avformat_alloc_conte... |
1 | void vnc_display_add_client(DisplayState *ds, int csock, int skipauth){ VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display; vnc_connect(vs, csock, skipauth, 0);} |
1 | av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp){#if HAVE_YASM int cpu_flags = av_get_cpu_flags();#define init_fpel(idx1, idx2, sz, type, opt) \ dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \ dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \ dsp->mc[idx1][FILTER_8TAP_SHARP ][idx2][0][0] = \ dsp->mc[idx1][FILTER... |
1 | static void tracked_request_end(BdrvTrackedRequest *req){ QLIST_REMOVE(req, list);} |
1 | static TranslationBlock *tb_alloc(target_ulong pc){ TranslationBlock *tb; if (tcg_ctx.tb_ctx.nb_tbs >= tcg_ctx.code_gen_max_blocks || (tcg_ctx.code_gen_ptr - tcg_ctx.code_gen_buffer) >= tcg_ctx.code_gen_buffer_max_size) { return NULL; } tb = &tcg_ctx.tb_ctx.tbs[tcg_ctx.tb_ctx.nb_tbs++]; tb->pc = pc; tb->cflags = 0; ret... |
1 | static void mxf_write_partition(AVFormatContext *s, int bodysid, int indexsid, const uint8_t *key, int write_metadata){ MXFContext *mxf = s->priv_data; AVIOContext *pb = s->pb; int64_t header_byte_count_offset; unsigned index_byte_count = 0; uint64_t partition_offset = avio_tell(pb); if (!mxf->edit_unit_byte_count && m... |
0 | static inline void RENAME(yuvPlanartouyvy)(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, long vertLumPerChroma){long y;const long chromWidth= width>>1;for(y=0; y<height; y++){#ifdef HAVE_MMX//FIXME handle 2 lines a o... |
0 | static void decodeplane32(uint32_t *dst, const uint8_t *const buf, int buf_size, int bps, int plane){ GetBitContext gb; int i, b; init_get_bits(&gb, buf, buf_size * 8); for(i = 0; i < (buf_size * 8 + bps - 1) / bps; i++) { for (b = 0; b < bps; b++) { dst[ i*bps + b ] |= get_bits1(&gb) << plane; } }} |
0 | static int swf_read_packet(AVFormatContext *s, AVPacket *pkt){ SWFContext *swf = s->priv_data; AVIOContext *pb = s->pb; AVStream *vst = NULL, *ast = NULL, *st = 0; int tag, len, i, frame, v; for(;;) { uint64_t pos = avio_tell(pb); tag = get_swf_tag(pb, &len); if (tag < 0) return AVERROR(EIO); if (tag == TAG_VIDEOSTREAM... |
0 | void qxl_render_update(PCIQXLDevice *qxl){ VGACommonState *vga = &qxl->vga; QXLRect dirty[32], update; void *ptr; int i; if (qxl->guest_primary.resized) { qxl->guest_primary.resized = 0; if (qxl->guest_primary.flipped) { g_free(qxl->guest_primary.flipped); qxl->guest_primary.flipped = NULL; } qemu_free_displaysurface(v... |
0 | static int local_fstat(FsContext *fs_ctx, int fid_type, V9fsFidOpenState *fs, struct stat *stbuf){ int err, fd; if (fid_type == P9_FID_DIR) { fd = dirfd(fs->dir); } else { fd = fs->fd; } err = fstat(fd, stbuf); if (err) { return err; } if (fs_ctx->export_flags & V9FS_SM_MAPPED) { /* Actual credentials are part of exten... |
0 | static uint64_t malta_fpga_read(void *opaque, target_phys_addr_t addr, unsigned size){ MaltaFPGAState *s = opaque; uint32_t val = 0; uint32_t saddr; saddr = (addr & 0xfffff); switch (saddr) { /* SWITCH Register */ case 0x00200: val = 0x00000000;/* All switches closed */ break; /* STATUS Register */ case 0x00208:#ifdef ... |
0 | static void replay_save_event(Event *event, int checkpoint){ if (replay_mode != REPLAY_MODE_PLAY) { /* put the event into the file */ replay_put_event(EVENT_ASYNC); replay_put_byte(checkpoint); replay_put_byte(event->event_kind); /* save event-specific data */ switch (event->event_kind) { default: error_report("Unknown... |
0 | static USBDevice *usb_msd_init(USBBus *bus, const char *filename){ static int nr=0; char id[8]; QemuOpts *opts; DriveInfo *dinfo; USBDevice *dev; const char *p1; char fmt[32]; /* parse -usbdevice disk: syntax into drive opts */ do { snprintf(id, sizeof(id), "usb%d", nr++); opts = qemu_opts_create(qemu_find_opts("drive"... |
0 | static size_t handle_aiocb_flush(struct qemu_paiocb *aiocb){ int ret; ret = qemu_fdatasync(aiocb->aio_fildes); if (ret == -1) return -errno; return 0;} |
0 | static int unin_internal_pci_host_init(PCIDevice *d){ pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_APPLE); pci_config_set_device_id(d->config, PCI_DEVICE_ID_APPLE_UNI_N_I_PCI); d->config[0x08] = 0x00; // revision pci_config_set_class(d->config, PCI_CLASS_BRIDGE_HOST); d->config[0x0C] = 0x08; // cache_line_size d->... |
0 | static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **img_convert_ctx) { int ret = 0; switch (frame->format) { case AV_PIX_FMT_YUV420P: if (frame->linesize[0] < 0 || frame->linesize[1] < 0 || frame->linesize[2] < 0) { av_log(NULL, AV_LOG_ERROR, "Negative linesize is not supported for YUV.\n");... |
0 | static void load_linux(const char *kernel_filename, const char *initrd_filename, const char *kernel_cmdline){ uint16_t protocol; uint32_t gpr[8]; uint16_t seg[6]; uint16_t real_seg; int setup_size, kernel_size, initrd_size, cmdline_size; uint32_t initrd_max; uint8_t header[1024]; target_phys_addr_t real_addr, prot_addr... |
0 | static void gen_neon_zip_u8(TCGv t0, TCGv t1){ TCGv rd, rm, tmp; rd = new_tmp(); rm = new_tmp(); tmp = new_tmp(); tcg_gen_andi_i32(rd, t0, 0xff); tcg_gen_shli_i32(tmp, t1, 8); tcg_gen_andi_i32(tmp, tmp, 0xff00); tcg_gen_or_i32(rd, rd, tmp); tcg_gen_shli_i32(tmp, t0, 16); tcg_gen_andi_i32(tmp, tmp, 0xff0000); tcg_gen_or... |
0 | static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo){ VncState *vs = cinfo->client_data; Buffer *buffer = &vs->tight_jpeg; buffer->offset = buffer->capacity; buffer_reserve(buffer, 2048); jpeg_init_destination(cinfo); return TRUE;} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.