label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void ivshmem_check_version(void *opaque, const uint8_t * buf, int size){ IVShmemState *s = opaque; int tmp; int64_t version; if (!fifo_update_and_get_i64(s, buf, size, &version)) { return; } tmp = qemu_chr_fe_get_msgfd(s->server_chr); if (tmp != -1 || version != IVSHMEM_PROTOCOL_VERSION) { fprintf(stderr, "incom... |
1 | static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof){ AVIOContext *pb = s->pb; char abss[24]; int hour, min, sec, i, ret, config; int dsd_layout[6]; ID3v2ExtraMeta *id3v2_extra_meta; while (avio_tell(pb) + 12 <= eof) { uint32_t tag = avio_rl32(pb); uint64_t size = avio_rb64(pb); uint64_t orig_pos =... |
0 | static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st, uint8_t *buf, int buf_size){ RTSPState *rt = s->priv_data; int id, len, i, ret; RTSPStream *rtsp_st;#ifdef DEBUG_RTP_TCP dprintf(s, "tcp_read_packet:\n");#endif redo: for(;;) { RTSPMessageHeader reply; ret = rtsp_read_reply(s, &reply, NULL, 1); if (r... |
1 | static int read_ts(const char *s, int64_t *start, int *duration){ int64_t end; int hh1, mm1, ss1, ms1; int hh2, mm2, ss2, ms2; if (sscanf(s, "%u:%u:%u.%u,%u:%u:%u.%u", &hh1, &mm1, &ss1, &ms1, &hh2, &mm2, &ss2, &ms2) == 8) { end = (hh2*3600 + mm2*60 + ss2) * 100 + ms2; *start = (hh1*3600 + mm1*60 + ss1) * 100 + ms1; *du... |
1 | static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap){ RMContext *rm = s->priv_data; AVStream *st; rm->old_format = 1; st = av_new_stream(s, 0); if (!st) goto fail; rm_read_audio_stream_info(s, st, 1); return 0; fail: return -1;} |
1 | static void alloc_aio_bitmap(BlkMigDevState *bmds){ BlockDriverState *bs = bmds->bs; int64_t bitmap_size; bitmap_size = bdrv_nb_sectors(bs) + BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; bmds->aio_bitmap = g_malloc0(bitmap_size);} |
1 | static uint8_t *xen_map_cache_unlocked(hwaddr phys_addr, hwaddr size, uint8_t lock, bool dma){ MapCacheEntry *entry, *pentry = NULL; hwaddr address_index; hwaddr address_offset; hwaddr cache_size = size; hwaddr test_bit_size; bool translated G_GNUC_UNUSED = false; bool dummy = false;tryagain: address_index = phys_addr ... |
1 | static void disas_arm_insn(CPUARMState * 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 = arm_ldl_code(env, s->pc, s->bswap_code); s->pc += 4; /* M variants do not implement ARM mode. */ if (IS_M(env)) goto illegal_... |
1 | static const uint8_t *pcx_rle_decode(const uint8_t *src, uint8_t *dst, unsigned int bytes_per_scanline, int compressed) { unsigned int i = 0; unsigned char run, value; if (compressed) { while (i<bytes_per_scanline) { run = 1; value = *src++; if (value >= 0xc0) { run = value & 0x3f; value = *src++; } while (i<bytes_per_... |
1 | static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs){ uint64_t reqid = request_id++; int ret = bdrv_co_flush(bs->file->bs); block_request_create(reqid, bs, qemu_coroutine_self()); qemu_coroutine_yield(); return ret;} |
1 | USBDevice *usb_net_init(NICInfo *nd){ USBNetState *s; s = qemu_mallocz(sizeof(USBNetState)); s->dev.speed = USB_SPEED_FULL; s->dev.handle_packet = usb_generic_handle_packet; s->dev.handle_reset = usb_net_handle_reset; s->dev.handle_control = usb_net_handle_control; s->dev.handle_data = usb_net_handle_data; s->dev.handl... |
1 | x11grab_read_header(AVFormatContext *s1){ struct x11_grab *x11grab = s1->priv_data; Display *dpy; AVStream *st = NULL; enum PixelFormat input_pixfmt; XImage *image; int x_off = 0; int y_off = 0; int screen; int use_shm; char *param, *offset; int ret = 0; AVRational framerate; param = av_strdup(s1->filename); if (!param... |
1 | static int mpc7_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t * buf, int buf_size){ MPCContext *c = avctx->priv_data; GetBitContext gb; uint8_t *bits; int i, j, ch, t; int mb = -1; Band bands[BANDS]; int Q[2][MPC_FRAME_SIZE]; int off; float mul; int bits_used, bits_avail; memset(bands, 0, siz... |
1 | void register_avcodec(AVCodec *codec){ AVCodec **p; p = &first_avcodec; while (*p != NULL) p = &(*p)->next; *p = codec; codec->next = NULL;} |
1 | static int uhci_broadcast_packet(UHCIState *s, USBPacket *p){ int i, ret; DPRINTF("uhci: packet enter. pid %s addr 0x%02x ep %d len %d\n", pid2str(p->pid), p->devaddr, p->devep, p->len); if (p->pid == USB_TOKEN_OUT || p->pid == USB_TOKEN_SETUP) dump_data(p->data, p->len); ret = USB_RET_NODEV; for (i = 0; i < NB_PORTS &... |
1 | static int vfio_early_setup_msix(VFIOPCIDevice *vdev){ uint8_t pos; uint16_t ctrl; uint32_t table, pba; int fd = vdev->vbasedev.fd; pos = pci_find_capability(&vdev->pdev, PCI_CAP_ID_MSIX); if (!pos) { return 0; } if (pread(fd, &ctrl, sizeof(ctrl), vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) { return -er... |
1 | static int local_mkdir(FsContext *fs_ctx, const char *path, FsCred *credp){ int err = -1; int serrno = 0; /* Determine the security model */ if (fs_ctx->fs_sm == SM_MAPPED) { err = mkdir(rpath(fs_ctx, path), SM_LOCAL_DIR_MODE_BITS); if (err == -1) { return err; } credp->fc_mode = credp->fc_mode|S_IFDIR; err = local_set... |
1 | static int pmp_header(AVFormatContext *s){ PMPContext *pmp = s->priv_data; AVIOContext *pb = s->pb; int tb_num, tb_den; uint32_t index_cnt; int audio_codec_id = AV_CODEC_ID_NONE; int srate, channels; int i; uint64_t pos; int64_t fsize = avio_size(pb); AVStream *vst = avformat_new_stream(s, NULL); if (!vst) return AVERR... |
1 | cpu_x86_dump_seg_cache(CPUX86State *env, FILE *f, fprintf_function cpu_fprintf, const char *name, struct SegmentCache *sc){#ifdef TARGET_X86_64 if (env->hflags & HF_CS64_MASK) { cpu_fprintf(f, "%-3s=%04x %016" PRIx64 " %08x %08x", name, sc->selector, sc->base, sc->limit, sc->flags & 0x00ffff00); } else#endif { cpu_fpri... |
1 | static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data){ int tileno, ret; J2kEncoderContext *s = avctx->priv_data; // init: s->buf = s->buf_start = buf; s->buf_end = buf + buf_size; s->picture = data; s->lambda = s->picture->quality * LAMBDA_SCALE; copy_frame(s); reinit(s); if (s->buf_end... |
1 | void do_POWER_divs (void){ if ((Ts0 == INT32_MIN && Ts1 == -1) || Ts1 == 0) { T0 = (long)((-1) * (T0 >> 31)); env->spr[SPR_MQ] = 0; } else { env->spr[SPR_MQ] = T0 % T1; T0 = Ts0 / Ts1; }} |
1 | static void vqa_decode_chunk(VqaContext *s){ unsigned int chunk_type; unsigned int chunk_size; int byte_skip; unsigned int index = 0; int i; unsigned char r, g, b; int index_shift; int cbf0_chunk = -1; int cbfz_chunk = -1; int cbp0_chunk = -1; int cbpz_chunk = -1; int cpl0_chunk = -1; int cplz_chunk = -1; int vptz_chun... |
1 | int decode_luma_intra_block(VC9Context *v, int mquant){ GetBitContext *gb = &v->s.gb; int dcdiff; dcdiff = get_vlc2(gb, v->luma_dc_vlc->table, DC_VLC_BITS, 2); if (dcdiff) { if (dcdiff == 119 /* ESC index value */) { /* TODO: Optimize */ if (mquant == 1) dcdiff = get_bits(gb, 10); else if (mquant == 2) dcdiff = get_bit... |
1 | static uint32_t nvic_readl(NVICState *s, uint32_t offset, MemTxAttrs attrs){ ARMCPU *cpu = s->cpu; uint32_t val; switch (offset) { case 4: /* Interrupt Control Type. */ return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1; case 0x380 ... 0x3bf: /* NVIC_ITNS<n> */ { int startvec = 32 * (offset - 0x380) + NVIC_FIRST_IRQ; int ... |
0 | static int init_opencl_env(GPUEnv *gpu_env, AVOpenCLExternalEnv *ext_opencl_env){ size_t device_length; cl_int status; cl_uint num_platforms, num_devices; cl_platform_id *platform_ids = NULL; cl_context_properties cps[3]; char platform_name[100]; int i, ret = 0; cl_device_type device_type[] = {CL_DEVICE_TYPE_GPU, CL_DE... |
1 | static int vhost_user_call(struct vhost_dev *dev, unsigned long int request, void *arg){ VhostUserMsg msg; VhostUserRequest msg_request; struct vhost_vring_file *file = 0; int need_reply = 0; int fds[VHOST_MEMORY_MAX_NREGIONS]; int i, fd; size_t fd_num = 0; assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER... |
1 | static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp){ uint64_t magic; uint32_t opt; uint32_t type; uint32_t len; uint32_t namelen; *name = NULL; if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) { error_setg(errp, "failed to read list option magic"); return -1; } magic = be64_to_cpu(magic);... |
1 | int64_t throttle_compute_wait(LeakyBucket *bkt){ double extra; /* the number of extra units blocking the io */ double bucket_size; /* I/O before throttling to bkt->avg */ double burst_bucket_size; /* Before throttling to bkt->max */ if (!bkt->avg) { return 0; } if (!bkt->max) { /* If bkt->max is 0 we still want to allo... |
1 | static uint64_t pci_host_data_read(void *opaque, hwaddr addr, unsigned len){ PCIHostState *s = opaque; uint32_t val; if (!(s->config_reg & (1 << 31))) return 0xffffffff; val = pci_data_read(s->bus, s->config_reg | (addr & 3), len); PCI_DPRINTF("read addr " TARGET_FMT_plx " len %d val %x\n", addr, len, val); return val;... |
1 | static void test_tco_timeout(void){ TestData d; const uint16_t ticks = TCO_SECS_TO_TICKS(4); uint32_t val; int ret; d.args = NULL; d.noreboot = true; test_init(&d); stop_tco(&d); clear_tco_status(&d); reset_on_second_timeout(false); set_tco_timeout(&d, ticks); load_tco(&d); start_tco(&d); clock_step(ticks * TCO_TICK_NS... |
0 | hwaddr memory_region_section_get_iotlb(CPUArchState *env, MemoryRegionSection *section, target_ulong vaddr, hwaddr paddr, hwaddr xlat, int prot, target_ulong *address){ hwaddr iotlb; CPUWatchpoint *wp; if (memory_region_is_ram(section->mr)) { /* Normal RAM. */ iotlb = (memory_region_get_ram_addr(section->mr) & TARGET_P... |
0 | static inline void gen_op_eval_fbule(TCGv dst, TCGv src, unsigned int fcc_offset){ gen_mov_reg_FCC0(dst, src, fcc_offset); tcg_gen_xori_tl(dst, dst, 0x1); gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset); tcg_gen_and_tl(dst, dst, cpu_tmp0); tcg_gen_xori_tl(dst, dst, 0x1);} |
0 | PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size){ PXA2xxState *s; int i; DriveInfo *dinfo; s = g_new0(PXA2xxState, 1); s->cpu = cpu_arm_init("pxa255"); if (s->cpu == NULL) { fprintf(stderr, "Unable to find CPU definition\n"); exit(1); } s->reset = qemu_allocate_irq(pxa2xx_reset, s, 0); /* ... |
0 | static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags){ uint8_t type, q, width, height; const uint8_t *qtables = NULL; uint16_t qtable_len; uint32_t off; int ret; if (len < 8) { av_log(ctx, AV_LOG_E... |
0 | int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr){#if defined(KVM_CAP_MCE) struct kvm_x86_mce mce = { .bank = 9, }; void *vaddr; ram_addr_t ram_addr; target_phys_addr_t paddr; int r; if ((env->mcg_cap & MCG_SER_P) && addr && (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) { if (code == BUS_MCEERR_AR) { /* F... |
0 | int kvm_has_pit_state2(void){ return 0;} |
0 | void mcf_fec_init(MemoryRegion *sysmem, NICInfo *nd, target_phys_addr_t base, qemu_irq *irq){ mcf_fec_state *s; qemu_check_nic_model(nd, "mcf_fec"); s = (mcf_fec_state *)g_malloc0(sizeof(mcf_fec_state)); s->sysmem = sysmem; s->irq = irq; memory_region_init_io(&s->iomem, &mcf_fec_ops, s, "fec", 0x400); memory_region_add... |
0 | static void dec10_reg_scc(DisasContext *dc){ int cond = dc->dst; LOG_DIS("s%s $r%u\n", cc_name(cond), dc->src); if (cond != CC_A) { int l1; gen_tst_cc (dc, cpu_R[dc->src], cond); l1 = gen_new_label(); tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_R[dc->src], 0, l1); tcg_gen_movi_tl(cpu_R[dc->src], 1); gen_set_label(l1); } else {... |
0 | void armv7m_nvic_acknowledge_irq(void *opaque){ NVICState *s = (NVICState *)opaque; CPUARMState *env = &s->cpu->env; const int pending = s->vectpending; const int running = nvic_exec_prio(s); int pendgroupprio; VecInfo *vec; assert(pending > ARMV7M_EXCP_RESET && pending < s->num_irq); vec = &s->vectors[pending]; assert... |
0 | static CharDriverState *text_console_init(ChardevVC *vc){ CharDriverState *chr; QemuConsole *s; unsigned width = 0; unsigned height = 0; chr = g_malloc0(sizeof(CharDriverState)); if (vc->has_width) { width = vc->width; } else if (vc->has_cols) { width = vc->cols * FONT_WIDTH; } if (vc->has_height) { height = vc->height... |
0 | static char *spapr_vio_get_dev_name(DeviceState *qdev){ VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev); VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); char *name; /* Device tree style name device@reg */ name = g_strdup_printf("%s@%x", pc->dt_name, dev->reg); return name;} |
0 | static int64_t migration_get_rate_limit(void *opaque){ MigrationState *s = opaque; return s->xfer_limit;} |
0 | static uint64_t pci_read(void *opaque, hwaddr addr, unsigned int size){ AcpiPciHpState *s = opaque; uint32_t val = 0; int bsel = s->hotplug_select; if (bsel < 0 || bsel > ACPI_PCIHP_MAX_HOTPLUG_BUS) { return 0; } switch (addr) { case PCI_UP_BASE - PCI_HOTPLUG_ADDR: /* Manufacture an "up" value to cause a device check o... |
0 | rdt_new_extradata (void){ PayloadContext *rdt = av_mallocz(sizeof(PayloadContext)); av_open_input_stream(&rdt->rmctx, NULL, "", &rdt_demuxer, NULL); return rdt;} |
0 | BlockInfoList *qmp_query_block(Error **errp){ BlockInfoList *head = NULL, **p_next = &head; BlockBackend *blk; Error *local_err = NULL; for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { BlockInfoList *info = g_malloc0(sizeof(*info)); bdrv_query_info(blk, &info->value, &local_err); if (local_err) { error_propagate(... |
0 | static int vhdx_create_new_region_table(BlockDriverState *bs, uint64_t image_size, uint32_t block_size, uint32_t sector_size, uint32_t log_size, bool use_zero_blocks, VHDXImageType type, uint64_t *metadata_offset){ int ret = 0; uint32_t offset = 0; void *buffer = NULL; uint64_t bat_file_offset; uint32_t bat_length; BDR... |
0 | void s390_cpu_do_interrupt(CPUState *cs){ S390CPU *cpu = S390_CPU(cs); CPUS390XState *env = &cpu->env; qemu_log_mask(CPU_LOG_INT, "%s: %d at pc=%" PRIx64 "\n", __func__, cs->exception_index, env->psw.addr); s390_cpu_set_state(CPU_STATE_OPERATING, cpu); /* handle machine checks */ if ((env->psw.mask & PSW_MASK_MCHECK) &... |
0 | static int handle_primary_tcp_pkt(NetFilterState *nf, Connection *conn, Packet *pkt){ struct tcphdr *tcp_pkt; tcp_pkt = (struct tcphdr *)pkt->transport_header; if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) { trace_colo_filter_rewriter_pkt_info(__func__, inet_ntoa(pkt->ip->ip_src), inet_ntoa(pkt->ip->ip_d... |
0 | static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result){ BDRVQEDState *s = bs->opaque; return qed_check(s, result, false);} |
0 | static void q35_host_initfn(Object *obj){ Q35PCIHost *s = Q35_HOST_DEVICE(obj); PCIHostState *phb = PCI_HOST_BRIDGE(obj); memory_region_init_io(&phb->conf_mem, obj, &pci_host_conf_le_ops, phb, "pci-conf-idx", 4); memory_region_init_io(&phb->data_mem, obj, &pci_host_data_le_ops, phb, "pci-conf-data", 4); object_initiali... |
0 | static PXBDev *convert_to_pxb(PCIDevice *dev){ return pci_bus_is_express(dev->bus) ? PXB_PCIE_DEV(dev) : PXB_DEV(dev);} |
1 | static void ivshmem_common_realize(PCIDevice *dev, Error **errp){ IVShmemState *s = IVSHMEM_COMMON(dev); Error *err = NULL; uint8_t *pci_conf; uint8_t attr = PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_PREFETCH; Error *local_err = NULL; /* IRQFD requires MSI */ if (ivshmem_has_feature(s, IVSHMEM_IOEVENTFD) && ... |
1 | int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt){ AVCodecInternal *avci = avctx->internal; int planar, channels; int ret = 0; *got_frame_ptr = 0; avctx->pkt = avpkt; if (!avpkt->data && avpkt->size) { av_log(avctx, AV_LOG_ERROR, "invalid packet: N... |
1 | static void extrapolate_isf(float isf[LP_ORDER_16k]){ float diff_isf[LP_ORDER - 2], diff_mean; float *diff_hi = diff_isf - LP_ORDER + 1; // diff array for extrapolated indexes float corr_lag[3]; float est, scale; int i, i_max_corr; isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1]; /* Calculate the difference vector */ for (i ... |
1 | QString *qobject_to_qstring(const QObject *obj){ if (qobject_type(obj) != QTYPE_QSTRING) return NULL; return container_of(obj, QString, base);} |
1 | static void gen_mfmsr(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG); return; } tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_msr);#endif} |
1 | static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size, uint32_t node, Error **errp){ sPAPRDRConnector *drc; sPAPRDRConnectorClass *drck; uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE; int i, fdt_offset, fdt_size; void *fdt; for (i = 0; i < nr_lmbs; i++) { drc = spapr_dr_connector_by_id(SPAPR_DR_CO... |
1 | static int bdrv_wr_badreq_bytes(BlockDriverState *bs, int64_t offset, int count){ int64_t size = bs->total_sectors << SECTOR_BITS; if (count < 0 || offset < 0) return 1; if (offset > size - count) { if (bs->autogrow) bs->total_sectors = (offset + count + SECTOR_SIZE - 1) >> SECTOR_BITS; else return 1; } return 0;} |
1 | static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev)); MachineClass *mc = MACHINE_GET_CLASS(spapr); sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev)); CPUCore *cc = CPU_CORE... |
0 | static void do_video_out(AVFormatContext *s, OutputStream *ost, AVFrame *next_picture, double sync_ipts){ int ret, format_video_sync; AVPacket pkt; AVCodecContext *enc = ost->enc_ctx; AVCodecContext *mux_enc = ost->st->codec; int nb_frames, nb0_frames, i; double delta, delta0; double duration = 0; int frame_size = 0; I... |
1 | static int vqa_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; VqaContext *s = avctx->priv_data; s->buf = buf; s->size = buf_size; if (s->frame.data[0]) avctx->release_buffer(avctx, &s->frame); if (avctx->get_buffer(avctx, &... |
1 | static int check_write_unsafe(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ /* assume that if the user specifies the format explicitly, then assume that they will continue to do so and provide no safety net */ if (!bs->probed) { return 0; } if (sector_num == 0 && nb_sectors > 0) { retur... |
1 | static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda){ int start = 0, i, w, w2, g; float uplim[128], maxq[128]; int minq, maxsf; float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda; int last = 0, lastband = 0, curband = 0; floa... |
0 | static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c){ int ret; ret = build_vlc(&c->dc_vlc[0], avpriv_mjpeg_bits_dc_luminance, avpriv_mjpeg_val_dc, 12, 0); if (ret) return ret; ret = build_vlc(&c->dc_vlc[1], avpriv_mjpeg_bits_dc_chrominance, avpriv_mjpeg_val_dc, 12, 0); if (ret) return ret; ret = build_vlc(... |
0 | static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap){ FFMContext *ffm = s->priv_data; AVStream *st; ByteIOContext *pb = s->pb; AVCodecContext *codec; int i, nb_streams; uint32_t tag; /* header */ tag = get_le32(pb); if (tag != MKTAG('F', 'F', 'M', '1')) goto fail; ffm->packet_size = get_be32(pb); if (... |
0 | static av_cold int msvideo1_decode_init(AVCodecContext *avctx){ Msvideo1Context *s = avctx->priv_data; s->avctx = avctx; /* figure out the colorspace based on the presence of a palette */ if (s->avctx->bits_per_coded_sample == 8) { s->mode_8bit = 1; avctx->pix_fmt = AV_PIX_FMT_PAL8; } else { s->mode_8bit = 0; avctx->pi... |
0 | static void avc_luma_hv_qrt_16w_msa(const uint8_t *src_x, const uint8_t *src_y, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height){ uint32_t multiple8_cnt; for (multiple8_cnt = 2; multiple8_cnt--;) { avc_luma_hv_qrt_8w_msa(src_x, src_y, src_stride, dst, dst_stride, height); src_x += 8; src_y += 8; ds... |
0 | int udp_output(struct socket *so, struct mbuf *m, struct sockaddr_in *addr){ struct sockaddr_in saddr, daddr; saddr = *addr; if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) { if ((so->so_faddr.s_addr & htonl(0x000000ff)) == htonl(0xff)) saddr.sin_addr.s_addr = alias_addr.s_addr; else if (addr->sin... |
0 | void qemu_chr_add_handlers(CharDriverState *s, IOCanReadHandler *fd_can_read, IOReadHandler *fd_read, IOEventHandler *fd_event, void *opaque){ if (!opaque) { /* chr driver being released. */ ++s->avail_connections; } s->chr_can_read = fd_can_read; s->chr_read = fd_read; s->chr_event = fd_event; s->handler_opaque = opaq... |
0 | static void guest_fsfreeze_init(void){ guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;} |
0 | static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors, bool is_write, BdrvRequestFlags flags){ QEMUIOVector qiov; struct iovec iov = { .iov_base = (void *)buf, .iov_len = nb_sectors * BDRV_SECTOR_SIZE, }; if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) { return -EINVA... |
0 | static uint32_t stellaris_enet_read(void *opaque, target_phys_addr_t offset){ stellaris_enet_state *s = (stellaris_enet_state *)opaque; uint32_t val; switch (offset) { case 0x00: /* RIS */ DPRINTF("IRQ status %02x\n", s->ris); return s->ris; case 0x04: /* IM */ return s->im; case 0x08: /* RCTL */ return s->rctl; case 0... |
0 | static void ide_reset(IDEState *s){ if (s->is_cf) s->mult_sectors = 0; else s->mult_sectors = MAX_MULT_SECTORS; s->cur_drive = s; s->select = 0xa0; s->status = READY_STAT; ide_set_signature(s); /* init the transfer handler so that 0xffff is returned on data accesses */ s->end_transfer_func = ide_dummy_transfer_stop; id... |
0 | int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func, void *opaque){ if (monitor_ctrl_mode(mon)) { qerror_report(QERR_MISSING_PARAMETER, "password"); return -EINVAL; } else if (mon->rs) { readline_start(mon->rs, "Password: ", 1, readline_func, opaque); /* prompt is printed on return from the command hand... |
0 | static void openrisc_sim_net_init(MemoryRegion *address_space, hwaddr base, hwaddr descriptors, qemu_irq irq, NICInfo *nd){ DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "open_eth"); qdev_set_nic_properties(dev, nd); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); sysbus_connect_irq(s, 0, irq); memory_regi... |
0 | build_srat(GArray *table_data, GArray *linker, MachineState *machine){ AcpiSystemResourceAffinityTable *srat; AcpiSratProcessorAffinity *core; AcpiSratMemoryAffinity *numamem; int i; uint64_t curnode; int srat_start, numa_start, slots; uint64_t mem_len, mem_base, next_base; MachineClass *mc = MACHINE_GET_CLASS(machine)... |
0 | static MaltaFPGAState *malta_fpga_init(MemoryRegion *address_space, target_phys_addr_t base, qemu_irq uart_irq, CharDriverState *uart_chr){ MaltaFPGAState *s; s = (MaltaFPGAState *)g_malloc0(sizeof(MaltaFPGAState)); memory_region_init_io(&s->iomem, &malta_fpga_ops, s, "malta-fpga", 0x100000); memory_region_init_alias(&... |
0 | static void tcg_reg_alloc_start(TCGContext *s){ int i; TCGTemp *ts; for(i = 0; i < s->nb_globals; i++) { ts = &s->temps[i]; if (ts->fixed_reg) { ts->val_type = TEMP_VAL_REG; } else { ts->val_type = TEMP_VAL_MEM; } } for(i = s->nb_globals; i < s->nb_temps; i++) { ts = &s->temps[i]; ts->val_type = TEMP_VAL_DEAD; ts->mem_... |
0 | static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags){ BlockDriver *drv = bs->drv; int64_t sector_num = offset >> BDRV_SECTOR_BITS; unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); assert((byte... |
0 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, int unit, bool removable, int bootindex, const char *serial, Error **errp){ const char *driver; DeviceState *dev; Error *err = NULL; driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk"; dev = qdev_create(&bus->qbus, driver); qdev_prop_set_... |
0 | static void check_exception(PowerPCCPU *cpu, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t mask, buf, len, event_len; uint64_t xinfo; sPAPREventLogEntry *event; struct rtas_error_log *hdr; if ((nargs < 6) || (nargs > 7) || nret != 1) { rtas_st(r... |
0 | static void test_qemu_strtoull_full_correct(void){ const char *str = "18446744073709551614"; uint64_t res = 999; int err; err = qemu_strtoull(str, NULL, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, 18446744073709551614LLU);} |
0 | QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque){ QEMUBH *bh; bh = qemu_malloc(sizeof(*bh)); bh->cb = cb; bh->opaque = opaque; return bh;} |
0 | static void omap_mcbsp_sink_tick(void *opaque){ struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 }; if (!s->tx_rate) return; if (s->tx_req) printf("%s: Tx FIFO underrun\n", __FUNCTION__); s->tx_req = s->tx_rate << bps[(s->xcr[0] >> 5) & 7]; omap_mcbsp_tx_... |
0 | static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass, int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p){ void (*idct_add)(uint8_t *dst, int16_t *block, int stride); int i; block_offset += 16 * p; if (!IS_INTRA4x4(mb_type))... |
0 | int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr, target_ulong len, int type){ struct kvm_sw_breakpoint *bp; CPUState *env; int err; if (type == GDB_BREAKPOINT_SW) { bp = kvm_find_sw_breakpoint(current_env, addr); if (bp) { bp->use_count++; return 0; } bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint)... |
0 | static uint32_t nvic_readl(NVICState *s, uint32_t offset, MemTxAttrs attrs){ ARMCPU *cpu = s->cpu; uint32_t val; switch (offset) { case 4: /* Interrupt Control Type. */ return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1; case 0xd00: /* CPUID Base. */ return cpu->midr; case 0xd04: /* Interrupt Control State. */ /* VECTACTI... |
0 | static gboolean vtd_hash_remove_by_page(gpointer key, gpointer value, gpointer user_data){ VTDIOTLBEntry *entry = (VTDIOTLBEntry *)value; VTDIOTLBPageInvInfo *info = (VTDIOTLBPageInvInfo *)user_data; uint64_t gfn = info->gfn & info->mask; return (entry->domain_id == info->domain_id) && ((entry->gfn & info->mask) == gfn... |
0 | int coroutine_fn bdrv_co_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes, QEMUIOVector *qiov, BdrvRequestFlags flags){ BlockDriverState *bs = child->bs; BdrvTrackedRequest req; uint64_t align = bs->bl.request_alignment; uint8_t *head_buf = NULL; uint8_t *tail_buf = NULL; QEMUIOVector local_qiov; bool use_l... |
0 | int kvm_init_vcpu(CPUState *env){ KVMState *s = kvm_state; long mmap_size; int ret; DPRINTF("kvm_init_vcpu\n"); ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index); if (ret < 0) { DPRINTF("kvm_create_vcpu failed\n"); goto err; } env->kvm_fd = ret; env->kvm_state = s; mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, ... |
0 | void bdrv_disable_copy_on_read(BlockDriverState *bs){ assert(bs->copy_on_read > 0); bs->copy_on_read--;} |
0 | void sdl_display_init(DisplayState *ds, int full_screen, int no_frame){ int flags; uint8_t data = 0;#if defined(__APPLE__) /* always use generic keymaps */ if (!keyboard_layout) keyboard_layout = "en-us";#endif if(keyboard_layout) { kbd_layout = init_keyboard_layout(keyboard_layout); if (!kbd_layout) exit(1); } if (no_... |
0 | int nbd_trip(BlockDriverState *bs, int csock, off_t size, uint64_t dev_offset, off_t *offset, uint32_t nbdflags, uint8_t *data, int data_size){ struct nbd_request request; struct nbd_reply reply; TRACE("Reading request."); if (nbd_receive_request(csock, &request) == -1) return -1; if (request.len + NBD_REPLY_SIZE > dat... |
0 | static inline void reloc_pc19(tcg_insn_unit *code_ptr, tcg_insn_unit *target){ ptrdiff_t offset = target - code_ptr; assert(offset == sextract64(offset, 0, 19)); *code_ptr = deposit32(*code_ptr, 5, 19, offset);} |
0 | void json_end_object(QJSON *json){ qstring_append(json->str, " }"); json->omit_comma = false;} |
0 | void timerlist_free(QEMUTimerList *timer_list){ assert(!timerlist_has_timers(timer_list)); if (timer_list->clock) { QLIST_REMOVE(timer_list, list); } qemu_mutex_destroy(&timer_list->active_timers_lock); g_free(timer_list);} |
0 | static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb){ ThreadPoolElement *elem = (ThreadPoolElement *)acb; ThreadPool *pool = elem->pool; return pool->ctx;} |
0 | static BlockDriverAIOCB *dma_bdrv_io( BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num, BlockDriverCompletionFunc *cb, void *opaque, int is_write){ DMABlockState *dbs = qemu_malloc(sizeof(*dbs)); dbs->bs = bs; dbs->acb = qemu_aio_get(bs, cb, opaque); dbs->sg = sg; dbs->sector_num = sector_num; dbs->sg_cur_inde... |
0 | static uint64_t watch_mem_read(void *opaque, target_phys_addr_t addr, unsigned size){ check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_READ); switch (size) { case 1: return ldub_phys(addr); case 2: return lduw_phys(addr); case 4: return ldl_phys(addr); default: abort(); }} |
1 | print_syscall_ret(int num, abi_long ret){ int i; for(i=0;i<nsyscalls;i++) if( scnames[i].nr == num ) { if( scnames[i].result != NULL ) { scnames[i].result(&scnames[i],ret); } else { if( ret < 0 ) { gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret)); } else { gemu_log(" = " TARGET_ABI_FMT_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.