label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | int ff_h264_decode_sei(H264Context *h){ while (get_bits_left(&h->gb) > 16) { int size, type; type=0; do{ if (get_bits_left(&h->gb) < 8) return AVERROR_INVALIDDATA; type+= show_bits(&h->gb, 8); }while(get_bits(&h->gb, 8) == 255); size=0; do{ if (get_bits_left(&h->gb) < 8) return AVERROR_INVALIDDATA; size+= show_bits(&h-... |
0 | static int mpeg_decode_postinit(AVCodecContext *avctx){ Mpeg1Context *s1 = avctx->priv_data; MpegEncContext *s = &s1->mpeg_enc_ctx; uint8_t old_permutation[64]; int ret; if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) { // MPEG-1 aspect avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255... |
1 | static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset){ MXFContext *mxf = arg; int item_num = avio_rb32(pb); int item_len = avio_rb32(pb); if (item_len != 18) { avpriv_request_sample(pb, "Primer pack item length %d", item_len); return AVERROR_PATCHWELCOME; } if (item... |
1 | void kvm_inject_x86_mce(CPUState *cenv, int bank, uint64_t status, uint64_t mcg_status, uint64_t addr, uint64_t misc, int abort_on_error){#ifdef KVM_CAP_MCE struct kvm_x86_mce mce = { .bank = bank, .status = status, .mcg_status = mcg_status, .addr = addr, .misc = misc, }; struct kvm_x86_mce_data data = { .env = cenv, .... |
1 | static inline void RENAME(yuv2bgr24_2)(SwsContext *c, const uint16_t *buf0, const uint16_t *buf1, const uint16_t *ubuf0, const uint16_t *ubuf1, const uint16_t *vbuf0, const uint16_t *vbuf1, const uint16_t *abuf0, const uint16_t *abuf1, uint8_t *dest, int dstW, int yalpha, int uvalpha, int y){ x86_reg uv_off = c->uv_off... |
1 | static int usb_xhci_initfn(struct PCIDevice *dev){ int i, ret; XHCIState *xhci = DO_UPCAST(XHCIState, pci_dev, dev); xhci->pci_dev.config[PCI_CLASS_PROG] = 0x30; /* xHCI */ xhci->pci_dev.config[PCI_INTERRUPT_PIN] = 0x01; /* interrupt pin 1 */ xhci->pci_dev.config[PCI_CACHE_LINE_SIZE] = 0x10; xhci->pci_dev.config[0x60] ... |
1 | int avformat_network_init(void){#if CONFIG_NETWORK int ret; ff_network_inited_globally = 1; if ((ret = ff_network_init()) < 0) return ret; ff_tls_init();#endif return 0;} |
1 | GList *range_list_insert(GList *list, Range *data){ GList *l, *next = NULL; Range *r, *nextr; if (!list) { list = g_list_insert_sorted(list, data, range_compare); return list; } nextr = data; l = list; while (l && l != next && nextr) { r = l->data; if (ranges_can_merge(r, nextr)) { range_merge(r, nextr); l = g_list_rem... |
1 | static int sab_diamond_search(MpegEncContext * s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags){ MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; Minima minima[MAX_SAB_SIZE]; const int minima_count= FFABS(c->dia_size); int i, j; LOAD_COMMON LO... |
1 | static void close_guest_eventfds(IVShmemState *s, int posn){ int i, guest_curr_max; if (!ivshmem_has_feature(s, IVSHMEM_IOEVENTFD)) { guest_curr_max = s->peers[posn].nb_eventfds; memory_region_transaction_begin(); for (i = 0; i < guest_curr_max; i++) { ivshmem_del_eventfd(s, posn, i); memory_region_transaction_commit()... |
1 | static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf){ unsigned tag, type, count, off, value = 0; int i; uint32_t *pal; const uint8_t *rp, *gp, *bp; if (end_buf - buf < 12) return AVERROR_INVALIDDATA; tag = tget_short(&buf, s->le); type = tget_short(&buf, s->le); c... |
0 | static int read_packet(AVFormatContext *s, AVPacket *pkt){ MmDemuxContext *mm = s->priv_data; AVIOContext *pb = s->pb; unsigned char preamble[MM_PREAMBLE_SIZE]; unsigned int type, length; while(1) { if (avio_read(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) { return AVERROR(EIO); } type = AV_RL16(&preamble[0]);... |
0 | static int handle_name_to_path(FsContext *ctx, V9fsPath *dir_path, const char *name, V9fsPath *target){ char buffer[PATH_MAX]; struct file_handle *fh; int dirfd, ret, mnt_id; struct handle_data *data = (struct handle_data *)ctx->private; /* "." and ".." are not allowed */ if (!strcmp(name, ".") || !strcmp(name, "..")) ... |
0 | static int qio_dns_resolver_lookup_sync_inet(QIODNSResolver *resolver, SocketAddress *addr, size_t *naddrs, SocketAddress ***addrs, Error **errp){ struct addrinfo ai, *res, *e; InetSocketAddress *iaddr = addr->u.inet.data; char port[33]; char uaddr[INET6_ADDRSTRLEN + 1]; char uport[33]; int rc; Error *err = NULL; size_... |
0 | void acpi_build(AcpiBuildTables *tables, MachineState *machine){ PCMachineState *pcms = PC_MACHINE(machine); PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms); GArray *table_offsets; unsigned facs, dsdt, rsdt, fadt; AcpiPmInfo pm; AcpiMiscInfo misc; AcpiMcfgInfo mcfg; Range pci_hole, pci_hole64; uint8_t *u; size_t aml_... |
0 | static Aml *build_crs(PCIHostState *host, GPtrArray *io_ranges, GPtrArray *mem_ranges){ Aml *crs = aml_resource_template(); uint8_t max_bus = pci_bus_num(host->bus); uint8_t type; int devfn; for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) { int i; uint64_t range_base, range_limit; PCIDevice *dev = host... |
0 | static int escc_init1(SysBusDevice *dev){ ESCCState *s = ESCC(dev); unsigned int i; s->chn[0].disabled = s->disabled; s->chn[1].disabled = s->disabled; for (i = 0; i < 2; i++) { sysbus_init_irq(dev, &s->chn[i].irq); s->chn[i].chn = 1 - i; s->chn[i].clock = s->frequency / 2; if (s->chn[i].chr) { qemu_chr_add_handlers(s-... |
0 | void aio_bh_update_timeout(AioContext *ctx, uint32_t *timeout){ QEMUBH *bh; for (bh = ctx->first_bh; bh; bh = bh->next) { if (!bh->deleted && bh->scheduled) { if (bh->idle) { /* idle bottom halves will be polled at least * every 10ms */ *timeout = MIN(10, *timeout); } else { /* non-idle bottom halves will be executed *... |
0 | void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f, ImageInfoSpecific *info_spec){ QObject *obj, *data; Visitor *v = qobject_output_visitor_new(&obj); visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort); visit_complete(v, &obj); assert(qobject_type(obj) == QTYPE_QDICT); data = qdict_g... |
0 | static mfxIMPL choose_implementation(const InputStream *ist){ static const struct { const char *name; mfxIMPL impl; } impl_map[] = { { "auto", MFX_IMPL_AUTO }, { "sw", MFX_IMPL_SOFTWARE }, { "hw", MFX_IMPL_HARDWARE }, { "auto_any", MFX_IMPL_AUTO_ANY }, { "hw_any", MFX_IMPL_HARDWARE_ANY }, { "hw2", MFX_IMPL_HARDWARE2 },... |
0 | SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat){ SocketAddress *addr = g_new(SocketAddress, 1); switch (addr_flat->type) { case SOCKET_ADDRESS_FLAT_TYPE_INET: addr->type = SOCKET_ADDRESS_KIND_INET; addr->u.inet.data = QAPI_CLONE(InetSocketAddress, &addr_flat->u.inet); break; case SOCKET_ADDRESS_FLAT... |
0 | void aio_set_event_notifier(AioContext *ctx, EventNotifier *e, EventNotifierHandler *io_notify){ AioHandler *node; QLIST_FOREACH(node, &ctx->aio_handlers, node) { if (node->e == e && !node->deleted) { break; } } /* Are we deleting the fd handler? */ if (!io_notify) { if (node) { g_source_remove_poll(&ctx->source, &node... |
0 | static void uhci_fill_queue(UHCIState *s, UHCI_TD *td){ uint32_t int_mask = 0; uint32_t plink = td->link; uint32_t token = uhci_queue_token(td); UHCI_TD ptd; int ret; while (is_valid(plink)) { pci_dma_read(&s->dev, plink & ~0xf, &ptd, sizeof(ptd)); le32_to_cpus(&ptd.link); le32_to_cpus(&ptd.ctrl); le32_to_cpus(&ptd.tok... |
0 | static inline int get_segment(CPUPPCState *env, mmu_ctx_t *ctx, target_ulong eaddr, int rw, int type){ hwaddr hash; target_ulong vsid; int ds, pr, target_page_bits; int ret, ret2; pr = msr_pr; ctx->eaddr = eaddr;#if defined(TARGET_PPC64) if (env->mmu_model & POWERPC_MMU_64) { ppc_slb_t *slb; target_ulong pageaddr; int ... |
0 | static void char_socket_test(void){ Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait"); Chardev *chr_client; QObject *addr; QDict *qdict, *data; const char *port; SocketIdleData d = { .chr = chr }; CharBackend be; CharBackend client_be; char *tmp; d.be = &be; d.client_be = &be; g_assert_nonnull(chr)... |
0 | void virtio_scsi_dataplane_start(VirtIOSCSI *s){ int i; int rc; BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s))); VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus); VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); if (s->dataplane_started || s->dataplane_starting || s->dataplane_fenced || s->ctx != iothread_get_aio_conte... |
0 | static void disas_fp_csel(DisasContext *s, uint32_t insn){ unsigned int mos, type, rm, cond, rn, rd; int label_continue = -1; mos = extract32(insn, 29, 3); type = extract32(insn, 22, 2); /* 0 = single, 1 = double */ rm = extract32(insn, 16, 5); cond = extract32(insn, 12, 4); rn = extract32(insn, 5, 5); rd = extract32(i... |
0 | int bdrv_open(BlockDriverState **pbs, const char *filename, const char *reference, QDict *options, int flags, BlockDriver *drv, Error **errp){ int ret; BlockDriverState *file = NULL, *bs; const char *drvname; Error *local_err = NULL; int snapshot_flags = 0; assert(pbs); if (reference) { bool options_non_empty = options... |
0 | START_TEST(qdict_haskey_test){ const char *key = "test"; qdict_put(tests_dict, key, qint_from_int(0)); fail_unless(qdict_haskey(tests_dict, key) == 1);} |
0 | static void pc_dimm_check_memdev_is_busy(const Object *obj, const char *name, Object *val, Error **errp){ Error *local_err = NULL; if (host_memory_backend_is_mapped(MEMORY_BACKEND(val))) { char *path = object_get_canonical_path_component(val); error_setg(&local_err, "can't use already busy memdev: %s", path); g_free(pa... |
0 | void co_run_in_worker_bh(void *opaque){ Coroutine *co = opaque; thread_pool_submit_aio(aio_get_thread_pool(qemu_get_aio_context()), coroutine_enter_func, co, coroutine_enter_cb, co);} |
0 | static int local_fstat(FsContext *ctx, int fd, struct stat *stbuf){ return fstat(fd, stbuf);} |
0 | static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, uint64_t sector, size_t size){ uint64_t nb_sectors = size >> BDRV_SECTOR_BITS; uint64_t total_sectors; if (nb_sectors > INT_MAX) { return false; } if (sector & dev->sector_mask) { return false; } if (size % dev->conf.conf.logical_block_size) { return false; } blk_g... |
0 | static inline void RENAME(rgb16to15)(const uint8_t *src, uint8_t *dst, long src_size){ register const uint8_t* s=src; register uint8_t* d=dst; register const uint8_t *end; const uint8_t *mm_end; end = s + src_size;#if COMPILE_TEMPLATE_MMX __asm__ volatile(PREFETCH" %0"::"m"(*s)); __asm__ volatile("movq %0, %%mm7"::"m"(... |
0 | static void do_interrupt64(CPUX86State *env, int intno, int is_int, int error_code, target_ulong next_eip, int is_hw){ SegmentCache *dt; target_ulong ptr; int type, dpl, selector, cpl, ist; int has_error_code, new_stack; uint32_t e1, e2, e3, ss; target_ulong old_eip, esp, offset; has_error_code = 0; if (!is_int && !is_... |
0 | static void sdhci_generic_reset(DeviceState *ds){ SDHCIState *s = SDHCI(ds); SDHCI_GET_CLASS(s)->reset(s);} |
0 | static void write_vec_element_i32(DisasContext *s, TCGv_i32 tcg_src, int destidx, int element, TCGMemOp memop){ int vect_off = vec_reg_offset(destidx, element, memop & MO_SIZE); switch (memop) { case MO_8: tcg_gen_st8_i32(tcg_src, cpu_env, vect_off); break; case MO_16: tcg_gen_st16_i32(tcg_src, cpu_env, vect_off); brea... |
0 | static void net_socket_cleanup(NetClientState *nc){ NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc); qemu_set_fd_handler(s->fd, NULL, NULL, NULL); close(s->fd);} |
0 | void qtest_init(const char *qtest_chrdev, const char *qtest_log, Error **errp){ CharDriverState *chr; chr = qemu_chr_new("qtest", qtest_chrdev, NULL); if (chr == NULL) { error_setg(errp, "Failed to initialize device for qtest: \"%s\"", qtest_chrdev); return; } qemu_chr_add_handlers(chr, qtest_can_read, qtest_read, qtes... |
0 | static uint32_t taihu_cpld_readl (void *opaque, hwaddr addr){ uint32_t ret; ret = taihu_cpld_readb(opaque, addr) << 24; ret |= taihu_cpld_readb(opaque, addr + 1) << 16; ret |= taihu_cpld_readb(opaque, addr + 2) << 8; ret |= taihu_cpld_readb(opaque, addr + 3); return ret;} |
0 | static int htab_save_complete(QEMUFile *f, void *opaque){ sPAPRMachineState *spapr = opaque; /* Iteration header */ qemu_put_be32(f, 0); if (!spapr->htab) { int rc; assert(kvm_enabled()); rc = spapr_check_htab_fd(spapr); if (rc < 0) { return rc; } rc = kvmppc_save_htab(f, spapr->htab_fd, MAX_KVM_BUF_SIZE, -1); if (rc <... |
0 | static uint32_t ahci_port_read(AHCIState *s, int port, int offset){ uint32_t val; AHCIPortRegs *pr; pr = &s->dev[port].port_regs; switch (offset) { case PORT_LST_ADDR: val = pr->lst_addr; break; case PORT_LST_ADDR_HI: val = pr->lst_addr_hi; break; case PORT_FIS_ADDR: val = pr->fis_addr; break; case PORT_FIS_ADDR_HI: va... |
0 | static void hscroll(AVCodecContext *avctx){ AnsiContext *s = avctx->priv_data; int i; if (s->y < avctx->height - s->font_height) { s->y += s->font_height; return; } i = 0; for (; i < avctx->height - s->font_height; i++) memcpy(s->frame->data[0] + i * s->frame->linesize[0], s->frame->data[0] + (i + s->font_height) * s->... |
0 | static int64_t buffered_set_rate_limit(void *opaque, int64_t new_rate){ QEMUFileBuffered *s = opaque; if (qemu_file_get_error(s->file)) { goto out; } if (new_rate > SIZE_MAX) { new_rate = SIZE_MAX; } s->xfer_limit = new_rate / 10; out: return s->xfer_limit;} |
0 | static int mp_dacl_setxattr(FsContext *ctx, const char *path, const char *name, void *value, size_t size, int flags){ char buffer[PATH_MAX]; return lsetxattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT, value, size, flags);} |
0 | static int spapr_vio_check_reg(VIOsPAPRDevice *sdev, VIOsPAPRDeviceInfo *info){ VIOsPAPRDevice *other_sdev; DeviceState *qdev; VIOsPAPRBus *sbus; sbus = DO_UPCAST(VIOsPAPRBus, bus, sdev->qdev.parent_bus); /* * Check two device aren't given clashing addresses by the user (or some * other mechanism). We have to open code... |
0 | static int vaapi_encode_issue(AVCodecContext *avctx, VAAPIEncodePicture *pic){ VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeSlice *slice; VAStatus vas; int err, i; char data[MAX_PARAM_BUFFER_SIZE]; size_t bit_len; av_log(avctx, AV_LOG_DEBUG, "Issuing encode for pic %"PRId64"/%"PRId64" " "as type %s.\n", pic->... |
0 | static void avc_luma_hv_qrt_8w_msa(const uint8_t *src_x, const uint8_t *src_y, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height){ uint32_t loop_cnt; v16i8 src_hz0, src_hz1, src_hz2, src_hz3; v16i8 src_vt0, src_vt1, src_vt2, src_vt3, src_vt4; v16i8 src_vt5, src_vt6, src_vt7, src_vt8; v16i8 mask0, mas... |
0 | static int dxva_get_decoder_guid(AVCodecContext *avctx, void *service, void *surface_format, unsigned guid_count, const GUID *guid_list, GUID *decoder_guid){ FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx); unsigned i, j; *decoder_guid = ff_GUID_NULL; for (i = 0; dxva_modes[i].guid; i++) { const dxva_mode *mode ... |
0 | static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb){ MpegEncContext *s = &ctx->m; int width, height, vo_ver_id; /* vol header */ skip_bits(gb, 1); /* random access */ s->vo_type = get_bits(gb, 8); if (get_bits1(gb) != 0) { /* is_ol_id */ vo_ver_id = get_bits(gb, 4); /* vo_ver_id */ skip_bits(gb, 3); /... |
0 | 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 }; struct pollfd p = { .fd = s->fd, .events = POLLIN }; int res; res = poll(&p, 1, s->timeout); if (res < 0) return AVERROR(e... |
1 | void cpu_ppc_set_papr(PowerPCCPU *cpu){ CPUPPCState *env = &cpu->env; /* PAPR always has exception vectors in RAM not ROM. To ensure this, * MSR[IP] should never be set. * * We also disallow setting of MSR_HV */ env->msr_mask &= ~((1ull << MSR_EP) | MSR_HVB); /* Set a full AMOR so guest can use the AMR as it sees fit *... |
1 | static int aac_encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size, void *data){ AACEncContext *s = avctx->priv_data; int16_t *samples = s->samples, *samples2, *la; ChannelElement *cpe; int i, j, chans, tag, start_ch; const uint8_t *chan_map = aac_chan_configs[avctx->channels-1]; int chan_el_counter[4]; FF... |
0 | static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset){ GetBitContext *gb = &v->s.gb; MpegEncContext *s = &v->s; int dc_pred_dir = 0; /* Direction of the DC prediction used */ int run_diff, i; int16_t *dc_val; int16_t *ac_val, *ac_val2; int dcdiff; int mb_pos = ... |
0 | static int vp3_decode_end(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; av_free(s->all_fragments); av_free(s->coded_fragment_list); av_free(s->superblock_fragments); av_free(s->superblock_macroblocks); av_free(s->macroblock_fragments); av_free(s->macroblock_coded); /* release all frames */ avctx->rele... |
1 | static uint64_t openpic_src_read(void *opaque, uint64_t addr, unsigned len){ OpenPICState *opp = opaque; uint32_t retval; int idx; DPRINTF("%s: addr %08x\n", __func__, addr); retval = 0xFFFFFFFF; if (addr & 0xF) { return retval; } addr = addr & 0xFFF0; idx = addr >> 5; if (addr & 0x10) { /* EXDE / IFEDE / IEEDE */ retv... |
1 | SchroFrame *ff_create_schro_frame(AVCodecContext *avccontext, SchroFrameFormat schro_frame_fmt){ AVPicture *p_pic; SchroFrame *p_frame; int y_width, uv_width; int y_height, uv_height; int i; y_width = avccontext->width; y_height = avccontext->height; uv_width = y_width >> (SCHRO_FRAME_FORMAT_H_SHIFT(schro_frame_fmt)); ... |
0 | static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags){ FFMContext *ffm = s->priv_data; int64_t pos_min, pos_max, pos; int64_t pts_min, pts_max, pts; double pos1; av_dlog(s, "wanted_pts=%0.6f\n", wanted_pts / 1000000.0); /* find the position using linear interpolation (better than dich... |
1 | static void moxie_cpu_realizefn(DeviceState *dev, Error **errp){ MoxieCPU *cpu = MOXIE_CPU(dev); MoxieCPUClass *mcc = MOXIE_CPU_GET_CLASS(dev); cpu_reset(CPU(cpu)); mcc->parent_realize(dev, errp);} |
1 | int ga_install_service(const char *path, const char *logfile){ SC_HANDLE manager; SC_HANDLE service; TCHAR cmdline[MAX_PATH]; if (GetModuleFileName(NULL, cmdline, MAX_PATH) == 0) { printf_win_error("No full path to service's executable"); return EXIT_FAILURE; } _snprintf(cmdline, MAX_PATH - strlen(cmdline), "%s -d", cm... |
1 | static inline void RENAME(rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size){ const uint16_t *end; const uint16_t *mm_end; uint8_t *d = (uint8_t *)dst; const uint16_t *s = (const uint16_t *)src; end = s + src_size/2; __asm__ volatile(PREFETCH" %0"::"m"(*s):"memory"); mm_end = end - 7; while (s < mm_end) { __... |
1 | static void thread_pool_cancel(BlockDriverAIOCB *acb){ ThreadPoolElement *elem = (ThreadPoolElement *)acb; ThreadPool *pool = elem->pool; trace_thread_pool_cancel(elem, elem->common.opaque); qemu_mutex_lock(&pool->lock); if (elem->state == THREAD_QUEUED && /* No thread has yet started working on elem. we can try to "st... |
1 | static void vhost_dev_unassign_memory(struct vhost_dev *dev, uint64_t start_addr, uint64_t size){ int from, to, n = dev->mem->nregions; /* Track overlapping/split regions for sanity checking. */ int overlap_start = 0, overlap_end = 0, overlap_middle = 0, split = 0; for (from = 0, to = 0; from < n; ++from, ++to) { struc... |
1 | static int pfpu_decode_insn(MilkymistPFPUState *s){ uint32_t pc = s->regs[R_PC]; uint32_t insn = s->microcode[pc]; uint32_t reg_a = (insn >> 18) & 0x7f; uint32_t reg_b = (insn >> 11) & 0x7f; uint32_t op = (insn >> 7) & 0xf; uint32_t reg_d = insn & 0x7f; uint32_t r; int latency = 0; switch (op) { case OP_NOP: break; cas... |
1 | double av_int2dbl(int64_t v){ if(v+v > 0xFFEULL<<52) return NAN; return ldexp(((v&((1LL<<52)-1)) + (1LL<<52)) * (v>>63|1), (v>>52&0x7FF)-1075);} |
1 | static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be){ int ret; size_t buf_size; if (size < 0) return AVERROR(EINVAL); buf_size = size + size / 2 + 1; *str = av_malloc(buf_size); if (!*str) return AVERROR(ENOMEM); if (be) ret = avio_get_str16be(pb, size, *str, buf_size); else ret = avio... |
1 | static void synth_block_fcb_acb(WMAVoiceContext *s, GetBitContext *gb, int block_idx, int size, int block_pitch_sh2, const struct frame_type_desc *frame_desc, float *excitation){ static const float gain_coeff[6] = { 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458 }; float pulses[MAX_FRAMESIZE / 2], pred_err, acb_gain... |
1 | type_init(serial_register_types)static bool serial_isa_init(ISABus *bus, int index, CharDriverState *chr){ DeviceState *dev; ISADevice *isadev; isadev = isa_try_create(bus, TYPE_ISA_SERIAL); if (!isadev) { return false; } dev = DEVICE(isadev); qdev_prop_set_uint32(dev, "index", index); qdev_prop_set_chr(dev, "chardev",... |
0 | void url_split(char *proto, int proto_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url){ const char *p; char *q; int port; port = -1; p = url; q = proto; while (*p != ':' && *p != '\0') { if ((q - proto) < proto_size - 1) *q++ = *p; p++; } if (proto_size > 0) *q = '\0';... |
0 | static unsigned long iv_decode_frame(Indeo3DecodeContext *s, const uint8_t *buf, int buf_size){ unsigned int image_width, image_height, chroma_width, chroma_height; unsigned long flags, cb_offset, data_size, y_offset, v_offset, u_offset, mc_vector_count; const uint8_t *hdr_pos, *buf_pos; buf_pos = buf; buf_pos += 18; /... |
0 | static void rtsp_send_cmd_async (AVFormatContext *s, const char *cmd, RTSPMessageHeader *reply, unsigned char **content_ptr){ RTSPState *rt = s->priv_data; char buf[4096], buf1[1024]; rt->seq++; av_strlcpy(buf, cmd, sizeof(buf)); snprintf(buf1, sizeof(buf1), "CSeq: %d\r\n", rt->seq); av_strlcat(buf, buf1, sizeof(buf));... |
1 | static void apply_channel_coupling(AC3EncodeContext *s){ LOCAL_ALIGNED_16(CoefType, cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);#if CONFIG_AC3ENC_FLOAT LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);#else int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;#en... |
1 | static int get_high_utility_cell(elbg_data *elbg){ int i=0; /* Using linear search, do binary if it ever turns to be speed critical */ int r = av_lfg_get(elbg->rand_state)%elbg->utility_inc[elbg->numCB-1] + 1; while (elbg->utility_inc[i] < r) i++; av_assert2(elbg->cells[i]); return i;} |
1 | static uint32_t acpi_find_vgia(void){ uint32_t rsdp_offset; uint32_t guid_offset = 0; AcpiRsdpDescriptor rsdp_table; uint32_t rsdt; AcpiRsdtDescriptorRev1 rsdt_table; int tables_nr; uint32_t *tables; AcpiTableHeader ssdt_table; VgidTable vgid_table; int i; /* Tables may take a short time to be set up by the guest */ fo... |
1 | static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block){ uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; dest[0] = cm[(block[0] + 4)>>3];} |
1 | int cpu_load(QEMUFile *f, void *opaque, int version_id){ CPUState *env = opaque; int i; uint32_t tmp; if (version_id != 5) return -EINVAL; for(i = 0; i < 8; i++) qemu_get_betls(f, &env->gregs[i]); qemu_get_be32s(f, &env->nwindows); for(i = 0; i < env->nwindows * 16; i++) qemu_get_betls(f, &env->regbase[i]); /* FPU */ f... |
0 | static av_cold int v410_encode_close(AVCodecContext *avctx){ av_freep(&avctx->coded_frame); return 0;} |
0 | static int vp3_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ Vp3DecodeContext *s = avctx->priv_data; GetBitContext gb; static int counter = 0; init_get_bits(&gb, buf, buf_size * 8); if (s->theora && get_bits1(&gb)) {int ptype = get_bits(&gb, 7);skip_bits(&gb, 6*8); /* "the... |
0 | static int au_read_header(AVFormatContext *s){ int size; unsigned int tag; AVIOContext *pb = s->pb; unsigned int id, channels, rate; enum AVCodecID codec; AVStream *st; /* check ".snd" header */ tag = avio_rl32(pb); if (tag != MKTAG('.', 's', 'n', 'd')) return -1; size = avio_rb32(pb); /* header size */ avio_rb32(pb); ... |
1 | static void mtree_print_mr(fprintf_function mon_printf, void *f, const MemoryRegion *mr, unsigned int level, target_phys_addr_t base, MemoryRegionListHead *alias_print_queue){ MemoryRegionList *new_ml, *ml, *next_ml; MemoryRegionListHead submr_print_queue; const MemoryRegion *submr; unsigned int i; if (!mr) { return; }... |
1 | int spapr_vio_check_tces(VIOsPAPRDevice *dev, target_ulong ioba, target_ulong len, enum VIOsPAPR_TCEAccess access){ int start, end, i; start = ioba >> SPAPR_VIO_TCE_PAGE_SHIFT; end = (ioba + len - 1) >> SPAPR_VIO_TCE_PAGE_SHIFT; for (i = start; i <= end; i++) { if ((dev->rtce_table[i].tce & access) != access) {#ifdef D... |
1 | void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp){ int ret = 0; FsMountList mounts; struct FsMount *mount; int fd; Error *local_err = NULL; struct fstrim_range r = { .start = 0, .len = -1, .minlen = has_minimum ? minimum : 0, }; slog("guest-fstrim called"); QTAILQ_INIT(&mounts); build_fs_mount_list... |
0 | static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count){ int16_t weight[8][64]; DCTELEM orig[8][64]; const int mb_x= s->mb_x; const int mb_y= s->mb_y; int i; int skip_dct[8]; int dct_offset = s->linesize*8; //default for progressive frames ... |
1 | vpc_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags){ BDRVVPCState *s = bs->opaque; int64_t image_offset; int64_t n_bytes; int64_t bytes_done = 0; int ret; VHDFooter *footer = (VHDFooter *) s->footer_buf; QEMUIOVector local_qiov; if (be32_to_cpu(footer->type) == VHD_FIXED... |
1 | bool memory_region_present(MemoryRegion *container, hwaddr addr){ MemoryRegion *mr = memory_region_find(container, addr, 1).mr; if (!mr || (mr == container)) { return false; } memory_region_unref(mr); return true;} |
1 | static void tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l){ TCGMemOp opc = l->opc; TCGReg data_reg; uint8_t **label_ptr = &l->label_ptr[0]; /* resolve label address */ *(uint32_t *)label_ptr[0] = (uint32_t)(s->code_ptr - label_ptr[0] - 4); if (TARGET_LONG_BITS > TCG_TARGET_REG_BITS) { *(uint32_t *)label_... |
1 | static long do_sigreturn_v1(CPUARMState *env){ abi_ulong frame_addr;struct sigframe_v1 *frame;target_sigset_t set; sigset_t host_set; int i;/* * Since we stacked the signal on a 64-bit boundary, * then 'sp' should be word aligned here. If it's * not, then the user is trying to mess with us. */if (env->regs[13] & 7)goto... |
1 | static void tcp_chr_connect(void *opaque){ CharDriverState *chr = opaque; TCPCharDriver *s = chr->opaque; QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(s->ioc); g_free(chr->filename); chr->filename = sockaddr_to_str(&sioc->localAddr, sioc->localAddrLen, &sioc->remoteAddr, sioc->remoteAddrLen, s->is_listen, s->is_telnet);... |
1 | static void gen_muldiv (DisasContext *ctx, uint32_t opc, int rs, int rt){ const char *opn = "mul/div"; TCGv t0, t1; unsigned int acc; switch (opc) { case OPC_DIV: case OPC_DIVU:#if defined(TARGET_MIPS64) case OPC_DDIV: case OPC_DDIVU:#endif t0 = tcg_temp_local_new(); t1 = tcg_temp_local_new(); break; default: t0 = tcg_... |
1 | static void usb_msd_copy_data(MSDState *s){ uint32_t len; len = s->usb_len; if (len > s->scsi_len) len = s->scsi_len; if (s->mode == USB_MSDM_DATAIN) { memcpy(s->usb_buf, s->scsi_buf, len); } else { memcpy(s->scsi_buf, s->usb_buf, len); } s->usb_len -= len; s->scsi_len -= len; s->usb_buf += len; s->scsi_buf += len; s->... |
1 | void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, char *line, int line_size, int *print_prefix){ char part[3][512]; format_line(ptr, level, fmt, vl, part, sizeof(part[0]), print_prefix, NULL); snprintf(line, line_size, "%s%s%s", part[0], part[1], part[2]);} |
1 | static inline void RENAME(rgb32tobgr15)(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, %%mm... |
0 | static int http_receive_data(HTTPContext *c){ HTTPContext *c1; if (c->buffer_end > c->buffer_ptr) { int len; len = recv(c->fd, c->buffer_ptr, c->buffer_end - c->buffer_ptr, 0); if (len < 0) { if (ff_neterrno() != FF_NETERROR(EAGAIN) && ff_neterrno() != FF_NETERROR(EINTR)) /* error : close connection */ goto fail; } els... |
0 | uint32_t kvmppc_get_dfp(void){ return kvmppc_read_int_cpu_dt("ibm,dfp");} |
0 | static int send_full_color_rect(VncState *vs, int w, int h){ int stream = 0; size_t bytes; vnc_write_u8(vs, stream << 4); /* no flushing, no filter */ if (vs->tight_pixel24) { tight_pack24(vs, vs->tight.buffer, w * h, &vs->tight.offset); bytes = 3; } else { bytes = vs->clientds.pf.bytes_per_pixel; } bytes = tight_compr... |
0 | static void test_visitor_in_string(TestInputVisitorData *data, const void *unused){ char *res = NULL, *value = (char *) "Q E M U"; Visitor *v; v = visitor_input_test_init(data, "%s", value); visit_type_str(v, NULL, &res, &error_abort); g_assert_cmpstr(res, ==, value); g_free(res);} |
0 | static int kvm_init(MachineState *ms){ MachineClass *mc = MACHINE_GET_CLASS(ms); static const char upgrade_note[] = "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n" "(see http://sourceforge.net/projects/kvm).\n"; struct { const char *name; int num; } num_cpus[] = { { "SMP", smp_cpus }, { "hotpluggable", ... |
0 | static void qemu_gluster_gconf_free(GlusterConf *gconf){ g_free(gconf->server); g_free(gconf->volname); g_free(gconf->image); g_free(gconf->transport); g_free(gconf);} |
0 | void net_tx_pkt_init(struct NetTxPkt **pkt, uint32_t max_frags, bool has_virt_hdr){ struct NetTxPkt *p = g_malloc0(sizeof *p); p->vec = g_malloc((sizeof *p->vec) * (max_frags + NET_TX_PKT_PL_START_FRAG)); p->raw = g_malloc((sizeof *p->raw) * max_frags); p->max_payload_frags = max_frags; p->max_raw_frags = max_frags; p-... |
0 | static void vtd_init(IntelIOMMUState *s){ memset(s->csr, 0, DMAR_REG_SIZE); memset(s->wmask, 0, DMAR_REG_SIZE); memset(s->w1cmask, 0, DMAR_REG_SIZE); memset(s->womask, 0, DMAR_REG_SIZE); s->iommu_ops.translate = vtd_iommu_translate; s->root = 0; s->root_extended = false; s->dmar_enabled = false; s->iq_head = 0; s->iq_t... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.