label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void vmsvga_init(struct vmsvga_state_s *s, MemoryRegion *address_space, MemoryRegion *io){ s->scratch_size = SVGA_SCRATCH_SIZE; s->scratch = g_malloc(s->scratch_size * 4); s->vga.con = graphic_console_init(vmsvga_update_display, vmsvga_invalidate_display, vmsvga_screen_dump, vmsvga_text_update, s); s->fifo_size ... |
0 | static int local_set_mapped_file_attr(FsContext *ctx, const char *path, FsCred *credp){ FILE *fp; int ret = 0; char buf[ATTR_MAX]; char attr_path[PATH_MAX]; int uid = -1, gid = -1, mode = -1, rdev = -1; fp = local_fopen(local_mapped_attr_path(ctx, path, attr_path), "r"); if (!fp) { goto create_map_file; } memset(buf, 0... |
0 | static int64_t qemu_next_alarm_deadline(void){ int64_t delta; int64_t rtdelta; if (!use_icount && vm_clock->active_timers) { delta = vm_clock->active_timers->expire_time - qemu_get_clock_ns(vm_clock); } else { delta = INT32_MAX; } if (host_clock->active_timers) { int64_t hdelta = host_clock->active_timers->expire_time ... |
0 | static int decode_motion_vector (bit_buffer_t *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) { uint32_t bit_cache; vlc_code_t *vlc; int diff, sign; int i; for (i=0; i < 2; i++) { /* get motion code */ bit_cache = get_bit_cache (bitbuf); if (!(bit_cache & 0xFFE00000)) return -1;/* invalid vlc code */ if (bit_cache & 0x80000... |
0 | static void drive_backup_prepare(BlkActionState *common, Error **errp){ DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common); BlockBackend *blk; DriveBackup *backup; Error *local_err = NULL; assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP); backup = common->action->u.drive_backup.da... |
0 | void ssi_register_slave(SSISlaveInfo *info){ assert(info->qdev.size >= sizeof(SSISlave)); info->qdev.init = ssi_slave_init; info->qdev.bus_type = BUS_TYPE_SSI; qdev_register(&info->qdev);} |
0 | uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap){ return hbitmap_serialization_align(bitmap->bitmap);} |
0 | static void parse_drive(DeviceState *dev, const char *str, void **ptr, const char *propname, Error **errp){ BlockBackend *blk; blk = blk_by_name(str); if (!blk) { error_setg(errp, "Property '%s.%s' can't find value '%s'", object_get_typename(OBJECT(dev)), propname, str); return; } if (blk_attach_dev(blk, dev) < 0) { Dr... |
0 | static int get_segment (CPUState *env, mmu_ctx_t *ctx, target_ulong eaddr, int rw, int type){ target_phys_addr_t sdr, hash, mask, sdr_mask, htab_mask; target_ulong sr, vsid, vsid_mask, pgidx, page_mask;#if defined(TARGET_PPC64) int attr;#endif int ds, nx, vsid_sh, sdr_sh; int ret, ret2;#if defined(TARGET_PPC64) if (env... |
0 | static void arm_gic_realize(DeviceState *dev, Error **errp){ /* Device instance realize function for the GIC sysbus device */ GICv3State *s = ARM_GICV3(dev); ARMGICv3Class *agc = ARM_GICV3_GET_CLASS(s); Error *local_err = NULL; agc->parent_realize(dev, &local_err); if (local_err) { error_propagate(errp, local_err); ret... |
0 | static void build_append_notify_target(GArray *method, GArray *target_name, uint32_t value, int size){ GArray *notify = build_alloc_array(); uint8_t op = 0xA0; /* IfOp */ build_append_byte(notify, 0x93); /* LEqualOp */ build_append_byte(notify, 0x68); /* Arg0Op */ build_append_value(notify, value, size); build_append_b... |
0 | static void contextidr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value){ ARMCPU *cpu = arm_env_get_cpu(env); if (env->cp15.contextidr_el1 != value && !arm_feature(env, ARM_FEATURE_MPU) && !extended_addresses_enabled(env)) { /* For VMSA (when not using the LPAE long descriptor page table * format) this re... |
1 | static ram_addr_t qxl_rom_size(void){ uint32_t required_rom_size = sizeof(QXLRom) + sizeof(QXLModes) + sizeof(qxl_modes); uint32_t rom_size = 8192; /* two pages */ QEMU_BUILD_BUG_ON(required_rom_size > rom_size); return rom_size;} |
1 | static NetSocketState *net_socket_fd_init(NetClientState *peer, const char *model, const char *name, int fd, int is_connected){ int so_type = -1, optlen=sizeof(so_type); if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, (socklen_t *)&optlen)< 0) { fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d faile... |
1 | static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix, uint16_t **refcount_table, int64_t *nb_clusters){ BDRVQcowState *s = bs->opaque; int64_t i; QCowSnapshot *sn; int ret; if (!*refcount_table) { *refcount_table = g_try_new0(uint16_t, *nb_clusters); if (*nb_clusters && *refcount... |
0 | long check_dcbzl_effect(void){ register char *fakedata = (char*)av_malloc(1024); register char *fakedata_middle; register long zero = 0; register long i = 0; long count = 0; if (!fakedata) { return 0L; } fakedata_middle = (fakedata + 512); memset(fakedata, 0xFF, 1024); /* below the constraint "b" seems to mean "Address... |
1 | static void vga_update_display(void *opaque){ VGACommonState *s = opaque; int full_update, graphic_mode; qemu_flush_coalesced_mmio_buffer(); if (ds_get_bits_per_pixel(s->ds) == 0) { /* nothing to do */ } else { full_update = 0; if (!(s->ar_index & 0x20)) { graphic_mode = GMODE_BLANK; } else { graphic_mode = s->gr[VGA_G... |
1 | static inline void comp_block(MadContext *t, int mb_x, int mb_y, int j, int mv_x, int mv_y, int add){ MpegEncContext *s = &t->s; if (j < 4) { comp(t->frame.data[0] + (mb_y*16 + ((j&2)<<2))*t->frame.linesize[0] + mb_x*16 + ((j&1)<<3), t->frame.linesize[0], t->last_frame.data[0] + (mb_y*16 + ((j&2)<<2) + mv_y)*t->last_fr... |
1 | static inline int gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb, int search_pc){ DisasContext dc1, *dc = &dc1; uint16_t *gen_opc_end; int j, lj; target_ulong pc_start; uint32_t next_page_start; /* generate intermediate code */ pc_start = tb->pc; dc->tb = tb; gen_opc_ptr = gen_opc_buf; gen_opc_end =... |
1 | static always_inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2, int add_ca, int compute_ca, int compute_ov){ TCGv t0, t1; if ((!compute_ca && !compute_ov) || (!TCGV_EQUAL(ret, arg1) && !TCGV_EQUAL(ret, arg2))) { t0 = ret; t0 = tcg_temp_local_new(); } if (add_ca) { t1 = tcg_temp_local_new(... |
0 | static uint64_t imx_ccm_read(void *opaque, target_phys_addr_t offset, unsigned size){ IMXCCMState *s = (IMXCCMState *)opaque; DPRINTF("read(offset=%x)", offset >> 2); switch (offset >> 2) { case 0: /* CCMR */ DPRINTF(" ccmr = 0x%x\n", s->ccmr); return s->ccmr; case 1: DPRINTF(" pdr0 = 0x%x\n", s->pdr0); return s->pdr0;... |
0 | static void ne2000_receive(void *opaque, const uint8_t *buf, size_t size){ NE2000State *s = opaque; uint8_t *p; unsigned int total_len, next, avail, len, index, mcast_idx; uint8_t buf1[60]; static const uint8_t broadcast_macaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };#if defined(DEBUG_NE2000) printf("NE2000: recei... |
0 | int kvm_init(void){ 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"; KVMState *s; const KVMCapabilityInfo *missing_cap; int ret; int i; int max_vcpus; s = g_malloc0(sizeof(KVMState)); /* * On systems where the kernel can s... |
0 | static int mov_open_dref(AVIOContext **pb, char *src, MOVDref *ref, AVIOInterruptCB *int_cb){ /* try relative path, we do not try the absolute because it can leak information about our system to an attacker */ if (ref->nlvl_to > 0 && ref->nlvl_from > 0) { char filename[1024]; char *src_path; int i, l; /* find a source ... |
0 | static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr, uint64_t asc, uint64_t asce, int level, target_ulong *raddr, int *flags, int rw){ CPUState *cs = CPU(s390_env_get_cpu(env)); uint64_t offs = 0; uint64_t origin; uint64_t new_asce; PTE_DPRINTF("%s: 0x%" PRIx64 "\n", __func__, asce); if (((level != _AS... |
0 | bool iommu_dma_memory_valid(DMAContext *dma, dma_addr_t addr, dma_addr_t len, DMADirection dir){ target_phys_addr_t paddr, plen;#ifdef DEBUG_IOMMU fprintf(stderr, "dma_memory_check context=%p addr=0x" DMA_ADDR_FMT " len=0x" DMA_ADDR_FMT " dir=%d\n", dma, addr, len, dir);#endif while (len) { if (dma->translate(dma, addr... |
0 | static void tm_put(QEMUFile *f, struct tm *tm) { qemu_put_be16(f, tm->tm_sec); qemu_put_be16(f, tm->tm_min); qemu_put_be16(f, tm->tm_hour); qemu_put_be16(f, tm->tm_mday); qemu_put_be16(f, tm->tm_min); qemu_put_be16(f, tm->tm_year);} |
0 | uint64_t helper_fsqrt(CPUPPCState *env, uint64_t arg){ CPU_DoubleU farg; farg.ll = arg; if (unlikely(float64_is_neg(farg.d) && !float64_is_zero(farg.d))) { /* Square root of a negative nonzero number */ farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT); } else { if (unlikely(float64_is_signaling_nan(farg.d))... |
0 | static int kvm_handle_internal_error(CPUState *env, struct kvm_run *run){ fprintf(stderr, "KVM internal error."); if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) { int i; fprintf(stderr, " Suberror: %d\n", run->internal.suberror); for (i = 0; i < run->internal.ndata; ++i) { fprintf(stderr, "extra data[... |
0 | int virtio_get_block_size(void){ return blk_cfg.blk_size;} |
0 | void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr){ tlb_set_page(cpu_single_env, addr & ~(TARGET_PAGE_SIZE - 1), addr & ~(TARGET_PAGE_SIZE - 1), PAGE_READ | PAGE_WRITE | PAGE_EXEC, mmu_idx, TARGET_PAGE_SIZE);} |
0 | pp_context_t *pp_get_context(int width, int height, int cpuCaps){PPContext *c= memalign(32, sizeof(PPContext));int i;int stride= (width+15)&(~15); //assumed / will realloc if needed memset(c, 0, sizeof(PPContext));c->cpuCaps= cpuCaps;if(cpuCaps&PP_FORMAT){c->hChromaSubSample= cpuCaps&0x3;c->vChromaSubSample= (cpuCaps>>... |
0 | static gboolean gd_leave_event(GtkWidget *widget, GdkEventCrossing *crossing, gpointer opaque){ VirtualConsole *vc = opaque; GtkDisplayState *s = vc->s; if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) { gd_ungrab_keyboard(s); } return TRUE;} |
0 | static void vty_receive(void *opaque, const uint8_t *buf, int size){ VIOsPAPRVTYDevice *dev = (VIOsPAPRVTYDevice *)opaque; int i; if ((dev->in == dev->out) && size) { /* toggle line to simulate edge interrupt */ qemu_irq_pulse(dev->sdev.qirq); } for (i = 0; i < size; i++) { assert((dev->in - dev->out) < VTERM_BUFSIZE);... |
0 | int kvm_arch_process_async_events(CPUState *env){ return 0;} |
0 | static void coroutine_fn stream_run(void *opaque){ StreamBlockJob *s = opaque; StreamCompleteData *data; BlockBackend *blk = s->common.blk; BlockDriverState *bs = blk_bs(blk); BlockDriverState *base = s->base; int64_t sector_num = 0; int64_t end = -1; uint64_t delay_ns = 0; int error = 0; int ret = 0; int n = 0; void *... |
0 | static void palmte_onoff_gpios(void *opaque, int line, int level){ switch (line) { case 0: printf("%s: current to MMC/SD card %sabled.\n", __FUNCTION__, level ? "dis" : "en"); break; case 1: printf("%s: internal speaker amplifier %s.\n", __FUNCTION__, level ? "down" : "on"); break; /* These LCD & Audio output signals h... |
0 | static int ppc_hash64_check_prot(int prot, int rwx){ int ret; if (rwx == 2) { if (prot & PAGE_EXEC) { ret = 0; } else { ret = -2; } } else if (rwx == 1) { if (prot & PAGE_WRITE) { ret = 0; } else { ret = -2; } } else { if (prot & PAGE_READ) { ret = 0; } else { ret = -2; } } return ret;} |
0 | static void exynos4210_pwm_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ Exynos4210PWMState *s = (Exynos4210PWMState *)opaque; int index; uint32_t new_val; int i; switch (offset) { case TCFG0: case TCFG1: index = (offset - TCFG0) >> 2; s->reg_tcfg[index] = value; /* update timers freque... |
0 | static void smbios_build_type_1_table(void){ SMBIOS_BUILD_TABLE_PRE(1, 0x100, true); /* required */ SMBIOS_TABLE_SET_STR(1, manufacturer_str, type1.manufacturer); SMBIOS_TABLE_SET_STR(1, product_name_str, type1.product); SMBIOS_TABLE_SET_STR(1, version_str, type1.version); SMBIOS_TABLE_SET_STR(1, serial_number_str, typ... |
0 | static int rv10_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 i; AVFrame *pict = data; int slice_count; const uint8_t *slices_hdr = NULL; av_dlog(avctx, "*****frame %d size=%d\n", ... |
0 | int css_do_rchp(uint8_t cssid, uint8_t chpid){ uint8_t real_cssid; if (cssid > channel_subsys.max_cssid) { return -EINVAL; } if (channel_subsys.max_cssid == 0) { real_cssid = channel_subsys.default_cssid; } else { real_cssid = cssid; } if (!channel_subsys.css[real_cssid]) { return -EINVAL; } if (!channel_subsys.css[rea... |
0 | static void gen_swap_asi(DisasContext *dc, TCGv dst, TCGv src, TCGv addr, int insn){ TCGv_i32 r_asi, r_size, r_sign; TCGv_i64 s64, t64 = tcg_temp_new_i64(); r_asi = gen_get_asi(dc, insn); r_size = tcg_const_i32(4); r_sign = tcg_const_i32(0); gen_helper_ld_asi(t64, cpu_env, addr, r_asi, r_size, r_sign); tcg_temp_free_i3... |
0 | static void borzoi_init(int ram_size, int vga_ram_size, int boot_device, DisplayState *ds, const char **fd_filename, int snapshot, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename, kernel_cmdline, ... |
1 | static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp){ struct addrinfo ai, *res; int rc; const char *addr; const char *port; memset(&ai, 0, sizeof(ai)); ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; ai.ai_family = PF_UNSPEC; ai.ai_socktype = SOCK_STREAM; addr = qemu_opt_get(opts, "host"); port = q... |
1 | static int arm_gic_init(SysBusDevice *dev){ /* Device instance init function for the GIC sysbus device */ int i; GICState *s = FROM_SYSBUS(GICState, dev); ARMGICClass *agc = ARM_GIC_GET_CLASS(s); agc->parent_init(dev); gic_init_irqs_and_distributor(s, s->num_irq); /* Memory regions for the CPU interfaces (NVIC doesn't ... |
1 | static bool addrrange_intersects(AddrRange r1, AddrRange r2){ return (r1.start >= r2.start && r1.start < r2.start + r2.size) || (r2.start >= r1.start && r2.start < r1.start + r1.size);} |
1 | static void network_to_result(RDMARegisterResult *result){ result->rkey = ntohl(result->rkey); result->host_addr = ntohll(result->host_addr);}; |
1 | static inline void RENAME(bgr24ToY_mmx)(uint8_t *dst, const uint8_t *src, int width, enum PixelFormat srcFormat){ if(srcFormat == PIX_FMT_BGR24) { __asm__ volatile( "movq "MANGLE(ff_bgr24toY1Coeff)", %%mm5 \n\t" "movq "MANGLE(ff_bgr24toY2Coeff)", %%mm6 \n\t" : ); } else { __asm__ volatile( "movq "MANGLE(ff_rgb24toY1Coe... |
0 | static int xvid_ff_2pass_after(struct xvid_context *ref, xvid_plg_data_t *param) { char *log = ref->twopassbuffer; const char *frame_types = " ipbs"; char frame_type; /* Quick bounds check */ if( log == NULL ) return XVID_ERR_FAIL; /* Convert the type given to us into a character */ if( param->type < 5 && param->type >... |
0 | int ff_vdpau_common_end_frame(AVCodecContext *avctx, AVFrame *frame, struct vdpau_picture_context *pic_ctx){ VDPAUContext *vdctx = avctx->internal->hwaccel_priv_data; AVVDPAUContext *hwctx = avctx->hwaccel_context; VdpVideoSurface surf = ff_vdpau_get_surface_id(frame); VdpStatus status; int val; val = ff_vdpau_common_r... |
0 | static CheckasmFunc *get_func(const char *name, int length){ CheckasmFunc *f, **f_ptr = &state.funcs; /* Search the tree for a matching node */ while ((f = *f_ptr)) { int cmp = cmp_func_names(name, f->name); if (!cmp) return f; f_ptr = &f->child[(cmp > 0)]; } /* Allocate and insert a new node into the tree */ f = *f_pt... |
0 | static void unref_picture(H264Context *h, Picture *pic){ int off = offsetof(Picture, tf) + sizeof(pic->tf); int i; if (!pic->f.data[0]) return; ff_thread_release_buffer(h->avctx, &pic->tf); av_buffer_unref(&pic->hwaccel_priv_buf); av_buffer_unref(&pic->qscale_table_buf); av_buffer_unref(&pic->mb_type_buf); for (i = 0; ... |
0 | void ff_free_parser_state(AVFormatContext *s, AVParserState *state){ int i; AVParserStreamState *ss; if (!state) return; for (i = 0; i < state->nb_streams; i++) { ss = &state->stream_states[i]; if (ss->parser) av_parser_close(ss->parser); av_free_packet(&ss->cur_pkt); } free_packet_list(state->packet_buffer); free_pack... |
1 | static int mjpeg_decode_com(MJpegDecodeContext *s){ /* XXX: verify len field validity */ int len = get_bits(&s->gb, 16); if (len >= 2 && len < 32768) {/* XXX: any better upper bound */uint8_t *cbuf = av_malloc(len - 1);if (cbuf) { int i; for (i = 0; i < len - 2; i++)cbuf[i] = get_bits(&s->gb, 8); if (i > 0 && cbuf[i-1]... |
1 | static void xhci_runtime_write(void *ptr, hwaddr reg, uint64_t val, unsigned size){ XHCIState *xhci = ptr; int v = (reg - 0x20) / 0x20; XHCIInterrupter *intr = &xhci->intr[v]; trace_usb_xhci_runtime_write(reg, val); if (reg < 0x20) { trace_usb_xhci_unimplemented("runtime write", reg); return; switch (reg & 0x1f) { case... |
1 | static void test_ide_none(void){ char *argv[256]; setup_common(argv, ARRAY_SIZE(argv)); qtest_start(g_strjoinv(" ", argv)); test_cmos(); qtest_end();} |
1 | int ff_dca_xll_decode_audio(DCAContext *s, AVFrame *frame){ /* FIXME: Decodes only the first frequency band. */ int seg, chset_i; /* Coding parameters for each channel set. */ struct coding_params { int seg_type; int rice_code_flag[16]; int pancAuxABIT[16]; int pancABIT0[16]; /* Not sure what this is */ int pancABIT[16... |
0 | static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile, int width, int height, int bandpos, int lev){ int pass_t = 2, passno, x, y, max=0, nmsedec, bpno; int64_t wmsedec = 0; for (y = 0; y < height+2; y++) memset(t1->flags[y], 0, (width+2)*sizeof(int)); for (y =... |
1 | void cpu_disable_ticks(void){ /* Here, the really thing protected by seqlock is cpu_clock_offset. */ seqlock_write_lock(&timers_state.vm_clock_seqlock); if (timers_state.cpu_ticks_enabled) { timers_state.cpu_ticks_offset = cpu_get_ticks(); timers_state.cpu_clock_offset = cpu_get_clock_locked(); timers_state.cpu_ticks_e... |
1 | static inline void RENAME(yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,unsigned int width, unsigned int height,int lumStride, int chromStride, int dstStride){//FIXME interpolate chromaRENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStri... |
0 | static int decode_residuals(FLACContext *s, int channel, int pred_order){ int i, tmp, partition, method_type, rice_order; int sample = 0, samples; method_type = get_bits(&s->gb, 2); if (method_type > 1) { av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", method_type); return -1; } rice_order = get_b... |
1 | static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts){ int ret, i; AVFormatContext *dev = NULL; AVDeviceInfoList *device_list = NULL; AVDictionary *tmp_opts = NULL; if (!fmt || !fmt->priv_class || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category)) return AVERROR(EINVAL); printf("Audo-detected sinks for %... |
1 | static int bmp_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ BMPContext *s = avctx->priv_data; AVFrame *picture = data; AVFrame *p = &s->picture; unsigned int fsize, hsize; int width, height; unsigned int depth; BiCompression comp; unsigned int ihsize; int i, j, n, linesiz... |
1 | void HELPER(stfl)(CPUS390XState *env){ uint64_t words[MAX_STFL_WORDS]; do_stfle(env, words); cpu_stl_data(env, 200, words[0] >> 32);} |
1 | static QDict *qmp_check_input_obj(QObject *input_obj){ const QDictEntry *ent; int has_exec_key = 0; QDict *input_dict; if (qobject_type(input_obj) != QTYPE_QDICT) { qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object"); return NULL; } input_dict = qobject_to_qdict(input_obj); for (ent = qdict_first(input_dict); ent; ent =... |
1 | static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels, int line_size){ int i; uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; /* read the pixels */ for(i=0;i<4;i++) { pixels[0] = cm[pixels[0] + block[0]]; pixels[1] = cm[pixels[1] + block[1]]; pixels[2] = cm[pixels[2] + block[2]]; pixels[3] = cm[pixe... |
1 | static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr){ int sign, code; int pred, extquant; int extrabits = 0; int16_t *dc_val; pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); /* update predictor */ if (n < 4) { *dc_val = level * s->y_dc_scale; } else { *dc_val = level * s->c_dc_scale; } /... |
1 | matroska_read_header (AVFormatContext *s, AVFormatParameters *ap){ MatroskaDemuxContext *matroska = s->priv_data; char *doctype; int version, last_level, res = 0; uint32_t id; matroska->ctx = s; /* First read the EBML header. */ doctype = NULL; if ((res = ebml_read_header(matroska, &doctype, &version)) < 0) return res;... |
1 | static void test_enabled(void){ int i; throttle_config_init(&cfg); g_assert(!throttle_enabled(&cfg)); for (i = 0; i < BUCKETS_COUNT; i++) { throttle_config_init(&cfg); set_cfg_value(false, i, 150); g_assert(throttle_enabled(&cfg)); } for (i = 0; i < BUCKETS_COUNT; i++) { throttle_config_init(&cfg); set_cfg_value(false,... |
1 | static inline void drawbox(AVFilterBufferRef *picref, unsigned int x, unsigned int y, unsigned int width, unsigned int height, uint8_t *line[4], int pixel_step[4], uint8_t color[4], int hsub, int vsub, int is_rgba_packed, uint8_t rgba_map[4]){ int i, j, alpha; if (color[3] != 0xFF) { if (is_rgba_packed) { uint8_t *p; f... |
1 | static void create_vorbis_context(venc_context_t * venc, AVCodecContext * avccontext) { codebook_t * cb; floor_t * fc; residue_t * rc; mapping_t * mc; int i, book; venc->channels = avccontext->channels; venc->sample_rate = avccontext->sample_rate; venc->blocksize[0] = venc->blocksize[1] = 8; venc->ncodebooks = 10; venc... |
1 | static int iscsi_readcapacity_sync(IscsiLun *iscsilun){ struct scsi_task *task = NULL; struct scsi_readcapacity10 *rc10 = NULL; struct scsi_readcapacity16 *rc16 = NULL; int ret = 0; int retries = ISCSI_CMD_RETRIES; do { if (task != NULL) { scsi_free_scsi_task(task); task = NULL; } switch (iscsilun->type) { case TYPE_DI... |
1 | int kvm_arch_process_async_events(CPUState *env){ if (kvm_irqchip_in_kernel()) { if (env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI)) { if (env->interrupt_request & CPU_INTERRUPT_INIT) { do_cpu_init(env); if (env->interrupt_request & CPU_INTERRUPT_SIPI) { do_cpu_sipi(env); return env->halted; |
1 | static void gen_slbmte(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG); return; } gen_helper_store_slb(cpu_env, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);#endif} |
1 | static void shifter_out_im(TCGv var, int shift){ TCGv tmp = new_tmp(); if (shift == 0) { tcg_gen_andi_i32(tmp, var, 1); } else { tcg_gen_shri_i32(tmp, var, shift); if (shift != 31) tcg_gen_andi_i32(tmp, tmp, 1); } gen_set_CF(tmp); dead_tmp(tmp);} |
1 | static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table, const char *language, kbd_layout_t *k){ FILE *f; char * filename; char line[1024]; int len; filename = qemu_find_file(QEMU_FILE_TYPE_KEYMAP, language); f = filename ? fopen(filename, "r") : NULL; g_free(filename); if (!f) { fprintf(stderr, "Could no... |
0 | static void ff_h264_idct_add8_mmx(uint8_t **dest, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){ int i; for(i=16; i<16+8; i++){ if(nnzc[ scan8[i] ] || block[i*16]) ff_h264_idct_add_mmx (dest[(i&4)>>2] + block_offset[i], block + i*16, stride); }} |
1 | static void vmxnet3_deactivate_device(VMXNET3State *s){ VMW_CBPRN("Deactivating vmxnet3..."); s->device_active = false;} |
1 | e1000e_set_pbaclr(E1000ECore *core, int index, uint32_t val){ int i; core->mac[PBACLR] = val & E1000_PBACLR_VALID_MASK; if (msix_enabled(core->owner)) { return; } for (i = 0; i < E1000E_MSIX_VEC_NUM; i++) { if (core->mac[PBACLR] & BIT(i)) { msix_clr_pending(core->owner, i); } }} |
1 | void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason){ SimpleSpiceDisplay *ssd = opaque; if (running) { ssd->worker->start(ssd->worker); } else { qemu_mutex_unlock_iothread(); ssd->worker->stop(ssd->worker); qemu_mutex_lock_iothread(); } ssd->running = running;} |
1 | static void do_audio_out(AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, unsigned char *buf, int size){ uint8_t *buftmp; uint8_t audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */ uint8_t audio_out[4*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it - yep really WMA */ int size_out, frame_bytes, ret; AVC... |
1 | static int ehci_state_waitlisthead(EHCIState *ehci, int async){ EHCIqh qh; int i = 0; int again = 0; uint32_t entry = ehci->asynclistaddr; /* set reclamation flag at start event (4.8.6) */ if (async) { ehci_set_usbsts(ehci, USBSTS_REC); } ehci_queues_rip_unused(ehci, async); /* Find the head of the list (4.9.1.1) */ fo... |
1 | static void aux_bus_map_device(AUXBus *bus, AUXSlave *dev, hwaddr addr){ memory_region_add_subregion(bus->aux_io, addr, dev->mmio);} |
1 | static int verify_md5(HEVCContext *s, AVFrame *frame){ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); int pixel_shift = desc->comp[0].depth_minus1 > 7; int i, j; if (!desc) return AVERROR(EINVAL); av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ", s->poc); /* the checksum... |
0 | static int dxva2_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size){ const VC1Context *v = avctx->priv_data; AVDXVAContext *ctx = avctx->hwaccel_context; struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private; if (!DXVA_CONTEXT_VALID(avctx... |
0 | static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){ while(bsfc){ AVPacket new_pkt= *pkt; int a= av_bitstream_filter_filter(bsfc, avctx, NULL, &new_pkt.data, &new_pkt.size, pkt->data, pkt->size, pkt->flags & PKT_FLAG_KEY); if(a){ av_free_packet(pkt); new_pkt... |
0 | static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int *tc0){ int i, d; for( i = 0; i < 4; i++ ) { if( tc0[i] < 0 ) { pix += 4*ystride; continue; } for( d = 0; d < 4; d++ ) { const int p0 = pix[-1*xstride]; const int p1 = pix[-2*xstride]; const int p2 = pix[-3*xstrid... |
0 | int64_t av_gettime_relative(void){#if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC) struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000;#else return av_gettime() + 42 * 60 * 60 * INT64_C(1000000);#endif} |
0 | static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix){ AVIOContext *pb = s->pb; AVIContext *avi = s->priv_data; AVIStream *avist = s->streams[stream_index]->priv_data; int64_t pos; int au_byterate, au_ssize, au_scale; avio_flush(pb); pos = avio_tell(pb); /* Updating one entry in the AVI OpenDM... |
0 | av_cold void ff_msmpeg4_encode_init(MpegEncContext *s){ static int init_done=0; int i; ff_msmpeg4_common_init(s); if(s->msmpeg4_version>=4){ s->min_qcoeff= -255; s->max_qcoeff= 255; } if (!init_done) { /* init various encoding tables */ init_done = 1; init_mv_table(&ff_mv_tables[0]); init_mv_table(&ff_mv_tables[1]); fo... |
0 | int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec){ if (*spec <= '9' && *spec >= '0') /* opt:index */ return strtol(spec, NULL, 0) == st->index; else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || *spec == 't') { /* opt:[vasdt] */ enum AVMediaType type; switch (*spec++) ... |
0 | static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { const int index_a = qp + h->slice_alpha_c0_offset; const int alpha = (alpha_table+52)[index_a]; const int beta = (beta_table+52)[qp + h->slice_beta_offset]; if (alpha ==0 || beta == 0) return; if( bS[0] < 4 ) { int8_t tc[4... |
1 | int x86_cpu_handle_mmu_fault(CPUState *cs, vaddr addr, int is_write1, int mmu_idx){ X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; uint64_t ptep, pte; target_ulong pde_addr, pte_addr; int error_code = 0; int is_dirty, prot, page_size, is_write, is_user; hwaddr paddr; uint64_t rsvd_mask = PG_HI_RSVD_MASK; uint... |
1 | uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr){ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); uint8_t val; k->get_config(vdev, vdev->config); if (addr > (vdev->config_len - sizeof(val))) return (uint32_t)-1; val = ldub_p(vdev->config + addr); return val;} |
0 | av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans){ int n = 1 << nbits; int ret; s->nbits = nbits; s->inverse = trans == IDFT_C2R || trans == DFT_C2R; s->sign_convention = trans == IDFT_R2C || trans == DFT_C2R ? 1 : -1; if (nbits < 4 || nbits > 16) return AVERROR(EINVAL); if ((ret = ff_fft... |
1 | static int uhci_handle_td(UHCIState *s, uint32_t addr, UHCI_TD *td, uint32_t *int_mask){ UHCIAsync *async; int len = 0, max_len; uint8_t pid; USBDevice *dev; USBEndpoint *ep; /* Is active ? */ if (!(td->ctrl & TD_CTRL_ACTIVE)) return TD_RESULT_NEXT_QH; async = uhci_async_find_td(s, addr, td); if (async) { /* Already su... |
1 | static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index){ if (s->correct_ts_overflow && st->pts_wrap_bits != 64 && st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) { int i; // reference time stamp should be 60 s before first time stamp int64_t pts_wrap_reference =... |
1 | static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len){ PtyCharDriver *s = chr->opaque; if (!s->connected) { /* guest sends data, check for (re-)connect */ pty_chr_update_read_handler_locked(chr); return 0; } return io_channel_send(s->fd, buf, len);} |
1 | int vnc_client_io_error(VncState *vs, int ret, int last_errno){ if (ret == 0 || ret == -1) { if (ret == -1) { switch (last_errno) { case EINTR: case EAGAIN:#ifdef _WIN32 case WSAEWOULDBLOCK:#endif return 0; default: break; } } VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0); qemu_set_fd_han... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.