label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void memory_region_dispatch_write(MemoryRegion *mr, hwaddr addr, uint64_t data, unsigned size){ if (!memory_region_access_valid(mr, addr, size, true)) { return; /* FIXME: better signalling */ } adjust_endianness(mr, &data, size); if (!mr->ops->write) { mr->ops->old_mmio.write[bitops_ctzl(size)](mr->opaque, addr,... |
0 | int bdrv_eject(BlockDriverState *bs, int eject_flag){ BlockDriver *drv = bs->drv; if (bs->locked) { return -EBUSY; } if (drv && drv->bdrv_eject) { drv->bdrv_eject(bs, eject_flag); } bs->tray_open = eject_flag; return 0;} |
0 | static struct XenDevice *xen_be_del_xendev(int dom, int dev){ struct XenDevice *xendev, *xnext; /* * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but * we save the next pointer in xnext because we might free xendev. */ xnext = xendevs.tqh_first; while (xnext) { xendev = xnext; xnext = xendev->next.tq... |
0 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, unsigned int max_pos, int depth) { AVCodecContext *acodec, *vcodec; ByteIOContext *ioc; AMFDataType amf_type; char str_val[256]; double num_val; num_val = 0; ioc = s->pb; amf_type = get_byte(ioc); switch(amf_type) { c... |
0 | static void kvm_init_irq_routing(KVMState *s){ int gsi_count; gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING); if (gsi_count > 0) { unsigned int gsi_bits, i; /* Round up so we can search ints using ffs */ gsi_bits = ALIGN(gsi_count, 32); s->used_gsi_bitmap = g_malloc0(gsi_bits / 8); s->max_gsi = gsi_bits; /* Ma... |
0 | static void uart_read_rx_fifo(UartState *s, uint32_t *c){ if ((s->r[R_CR] & UART_CR_RX_DIS) || !(s->r[R_CR] & UART_CR_RX_EN)) { return; } if (s->rx_count) { uint32_t rx_rpos = (RX_FIFO_SIZE + s->rx_wpos - s->rx_count) % RX_FIFO_SIZE; *c = s->rx_fifo[rx_rpos]; s->rx_count--; qemu_chr_accept_input(s->chr); } else { *c = ... |
0 | static void setup_frame(int sig, struct target_sigaction *ka, target_sigset_t *set, CPUAlphaState *env){ abi_ulong frame_addr, r26; struct target_sigframe *frame; int err = 0; frame_addr = get_sigframe(ka, env, sizeof(*frame)); if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { goto give_sigsegv; } err |= set... |
0 | static void spin_kick(void *data){ SpinKick *kick = data; CPUState *cpu = CPU(kick->cpu); CPUPPCState *env = &kick->cpu->env; SpinInfo *curspin = kick->spin; hwaddr map_size = 64 * 1024 * 1024; hwaddr map_start; cpu_synchronize_state(cpu); stl_p(&curspin->pir, env->spr[SPR_PIR]); env->nip = ldq_p(&curspin->addr) & (map... |
0 | static void sd_blk_write(SDState *sd, uint64_t addr, uint32_t len){ uint64_t end = addr + len; if ((addr & 511) || len < 512) if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) < 0) { fprintf(stderr, "sd_blk_write: read error on host side\n"); return; } if (end > (addr & ~511) + 512) { memcpy(sd->buf + (addr &... |
0 | static struct omap_uwire_s *omap_uwire_init(MemoryRegion *system_memory, target_phys_addr_t base, qemu_irq txirq, qemu_irq rxirq, qemu_irq dma, omap_clk clk){ struct omap_uwire_s *s = (struct omap_uwire_s *) g_malloc0(sizeof(struct omap_uwire_s)); s->txirq = txirq; s->rxirq = rxirq; s->txdrq = dma; omap_uwire_reset(s);... |
0 | static void exception_action(CPUState *cpu){#if defined(TARGET_I386) X86CPU *x86_cpu = X86_CPU(cpu); CPUX86State *env1 = &x86_cpu->env; raise_exception_err(env1, cpu->exception_index, env1->error_code);#else cpu_loop_exit(cpu);#endif} |
0 | void term_printf(const char *fmt, ...){ char buf[4096]; va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); qemu_chr_write(monitor_hd, buf, strlen(buf)); va_end(ap);} |
0 | static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf){ switch (buf[0] >> 5) { case 0: cmd->xfer = buf[4]; cmd->len = 6; break; case 1: case 2: cmd->xfer = lduw_be_p(&buf[7]); cmd->len = 10; break; case 4: cmd->xfer = ldl_be_p(&buf[10]) & 0xffffffffULL; cmd->len = 16; break; case 5: cmd->xfer = ldl... |
0 | static void draw_slice(AVFilterLink *link, int y, int h){ ScaleContext *scale = link->dst->priv; int out_h; AVFilterPicRef *cur_pic = link->cur_pic; uint8_t *data[4]; if (!scale->slice_dir) { if (y != 0 && y + h != link->h) { av_log(scale, AV_LOG_ERROR, "Slices start in the middle!\n"); return; } scale->slice_dir = y ?... |
0 | static void spapr_phb_finish_realize(sPAPRPHBState *sphb, Error **errp){ sphb->dma_window_start = 0; sphb->dma_window_size = 0x40000000; sphb->tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn, sphb->dma_window_size); if (!sphb->tcet) { error_setg(errp, "Unable to create TCE table for %s", sphb->dtbusname); retu... |
0 | static void tcx_rblit_writel(void *opaque, hwaddr addr, uint64_t val, unsigned size){ TCXState *s = opaque; uint32_t adsr, len; int i; if (!(addr & 4)) { s->tmpblit = val; } else { addr = (addr >> 3) & 0xfffff; adsr = val & 0xffffff; len = ((val >> 24) & 0x1f) + 1; if (adsr == 0xffffff) { memset(&s->vram[addr], s->tmpb... |
0 | static CharDriverState *qemu_chr_open_mux(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp){ ChardevMux *mux = backend->mux; CharDriverState *chr, *drv; MuxDriver *d; drv = qemu_chr_find(mux->chardev); if (drv == NULL) { error_setg(errp, "mux: base chardev %s not found", mux->chardev); return N... |
0 | static void pmac_ide_transfer(DBDMA_io *io){ MACIOIDEState *m = io->opaque; IDEState *s = idebus_active_if(&m->bus); MACIO_DPRINTF("\n"); s->io_buffer_size = 0; if (s->drive_kind == IDE_CD) { /* Handle non-block ATAPI DMA transfers */ if (s->lba == -1) { s->io_buffer_size = MIN(io->len, s->packet_transfer_size); block_... |
0 | static void do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data){ int index = qdict_get_int(qdict, "index"); if (mon_set_cpu(index) < 0) qemu_error_new(QERR_INVALID_CPU_INDEX);} |
0 | static int get_phys_addr_lpae(CPUARMState *env, target_ulong address, int access_type, ARMMMUIdx mmu_idx, hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot, target_ulong *page_size_ptr){ CPUState *cs = CPU(arm_env_get_cpu(env)); /* Read an LPAE long-descriptor translation table. */ MMUFaultType fault_type = translation_... |
1 | static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind, const char *name, size_t size, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); const QObject *qobj = qmp_input_get_object(qiv, name); if (!qobj || qobject_type(qobj) != QTYPE_QDICT) { error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name :... |
1 | static int join_request_frame(AVFilterLink *outlink){ AVFilterContext *ctx = outlink->src; JoinContext *s = ctx->priv; AVFilterBufferRef *buf; JoinBufferPriv *priv; int linesize = INT_MAX; int perms = ~0; int nb_samples; int i, j, ret; /* get a frame on each input */ for (i = 0; i < ctx->nb_inputs; i++) { AVFilterLink ... |
1 | static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW){ //FIXME Optimize (just quickly writen not opti..) int i; for (i=0; i<dstW; i++) { int val=1<<18; int j; ... |
1 | static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ target_ulong id, start, r3; PowerPCCPU *cpu; if (nargs != 3 || nret != 1) { rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); return; } id = rtas_ld(args, 0); start = rtas_l... |
1 | static void check_decode_result(int *got_output, int ret){ if (*got_output || ret<0) decode_error_stat[ret<0] ++; if (ret < 0 && exit_on_error) exit_program(1);} |
1 | int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, const VMStateDescription *vmsd, void *opaque, int alias_id, int required_for_version, Error **errp){ SaveStateEntry *se; /* If this triggers, alias support can be dropped for the vmsd. */ assert(alias_id == -1 || required_for_version >= vmsd->minimum... |
1 | static void test_qemu_strtoll_max(void){ const char *str = g_strdup_printf("%lld", LLONG_MAX); char f = 'X'; const char *endptr = &f; int64_t res = 999; int err; err = qemu_strtoll(str, &endptr, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, LLONG_MAX); g_assert(endptr == str + strlen(str));} |
1 | static int mace_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AVFrame *frame = data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int16_t **samples; MACEContext *ctx = avctx->priv_data; int i, j, k, l, ret; int is_mace3 = (avctx->codec_id == AV_CODEC_ID_MACE3); /... |
1 | static av_cold int rv30_decode_init(AVCodecContext *avctx){ RV34DecContext *r = avctx->priv_data; int ret; r->rv30 = 1; if ((ret = ff_rv34_decode_init(avctx)) < 0) return ret; if(avctx->extradata_size < 2){ av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n"); return -1; r->max_rpr = avctx->extradata[1] & 7; r->par... |
1 | static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *cpu_model){ unsigned int i; x86_def_t *def; char *s = g_strdup(cpu_model); char *featurestr, *name = strtok(s, ","); /* Features to be added*/ uint32_t plus_features = 0, plus_ext_features = 0; uint32_t plus_ext2_features = 0, plus_ext3_features = 0; u... |
1 | static int virtio_gpu_ui_info(void *opaque, uint32_t idx, QemuUIInfo *info){ VirtIOGPU *g = opaque; if (idx > g->conf.max_outputs) { return -1; } g->req_state[idx].x = info->xoff; g->req_state[idx].y = info->yoff; g->req_state[idx].width = info->width; g->req_state[idx].height = info->height; if (info->width && info->h... |
1 | void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); PowerPCCPU *cpu = POWERPC_CPU(core->threads); int id = ppc_get_vcpu_dt_id(cpu); sPAPRDRConnector *drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, id); sPAPRDRConnectorClass ... |
1 | static void qobject_input_check_struct(Visitor *v, Error **errp){ QObjectInputVisitor *qiv = to_qiv(v); StackObject *tos = QSLIST_FIRST(&qiv->stack); assert(tos && !tos->entry); if (qiv->strict) { GHashTable *const top_ht = tos->h; if (top_ht) { GHashTableIter iter; const char *key; g_hash_table_iter_init(&iter, top_ht... |
0 | static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size){ AVCodecContext *avctx = s->avctx; const int field_pic = s->picture_structure != PICT_FRAME; int ret; s->resync_mb_x = s->resync_mb_y = -1; assert(mb_y < s->mb_height); init_get_bits(&s->gb, *buf, buf_size * 8); ff_mpeg1_clean_... |
1 | create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern){size_t *sizes = calloc(nr_iov, sizeof(size_t));size_t count = 0;void *buf, *p;int i;for (i = 0; i < nr_iov; i++) {char *arg = argv[i];long long len;len = cvtnum(arg);if (len < 0) {printf("non-numeric length argument -- %s\n", arg);return NULL;}/* sh... |
1 | static int vid_probe(AVProbeData *p){ // little-endian VID tag, file starts with "VID\0" if (AV_RL32(p->buf) != MKTAG('V', 'I', 'D', 0)) return 0; return AVPROBE_SCORE_MAX;} |
1 | void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...)){ int i; for (i = 0; ; i++) { (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n", ppc_defs[i].name, ppc_defs[i].pvr); if (strcmp(ppc_defs[i].name, "default") == 0) break; }} |
1 | void object_delete(Object *obj){ object_unparent(obj); g_assert(obj->ref == 1); object_unref(obj); g_free(obj);} |
0 | static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ Mpeg1Context *s = avctx->priv_data; uint8_t *buf_end, *buf_ptr; int ret, start_code, input_size; AVFrame *picture = data; MpegEncContext *s2 = &s->mpeg_enc_ctx; dprintf("fill_buffer\n"); *data_size = 0; /* speci... |
1 | static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun, int evpd, int pc){ int full_size; struct scsi_task *task = NULL; task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64); if (task == NULL || task->status != SCSI_STATUS_GOOD) { goto fail; } full_size = scsi_datain_getfullsize(task); if (full_s... |
1 | static target_ulong h_add_logical_lan_buffer(CPUPPCState *env, sPAPREnvironment *spapr, target_ulong opcode, target_ulong *args){ target_ulong reg = args[0]; target_ulong buf = args[1]; VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev; vlan_bd_t bd;... |
1 | static uint32_t unassigned_mem_readw(void *opaque, target_phys_addr_t addr){#ifdef DEBUG_UNASSIGNED printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);#endif#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE) do_unassigned_access(addr, 0, 0, 0, 2);#endif return 0;} |
0 | static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ int n, c, sample_size, v, ret; const short *samples; unsigned char *dst; const uint8_t *samples_uint8_t; const int16_t *samples_int16_t; const int32_t *samples_int32_t; const int64_t *samples_int64_t; const u... |
0 | static int RENAME(epzs_motion_search)(MpegEncContext * s, int *mx_ptr, int *my_ptr, int P[10][2], int pred_x, int pred_y, uint8_t *src_data[3], uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2], int ref_mv_scale, uint8_t * const mv_penalty){ int best[2]={0, 0}; int d, dmin; const int shift= 1+s->qua... |
1 | static void megasas_complete_frame(MegasasState *s, uint64_t context){ PCIDevice *pci_dev = PCI_DEVICE(s); int tail, queue_offset; /* Decrement busy count */ s->busy--; if (s->reply_queue_pa) { /* * Put command on the reply queue. * Context is opaque, but emulation is running in * little endian. So convert it. */ tail ... |
1 | static int decode_residual_block(AVSContext *h, GetBitContext *gb, const dec_2dvlc_t *r, int esc_golomb_order, int qp, uint8_t *dst, int stride) { int i, level_code, esc_code, level, run, mask; DCTELEM level_buf[64]; uint8_t run_buf[64]; DCTELEM *block = h->block; for(i=0;i<65;i++) { level_code = get_ue_code(gb,r->golo... |
1 | int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt){ FrameThreadContext *fctx = avctx->internal->thread_ctx; int finished = fctx->next_finished; PerThreadContext *p; int err; /* release the async lock, permitting blocked hwaccel threads to * go forward while we are... |
1 | static void gen_tlbld_6xx(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } gen_helper_6xx_tlbd(cpu_env, cpu_gpr[rB(ctx->opcode)]);#endif} |
1 | static int ehci_process_itd(EHCIState *ehci, EHCIitd *itd){ USBDevice *dev; USBEndpoint *ep; int ret; uint32_t i, len, pid, dir, devaddr, endp; uint32_t pg, off, ptr1, ptr2, max, mult; dir =(itd->bufptr[1] & ITD_BUFPTR_DIRECTION); devaddr = get_field(itd->bufptr[0], ITD_BUFPTR_DEVADDR); endp = get_field(itd->bufptr[0],... |
0 | static int swf_probe(AVProbeData *p){ /* check file header */ if (p->buf_size <= 16) return 0; if ((p->buf[0] == 'F' || p->buf[0] == 'C') && p->buf[1] == 'W' && p->buf[2] == 'S') return AVPROBE_SCORE_MAX; else return 0;} |
0 | static int16_t *precalc_coefs(double dist25, int depth){ int i; double gamma, simil, C; int16_t *ct = av_malloc((512<<LUT_BITS)*sizeof(int16_t)); if (!ct) return NULL; gamma = log(0.25) / log(1.0 - FFMIN(dist25,252.0)/255.0 - 0.00001); for (i = -255<<LUT_BITS; i <= 255<<LUT_BITS; i++) { double f = ((i<<(9-LUT_BITS)) + ... |
0 | static void avc_biwgt_4x2_msa(uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t log2_denom, int32_t src_weight, int32_t dst_weight, int32_t offset_in){ uint32_t load0, load1, out0, out1; v16i8 src_wgt, dst_wgt, wgt; v16i8 src0, src1, dst0, dst1; v8i16 temp0, temp1, denom, offset, add_val; int3... |
1 | static int asf_read_value(AVFormatContext *s, uint8_t *name, uint16_t name_len, uint16_t val_len, int type, AVDictionary **met){ int ret; uint8_t *value; uint16_t buflen = 2 * val_len + 1; AVIOContext *pb = s->pb; value = av_malloc(buflen); if (!value) return AVERROR(ENOMEM); if (type == ASF_UNICODE) { // get_asf_strin... |
1 | static int vdi_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix){ /* TODO: additional checks possible. */ BDRVVdiState *s = (BDRVVdiState *)bs->opaque; uint32_t blocks_allocated = 0; uint32_t block; uint32_t *bmap; logout("\n"); if (fix) { return -ENOTSUP; } bmap = g_try_malloc(s->header.blocks_in_im... |
1 | static void uart_write(void *opaque, hwaddr addr, uint64_t value, unsigned size){ LM32UartState *s = opaque; unsigned char ch = value; trace_lm32_uart_memory_write(addr, value); addr >>= 2; switch (addr) { case R_RXTX: if (s->chr) { qemu_chr_fe_write_all(s->chr, &ch, 1); } break; case R_IER: case R_LCR: case R_MCR: cas... |
1 | static void test_opts_parse_size(void){ Error *err = NULL; QemuOpts *opts; /* Lower limit zero */ opts = qemu_opts_parse(&opts_list_02, "size1=0", false, &error_abort); g_assert_cmpuint(opts_count(opts), ==, 1); g_assert_cmpuint(qemu_opt_get_size(opts, "size1", 1), ==, 0); /* Note: precision is 53 bits since we're pars... |
1 | static int usbredir_post_load(void *priv, int version_id){ USBRedirDevice *dev = priv; switch (dev->device_info.speed) { case usb_redir_speed_low: dev->dev.speed = USB_SPEED_LOW; break; case usb_redir_speed_full: dev->dev.speed = USB_SPEED_FULL; break; case usb_redir_speed_high: dev->dev.speed = USB_SPEED_HIGH; break; ... |
1 | static void smc_decode_stream(SmcContext *s){ int width = s->avctx->width; int height = s->avctx->height; int stride = s->frame.linesize[0]; int i; int stream_ptr = 0; int chunk_size; unsigned char opcode; int n_blocks; unsigned int color_flags; unsigned int color_flags_a; unsigned int color_flags_b; unsigned int flag_... |
1 | static void vhost_scsi_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); dc->exit = vhost_scsi_exit; dc->props = vhost_scsi_properties; set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); vdc->init = vhost_scsi_init; vdc->get_features =... |
1 | ivshmem_client_parse_args(IvshmemClientArgs *args, int argc, char *argv[]){ int c; while ((c = getopt(argc, argv, "h" /* help */ "v" /* verbose */ "S:" /* unix_sock_path */ )) != -1) { switch (c) { case 'h': /* help */ ivshmem_client_usage(argv[0], 0); break; case 'v': /* verbose */ args->verbose = 1; break; case 'S': ... |
1 | static int estimate_sid_gain(G723_1_Context *p){ int i, shift, seg, seg2, t, val, val_add, x, y; shift = 16 - p->cur_gain * 2; if (shift > 0) t = p->sid_gain << shift; else t = p->sid_gain >> -shift; x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16); if (x >= cng_bseg[2]) return 0x3F; if (x >= cng_bseg[1]) { shift = 4... |
1 | static int decode_exp_vlc(WMACodecContext *s, int ch){ int last_exp, n, code; const uint16_t *ptr; float v, max_scale; uint32_t *q, *q_end, iv; const float *ptab = pow_tab + 60; const uint32_t *iptab = (const uint32_t*)ptab; ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; q = (uint32_t *)s->exponents[ch... |
1 | static int decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ BC_STATUS ret; BC_DTS_STATUS decoder_status; CopyRet rec_ret; CHDContext *priv = avctx->priv_data; HANDLE dev = priv->dev; int len = avpkt->size; uint8_t pic_type = 0; av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_frame\n"); if (l... |
1 | static int au_read_packet(AVFormatContext *s, AVPacket *pkt){ int ret; ret= av_get_packet(s->pb, pkt, BLOCK_SIZE * s->streams[0]->codec->channels * av_get_bits_per_sample(s->streams[0]->codec->codec_id) >> 3); if (ret < 0) return ret; pkt->stream_index = 0; /* note: we need to modify the packet size here to handle the ... |
0 | static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track){ int tag = track->enc->codec_tag; if (track->mode == MODE_MP4 || track->mode == MODE_PSP) { if (!codec_get_tag(ff_mp4_obj_type, track->enc->codec_id)) return 0; if (track->enc->codec_id == CODEC_ID_H264) tag = MKTAG('a','v','c','1'); else if (track->enc... |
0 | static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx){ NvencContext *ctx = avctx->priv_data; if (avctx->bit_rate > 0) { ctx->encode_config.rcParams.averageBitRate = avctx->bit_rate; } else if (ctx->encode_config.rcParams.averageBitRate > 0) { ctx->encode_config.rcParams.maxBitRate = ctx->encode_config.rcP... |
0 | int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ RV34DecContext *r = avctx->priv_data; MpegEncContext *s = &r->s; AVFrame *pict = data; SliceInfo si; int i; int slice_count; uint8_t *slices_hdr = NULL; int last = 0; /* no supplementary picture */ if (buf_size == 0... |
0 | static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh){ int x, y, Y, U, V, A; uint8_t *lum, *cb, *cr; int dstx, dsty, dstw, dsth; const AVPicture *src = &rect->pict; dstw = av_clip(rect->w, 0, imgw); dsth = av_clip(rect->h, 0, imgh); dstx = av_clip(rect->x, 0, imgw - dstw); dsty = av_... |
0 | int avio_read_partial(AVIOContext *s, unsigned char *buf, int size){ int len; if (size < 0) return -1; if (s->read_packet && s->write_flag) { len = s->read_packet(s->opaque, buf, size); if (len > 0) s->pos += len; return len; } len = s->buf_end - s->buf_ptr; if (len == 0) { /* Reset the buf_end pointer to the start of ... |
0 | static int sp5x_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){#if 0 MJpegDecodeContext *s = avctx->priv_data;#endif const int qscale = 5; uint8_t *buf_ptr, *buf_end, *recoded; int i = 0, j = 0; /* no supplementary picture */ if (buf_size == 0) return 0; if (!avctx->width ||... |
0 | float32 helper_fdtos(CPUSPARCState *env, float64 src){ float32 ret; clear_float_exceptions(env); ret = float64_to_float32(src, &env->fp_status); check_ieee_exceptions(env); return ret;} |
0 | static void icp_control_init(target_phys_addr_t base){ MemoryRegion *io; io = (MemoryRegion *)g_malloc0(sizeof(MemoryRegion)); memory_region_init_io(io, &icp_control_ops, NULL, "control", 0x00800000); memory_region_add_subregion(get_system_memory(), base, io); /* ??? Save/restore. */} |
0 | gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); DisasContext ctx; target_ulong pc_start; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj = -1; CPUMoxieState *env = &cpu->env; int num_insns; pc_start = tb->pc; gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_S... |
0 | USBBus *usb_bus_find(int busnr){ USBBus *bus; if (-1 == busnr) return TAILQ_FIRST(&busses); TAILQ_FOREACH(bus, &busses, next) { if (bus->busnr == busnr) return bus; } return NULL;} |
0 | vreader_copy_list(VReaderList *list){ VReaderList *new_list = NULL; VReaderListEntry *current_entry = NULL; new_list = vreader_list_new(); if (new_list == NULL) { return NULL; } for (current_entry = vreader_list_get_first(list); current_entry; current_entry = vreader_list_get_next(current_entry)) { VReader *reader = vr... |
0 | static int cow_find_streak(const uint8_t *bitmap, int value, int start, int nb_sectors){ int streak_value = value ? 0xFF : 0; int last = MIN(start + nb_sectors, BITS_PER_BITMAP_SECTOR); int bitnum = start; while (bitnum < last) { if ((bitnum & 7) == 0 && bitmap[bitnum / 8] == streak_value) { bitnum += 8; continue; } if... |
0 | static int raw_read_options(QDict *options, BlockDriverState *bs, BDRVRawState *s, Error **errp){ Error *local_err = NULL; QemuOpts *opts = NULL; int64_t real_size = 0; int ret; real_size = bdrv_getlength(bs->file->bs); if (real_size < 0) { error_setg_errno(errp, -real_size, "Could not get image size"); return real_siz... |
0 | static inline void RENAME(hyscale_fast)(SwsContext *c, int16_t *dst, long dstWidth, const uint8_t *src, int srcW, int xInc){#if ARCH_X86#if COMPILE_TEMPLATE_MMX2 int32_t *filterPos = c->hLumFilterPos; int16_t *filter = c->hLumFilter; int canMMX2BeUsed = c->canMMX2BeUsed; void *mmx2FilterCode= c->lumMmx2FilterCode; int ... |
0 | bool memory_region_is_skip_dump(MemoryRegion *mr){ return mr->skip_dump;} |
0 | static ssize_t nbd_send_reply(int csock, struct nbd_reply *reply){ uint8_t buf[4 + 4 + 8]; /* Reply [ 0 .. 3] magic (NBD_REPLY_MAGIC) [ 4 .. 7] error (0 == no error) [ 7 .. 15] handle */ cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC); cpu_to_be32w((uint32_t*)(buf + 4), reply->error); cpu_to_be64w((uint64_t*)(buf + 8), r... |
0 | static void switch_tss(CPUX86State *env, int tss_selector, uint32_t e1, uint32_t e2, int source, uint32_t next_eip){ int tss_limit, tss_limit_max, type, old_tss_limit_max, old_type, v1, v2, i; target_ulong tss_base; uint32_t new_regs[8], new_segs[6]; uint32_t new_eflags, new_eip, new_cr3, new_ldt, new_trap; uint32_t ol... |
0 | void kvmppc_read_hptes(ppc_hash_pte64_t *hptes, hwaddr ptex, int n){ int fd, rc; int i; fd = kvmppc_get_htab_fd(false, ptex, &error_abort); i = 0; while (i < n) { struct kvm_get_htab_header *hdr; int m = n < HPTES_PER_GROUP ? n : HPTES_PER_GROUP; char buf[sizeof(*hdr) + m * HASH_PTE_SIZE_64]; rc = read(fd, buf, sizeof(... |
0 | void qmp_output_visitor_cleanup(QmpOutputVisitor *v){ QStackEntry *e, *tmp; QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) { QTAILQ_REMOVE(&v->stack, e, node); g_free(e); } qobject_decref(v->root); g_free(v);} |
0 | static int check_host_key(BDRVSSHState *s, const char *host, int port, const char *host_key_check){ /* host_key_check=no */ if (strcmp(host_key_check, "no") == 0) { return 0; } /* host_key_check=md5:xx:yy:zz:... */ if (strncmp(host_key_check, "md5:", 4) == 0) { return check_host_key_hash(s, &host_key_check[4], LIBSSH2_... |
0 | void memory_region_notify_iommu(MemoryRegion *mr, IOMMUTLBEntry entry){ IOMMUNotifier *iommu_notifier; IOMMUNotifierFlag request_flags; assert(memory_region_is_iommu(mr)); if (entry.perm & IOMMU_RW) { request_flags = IOMMU_NOTIFIER_MAP; } else { request_flags = IOMMU_NOTIFIER_UNMAP; } IOMMU_NOTIFIER_FOREACH(iommu_notif... |
0 | static IOWatchPoll *io_watch_poll_from_source(GSource *source){ IOWatchPoll *i; QTAILQ_FOREACH(i, &io_watch_poll_list, node) { if (i->src == source) { return i; } } return NULL;} |
0 | void memory_region_init_io(MemoryRegion *mr, Object *owner, const MemoryRegionOps *ops, void *opaque, const char *name, uint64_t size){ memory_region_init(mr, owner, name, size); mr->ops = ops; mr->opaque = opaque; mr->terminates = true; mr->ram_addr = ~(ram_addr_t)0;} |
0 | static void filter_mb( H264Context *h, int mb_x, int mb_y ) { MpegEncContext * const s = &h->s; const int mb_xy= mb_x + mb_y*s->mb_stride; uint8_t *img_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; uint8_t *img_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; uint8_t *i... |
1 | void mpeg_motion_internal(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, op_pixels_func (*pix_op)[4], int motion_x, int motion_y, int h, int is_mpeg12, int mb_y){ uint8_t *ptr_y, *ptr_cb, *ptr_cr; int dxy, uvdxy, mx, my... |
1 | static void i6300esb_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->config_read = i6300esb_config_read; k->config_write = i6300esb_config_write; k->realize = i6300esb_realize; k->vendor_id = PCI_VENDOR_ID_INTEL; k->device_id = PCI_DEVIC... |
1 | BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs, QEMUWin32AIOState *aio, HANDLE hfile, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int type){ struct QEMUWin32AIOCB *waiocb; uint64_t offset = sector_num * 512; DWORD rc; waiocb = qemu_aio_get(&win32_aiocb_i... |
1 | static av_cold int vp9_decode_free(AVCodecContext *ctx){ VP9Context *s = ctx->priv_data; int i; for (i = 0; i < 2; i++) { if (s->frames[i].tf.f->data[0]) vp9_unref_frame(ctx, &s->frames[i]); av_frame_free(&s->frames[i].tf.f); } for (i = 0; i < 8; i++) { if (s->refs[i].f->data[0]) ff_thread_release_buffer(ctx, &s->refs[... |
1 | static int sd_create(const char *filename, QemuOpts *opts, Error **errp){ int ret = 0; uint32_t vid = 0; char *backing_file = NULL; char *buf = NULL; BDRVSheepdogState *s; char tag[SD_MAX_VDI_TAG_LEN]; uint32_t snapid; bool prealloc = false; s = g_malloc0(sizeof(BDRVSheepdogState)); memset(tag, 0, sizeof(tag)); if (str... |
1 | static void ics_base_realize(DeviceState *dev, Error **errp){ ICSStateClass *icsc = ICS_BASE_GET_CLASS(dev); ICSState *ics = ICS_BASE(dev); Object *obj; Error *err = NULL; obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err); if (!obj) { error_setg(errp, "%s: required link '" ICS_PROP_XICS "' not found: %s"... |
1 | static int ffm_read_header(AVFormatContext *s){ FFMContext *ffm = s->priv_data; AVStream *st; AVIOContext *pb = s->pb; AVCodecContext *codec; const AVCodecDescriptor *codec_desc; int i, nb_streams; uint32_t tag; /* header */ tag = avio_rl32(pb); if (tag == MKTAG('F', 'F', 'M', '2')) return ffm2_read_header(s); if (tag ... |
1 | static void shpc_interrupt_update(PCIDevice *d){ SHPCDevice *shpc = d->shpc; int slot; int level = 0; uint32_t serr_int; uint32_t int_locator = 0; /* Update interrupt locator register */ for (slot = 0; slot < shpc->nslots; ++slot) { uint8_t event = shpc->config[SHPC_SLOT_EVENT_LATCH(slot)]; uint8_t disable = shpc->conf... |
1 | static void usb_mtp_command(MTPState *s, MTPControl *c){ MTPData *data_in = NULL; MTPObject *o; uint32_t nres = 0, res0 = 0; /* sanity checks */ if (c->code >= CMD_CLOSE_SESSION && s->session == 0) { usb_mtp_queue_result(s, RES_SESSION_NOT_OPEN, c->trans, 0, 0, 0); return; } /* process commands */ switch (c->code) { ca... |
1 | static int sdp_read_header(AVFormatContext *s){ RTSPState *rt = s->priv_data; RTSPStream *rtsp_st; int size, i, err; char *content; char url[1024]; if (!ff_network_init()) return AVERROR(EIO); if (s->max_delay < 0) /* Not set by the caller */ s->max_delay = DEFAULT_REORDERING_DELAY; if (rt->rtsp_flags & RTSP_FLAG_CUSTO... |
1 | static inline void gen_op_mfspr(DisasContext *ctx){ void (*read_cb)(void *opaque, int gprn, int sprn); uint32_t sprn = SPR(ctx->opcode);#if !defined(CONFIG_USER_ONLY) if (ctx->mem_idx == 2) read_cb = ctx->spr_cb[sprn].hea_read; else if (ctx->mem_idx) read_cb = ctx->spr_cb[sprn].oea_read; else#endif read_cb = ctx->spr_c... |
1 | static int mov_create_chapter_track(AVFormatContext *s, int tracknum){ MOVMuxContext *mov = s->priv_data; MOVTrack *track = &mov->tracks[tracknum]; AVPacket pkt = { .stream_index = tracknum, .flags = AV_PKT_FLAG_KEY }; int i, len; // These properties are required to make QT recognize the chapter track uint8_t chapter_p... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.