label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static QDict *do_info_vnc_client(Monitor *mon, VncState *client){ QDict *qdict; qdict = qdict_new(); if (vnc_qdict_remote_addr(qdict, client->csock) < 0) { QDECREF(qdict); return NULL; }#ifdef CONFIG_VNC_TLS if (client->tls.session && client->tls.dname) { qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dnam... |
0 | static av_cold int vp3_decode_init(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; int i, inter, plane; int c_width; int c_height; int y_fragment_count, c_fragment_count; if (avctx->codec_tag == MKTAG('V','P','3','0')) s->version = 0; else s->version = 1; s->avctx = avctx; s->width = FFALIGN(avctx->widt... |
0 | static void nvdimm_build_fit(Aml *dev){ Aml *method, *pkg, *buf, *buf_size, *offset, *call_result; Aml *whilectx, *ifcond, *ifctx, *elsectx, *fit; buf = aml_local(0); buf_size = aml_local(1); fit = aml_local(2); aml_append(dev, aml_create_dword_field(aml_buffer(4, NULL), aml_int(0), NVDIMM_DSM_RFIT_STATUS)); /* build h... |
0 | PXA2xxLCDState *pxa2xx_lcdc_init(MemoryRegion *sysmem, hwaddr base, qemu_irq irq){ PXA2xxLCDState *s; DisplaySurface *surface; s = (PXA2xxLCDState *) g_malloc0(sizeof(PXA2xxLCDState)); s->invalidated = 1; s->irq = irq; s->sysmem = sysmem; pxa2xx_lcdc_orientation(s, graphic_rotate); memory_region_init_io(&s->iomem, NULL... |
0 | static unsigned int dec_movem_mr(DisasContext *dc){TCGv tmp[16];TCGv addr;int i;int nr = dc->op2 + 1;DIS(fprintf (logfile, "movem [$r%u%s, $r%u\n", dc->op1, dc->postinc ? "+]" : "]", dc->op2));addr = tcg_temp_new(TCG_TYPE_TL);/* There are probably better ways of doing this. */cris_flush_cc_state(dc);for (i = 0; i < (nr... |
0 | static int xen_pt_msgdata_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry, uint16_t *val, uint16_t dev_value, uint16_t valid_mask){ XenPTRegInfo *reg = cfg_entry->reg; XenPTMSI *msi = s->msi; uint16_t writable_mask = 0; uint16_t old_data = cfg_entry->data; uint32_t offset = reg->offset; /* check the offset whe... |
0 | void HELPER(cdsg)(CPUS390XState *env, uint64_t addr, uint32_t r1, uint32_t r3){ uintptr_t ra = GETPC(); Int128 cmpv = int128_make128(env->regs[r1 + 1], env->regs[r1]); Int128 newv = int128_make128(env->regs[r3 + 1], env->regs[r3]); Int128 oldv; bool fail; if (parallel_cpus) {#ifndef CONFIG_ATOMIC128 cpu_loop_exit_atomi... |
0 | static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVQcow2State *s = bs->opaque; unsigned int len, i; int ret = 0; QCowHeader header; Error *local_err = NULL; uint64_t ext_end; uint64_t l1_vm_state_index; ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); if (ret < 0) { erro... |
0 | static XHCIEPContext *xhci_alloc_epctx(XHCIState *xhci, unsigned int slotid, unsigned int epid){ XHCIEPContext *epctx; int i; epctx = g_new0(XHCIEPContext, 1); epctx->xhci = xhci; epctx->slotid = slotid; epctx->epid = epid; for (i = 0; i < ARRAY_SIZE(epctx->transfers); i++) { epctx->transfers[i].xhci = xhci; epctx->tra... |
0 | static uint16_t phys_map_node_alloc(void){ unsigned i; uint16_t ret; ret = next_map.nodes_nb++; assert(ret != PHYS_MAP_NODE_NIL); assert(ret != next_map.nodes_nb_alloc); for (i = 0; i < L2_SIZE; ++i) { next_map.nodes[ret][i].is_leaf = 0; next_map.nodes[ret][i].ptr = PHYS_MAP_NODE_NIL; } return ret;} |
0 | bool qemu_peer_has_vnet_hdr_len(NetClientState *nc, int len){ if (!nc->peer || !nc->peer->info->has_vnet_hdr_len) { return false; } return nc->peer->info->has_vnet_hdr_len(nc->peer, len);} |
0 | static void avc_luma_midh_qrt_16w_msa(const uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height, uint8_t horiz_offset){ uint32_t multiple8_cnt; for (multiple8_cnt = 4; multiple8_cnt--;) { avc_luma_midh_qrt_4w_msa(src, src_stride, dst, dst_stride, height, horiz_offset); src += 4; dst += 4;... |
0 | static void vc1_put_block(VC1Context *v, DCTELEM block[6][64]){ uint8_t *Y; int ys, us, vs; DSPContext *dsp = &v->s.dsp; if(v->rangeredfrm) { int i, j, k; for(k = 0; k < 6; k++) for(j = 0; j < 8; j++) for(i = 0; i < 8; i++) block[k][i + j*8] = (block[k][i + j*8] - 64) << 1; } ys = v->s.current_picture.linesize[0]; us =... |
1 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; H264Context *h = avctx->priv_data; MpegEncContext *s = &h->s; AVFrame *pict = data; int buf_index; s->flags= avctx->flags; s->flags2= avctx->flags2; /* end of stream... |
1 | void kvm_remove_all_breakpoints(CPUState *cpu){ struct kvm_sw_breakpoint *bp, *next; KVMState *s = cpu->kvm_state; QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { if (kvm_arch_remove_sw_breakpoint(cpu, bp) != 0) { /* Try harder to find a CPU that currently sees the breakpoint. */ CPU_FOREACH(cpu) { if (k... |
1 | static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr, GetBitContext *gb, int id_aac){ unsigned int cnt = get_bits_count(gb); if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) { read_sbr_single_channel_element(ac, sbr, gb); } else if (id_aac == TYPE_CPE) { read_sbr_channel_pair_element(ac, sbr, gb)... |
1 | ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host, MemoryRegion *mr){ RAMBlock *new_block; size = TARGET_PAGE_ALIGN(size); new_block = g_malloc0(sizeof(*new_block)); new_block->mr = mr; new_block->offset = find_ram_offset(size); if (host) { new_block->host = host; new_block->flags |= RAM_PREALLOC_MASK; } e... |
1 | static MemTxResult memory_region_read_accessor(MemoryRegion *mr, hwaddr addr, uint64_t *value, unsigned size, unsigned shift, uint64_t mask, MemTxAttrs attrs){ uint64_t tmp; tmp = mr->ops->read(mr->opaque, addr, size); if (mr->subpage) { trace_memory_region_subpage_read(get_cpu_index(), mr, addr, tmp, size); } else if ... |
1 | static void unmanageable_intercept(S390CPU *cpu, const char *str, int pswoffset){ CPUState *cs = CPU(cpu); error_report("Unmanageable %s! CPU%i new PSW: 0x%016lx:%016lx", str, cs->cpu_index, ldq_phys(cs->as, cpu->env.psa + pswoffset), ldq_phys(cs->as, cpu->env.psa + pswoffset + 8)); s390_cpu_halt(cpu); guest_panicked()... |
0 | static int cook_decode_init(AVCodecContext *avctx){ COOKextradata *e = (COOKextradata *)avctx->extradata; COOKContext *q = avctx->priv_data; /* Take care of the codec specific extradata. */ if (avctx->extradata_size <= 0) { av_log(avctx,AV_LOG_ERROR,"Necessary extradata missing!\n"); return -1; } else { /* 8 for mono, ... |
0 | static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno, int seg_symbols, int vert_causal_ctx_csty_symbol){ int mask = 3 << (bpno - 1), y0, x, y, runlen, dec; for (y0 = 0; y0 < height; y0 += 4) { for (x = 0; x < width; x++) { int flags_mask = -1; if (vert... |
1 | static int hls_write_packet(AVFormatContext *s, AVPacket *pkt){ HLSContext *hls = s->priv_data; AVFormatContext *oc = NULL; AVStream *st = s->streams[pkt->stream_index]; int64_t end_pts = 0; int is_ref_pkt = 1; int ret = 0, can_split = 1, i, j; int stream_index = 0; int range_length = 0; uint8_t *buffer = NULL; Variant... |
1 | void sample_dump(int fnum, int32_t *tab, int n){ static FILE *files[16], *f; char buf[512]; int i; int32_t v; f = files[fnum]; if (!f) { snprintf(buf, sizeof(buf), "/tmp/out%d.%s.pcm", fnum, #ifdef USE_HIGHPRECISION "hp"#else "lp"#endif ); f = fopen(buf, "w"); if (!f) return; files[fnum] = f; } if (fnum == 0) { static ... |
1 | int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx){ AVVDPAUContext *hwctx = avctx->hwaccel_context; MpegEncContext *s = avctx->priv_data; Picture *pic = s->current_picture_ptr; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; VdpVideoSurface surf = ff_vdpau_get_surface_id(&pic->f); hwctx->render(hw... |
1 | static void skip_data_stream_element(GetBitContext *gb){ int byte_align = get_bits1(gb); int count = get_bits(gb, 8); if (count == 255) count += get_bits(gb, 8); if (byte_align) align_get_bits(gb); skip_bits_long(gb, 8 * count);} |
1 | NetQueue *qemu_new_net_queue(void *opaque){ NetQueue *queue; queue = g_malloc0(sizeof(NetQueue)); queue->opaque = opaque; QTAILQ_INIT(&queue->packets); queue->delivering = 0; return queue;} |
1 | static void gen_dmfc0(DisasContext *ctx, TCGv arg, int reg, int sel){ const char *rn = "invalid"; if (sel != 0) check_insn(ctx, ISA_MIPS64); switch (reg) { case 0: switch (sel) { case 0: gen_mfc0_load32(arg, offsetof(CPUMIPSState, CP0_Index)); rn = "Index"; case 1: CP0_CHECK(ctx->insn_flags & ASE_MT); gen_helper_mfc0_m... |
1 | static inline uint16_t mipsdsp_trunc16_sat16_round(int32_t a, CPUMIPSState *env){ int64_t temp; temp = (int32_t)a + 0x00008000; if (a > (int)0x7fff8000) { temp = 0x7FFFFFFF; set_DSPControl_overflow_flag(1, 22, env); } return (temp >> 16) & 0xFFFF;} |
0 | static void celt_pvq_search(float *X, int *y, int K, int N){ int i; float res = 0.0f, y_norm = 0.0f, xy_norm = 0.0f; for (i = 0; i < N; i++) res += FFABS(X[i]); res = K/res; for (i = 0; i < N; i++) { y[i] = lrintf(res*X[i]); y_norm += y[i]*y[i]; xy_norm += y[i]*X[i]; K -= FFABS(y[i]); } while (K) { int max_idx = 0, pha... |
0 | static int rtsp_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags){ RTSPState *rt = s->priv_data; rt->seek_timestamp = av_rescale_q(timestamp, s->streams[stream_index]->time_base, AV_TIME_BASE_Q); switch(rt->state) { default: case RTSP_STATE_IDLE: break; case RTSP_STATE_PLAYING: if (rtsp_read... |
0 | static inline void RENAME(yuy2ToY)(uint8_t *dst, const uint8_t *src, long width, uint32_t *unused){#if COMPILE_TEMPLATE_MMX __asm__ volatile( "movq "MANGLE(bm01010101)", %%mm2 \n\t" "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" "pand %%mm2, %%mm0 \n\t" "pa... |
0 | static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ AVFrame *pic=NULL; int64_t pts; int i; const int encoding_delay= s->max_b_frames; int direct=1; if(pic_arg){ pts= pic_arg->pts; pic_arg->display_picture_number= s->input_picture_number++; if(pts != AV_NOPTS_VALUE){ if(s->user_specified_pts != AV_NOPTS_... |
0 | static inline void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, h264_chroma_mc_func *pix_op){ int mx, my; int mb_x, mb_y, i; const int lowres= s->avctx->lowres; const int block_s= 8>>lowres; mb_x = s->mb_x; mb_y = s->mb_y; switch(s->mv_type) {... |
0 | static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile){ int ret, i; int tp_index = 0; s->bit_index = 8; if (tile->poc.nb_poc) { for (i=0; i<tile->poc.nb_poc; i++) { Jpeg2000POCEntry *e = &tile->poc.poc[i]; ret = jpeg2000_decode_packets_po_iteration(s, tile, e->RSpoc, e->CSpoc, e->LYEpoc, e->R... |
1 | static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf, int64_t bytes, CoroutineEntry co_entry, BdrvRequestFlags flags){ AioContext *aio_context; QEMUIOVector qiov; struct iovec iov; Coroutine *co; BlkRwCo rwco; iov = (struct iovec) { .iov_base = buf, .iov_len = bytes, }; qemu_iovec_init_external(&qiov, &io... |
1 | static void gen_spr_thrm (CPUPPCState *env){ /* Thermal management */ /* XXX : not implemented */ spr_register(env, SPR_THRM1, "THRM1", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, &spr_write_generic, 0x00000000); /* XXX : not implemented */ spr_register(env, SPR_THRM2, "THRM2", SPR_NOACCESS, SPR_NOACCESS, &spr_read_... |
1 | static int pix_sum_altivec(uint8_t *pix, int line_size){ int i, s; const vector unsigned int zero = (const vector unsigned int) vec_splat_u32(0); vector unsigned int sad = (vector unsigned int) vec_splat_u32(0); vector signed int sumdiffs; for (i = 0; i < 16; i++) { /* Read the potentially unaligned 16 pixels into t1. ... |
1 | static void mb_cpu_initfn(Object *obj){ CPUState *cs = CPU(obj); MicroBlazeCPU *cpu = MICROBLAZE_CPU(obj); CPUMBState *env = &cpu->env; static bool tcg_initialized; cs->env_ptr = env; cpu_exec_init(cs, &error_abort); set_float_rounding_mode(float_round_nearest_even, &env->fp_status);#ifndef CONFIG_USER_ONLY /* Inbound ... |
1 | int bdrv_create(BlockDriver *drv, const char* filename, QemuOpts *opts, Error **errp){ int ret; Coroutine *co; CreateCo cco = { .drv = drv, .filename = g_strdup(filename), .opts = opts, .ret = NOT_DONE, .err = NULL, }; if (!drv->bdrv_create) { error_setg(errp, "Driver '%s' does not support image creation", drv->format_... |
1 | ssize_t qsb_get_buffer(const QEMUSizedBuffer *qsb, off_t start, size_t count, uint8_t *buffer){ const struct iovec *iov; size_t to_copy, all_copy; ssize_t index; off_t s_off; off_t d_off = 0; char *s; if (start > qsb->used) { return 0; } all_copy = qsb->used - start; if (all_copy > count) { all_copy = count; } else { c... |
1 | static void vfio_probe_ati_bar4_quirk(VFIOPCIDevice *vdev, int nr){ VFIOQuirk *quirk; VFIOConfigWindowQuirk *window; /* This windows doesn't seem to be used except by legacy VGA code */ if (!vfio_pci_is(vdev, PCI_VENDOR_ID_ATI, PCI_ANY_ID) || !vdev->has_vga || nr != 4) { return; } quirk = g_malloc0(sizeof(*quirk)); qui... |
1 | static void scsi_read_data(SCSIDevice *d, uint32_t tag){ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d); SCSIDiskReq *r; r = scsi_find_request(s, tag); if (!r) { BADF("Bad read tag 0x%x\n", tag); /* ??? This is the wrong error. */ scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR); return; } scsi_read_requ... |
0 | static inline void mix_3f_1r_to_dolby(AC3DecodeContext *ctx){ int i; float (*output)[256] = ctx->audio_block.block_output; for (i = 0; i < 256; i++) { output[1][i] += (output[2][i] - output[4][i]); output[2][i] += (output[3][i] + output[4][i]); } memset(output[3], 0, sizeof(output[3])); memset(output[4], 0, sizeof(outp... |
0 | static int has_codec_parameters(AVCodecContext *enc){ int val; switch(enc->codec_type) { case CODEC_TYPE_AUDIO: val = enc->sample_rate; break; case CODEC_TYPE_VIDEO: val = enc->width && enc->pix_fmt != PIX_FMT_NONE; break; default: val = 1; break; } return (val != 0);} |
0 | static int test_vector_fmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp, const float *v1, float scale){ LOCAL_ALIGNED(32, float, cdst, [LEN]); LOCAL_ALIGNED(32, float, odst, [LEN]); int ret; cdsp->vector_fmul_scalar(cdst, v1, scale, LEN); fdsp->vector_fmul_scalar(odst, v1, scale, LEN); if (ret = compare_flo... |
1 | static void smp_parse(QemuOpts *opts){ if (opts) { unsigned cpus = qemu_opt_get_number(opts, "cpus", 0); unsigned sockets = qemu_opt_get_number(opts, "sockets", 0); unsigned cores = qemu_opt_get_number(opts, "cores", 0); unsigned threads = qemu_opt_get_number(opts, "threads", 0); /* compute missing values, prefer socke... |
1 | static void interface_set_client_capabilities(QXLInstance *sin, uint8_t client_present, uint8_t caps[58]){ PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl); qxl->shadow_rom.client_present = client_present; memcpy(qxl->shadow_rom.client_capabilities, caps, sizeof(caps)); qxl->rom->client_present = client_pre... |
1 | AUXReply aux_request(AUXBus *bus, AUXCommand cmd, uint32_t address, uint8_t len, uint8_t *data){ AUXReply ret = AUX_NACK; I2CBus *i2c_bus = aux_get_i2c_bus(bus); size_t i; bool is_write = false; DPRINTF("request at address 0x%" PRIX32 ", command %u, len %u\n", address, cmd, len); switch (cmd) { /* * Forward the request... |
1 | static sd_rsp_type_t sd_app_command(SDState *sd, SDRequest req){ DPRINTF("ACMD%d 0x%08x\n", req.cmd, req.arg); switch (req.cmd) { case 6:/* ACMD6: SET_BUS_WIDTH */ switch (sd->state) { case sd_transfer_state: sd->sd_status[0] &= 0x3f; sd->sd_status[0] |= (req.arg & 0x03) << 6; return sd_r1; default: break; } break; cas... |
1 | static int smc91c111_can_receive(NetClientState *nc){ smc91c111_state *s = qemu_get_nic_opaque(nc); if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST)) return 1; if (s->allocated == (1 << NUM_PACKETS) - 1) return 0; return 1;} |
1 | static ssize_t mp_dacl_listxattr(FsContext *ctx, const char *path, char *name, void *value, size_t osize){ ssize_t len = sizeof(ACL_DEFAULT); if (!value) { return len; } if (osize < len) { errno = ERANGE; return -1; } /* len includes the trailing NUL */ memcpy(value, ACL_ACCESS, len); return 0;} |
0 | static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64]){ MpegEncContext *s = &v->s; GetBitContext *gb = &s->gb; int i, j; int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int cbp; /* cbp decoding stuff */ int mqdiff, mquant; /* MB quantization */ int ttmb = v->ttfrm; /* MB Transform type */ int status; static con... |
0 | int avfilter_parse_graph(AVFilterGraph *graph, const char *filters, AVFilterInOut *open_inputs, AVFilterInOut *open_outputs, AVClass *log_ctx){ int index = 0; char chr = 0; AVFilterInOut *curr_inputs = NULL; do { AVFilterContext *filter; filters += consume_whitespace(filters); if(parse_inputs(&filters, &curr_inputs, &o... |
0 | int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize){ int alloc_size = FFALIGN(FFABS(linesize) + 64, 32); // edge emu needs blocksize + filter length - 1 // (= 17x17 for halfpel / 21x21 for h264) // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9 // at uvlinesize. It supports only YUV420 so 24... |
0 | static av_cold int cook_decode_init(AVCodecContext *avctx){ COOKContext *q = avctx->priv_data; const uint8_t *edata_ptr = avctx->extradata; const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size; int extradata_size = avctx->extradata_size; int s = 0; unsigned int channel_mask = 0; q->avctx = avctx; /* Take ca... |
0 | static int http_read(URLContext *h, uint8_t *buf, int size){ HTTPContext *s = h->priv_data; int size1, len; size1 = size; while (size > 0) { /* read bytes from input buffer first */ len = s->buf_end - s->buf_ptr; if (len > 0) { if (len > size) len = size; memcpy(buf, s->buf_ptr, len); s->buf_ptr += len; } else { len = ... |
1 | static void dump_json_image_info_list(ImageInfoList *list){ Error *local_err = NULL; QString *str; QmpOutputVisitor *ov = qmp_output_visitor_new(); QObject *obj; visit_type_ImageInfoList(qmp_output_get_visitor(ov), NULL, &list, &local_err); obj = qmp_output_get_qobject(ov); str = qobject_to_json_pretty(obj); assert(str... |
1 | static void setup_frame(int sig, struct target_sigaction *ka, target_sigset_t *set, CPUS390XState *env){ sigframe *frame; abi_ulong frame_addr; frame_addr = get_sigframe(ka, env, sizeof(*frame)); qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, (unsigned long long)frame_addr); if (!lock_user_struct(VERIFY_WRITE, frame... |
1 | av_cold void ff_vc2enc_free_transforms(VC2TransformContext *s){ av_freep(&s->buffer);} |
1 | static int find_snapshot_by_id_or_name(BlockDriverState *bs, const char *name){ BDRVQcowState *s = bs->opaque; int i, ret; ret = find_snapshot_by_id(bs, name); if (ret >= 0) return ret; for(i = 0; i < s->nb_snapshots; i++) { if (!strcmp(s->snapshots[i].name, name)) return i; } return -1;} |
1 | void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors){ BdrvDirtyBitmap *bitmap; QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors); }} |
0 | static av_cold int v410_encode_init(AVCodecContext *avctx){ if (avctx->width & 1) { av_log(avctx, AV_LOG_ERROR, "v410 requires even width.\n"); return AVERROR_INVALIDDATA; } avctx->coded_frame = av_frame_alloc(); if (!avctx->coded_frame) { av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n"); return AVERROR(ENOME... |
0 | static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block, int index, const int type){ static const uint8_t *const scan_patterns[4] = { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan }; int run, level, sign, vlc, limit; const int intra = (3 * type) >> 2; const uint8_t *const scan = scan_pattern... |
1 | static void pci_device_class_init(ObjectClass *klass, void *data){ DeviceClass *k = DEVICE_CLASS(klass); k->init = pci_qdev_init; k->exit = pci_unregister_device; k->bus_type = TYPE_PCI_BUS; k->props = pci_props;} |
1 | CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*init)(struct CharDriverState *s)){ const char *p; CharDriverState *chr; QemuOpts *opts; if (strstart(filename, "chardev:", &p)) { return qemu_chr_find(p); } opts = qemu_chr_parse_compat(label, filename); if (!opts) return NULL; chr = qemu_ch... |
1 | static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len){ DriveInfo **ptr = qdev_get_prop_ptr(dev, prop); return snprintf(dest, len, "%s", (*ptr)->id);} |
1 | static int find_headers_search_validate(FLACParseContext *fpc, int offset){ FLACFrameInfo fi; uint8_t *header_buf; int size = 0; header_buf = flac_fifo_read_wrap(fpc, offset, MAX_FRAME_HEADER_SIZE, &fpc->wrap_buf, &fpc->wrap_buf_allocated_size); if (frame_header_is_valid(fpc->avctx, header_buf, &fi)) { FLACHeaderMarker... |
1 | void ppc_set_compat(PowerPCCPU *cpu, uint32_t compat_pvr, Error **errp){ const CompatInfo *compat = compat_by_pvr(compat_pvr); CPUPPCState *env = &cpu->env; PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu); uint64_t pcr; if (!compat_pvr) { pcr = 0; } else if (!compat) { error_setg(errp, "Unknown compatibility PVR 0x%0... |
1 | static int mxf_timestamp_to_str(uint64_t timestamp, char **str){ struct tm time = { 0 }; time.tm_year = (timestamp >> 48) - 1900; time.tm_mon = (timestamp >> 40 & 0xFF) - 1; time.tm_mday = (timestamp >> 32 & 0xFF); time.tm_hour = (timestamp >> 24 & 0xFF); time.tm_min = (timestamp >> 16 & 0xFF); time.tm_sec = (timestamp... |
0 | static int check_pkt(AVFormatContext *s, AVPacket *pkt){ MOVMuxContext *mov = s->priv_data; MOVTrack *trk = &mov->tracks[pkt->stream_index]; if (trk->entry) { int64_t duration = pkt->dts - trk->cluster[trk->entry - 1].dts; if (duration < 0 || duration > INT_MAX) { av_log(s, AV_LOG_ERROR, "Application provided duration:... |
0 | static int get_siz(Jpeg2000DecoderContext *s){ int i; if (bytestream2_get_bytes_left(&s->g) < 36) return AVERROR(EINVAL); s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz s->width = bytestream2_get_be32u(&s->g); // Width s->height = bytestream2_get_be32u(&s->g); // Height s->image_offset_x = bytestream2_get_be... |
1 | void qemu_start_incoming_migration(const char *uri, Error **errp){ const char *p; if (strstart(uri, "tcp:", &p)) tcp_start_incoming_migration(p, errp);#ifdef CONFIG_RDMA else if (strstart(uri, "rdma:", &p)) rdma_start_incoming_migration(p, errp);#endif#if !defined(WIN32) else if (strstart(uri, "exec:", &p)) exec_start_... |
1 | static int decode_frame_mp3on4(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MP3On4DecodeContext *s = avctx->priv_data; MPADecodeContext *m; int fsize, len = buf_size, out_size = 0; uint32_t header; OUT_INT *out_samples; OUT_INT *o... |
1 | void OPPROTO op_subfo (void){ do_subfo(); RETURN();} |
1 | static void ehci_port_test(struct qhc *hc, int port, uint32_t expect){ void *addr = hc->base + 0x64 + 4 * port; uint32_t value = qpci_io_readl(hc->dev, addr); uint16_t mask = ~(PORTSC_CSC | PORTSC_PEDC | PORTSC_OCC);#if 0 fprintf(stderr, "%s: %d, have 0x%08x, want 0x%08x\n", __func__, port, value & mask, expect & mask)... |
1 | static int read_dcs(AVCodecContext *avctx, GetBitContext *gb, Bundle *b, int start_bits, int has_sign){ int i, j, len, len2, bsize, sign, v, v2; int16_t *dst = (int16_t*)b->cur_dec; CHECK_READ_VAL(gb, b, len); v = get_bits(gb, start_bits - has_sign); if (v && has_sign) { sign = -get_bits1(gb); v = (v ^ sign) - sign; } ... |
1 | static void opt_output_file(void *optctx, const char *filename){ OptionsContext *o = optctx; AVFormatContext *oc; int i, err; AVOutputFormat *file_oformat; OutputStream *ost; InputStream *ist; if (!strcmp(filename, "-")) filename = "pipe:"; err = avformat_alloc_output_context2(&oc, NULL, o->format, filename); if (!oc) ... |
0 | static int hdcd_integrate(HDCDContext *ctx, hdcd_state_t *state, int *flag, const int32_t *samples, int count, int stride){ uint32_t bits = 0; int result = FFMIN(state->readahead, count); int i; *flag = 0; for (i = result - 1; i >= 0; i--) { bits |= (*samples & 1) << i; /* might be better as a conditional? */ samples +... |
1 | static void gen_mtspr(DisasContext *ctx){ void (*write_cb)(DisasContext *ctx, int sprn, int gprn); uint32_t sprn = SPR(ctx->opcode);#if defined(CONFIG_USER_ONLY) write_cb = ctx->spr_cb[sprn].uea_write;#else if (ctx->pr) { write_cb = ctx->spr_cb[sprn].uea_write; } else if (ctx->hv) { write_cb = ctx->spr_cb[sprn].hea_wri... |
1 | static void usage(const char *cmd){ printf("Usage: %s [-m <method> -p <path>] [<options>]\n""QEMU Guest Agent %s\n""\n"" -m, --method transport method: one of unix-listen, virtio-serial, or\n"" isa-serial (virtio-serial is the default)\n"" -p, --path device/socket path (the default for virtio-serial is:\n"" %s)\n"" -l,... |
1 | static void await_reference_mb_row(const H264Context *const h, H264Picture *ref, int mb_y){ int ref_field = ref->reference - 1; int ref_field_picture = ref->field_picture; int ref_height = 16 * h->mb_height >> ref_field_picture; if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_FRAME)) return; /* FIXME: I... |
1 | static int gxf_packet(AVFormatContext *s, AVPacket *pkt) { ByteIOContext *pb = s->pb; pkt_type_t pkt_type; int pkt_len; while (!url_feof(pb)) { int track_type, track_id, ret; int field_nr; if (!parse_packet_header(pb, &pkt_type, &pkt_len)) { if (!url_feof(pb)) av_log(s, AV_LOG_ERROR, "GXF: sync lost\n"); return -1; } i... |
1 | void hmp_drive_add(Monitor *mon, const QDict *qdict){ DriveInfo *dinfo = NULL; const char *opts = qdict_get_str(qdict, "opts"); dinfo = add_init_drive(opts); if (!dinfo) { goto err; } if (dinfo->devaddr) { monitor_printf(mon, "Parameter addr not supported\n"); goto err; } switch (dinfo->type) { case IF_NONE: monitor_pr... |
0 | char *ff_AMediaCodecList_getCodecNameByType(const char *mime, int width, int height, void *log_ctx){ int ret; char *name = NULL; char *supported_type = NULL; int attached = 0; JNIEnv *env = NULL; struct JNIAMediaCodecListFields jfields = { 0 }; jobject format = NULL; jobject codec = NULL; jstring tmp = NULL; jobject in... |
0 | static void cchip_write(void *opaque, target_phys_addr_t addr, uint64_t v32, unsigned size){ TyphoonState *s = opaque; uint64_t val, oldval, newval; if (addr & 4) { val = v32 << 32 | s->latch_tmp; addr ^= 4; } else { s->latch_tmp = v32; return; } switch (addr) { case 0x0000: /* CSC: Cchip System Configuration Register.... |
0 | static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr){ size_t mmu_idx = get_mmuidx(oi); size_t index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1); CPUTLBEntry *tlbe = &env->tlb_table[mmu_idx][index]; target_ulong tlb_addr = tlbe->addr_write; TCGMemOp mop = get_memo... |
0 | BlockAIOCB *dma_bdrv_read(BlockDriverState *bs, QEMUSGList *sg, uint64_t sector, void (*cb)(void *opaque, int ret), void *opaque){ return dma_bdrv_io(bs, sg, sector, bdrv_aio_readv, cb, opaque, DMA_DIRECTION_FROM_DEVICE);} |
0 | TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name){ int idx; idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name); return MAKE_TCGV_I32(idx);} |
0 | static void check_pred8x8l(H264PredContext *h, uint8_t *buf0, uint8_t *buf1, int codec, int chroma_format, int bit_depth){ if (chroma_format == 1 && codec_ids[codec] == AV_CODEC_ID_H264) { int pred_mode; for (pred_mode = 0; pred_mode < 12; pred_mode++) { if (check_pred_func(h->pred8x8l[pred_mode], "8x8l", pred4x4_modes... |
0 | opts_next_list(Visitor *v, GenericList **list, Error **errp){ OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); GenericList **link; if (ov->repeated_opts_first) { ov->repeated_opts_first = false; link = list; } else { const QemuOpt *opt; opt = g_queue_pop_head(ov->repeated_opts); if (g_queue_is_empty(ov->repeated_o... |
0 | static inline int gen_neon_add(int size, TCGv t0, TCGv t1){ switch (size) { case 0: gen_helper_neon_add_u8(t0, t0, t1); break; case 1: gen_helper_neon_add_u16(t0, t0, t1); break; case 2: tcg_gen_add_i32(t0, t0, t1); break; default: return 1; } return 0;} |
0 | static void bt_l2cap_sdp_sdu_in(void *opaque, const uint8_t *data, int len){ struct bt_l2cap_sdp_state_s *sdp = opaque; enum bt_sdp_cmd pdu_id; uint8_t rsp[MAX_PDU_OUT_SIZE - PDU_HEADER_SIZE], *sdu_out; int transaction_id, plen; int err = 0; int rsp_len = 0; if (len < 5) { fprintf(stderr, "%s: short SDP PDU (%iB).\n", ... |
0 | static inline void memcpy_tofs(void * to, const void * from, unsigned long n){memcpy(to, from, n);} |
0 | static IOMMUTLBEntry s390_translate_iommu(MemoryRegion *iommu, hwaddr addr, bool is_write){ uint64_t pte; uint32_t flags; S390PCIBusDevice *pbdev = container_of(iommu, S390PCIBusDevice, mr); S390pciState *s; IOMMUTLBEntry ret = { .target_as = &address_space_memory, .iova = 0, .translated_addr = 0, .addr_mask = ~(hwaddr... |
0 | static GenericList *qmp_output_next_list(Visitor *v, GenericList **listp, size_t size){ GenericList *list = *listp; QmpOutputVisitor *qov = to_qov(v); QStackEntry *e = QTAILQ_FIRST(&qov->stack); assert(e); if (e->is_list_head) { e->is_list_head = false; return list; } return list ? list->next : NULL;} |
0 | static CharDriverState *qemu_chr_open_win_path(const char *filename, Error **errp){ CharDriverState *chr; WinCharState *s; chr = qemu_chr_alloc(); s = g_new0(WinCharState, 1); chr->opaque = s; chr->chr_write = win_chr_write; chr->chr_close = win_chr_close; if (win_chr_init(chr, filename, errp) < 0) { g_free(s); g_free(... |
0 | void smbios_add_field(int type, int offset, const void *data, size_t len){ struct smbios_field *field; smbios_check_collision(type, SMBIOS_FIELD_ENTRY); if (!smbios_entries) { smbios_entries_len = sizeof(uint16_t); smbios_entries = g_malloc0(smbios_entries_len); } smbios_entries = g_realloc(smbios_entries, smbios_entri... |
0 | Visitor *qmp_output_visitor_new(QObject **result){ QmpOutputVisitor *v; v = g_malloc0(sizeof(*v)); v->visitor.type = VISITOR_OUTPUT; v->visitor.start_struct = qmp_output_start_struct; v->visitor.end_struct = qmp_output_end_struct; v->visitor.start_list = qmp_output_start_list; v->visitor.next_list = qmp_output_next_lis... |
0 | static int ast2500_rambits(AspeedSDMCState *s){ switch (s->ram_size >> 20) { case 128: return ASPEED_SDMC_AST2500_128MB; case 256: return ASPEED_SDMC_AST2500_256MB; case 512: return ASPEED_SDMC_AST2500_512MB; case 1024: return ASPEED_SDMC_AST2500_1024MB; default: break; } /* use a common default */ error_report("warnin... |
0 | void helper_lswx(CPUPPCState *env, target_ulong addr, uint32_t reg, uint32_t ra, uint32_t rb){ if (likely(xer_bc != 0)) { int num_used_regs = (xer_bc + 3) / 4; if (unlikely((ra != 0 && reg < ra && (reg + num_used_regs) > ra) || (reg < rb && (reg + num_used_regs) > rb))) { helper_raise_exception_err(env, POWERPC_EXCP_PR... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.