label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void gen_arith_imm (CPUState *env, DisasContext *ctx, uint32_t opc, int rt, int rs, int16_t imm){ target_ulong uimm; const char *opn = "imm arith"; TCGv t0 = tcg_temp_local_new(TCG_TYPE_TL); if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) { /* If no destination, treat it as a NOP. For addi, we must generate ... |
0 | static ImageInfoSpecific *vmdk_get_specific_info(BlockDriverState *bs){ int i; BDRVVmdkState *s = bs->opaque; ImageInfoSpecific *spec_info = g_new0(ImageInfoSpecific, 1); ImageInfoList **next; *spec_info = (ImageInfoSpecific){ .type = IMAGE_INFO_SPECIFIC_KIND_VMDK, { .vmdk = g_new0(ImageInfoSpecificVmdk, 1), }, }; *spe... |
0 | void do_smbios_option(const char *optarg){#ifdef TARGET_I386 if (smbios_entry_add(optarg) < 0) { fprintf(stderr, "Wrong smbios provided\n"); exit(1); }#endif} |
0 | static int oss_run_in (HWVoiceIn *hw){ OSSVoiceIn *oss = (OSSVoiceIn *) hw; int hwshift = hw->info.shift; int i; int live = audio_pcm_hw_get_live_in (hw); int dead = hw->samples - live; size_t read_samples = 0; struct { int add; int len; } bufs[2] = { { hw->wpos, 0 }, { 0, 0 } }; if (!dead) { return 0; } if (hw->wpos +... |
0 | int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag){ while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) { bs = bs->file; } if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) { return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); } return -ENOTSUP;} |
0 | int rtp_set_remote_url(URLContext *h, const char *uri){ RTPContext *s = h->priv_data; char hostname[256]; int port; char buf[1024]; char path[1024]; url_split(NULL, 0, hostname, sizeof(hostname), &port, path, sizeof(path), uri); snprintf(buf, sizeof(buf), "udp://%s:%d%s", hostname, port, path); udp_set_remote_url(s->rt... |
0 | int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr, int is_vp7){ VP8Context *s = avctx->priv_data; VP8ThreadData *td = &s->thread_data[jobnr]; VP8ThreadData *next_td = NULL, *prev_td = NULL; VP8Frame *curframe = s->curframe; int mb_y, num_jobs = s->num_jobs; int ret; td->thread_nr... |
0 | const char *avfilter_configuration(void){ return FFMPEG_CONFIGURATION;} |
0 | static void uart_send_breaks(UartState *s){ int break_enabled = 1; qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_BREAK, &break_enabled);} |
0 | static void cris_alu(DisasContext *dc, int op, TCGv d, TCGv op_a, TCGv op_b, int size){TCGv tmp;int writeback;writeback = 1;if (op == CC_OP_BOUND || op == CC_OP_BTST)tmp = tcg_temp_local_new(TCG_TYPE_TL);if (op == CC_OP_CMP) {tmp = tcg_temp_new(TCG_TYPE_TL);writeback = 0;} else if (size == 4) {tmp = d;writeback = 0;} e... |
0 | void ide_atapi_cmd_reply_end(IDEState *s){ int byte_count_limit, size, ret;#ifdef DEBUG_IDE_ATAPI printf("reply: tx_size=%d elem_tx_size=%d index=%d\n", s->packet_transfer_size, s->elementary_transfer_size, s->io_buffer_index);#endif if (s->packet_transfer_size <= 0) { /* end of transfer */ s->status = READY_STAT | SEE... |
0 | static int ehci_execute(EHCIQueue *q){ USBDevice *dev; int ret; int endp; int devadr; if ( !(q->qh.token & QTD_TOKEN_ACTIVE)) { fprintf(stderr, "Attempting to execute inactive QH\n"); return USB_RET_PROCERR; } q->tbytes = (q->qh.token & QTD_TOKEN_TBYTES_MASK) >> QTD_TOKEN_TBYTES_SH; if (q->tbytes > BUFF_SIZE) { fprintf... |
0 | static void sdl_resize(DisplayState *ds, int w, int h){ int flags; // printf("resizing to %d %d\n", w, h); flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL; flags |= SDL_RESIZABLE; if (gui_fullscreen) flags |= SDL_FULLSCREEN; screen = SDL_SetVideoMode(w, h, 0, flags); if (!screen) { fprintf(stderr, "Could not open SDL d... |
0 | static uint64_t imx_avic_read(void *opaque, target_phys_addr_t offset, unsigned size){ IMXAVICState *s = (IMXAVICState *)opaque; DPRINTF("read(offset = 0x%x)\n", offset >> 2); switch (offset >> 2) { case 0: /* INTCNTL */ return s->intcntl; case 1: /* Normal Interrupt Mask Register, NIMASK */ return s->intmask; case 2: ... |
0 | static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder){ const char *codec_string = encoder ? "encoder" : "decoder"; AVCodec *codec; if(!name) return CODEC_ID_NONE; codec = encoder ? avcodec_find_encoder_by_name(name) : avcodec_find_decoder_by_name(name); if(!codec) { av_log(NULL, AV... |
0 | static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len){ uint64_t end = addr + len; DPRINTF("sd_blk_read: addr = 0x%08llx, len = %d\n", (unsigned long long) addr, len); if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_read: read error on host side\n"); return; } if (e... |
0 | static void thumb_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu){ DisasContext *dc = container_of(dcbase, DisasContext, base); CPUARMState *env = cpu->env_ptr; uint32_t insn; bool is_16bit; if (arm_pre_translate_insn(dc)) { return; } insn = arm_lduw_code(env, dc->pc, dc->sctlr_b); is_16bit = thumb_insn_is_1... |
0 | void qemu_set_dfilter_ranges(const char *filter_spec, Error **errp){ gchar **ranges = g_strsplit(filter_spec, ",", 0); int i; if (debug_regions) { g_array_unref(debug_regions); debug_regions = NULL; } debug_regions = g_array_sized_new(FALSE, FALSE, sizeof(Range), g_strv_length(ranges)); for (i = 0; ranges[i]; i++) { co... |
0 | static void disas_arm_insn(CPUState * env, DisasContext *s){ unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh; TCGv tmp; TCGv tmp2; TCGv tmp3; TCGv addr; TCGv_i64 tmp64; insn = ldl_code(s->pc); s->pc += 4; /* M variants do not implement ARM mode. */ if (IS_M(env)) goto illegal_op; cond = insn >> 28; if (... |
0 | static int ppc_hash64_translate(CPUPPCState *env, struct mmu_ctx_hash64 *ctx, target_ulong eaddr, int rwx){ int ret; ppc_slb_t *slb; hwaddr pte_offset; ppc_hash_pte64_t pte; int target_page_bits; assert((rwx == 0) || (rwx == 1) || (rwx == 2)); /* 1. Handle real mode accesses */ if (((rwx == 2) && (msr_ir == 0)) || ((rw... |
0 | void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi, ISADevice **rtc_state, ISADevice **floppy, bool no_vmport){ int i; DriveInfo *fd[MAX_FD]; DeviceState *hpet = NULL; int pit_isa_irq = 0; qemu_irq pit_alt_irq = NULL; qemu_irq rtc_irq = NULL; qemu_irq *a20_line; ISADevice *i8042, *port92, *vmmouse, *pit; qemu_irq... |
0 | void stream_start(BlockDriverState *bs, BlockDriverState *base, const char *base_id, BlockDriverCompletionFunc *cb, void *opaque, Error **errp){ StreamBlockJob *s; Coroutine *co; s = block_job_create(&stream_job_type, bs, cb, opaque, errp); if (!s) { return; } s->base = base; if (base_id) { pstrcpy(s->backing_file_id, ... |
0 | static int decode_subframe(WMAProDecodeCtx *s){ int offset = s->samples_per_frame; int subframe_len = s->samples_per_frame; int i; int total_samples = s->samples_per_frame * s->num_channels; int transmit_coeffs = 0; int cur_subwoofer_cutoff; s->subframe_offset = get_bits_count(&s->gb); /** reset channel context and fin... |
0 | int kvm_vm_ioctl(KVMState *s, int type, ...){ int ret; void *arg; va_list ap; va_start(ap, type); arg = va_arg(ap, void *); va_end(ap); ret = ioctl(s->vmfd, type, arg); if (ret == -1) ret = -errno; return ret;} |
0 | void kqemu_cpu_interrupt(CPUState *env){#if defined(_WIN32) /* cancelling the I/O request causes KQEMU to finish executing the current block and successfully returning. */ CancelIo(kqemu_fd);#endif} |
0 | target_ulong helper_cfc1(CPUMIPSState *env, uint32_t reg){ target_ulong arg1; switch (reg) { case 0: arg1 = (int32_t)env->active_fpu.fcr0; break; case 25: arg1 = ((env->active_fpu.fcr31 >> 24) & 0xfe) | ((env->active_fpu.fcr31 >> 23) & 0x1); break; case 26: arg1 = env->active_fpu.fcr31 & 0x0003f07c; break; case 28: arg... |
0 | static void setup_frame(int sig, struct target_sigaction *ka, target_sigset_t *set, CPUSH4State *regs){ struct target_sigframe *frame; abi_ulong frame_addr; int i; int err = 0; int signal; frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))goto give... |
0 | static int qcow_open(BlockDriverState *bs, const char *filename, int flags){ BDRVQcowState *s = bs->opaque; int len, i, shift, ret; QCowHeader header; uint64_t ext_end; ret = bdrv_file_open(&s->hd, filename, flags); if (ret < 0) return ret; if (bdrv_pread(s->hd, 0, &header, sizeof(header)) != sizeof(header)) goto fail;... |
0 | static void get_enum(Object *obj, Visitor *v, void *opaque, const char *name, Error **errp){ DeviceState *dev = DEVICE(obj); Property *prop = opaque; int *ptr = qdev_get_prop_ptr(dev, prop); visit_type_enum(v, ptr, prop->info->enum_table, prop->info->name, prop->name, errp);} |
0 | QapiDeallocVisitor *qapi_dealloc_visitor_new(void){ QapiDeallocVisitor *v; v = g_malloc0(sizeof(*v)); v->visitor.type = VISITOR_DEALLOC; v->visitor.start_struct = qapi_dealloc_start_struct; v->visitor.end_struct = qapi_dealloc_end_struct; v->visitor.start_alternate = qapi_dealloc_start_alternate; v->visitor.end_alterna... |
0 | static uint32_t dp8393x_readb(void *opaque, target_phys_addr_t addr){ uint16_t v = dp8393x_readw(opaque, addr & ~0x1); return (v >> (8 * (addr & 0x1))) & 0xff;} |
0 | int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, intptr_t offset, const char *name){ TCGContext *s = &tcg_ctx; TCGTemp *ts, *base_ts = &s->temps[GET_TCGV_PTR(base)]; int idx, reg = base_ts->reg; idx = s->nb_globals;#if TCG_TARGET_REG_BITS == 32 if (type == TCG_TYPE_I64) { char buf[64]; tcg_temp_alloc(s, s->... |
0 | hwaddr sparc_cpu_get_phys_page_debug(CPUState *cs, vaddr addr){ SPARCCPU *cpu = SPARC_CPU(cs); CPUSPARCState *env = &cpu->env; hwaddr phys_addr; int mmu_idx = cpu_mmu_index(env, false); MemoryRegionSection section; if (cpu_sparc_get_phys_page(env, &phys_addr, addr, 2, mmu_idx) != 0) { if (cpu_sparc_get_phys_page(env, &... |
0 | int qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset){ int ret; qed_unref_l2_cache_entry(request->l2_table); /* Check for cached L2 entry */ request->l2_table = qed_find_l2_cache_entry(&s->l2_cache, offset); if (request->l2_table) { return 0; } request->l2_table = qed_alloc_l2_cache_entry(&s->l2_... |
0 | static int audio_pcm_info_eq (struct audio_pcm_info *info, audsettings_t *as){ int bits = 8, sign = 0; switch (as->fmt) { case AUD_FMT_S8: sign = 1; case AUD_FMT_U8: break; case AUD_FMT_S16: sign = 1; case AUD_FMT_U16: bits = 16; break; case AUD_FMT_S32: sign = 1; case AUD_FMT_U32: bits = 32; break; } return info->freq... |
0 | static int parse_adaptation_sets(AVFormatContext *s){ WebMDashMuxContext *w = s->priv_data; char *p = w->adaptation_sets; char *q; enum { new_set, parsed_id, parsing_streams } state; // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on state = new_set; while (p < w->adaptation_sets + strlen(w->adaptation_sets)) { if... |
0 | static int filter_frame(AVFilterLink *link, AVFrame *picref){ AVFilterContext *ctx = link->dst; IDETContext *idet = ctx->priv; if (idet->prev) av_frame_free(&idet->prev); idet->prev = idet->cur; idet->cur = idet->next; idet->next = picref; if (!idet->cur) return 0; if (!idet->prev) idet->prev = av_frame_clone(idet->cur... |
0 | void ff_dsputil_init_arm(DSPContext* c, AVCodecContext *avctx){ const int high_bit_depth = avctx->bits_per_raw_sample > 8; int cpu_flags = av_get_cpu_flags(); ff_put_pixels_clamped = c->put_pixels_clamped; ff_add_pixels_clamped = c->add_pixels_clamped; if (avctx->bits_per_raw_sample <= 8) { if(avctx->idct_algo == FF_ID... |
0 | static void fft(AC3MDCTContext *mdct, IComplex *z, int ln){ int j, l, np, np2; int nblocks, nloops; register IComplex *p,*q; int tmp_re, tmp_im; np = 1 << ln; /* reverse */ for (j = 0; j < np; j++) { int k = av_reverse[j] >> (8 - ln); if (k < j) FFSWAP(IComplex, z[k], z[j]); } /* pass 0 */ p = &z[0]; j = np >> 1; do { ... |
1 | static inline void gen_lookup_tb(DisasContext *s){ tcg_gen_movi_i32(cpu_R[15], s->pc & ~1); s->is_jmp = DISAS_UPDATE;} |
1 | static int parse_interval(Interval *interval, int interval_count, const char **buf, void *log_ctx){ char *intervalstr; int ret; *buf += strspn(*buf, SPACES); if (!**buf) return 0; /* reset data */ memset(interval, 0, sizeof(Interval)); interval->index = interval_count; /* format: INTERVAL COMMANDS */ /* parse interval ... |
1 | static void gen_load_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp){ TCGv tmp; TCGv_i64 t64; int index = IS_USER(s); t64 = tcg_temp_new_i64(); tmp = tcg_temp_new(); switch (opsize) { case OS_BYTE: tcg_gen_qemu_ld8s(tmp, addr, index); gen_helper_exts32(cpu_env, fp, tmp); break; case OS_WORD: tcg_gen_qemu_ld16s(... |
0 | static av_cold int j2kenc_init(AVCodecContext *avctx){ int i, ret; Jpeg2000EncoderContext *s = avctx->priv_data; Jpeg2000CodingStyle *codsty = &s->codsty; Jpeg2000QuantStyle *qntsty = &s->qntsty; s->avctx = avctx; av_log(s->avctx, AV_LOG_DEBUG, "init\n"); // defaults: // TODO: implement setting non-standard precinct si... |
1 | static int vp9_handle_packet(AVFormatContext *ctx, PayloadContext *rtp_vp9_ctx, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags){ int has_pic_id, has_layer_idc, has_ref_idc, has_ss_data, has_su_data; av_unused int pic_id = 0, non_key_frame = 0; av_unused int layer_... |
1 | int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags){ NBDRequest request = { .type = NBD_CMD_READ, .from = offset, .len = bytes, }; assert(bytes <= NBD_MAX_BUFFER_SIZE); assert(!flags); return nbd_co_request(bs, &request, qiov);} |
1 | writev_f(int argc, char **argv){struct timeval t1, t2;int Cflag = 0, qflag = 0;int c, cnt;char *buf;int64_t offset;int total;int nr_iov;int pattern = 0xcd;QEMUIOVector qiov;while ((c = getopt(argc, argv, "CqP:")) != EOF) {switch (c) {case 'C':Cflag = 1;break;case 'q':qflag = 1;break;case 'P':pattern = atoi(optarg);brea... |
1 | static off_t read_off(BlockDriverState *bs, int64_t offset){uint64_t buffer;if (bdrv_pread(bs->file, offset, &buffer, 8) < 8)return 0;return be64_to_cpu(buffer);} |
1 | static void qmp_input_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true); if (!qobj || qobject_type(qobj) != QTYPE_QINT) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", "integer"); return; } *o... |
1 | static void emulated_push_type(EmulatedState *card, uint32_t type){ EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent)); assert(event); event->p.gen.type = type; emulated_push_event(card, event);} |
1 | static target_ulong h_protect(CPUPPCState *env, sPAPREnvironment *spapr, target_ulong opcode, target_ulong *args){ target_ulong flags = args[0]; target_ulong pte_index = args[1]; target_ulong avpn = args[2]; uint8_t *hpte; target_ulong v, r, rb; if ((pte_index * HASH_PTE_SIZE_64) & ~env->htab_mask) { return H_PARAMETER... |
1 | static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst, int pitch, const uint8_t *table){ int j; int out = 0; int c; int t; if (width & 1) for (j = 0; j < height; j++) { out = 0; while (out < width) { c = ir2_get_code(&ctx->gb); if (c >= 0x80) { /* we have a skip */ c -= 0x7F; out += c *... |
1 | static ExitStatus op_ex(DisasContext *s, DisasOps *o){ /* ??? Perhaps a better way to implement EXECUTE is to set a bit in tb->flags, (ab)use the tb->cs_base field as the address of the template in memory, and grab 8 bits of tb->flags/cflags for the contents of the register. We would then recognize all this in gen_inte... |
1 | static int initFilter(int16_t **outFilter, int16_t **filterPos, int *outFilterSize, int xInc, int srcW, int dstW, int filterAlign, int one, int flags, int cpu_flags, SwsVector *srcFilter, SwsVector *dstFilter, double param[2]){ int i; int filterSize; int filter2Size; int minFilterSize; int64_t *filter=NULL; int64_t *fi... |
0 | int update_dimensions(VP8Context *s, int width, int height, int is_vp7){ AVCodecContext *avctx = s->avctx; int i, ret; if (width != s->avctx->width || height != s->avctx->height) { vp8_decode_flush_impl(s->avctx, 1); ret = ff_set_dimensions(s->avctx, width, height); if (ret < 0) return ret; } s->mb_width = (s->avctx->c... |
0 | static int decode_main_header(NUTContext *nut){ AVFormatContext *s= nut->avf; ByteIOContext *bc = &s->pb; uint64_t tmp; int i, j; get_packetheader(nut, bc, 8, 1); tmp = get_v(bc); if (tmp != 1){av_log(s, AV_LOG_ERROR, "bad version (%Ld)\n", tmp); return -1; } nut->stream_count = get_v(bc); get_v(bc); //checksum thresho... |
1 | void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem){ /* see similar ffmpeg.c:grow_array() */ int nb, nb_alloc; intptr_t *tab; nb = *nb_ptr; tab = *(intptr_t**)tab_ptr; if ((nb & (nb - 1)) == 0) { if (nb == 0) nb_alloc = 1; else nb_alloc = nb * 2; tab = av_realloc(tab, nb_alloc * sizeof(intptr_t)); *(intptr_t**... |
1 | static void write_long(unsigned char *p,uint32_t v){p[0] = v>>24;p[1] = v>>16;p[2] = v>>8;p[3] = v;} |
1 | static void filter_edges_16bit(void *dst1, void *prev1, void *cur1, void *next1, int w, int prefs, int mrefs, int parity, int mode){ uint16_t *dst = dst1; uint16_t *prev = prev1; uint16_t *cur = cur1; uint16_t *next = next1; int x; uint16_t *prev2 = parity ? prev : cur ; uint16_t *next2 = parity ? cur : next; mrefs /= ... |
1 | int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM ){ flag aSign; int16 aExp, shiftCount; uint32_t aSig; int32 z; a = float32_squash_input_denormal(a STATUS_VAR); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); shiftCount = aExp - 0x9E; if ( 0 <= shiftCount ) { ... |
1 | static int avi_load_index(AVFormatContext *s){ AVIContext *avi = s->priv_data; ByteIOContext *pb = s->pb; uint32_t tag, size; int64_t pos= url_ftell(pb); url_fseek(pb, avi->movi_end, SEEK_SET);#ifdef DEBUG_SEEK printf("movi_end=0x%"PRIx64"\n", avi->movi_end);#endif for(;;) { if (url_feof(pb)) break; tag = get_le32(pb);... |
1 | int usb_desc_handle_control(USBDevice *dev, USBPacket *p, int request, int value, int index, int length, uint8_t *data){ const USBDesc *desc = usb_device_get_usb_desc(dev); int ret = -1; assert(desc != NULL); switch(request) { case DeviceOutRequest | USB_REQ_SET_ADDRESS: dev->addr = value; trace_usb_set_addr(dev->addr)... |
1 | static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){ IMXFECState *s = IMX_FEC(opaque); uint32_t index = offset >> 2; FEC_PRINTF("reg[%s] <= 0x%" PRIx32 "\n", imx_eth_reg_name(s, index), (uint32_t)value); switch (index) { case ENET_EIR: s->regs[index] &= ~value; break; case ENET_EIMR: s... |
1 | int qemu_chr_open_spice(QemuOpts *opts, CharDriverState **_chr){ CharDriverState *chr; SpiceCharDriver *s; const char* name = qemu_opt_get(opts, "name"); uint32_t debug = qemu_opt_get_number(opts, "debug", 0); const char** psubtype = spice_server_char_device_recognized_subtypes(); const char *subtype = NULL; if (name =... |
1 | static char *get_content_url(xmlNodePtr *baseurl_nodes, int n_baseurl_nodes, char *rep_id_val, char *rep_bandwidth_val, char *val){ int i; char *text; char *url = NULL; char tmp_str[MAX_URL_SIZE]; char tmp_str_2[MAX_URL_SIZE]; memset(tmp_str, 0, sizeof(tmp_str)); for (i = 0; i < n_baseurl_nodes; ++i) { if (baseurl_node... |
1 | av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx){ const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8; if (avctx->lowres==1) { c->idct_put = ff_jref_idct4_put; c->idct_add = ff_jref_idct4_add; c->idct = ff_j_rev_dct4; c->perm_type = FF_IDCT_PERM_NONE; } else if (avctx->lowres==2) { c->i... |
1 | static void vnc_display_close(VncDisplay *vs){ if (!vs) return; vs->enabled = false; vs->is_unix = false; if (vs->lsock != NULL) { if (vs->lsock_tag) { g_source_remove(vs->lsock_tag); } object_unref(OBJECT(vs->lsock)); vs->lsock = NULL; } vs->ws_enabled = false; if (vs->lwebsock != NULL) { if (vs->lwebsock_tag) { g_sou... |
1 | void cpu_reset(CPUX86State *env){ int i; memset(env, 0, offsetof(CPUX86State, breakpoints)); tlb_flush(env, 1); env->old_exception = -1; /* init to reset state */#ifdef CONFIG_SOFTMMU env->hflags |= HF_SOFTMMU_MASK;#endif env->hflags2 |= HF2_GIF_MASK; cpu_x86_update_cr0(env, 0x60000010); env->a20_mask = ~0x0; env->smba... |
1 | static int get_cod(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties){ J2kCodingStyle tmp; int compno; if (s->buf_end - s->buf < 5) return AVERROR(EINVAL); tmp.log2_prec_width = tmp.log2_prec_height = 15; tmp.csty = bytestream_get_byte(&s->buf); if (bytestream_get_byte(&s->buf)){ // progression level av_log(... |
0 | static void create_cps(MaltaState *s, const char *cpu_model, qemu_irq *cbus_irq, qemu_irq *i8259_irq){ Error *err = NULL; s->cps = g_new0(MIPSCPSState, 1); object_initialize(s->cps, sizeof(MIPSCPSState), TYPE_MIPS_CPS); qdev_set_parent_bus(DEVICE(s->cps), sysbus_get_default()); object_property_set_str(OBJECT(s->cps), c... |
0 | void qmp_change_backing_file(const char *device, const char *image_node_name, const char *backing_file, Error **errp){ BlockBackend *blk; BlockDriverState *bs = NULL; AioContext *aio_context; BlockDriverState *image_bs = NULL; Error *local_err = NULL; bool ro; int open_flags; int ret; blk = blk_by_name(device); if (!bl... |
0 | int pci_parse_devaddr(const char *addr, int *domp, int *busp, unsigned int *slotp, unsigned int *funcp){ const char *p; char *e; unsigned long val; unsigned long dom = 0, bus = 0; unsigned int slot = 0; unsigned int func = 0; p = addr; val = strtoul(p, &e, 16); if (e == p)return -1; if (*e == ':') {bus = val;p = e + 1;... |
0 | static void x86_cpu_load_features(X86CPU *cpu, Error **errp){ CPUX86State *env = &cpu->env; FeatureWord w; GList *l; Error *local_err = NULL; /*TODO: cpu->max_features incorrectly overwrites features * set using "feat=on|off". Once we fix this, we can convert * plus_features & minus_features to global properties * insi... |
0 | static void vnc_init_basic_info(SocketAddressLegacy *addr, VncBasicInfo *info, Error **errp){ switch (addr->type) { case SOCKET_ADDRESS_LEGACY_KIND_INET: info->host = g_strdup(addr->u.inet.data->host); info->service = g_strdup(addr->u.inet.data->port); if (addr->u.inet.data->ipv6) { info->family = NETWORK_ADDRESS_FAMIL... |
0 | static int mirror_cow_align(MirrorBlockJob *s, int64_t *sector_num, int *nb_sectors){ bool need_cow; int ret = 0; int chunk_sectors = s->granularity >> BDRV_SECTOR_BITS; int64_t align_sector_num = *sector_num; int align_nb_sectors = *nb_sectors; int max_sectors = chunk_sectors * s->max_iov; need_cow = !test_bit(*sector... |
0 | static void bonito_pciconf_writel(void *opaque, target_phys_addr_t addr, uint32_t val){ PCIBonitoState *s = opaque; DPRINTF("bonito_pciconf_writel "TARGET_FMT_plx" val %x \n", addr, val); s->dev.config_write(&s->dev, addr, val, 4);} |
0 | static int vhdx_create(const char *filename, QemuOpts *opts, Error **errp){ int ret = 0; uint64_t image_size = (uint64_t) 2 * GiB; uint32_t log_size = 1 * MiB; uint32_t block_size = 0; uint64_t signature; uint64_t metadata_offset; bool use_zero_blocks = false; gunichar2 *creator = NULL; glong creator_items; BlockBacken... |
0 | static void vc1_mc_1mv(VC1Context *v, int dir){ MpegEncContext *s = &v->s; DSPContext *dsp = &v->s.dsp; H264ChromaContext *h264chroma = &v->h264chroma; uint8_t *srcY, *srcU, *srcV; int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y; int off, off_uv; int v_edge_pos = s->v_edge_pos >> v->field_mode; if ((!v->fie... |
0 | static void rng_egd_chr_read(void *opaque, const uint8_t *buf, int size){ RngEgd *s = RNG_EGD(opaque); size_t buf_offset = 0; while (size > 0 && s->parent.requests) { RngRequest *req = s->parent.requests->data; int len = MIN(size, req->size - req->offset); memcpy(req->data + req->offset, buf + buf_offset, len); buf_off... |
0 | static void virgl_cmd_get_capset(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd){ struct virtio_gpu_get_capset gc; struct virtio_gpu_resp_capset *resp; uint32_t max_ver, max_size; VIRTIO_GPU_FILL_CMD(gc); virgl_renderer_get_cap_set(gc.capset_id, &max_ver, &max_size); resp = g_malloc(sizeof(*resp) + max_size); resp->... |
0 | static int get_device_type(SCSIDiskState *s){ BlockDriverState *bdrv = s->qdev.conf.bs; uint8_t cmd[16]; uint8_t buf[36]; uint8_t sensebuf[8]; sg_io_hdr_t io_header; int ret; memset(cmd, 0, sizeof(cmd)); memset(buf, 0, sizeof(buf)); cmd[0] = INQUIRY; cmd[4] = sizeof(buf); memset(&io_header, 0, sizeof(io_header)); io_he... |
0 | static always_inline void powerpc_excp (CPUState *env, int excp_model, int excp){ target_ulong msr, vector; int srr0, srr1, asrr0, asrr1; if (loglevel & CPU_LOG_INT) { fprintf(logfile, "Raise exception at 0x" ADDRX " => 0x%08x (%02x)\n", env->nip, excp, env->error_code); } msr = do_load_msr(env); srr0 = SPR_SRR0; srr1 ... |
0 | static int parse_pair(JSONParserContext *ctxt, QDict *dict, QList **tokens, va_list *ap){ QObject *key = NULL, *token = NULL, *value, *peek; QList *working = qlist_copy(*tokens); peek = qlist_peek(working); if (peek == NULL) { parse_error(ctxt, NULL, "premature EOI"); goto out; } key = parse_value(ctxt, &working, ap); ... |
0 | void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down){ KeyValue *key = g_new0(KeyValue, 1); key->type = KEY_VALUE_KIND_NUMBER; key->u.number = num; qemu_input_event_send_key(src, key, down);} |
0 | opts_start_optional(Visitor *v, bool *present, const char *name, Error **errp){ OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); /* we only support a single mandatory scalar field in a list node */ assert(ov->repeated_opts == NULL); *present = (lookup_distinct(ov, name, NULL) != NULL);} |
0 | static void async_complete(void *opaque){ USBHostDevice *s = opaque; AsyncURB *aurb; int urbs = 0; while (1) { USBPacket *p; int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb); if (r < 0) { if (errno == EAGAIN) { if (urbs > 2) { fprintf(stderr, "husb: %d iso urbs finished at once\n", urbs); } return; } if (errno == EN... |
0 | static void next(DBDMA_channel *ch){ uint32_t cp; ch->regs[DBDMA_STATUS] &= cpu_to_be32(~BT); cp = be32_to_cpu(ch->regs[DBDMA_CMDPTR_LO]); ch->regs[DBDMA_CMDPTR_LO] = cpu_to_be32(cp + sizeof(dbdma_cmd)); dbdma_cmdptr_load(ch);} |
0 | DeviceState *nand_init(BlockBackend *blk, int manf_id, int chip_id){ DeviceState *dev; if (nand_flash_ids[chip_id].size == 0) { hw_error("%s: Unsupported NAND chip ID.\n", __FUNCTION__); } dev = DEVICE(object_new(TYPE_NAND)); qdev_prop_set_uint8(dev, "manufacturer_id", manf_id); qdev_prop_set_uint8(dev, "chip_id", chip... |
0 | static void decode_mb(MadContext *t, int inter){ MpegEncContext *s = &t->s; int mv_map = 0; int mv_x, mv_y; int j; if (inter) { int v = decode210(&s->gb); if (v < 2) { mv_map = v ? get_bits(&s->gb, 6) : 63; mv_x = decode_motion(&s->gb); mv_y = decode_motion(&s->gb); } else { mv_map = 0; } } for (j=0; j<6; j++) { if (mv... |
0 | static void ioq_submit(LinuxAioState *s){ int ret, len; struct qemu_laiocb *aiocb; struct iocb *iocbs[MAX_QUEUED_IO]; QSIMPLEQ_HEAD(, qemu_laiocb) completed; do { len = 0; QSIMPLEQ_FOREACH(aiocb, &s->io_q.pending, next) { iocbs[len++] = &aiocb->iocb; if (len == MAX_QUEUED_IO) { break; } } ret = io_submit(s->ctx, len, i... |
0 | static void envelope_instant16(WaveformContext *s, AVFrame *out, int plane, int component){ const int dst_linesize = out->linesize[component] / 2; const int bg = s->bg_color[component] * (s->size / 256); const int limit = s->size - 1; const int is_chroma = (component == 1 || component == 2); const int shift_w = (is_chr... |
0 | static int advanced_decode_picture_header(VC9Context *v){ static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE }; int type, i, ret; if (v->interlace) { v->fcm = get_bits(&v->gb, 1); if (v->fcm) v->fcm = 2+get_bits(&v->gb, 1); } type = get_prefix(&v->gb, 0, 4); if (type > 4 || type < 0) return FRAME_SKIPED... |
0 | static void dss_sp_unpack_coeffs(DssSpContext *p, const uint8_t *src){ GetBitContext gb; DssSpFrame *fparam = &p->fparam; int i; int subframe_idx; uint32_t combined_pitch; uint32_t tmp; uint32_t pitch_lag; for (i = 0; i < DSS_SP_FRAME_SIZE; i += 2) { p->bits[i] = src[i + 1]; p->bits[i + 1] = src[i]; } init_get_bits(&gb... |
0 | int av_packet_copy_props(AVPacket *dst, const AVPacket *src){ int i; dst->pts = src->pts; dst->dts = src->dts; dst->pos = src->pos; dst->duration = src->duration; dst->convergence_duration = src->convergence_duration; dst->flags = src->flags; dst->stream_index = src->stream_index; dst->side_data_elems = src->side_data_... |
1 | void configure_icount(const char *option){ vmstate_register(NULL, 0, &vmstate_timers, &timers_state); if (!option) return;#ifdef CONFIG_IOTHREAD vm_clock->warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);#endif if (strcmp(option, "auto") != 0) { icount_time_shift = strtol(option, NULL, 0); use_icount = 1;... |
1 | static int spapr_set_associativity(void *fdt, sPAPREnvironment *spapr){ int ret = 0, offset; CPUPPCState *env; char cpu_model[32]; int smt = kvmppc_smt_threads(); assert(spapr->cpu_model); for (env = first_cpu; env != NULL; env = env->next_cpu) { uint32_t associativity[] = {cpu_to_be32(0x5), cpu_to_be32(0x0), cpu_to_be... |
1 | static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq){ VirtIONet *n = VIRTIO_NET(vdev); struct virtio_net_ctrl_hdr ctrl; virtio_net_ctrl_ack status = VIRTIO_NET_ERR; VirtQueueElement elem; size_t s; struct iovec *iov; unsigned int iov_cnt; while (virtqueue_pop(vq, &elem)) { if (iov_size(elem.in_sg, elem... |
1 | static void *oss_audio_init (void){ OSSConf *conf = g_malloc(sizeof(OSSConf)); *conf = glob_conf; if (access(conf->devpath_in, R_OK | W_OK) < 0 || access(conf->devpath_out, R_OK | W_OK) < 0) { return NULL; } return conf;} |
1 | static inline int get_len(LZOContext *c, int x, int mask){ int cnt = x & mask; if (!cnt) { while (!(x = get_byte(c))) cnt += 255; cnt += mask + x; } return cnt;} |
1 | static void rtas_write_pci_config(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t val, size, addr; PCIDevice *dev = find_dev(spapr, 0, rtas_ld(args, 0)); if (!dev) { rtas_st(rets, 0, -1); return; } val = rtas_ld(args, 2); size = rtas_ld(args, 1); a... |
1 | QEMUFile *qemu_fopen(const char *filename, const char *mode){ QEMUFileStdio *s; if (qemu_file_mode_is_not_valid(mode)) { return NULL; } s = g_malloc0(sizeof(QEMUFileStdio)); s->stdio_file = fopen(filename, mode); if (!s->stdio_file) { goto fail; } if (mode[0] == 'w') { s->file = qemu_fopen_ops(s, &stdio_file_write_ops)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.