label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | void cpu_loop(CPUS390XState *env){ CPUState *cs = CPU(s390_env_get_cpu(env)); int trapnr, n, sig; target_siginfo_t info; target_ulong addr; while (1) { cpu_exec_start(cs); trapnr = cpu_s390x_exec(cs); cpu_exec_end(cs); switch (trapnr) { case EXCP_INTERRUPT: /* Just indicate that signals should be handled asap. */ break... |
0 | Object *object_resolve_path_component(Object *parent, const gchar *part){ ObjectProperty *prop = object_property_find(parent, part, NULL); if (prop == NULL) { return NULL; } if (object_property_is_link(prop)) { LinkProperty *lprop = prop->opaque; return *lprop->child; } else if (object_property_is_child(prop)) { return... |
0 | static void *virtio_scsi_load_request(QEMUFile *f, SCSIRequest *sreq){ SCSIBus *bus = sreq->bus; VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); VirtIOSCSIReq *req; uint32_t n; req = g_malloc(sizeof(*req)); qemu_get_be32s(f, &n); assert(n < vs->conf.num_queues); qemu_ge... |
0 | static void phys_sections_free(PhysPageMap *map){ while (map->sections_nb > 0) { MemoryRegionSection *section = &map->sections[--map->sections_nb]; phys_section_destroy(section->mr); } g_free(map->sections); g_free(map->nodes); g_free(map);} |
0 | static void fill_buffer(ByteIOContext *s){ int len; /* no need to do anything if EOF already reached */ if (s->eof_reached) return; if(s->update_checksum){ if(s->buf_end > s->checksum_ptr) s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr); s->checksum_ptr= s->buffer; } len = s-... |
0 | static int adx_encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size, void *data){ ADXContext *c = avctx->priv_data; const int16_t *samples = data; uint8_t *dst = frame; int ch; if (!c->header_parsed) { int hdrsize = adx_encode_header(avctx, dst, buf_size); dst += hdrsize; c->header_parsed = 1; } for (ch = 0... |
0 | static int bmp_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size){ BMPParseContext *bpc = s->priv_data; uint64_t state = bpc->pc.state64; int next = END_NOT_FOUND; int i = 0; *poutbuf_size = 0;restart: if (bpc->pc.frame_start_found <= 2+4+... |
0 | static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags){ AVIContext *avi = s->priv_data; AVStream *st; int i, index; int64_t pos; AVIStream *ast; if (!avi->index_loaded) { /* we only load the index on demand */ avi_load_index(s); avi->index_loaded = 1; } assert(stream_index>= 0); st... |
0 | static int opt_streamid(const char *opt, const char *arg){ int idx; char *p; char idx_str[16]; av_strlcpy(idx_str, arg, sizeof(idx_str)); p = strchr(idx_str, ':'); if (!p) { fprintf(stderr, "Invalid value '%s' for option '%s', required syntax is 'index:value'\n", arg, opt); ffmpeg_exit(1); } *p++ = '\0'; idx = parse_nu... |
0 | static void avc_luma_midv_qrt_16w_msa(const uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height, uint8_t vert_offset){ uint32_t multiple8_cnt; for (multiple8_cnt = 2; multiple8_cnt--;) { avc_luma_midv_qrt_8w_msa(src, src_stride, dst, dst_stride, height, vert_offset); src += 8; dst += 8; }... |
0 | static void RENAME(yuv2rgb32_1)(SwsContext *c, const uint16_t *buf0, const uint16_t *ubuf0, const uint16_t *ubuf1, const uint16_t *vbuf0, const uint16_t *vbuf1, const uint16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, enum PixelFormat dstFormat, int flags, int y){ const uint16_t *buf1= buf0; //FIXME needed for RGB1... |
0 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ HYuvContext *s = avctx->priv_data; const int width= s->width; const int width2= s->width>>1; const int height= s->height; int fake_ystride, fake_ustride, fake_vstride; AVFrame * const p= &s->picture; AVFrame *picture... |
1 | static QemuOpts *opts_parse(QemuOptsList *list, const char *params, int permit_abbrev, bool defaults){ const char *firstname; char value[1024], *id = NULL; const char *p; QemuOpts *opts; Error *local_err = NULL; assert(!permit_abbrev || list->implied_opt_name); firstname = permit_abbrev ? list->implied_opt_name : NULL;... |
1 | static int get_bool(QEMUFile *f, void *pv, size_t size){ bool *v = pv; *v = qemu_get_byte(f); return 0;} |
1 | int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt){ 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: NULL data, size != 0\n"); return AVERROR(E... |
1 | int ff_j2k_init_component(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, Jpeg2000QuantStyle *qntsty, int cbps, int dx, int dy){ int reslevelno, bandno, gbandno = 0, ret, i, j, csize = 1; if (ret=ff_j2k_dwt_init(&comp->dwt, comp->coord, codsty->nreslevels-1, codsty->transform)) return ret; for (i = 0; i < 2; i++)... |
1 | static int disas_cp_insn(CPUState *env, DisasContext *s, uint32_t insn){ TCGv tmp, tmp2; uint32_t rd = (insn >> 12) & 0xf; uint32_t cp = (insn >> 8) & 0xf; if (IS_USER(s)) { return 1; } if (insn & ARM_CP_RW_BIT) { if (!env->cp[cp].cp_read) return 1; gen_set_pc_im(s->pc); tmp = new_tmp(); tmp2 = tcg_const_i32(insn); gen... |
1 | static int read_frame_internal(AVFormatContext *s, AVPacket *pkt){ AVStream *st; int len, ret, i; av_init_packet(pkt); for(;;) { /* select current input stream component */ st = s->cur_st; if (st) { if (!st->need_parsing || !st->parser) { /* no parsing needed: we just output the packet as is */ /* raw data support */ *... |
1 | void qemu_co_rwlock_unlock(CoRwlock *lock){ assert(qemu_in_coroutine()); if (lock->writer) { lock->writer = false; qemu_co_queue_restart_all(&lock->queue); } else { lock->reader--; assert(lock->reader >= 0); /* Wakeup only one waiting writer */ if (!lock->reader) { qemu_co_queue_next(&lock->queue); } }} |
1 | void do_addzeo (void){ T1 = T0; T0 += xer_ca; if (likely(!((T1 ^ (-1)) & (T1 ^ T0) & (1 << 31)))) { xer_ov = 0; } else { xer_so = 1; xer_ov = 1; } if (likely(T0 >= T1)) { xer_ca = 0; } else { xer_ca = 1; }} |
1 | 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 */ ide_atapi_cmd_ok(s); ide_set... |
1 | static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int channel, unsigned int filter){ SubStream *s = &m->substream[substr]; FilterParams *fp = &s->channel_params[channel].filter_params[filter]; const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; const char fch... |
1 | static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref){ IlContext *il = inlink->dst->priv; AVFilterLink *outlink = inlink->dst->outputs[0]; AVFilterBufferRef *out; int ret; out = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h); if (!out) { avfilter_unref_bufferp(&inpicref); retur... |
1 | decode_lpc(WmallDecodeCtx *s){ int ch, i, cbits; s->lpc_order = get_bits(&s->gb, 5) + 1; s->lpc_scaling = get_bits(&s->gb, 4); s->lpc_intbits = get_bits(&s->gb, 3) + 1; cbits = s->lpc_scaling + s->lpc_intbits; for(ch = 0; ch < s->num_channels; ch++) {for(i = 0; i < s->lpc_order; i++) { s->lpc_coefs[ch][i] = get_sbits(&... |
1 | static double get_scene_score(AVFilterContext *ctx, AVFrame *crnt, AVFrame *next){ FrameRateContext *s = ctx->priv; double ret = 0; ff_dlog(ctx, "get_scene_score()\n"); if (crnt->height == next->height && crnt->width == next->width) { int64_t sad; double mafd, diff; ff_dlog(ctx, "get_scene_score() process\n"); if (s->b... |
0 | int main(int argc,char* argv[]){ int i, j; uint64_t sse=0; uint64_t dev; FILE *f[2]; uint8_t buf[2][SIZE]; uint64_t psnr; int len= argc<4 ? 1 : atoi(argv[3]); int64_t max= (1<<(8*len))-1; int shift= argc<5 ? 0 : atoi(argv[4]); int skip_bytes = argc<6 ? 0 : atoi(argv[5]); if(argc<3){ printf("tiny_psnr <file1> <file2> [<... |
1 | StrongARMState *sa1110_init(MemoryRegion *sysmem, unsigned int sdram_size, const char *rev){ StrongARMState *s; int i; s = g_new0(StrongARMState, 1); if (!rev) { rev = "sa1110-b5"; } if (strncmp(rev, "sa1110", 6)) { error_report("Machine requires a SA1110 processor."); exit(1); } s->cpu = ARM_CPU(cpu_generic_init(TYPE_... |
1 | static int celt_header(AVFormatContext *s, int idx){ struct ogg *ogg = s->priv_data; struct ogg_stream *os = ogg->streams + idx; AVStream *st = s->streams[idx]; struct oggcelt_private *priv = os->private; uint8_t *p = os->buf + os->pstart; if (os->psize == 60 && !memcmp(p, ff_celt_codec.magic, ff_celt_codec.magicsize))... |
1 | static abi_long do_sendrecvmsg_locked(int fd, struct target_msghdr *msgp, int flags, int send){ abi_long ret, len; struct msghdr msg; int count; struct iovec *vec; abi_ulong target_vec; if (msgp->msg_name) { msg.msg_namelen = tswap32(msgp->msg_namelen); msg.msg_name = alloca(msg.msg_namelen+1); ret = target_to_host_soc... |
0 | static int decode_group3_1d_line(AVCodecContext *avctx, GetBitContext *gb, int pix_left, int *runs){ int mode = 0, run = 0; unsigned int t; for(;;){ t = get_vlc2(gb, ccitt_vlc[mode].table, 9, 2); run += t; if(t < 64){ pix_left -= run; *runs++ = run; if(pix_left <= 0){ if(!pix_left) break; runs[-1] = 0; av_log(avctx, AV... |
0 | static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q){ int i, x; if (s->buf_end - s->buf < 1) return AVERROR(EINVAL); x = bytestream_get_byte(&s->buf); // Sqcd q->nguardbits = x >> 5; q->quantsty = x & 0x1f; if (q->quantsty == JPEG2000_QSTY_NONE) { n -= 3; if (s->buf_end - s->buf < n || 32*3 < n) ... |
1 | void do_compare_and_swap32(void *cpu_env, int num){#ifdef TARGET_I386 uint32_t old = ((CPUX86State*)cpu_env)->regs[R_EAX]; uint32_t *value = (uint32_t*)((CPUX86State*)cpu_env)->regs[R_ECX]; DPRINTF("commpage: compare_and_swap32(%x,new,%p)\n", old, value); if(value && old == tswap32(*value)) { uint32_t new = ((CPUX86Sta... |
1 | static void ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc){ int i; assert(rc->type == 2); rc->maxes = av_mallocz(sizeof(float[2]) * rc->classifications); for (i = 0; i < rc->classifications; i++) { int j; vorbis_enc_codebook * cb; for (j = 0; j < 8; j++) if (rc->books[i][j] != -1) break; if (j == 8) //... |
1 | BlockDriverState *bdrv_all_find_vmstate_bs(void){ bool not_found = true; BlockDriverState *bs; BdrvNextIterator *it = NULL; while (not_found && (it = bdrv_next(it, &bs))) { AioContext *ctx = bdrv_get_aio_context(bs); aio_context_acquire(ctx); not_found = !bdrv_can_snapshot(bs); aio_context_release(ctx); } return bs;} |
0 | static av_cold int initFilter(int16_t **outFilter, int32_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 is_horizontal){ int i; int filterSize; int filter2Size; int minFilterSize; int64_... |
1 | int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags){ VLCcode *buf; int i, j, ret; vlc->bits = nb_bits; if (flags & INIT_VLC_USE_NEW_STATIC) { VLC... |
1 | static uint64_t macio_nvram_readb(void *opaque, hwaddr addr, unsigned size){ MacIONVRAMState *s = opaque; uint32_t value; addr = (addr >> s->it_shift) & (s->size - 1); value = s->data[addr]; NVR_DPRINTF("readb addr %04x val %x\n", (int)addr, value); return value;} |
1 | void HELPER(v7m_msr)(CPUARMState *env, uint32_t reg, uint32_t val){ ARMCPU *cpu = arm_env_get_cpu(env); switch (reg) { case 0: /* APSR */ xpsr_write(env, val, 0xf8000000); break; case 1: /* IAPSR */ xpsr_write(env, val, 0xf8000000); break; case 2: /* EAPSR */ xpsr_write(env, val, 0xfe00fc00); break; case 3: /* xPSR */ ... |
0 | AVRational av_d2q(double d, int max){ AVRational a; int exponent; int64_t den; if (isnan(d)) return (AVRational) { 0,0 }; if (fabs(d) > INT_MAX + 3LL) return (AVRational) { d < 0 ? -1 : 1, 0 }; frexp(d, &exponent); exponent = FFMAX(exponent-1, 0); den = 1LL << (61 - exponent); // (int64_t)rint() and llrint() do not wor... |
0 | static unsigned tget(GetByteContext *gb, int type, int le){ switch (type) { case TIFF_BYTE : return bytestream2_get_byteu(gb); case TIFF_SHORT: return tget_short(gb, le); case TIFF_LONG : return tget_long(gb, le); default : return UINT_MAX; }} |
1 | PCIDevice *pci_pcnet_init(PCIBus *bus, NICInfo *nd, int devfn){ PCNetState *d; uint8_t *pci_conf;#if 0 printf("sizeof(RMD)=%d, sizeof(TMD)=%d\n", sizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD));#endif d = (PCNetState *)pci_register_device(bus, "PCNet", sizeof(PCNetState), devfn, NULL, NULL); pci_conf = d->dev.confi... |
1 | void aio_notify(AioContext *ctx){ /* Write e.g. bh->scheduled before reading ctx->dispatching. */ smp_mb(); if (!ctx->dispatching) { event_notifier_set(&ctx->notifier); }} |
1 | static void tb_invalidate_phys_page(tb_page_addr_t addr, uintptr_t pc, void *puc){ TranslationBlock *tb; PageDesc *p; int n;#ifdef TARGET_HAS_PRECISE_SMC TranslationBlock *current_tb = NULL; CPUState *cpu = current_cpu; CPUArchState *env = NULL; int current_tb_modified = 0; target_ulong current_pc = 0; target_ulong cur... |
1 | static int rtp_parse_mp4_au(PayloadContext *data, const uint8_t *buf){ int au_headers_length, au_header_size, i; GetBitContext getbitcontext; /* decode the first 2 bytes where the AUHeader sections are stored length in bits */ au_headers_length = AV_RB16(buf); if (au_headers_length > RTP_MAX_PACKET_LENGTH) return -1; d... |
1 | static inline void RENAME(palToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, int width, uint32_t *pal){int i; assert(src1 == src2);for(i=0; i<width; i++){int p= pal[src1[i]];dstU[i]= p>>8;dstV[i]= p>>16;}} |
1 | static uint64_t pl011_read(void *opaque, target_phys_addr_t offset, unsigned size){ pl011_state *s = (pl011_state *)opaque; uint32_t c; if (offset >= 0xfe0 && offset < 0x1000) { return s->id[(offset - 0xfe0) >> 2]; } switch (offset >> 2) { case 0: /* UARTDR */ s->flags &= ~PL011_FLAG_RXFF; c = s->read_fifo[s->read_pos]... |
1 | static void icp_pit_write(void *opaque, hwaddr offset, uint64_t value, unsigned size){ icp_pit_state *s = (icp_pit_state *)opaque; int n; n = offset >> 8; if (n > 2) { qemu_log_mask(LOG_GUEST_ERROR, "%s: Bad timer %d\n", __func__, n); } arm_timer_write(s->timer[n], offset & 0xff, value);} |
1 | static void targa_decode_rle(AVCodecContext *avctx, TargaContext *s, const uint8_t *src, uint8_t *dst, int w, int h, int stride, int bpp){ int i, x, y; int depth = (bpp + 1) >> 3; int type, count; int diff; diff = stride - w * depth; x = y = 0; while(y < h){ type = *src++; count = (type & 0x7F) + 1; type &= 0x80; if((x... |
1 | static int aasc_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AascContext *s = avctx->priv_data; int compr, i, stride, psize; s->frame.reference = 3; s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE... |
1 | int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset, int64_t size){ int ret = qcow2_check_metadata_overlap(bs, ign, offset, size); if (ret < 0) { return ret; } else if (ret > 0) { int metadata_ol_bitnr = ffs(ret) - 1; char *message; assert(metadata_ol_bitnr < QCOW2_OL_MAX_BITNR); fprintf(std... |
1 | static int dmg_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVDMGState *s = bs->opaque; uint64_t info_begin, info_end, last_in_offset, last_out_offset; uint32_t count, tmp; uint32_t max_compressed_size = 1, max_sectors_per_chunk = 1, i; int64_t offset; int ret; bs->read_only = 1; s->n_chunks =... |
0 | int ff_mjpeg_decode_sof(MJpegDecodeContext *s){ int len, nb_components, i, width, height, pix_fmt_id; s->cur_scan = 0; s->upscale_h = s->upscale_v = 0; /* XXX: verify len field validity */ len = get_bits(&s->gb, 16); s->bits = get_bits(&s->gb, 8); if (s->pegasus_rct) s->bits = 9; if (s->bits == 9 && !s->pegasus_rct) s-... |
0 | void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error, BlockdevOnError on_write_error){ bs->on_read_error = on_read_error; bs->on_write_error = on_write_error;} |
0 | static void test_acpi_one(const char *params, test_data *data){ char *args; uint8_t signature_low; uint8_t signature_high; uint16_t signature; int i; const char *device = ""; if (!g_strcmp0(data->machine, MACHINE_Q35)) { device = ",id=hd -device ide-hd,drive=hd"; } args = g_strdup_printf("-net none -display none %s -dr... |
0 | static void rocker_io_writel(void *opaque, hwaddr addr, uint32_t val){ Rocker *r = opaque; if (rocker_addr_is_desc_reg(r, addr)) { unsigned index = ROCKER_RING_INDEX(addr); unsigned offset = addr & ROCKER_DMA_DESC_MASK; switch (offset) { case ROCKER_DMA_DESC_ADDR_OFFSET: r->lower32 = (uint64_t)val; break; case ROCKER_D... |
0 | build_rsdt(GArray *table_data, GArray *linker, GArray *table_offsets){ AcpiRsdtDescriptorRev1 *rsdt; size_t rsdt_len; int i; const int table_data_len = (sizeof(uint32_t) * table_offsets->len); rsdt_len = sizeof(*rsdt) + table_data_len; rsdt = acpi_data_push(table_data, rsdt_len); memcpy(rsdt->table_offset_entry, table_... |
0 | int nbd_client_session_co_writev(NbdClientSession *client, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov){ int offset = 0; int ret; while (nb_sectors > NBD_MAX_SECTORS) { ret = nbd_co_writev_1(client, sector_num, NBD_MAX_SECTORS, qiov, offset); if (ret < 0) { return ret; } offset += NBD_MAX_SECTORS * 512; sect... |
0 | static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf){ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); uint64_t nb_sectors; bool dbd; int page, buflen, ret, page_control; uint8_t *p; uint8_t dev_specific_param; dbd = (r->req.cmd.buf[1] & 0x8) != 0; page = r->req.cmd.buf[2] & 0x3f; page... |
0 | static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend, Error **errp){ const char *device = qemu_opt_get(opts, "path"); ChardevHostdev *dev; if (device == NULL) { error_setg(errp, "chardev: pipe: no device path given"); return; } dev = backend->u.pipe = g_new0(ChardevHostdev, 1); qemu_chr_parse_common(... |
0 | static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOVAtom atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = st->priv_data; unsigned int i, entries; int64_t duration=0; int64_t total_sample_count=0; get_byte(pb); /* version */ get_be24(pb); /* flags */ entries = get_be32(pb); dpr... |
0 | static void bt_submit_sco(struct HCIInfo *info, const uint8_t *data, int length){ struct bt_hci_s *hci = hci_from_info(info); uint16_t handle; int datalen; if (length < 3) return; handle = acl_handle((data[1] << 8) | data[0]); datalen = data[2]; length -= 3; if (bt_hci_handle_bad(hci, handle)) { fprintf(stderr, "%s: in... |
0 | static void do_v7m_exception_exit(ARMCPU *cpu){ CPUARMState *env = &cpu->env; uint32_t type; uint32_t xpsr; bool ufault = false; bool return_to_sp_process = false; bool return_to_handler = false; bool rettobase = false; /* We can only get here from an EXCP_EXCEPTION_EXIT, and * gen_bx_excret() enforces the architectura... |
0 | static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res, uint16_t *refcount_table, int refcount_table_size, int64_t l2_offset, int flags){ BDRVQcowState *s = bs->opaque; uint64_t *l2_table, l2_entry; uint64_t next_contiguous_offset = 0; int i, l2_size, nb_csectors; /* Read L2 table from disk */ l2_size... |
0 | static inline void gen_op_fcmpq(int fccno){ switch (fccno) { case 0: gen_helper_fcmpq(cpu_env); break; case 1: gen_helper_fcmpq_fcc1(cpu_env); break; case 2: gen_helper_fcmpq_fcc2(cpu_env); break; case 3: gen_helper_fcmpq_fcc3(cpu_env); break; }} |
0 | static int proxy_closedir(FsContext *ctx, V9fsFidOpenState *fs){ return closedir(fs->dir);} |
1 | static int ne2000_can_receive(void *opaque){ NE2000State *s = opaque; int avail, index, boundary; if (s->cmd & E8390_STOP) return 0; index = s->curpag << 8; boundary = s->boundary << 8; if (index < boundary) avail = boundary - index; else avail = (s->stop - s->start) - (index - boundary); if (avail < (MAX_ETH_FRAME_SIZ... |
1 | static void test_qemu_strtoll_invalid(void){ const char *str = " xxxx \t abc"; 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(endptr == str);} |
1 | static int decode_i_picture_secondary_header(VC9Context *v){ int status;#if HAS_ADVANCED_PROFILE if (v->profile > PROFILE_MAIN) { v->s.ac_pred = get_bits(&v->s.gb, 1); if (v->postprocflag) v->postproc = get_bits(&v->s.gb, 1); /* 7.1.1.34 + 8.5.2 */ if (v->overlap && v->pq<9) { v->condover = get_bits(&v->s.gb, 1); if (v... |
1 | void visit_type_enum(Visitor *v, int *obj, const char *strings[], const char *kind, const char *name, Error **errp){ if (!error_is_set(errp)) { v->type_enum(v, obj, strings, kind, name, errp); }} |
1 | static AVStream *get_subtitle_pkt(AVFormatContext *s, AVStream *next_st, AVPacket *pkt){ AVIStream *ast, *next_ast = next_st->priv_data; int64_t ts, next_ts, ts_min = INT64_MAX; AVStream *st, *sub_st = NULL; int i; next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base, AV_TIME_BASE_Q); for (i=0; i<s->nb_str... |
1 | static void adb_keyboard_event(DeviceState *dev, QemuConsole *src, InputEvent *evt){ KBDState *s = (KBDState *)dev; int qcode, keycode; qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key); if (qcode >= ARRAY_SIZE(qcode_to_adb_keycode)) { return; } /* FIXME: take handler into account when translating qcode */ ke... |
0 | void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx){ mm_flags = mm_support(); if (avctx->dsp_mask) { if (avctx->dsp_mask & FF_MM_FORCE) mm_flags |= (avctx->dsp_mask & 0xffff); else mm_flags &= ~(avctx->dsp_mask & 0xffff); }#if 0 av_log(avctx, AV_LOG_INFO, "libavcodec: CPU flags:"); if (mm_flags & MM_MMX) av_log... |
1 | static void iscsi_retry_timer_expired(void *opaque){ struct IscsiTask *iTask = opaque; iTask->complete = 1; if (iTask->co) { qemu_coroutine_enter(iTask->co, NULL); }} |
1 | int qemu_shutdown_requested_get(void){ return shutdown_requested;} |
1 | static inline void RENAME(rgb15ToY)(uint8_t *dst, uint8_t *src, int width){int i;for(i=0; i<width; i++){int d= ((uint16_t*)src)[i];int r= d&0x1F;int g= (d>>5)&0x1F;int b= (d>>10)&0x1F;dst[i]= ((RY*r + GY*g + BY*b)>>(RGB2YUV_SHIFT-3)) + 16;}} |
1 | static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr, target_phys_addr_t end_addr, unsigned flags, unsigned mask){ KVMState *s = kvm_state; KVMSlot *mem = kvm_lookup_slot(s, phys_addr); if (mem == NULL) { dprintf("invalid parameters %llx-%llx\n", phys_addr, end_addr); return -EINVAL; } flags = (mem->flags... |
0 | static void RENAME(uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, long width, long height, long lumStride, long chromStride, long srcStride){ long y; const long chromWidth= -((-width)>>1); for (y=0; y<height; y++) { RENAME(extract_even)(src+1, ydst, width); if(y&1) { RENAME(extract_even2... |
0 | static int bayer_to_yv12_wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]){ const uint8_t *srcPtr= src[0]; uint8_t *dstY= dst[0]; uint8_t *dstU= dst[1]; uint8_t *dstV= dst[2]; int i; void (*copy) (const uint8_t *src, int src_stride, uint8_t *dst... |
0 | static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic){ VAAPIEncodeContext *ctx = avctx->priv_data; VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params; VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params; VAAPIEncodeH264Context *priv = ctx->priv_d... |
1 | static inline int is_bit_set(BlockDriverState *bs, int64_t bitnum){ uint64_t offset = sizeof(struct cow_header_v2) + bitnum / 8; uint8_t bitmap; if (bdrv_pread(bs->file, offset, &bitmap, sizeof(bitmap)) != sizeof(bitmap)) { return -errno; } return !!(bitmap & (1 << (bitnum % 8)));} |
1 | bool st_init(const char *file){ pthread_t thread; pthread_attr_t attr; sigset_t set, oldset; int ret; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); sigfillset(&set); pthread_sigmask(SIG_SETMASK, &set, &oldset); ret = pthread_create(&thread, &attr, writeout_thread, NULL); pthread... |
1 | static int libquvi_close(AVFormatContext *s){ LibQuviContext *qc = s->priv_data; if (qc->fmtctx) avformat_close_input(&qc->fmtctx); return 0;} |
1 | static void aspeed_soc_class_init(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); AspeedSoCClass *sc = ASPEED_SOC_CLASS(oc); sc->info = (AspeedSoCInfo *) data; dc->realize = aspeed_soc_realize;} |
1 | static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer, struct in_addr my_ip){ AVFormatContext *avc; AVStream avs[MAX_STREAMS]; int i; avc = avformat_alloc_context(); if (avc == NULL) { return -1; } av_metadata_set2(&avc->metadata, "title", stream->title[0] ? stream->title : "No Title", 0); avc->nb_stre... |
1 | static int dvdsub_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ DVDSubContext *ctx = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AVSubtitle *sub = data; int is_menu; if (ctx->buf) { int ret = append_to_cached_buf(avctx, buf, buf_size); if (ret < 0) { *da... |
1 | static void ibm_40p_init(MachineState *machine){ CPUPPCState *env = NULL; uint16_t cmos_checksum; PowerPCCPU *cpu; DeviceState *dev; SysBusDevice *pcihost; Nvram *m48t59 = NULL; PCIBus *pci_bus; ISABus *isa_bus; void *fw_cfg; int i; uint32_t kernel_base = 0, initrd_base = 0; long kernel_size = 0, initrd_size = 0; char ... |
1 | static void *iommu_init(target_phys_addr_t addr, uint32_t version, qemu_irq irq){ DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "iommu"); qdev_prop_set_uint32(dev, "version", version); qdev_init(dev); s = sysbus_from_qdev(dev); sysbus_connect_irq(s, 0, irq); sysbus_mmio_map(s, 0, addr); return s;} |
1 | static void test_qemu_strtoull_full_empty(void){ const char *str = ""; uint64_t res = 999; int err; err = qemu_strtoull(str, NULL, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, 0);} |
0 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc){ int32_t *filterPos = c->hChrFilterPos; int16_t *filter = c->hChrFilter; void *mmx2FilterCode= c->chrMmx2FilterCode; int i;#if defined(PIC) DECLARE_ALIGNED(8, ... |
0 | static void get_pointer(Object *obj, Visitor *v, Property *prop, const char *(*print)(void *ptr), const char *name, Error **errp){ DeviceState *dev = DEVICE(obj); void **ptr = qdev_get_prop_ptr(dev, prop); char *p; p = (char *) (*ptr ? print(*ptr) : ""); visit_type_str(v, &p, name, errp);} |
0 | static uint64_t jazz_led_read(void *opaque, target_phys_addr_t addr, unsigned int size){ LedState *s = opaque; uint8_t val; val = s->segments; trace_jazz_led_read(addr, val); return val;} |
0 | float32 HELPER(ucf64_divs)(float32 a, float32 b, CPUUniCore32State *env){ return float32_div(a, b, &env->ucf64.fp_status);} |
0 | static void scsi_generic_class_initfn(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass); sc->realize = scsi_generic_realize; sc->unrealize = scsi_unrealize; sc->alloc_req = scsi_new_request; sc->parse_cdb = scsi_generic_parse_cdb; dc->fw_name = "disk"... |
0 | START_TEST(qlist_destroy_test){ int i; QList *qlist; qlist = qlist_new(); for (i = 0; i < 42; i++) qlist_append(qlist, qint_from_int(i)); QDECREF(qlist);} |
0 | static void vnc_client_read(void *opaque){ VncState *vs = opaque; long ret; buffer_reserve(&vs->input, 4096);#ifdef CONFIG_VNC_TLS if (vs->tls_session) {ret = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);if (ret < 0) { if (ret == GNUTLS_E_AGAIN)errno = EAGAIN; elseerrno = EIO; ret = -1;} } else#endif /* C... |
0 | POWERPC_FAMILY(e5500)(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc); dc->desc = "e5500 core"; pcc->init_proc = init_proc_e5500; pcc->check_pow = check_pow_none; pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_WRTEE | PPC_RFDI | PPC_RFMCI | PPC_CACHE | ... |
0 | void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len){ const uint8_t *end; int j; j = ctx->len & 63; ctx->len += len; if (j) { int cnt = FFMIN(len, 64 - j); memcpy(ctx->block + j, src, cnt); src += cnt; len -= cnt; if (j + cnt < 64) return; body(ctx->ABCD, (uint32_t *)ctx->block); } end = src + (len & ~63); if (H... |
0 | int main(){ int rt, rs; int achi, acli; int dsp; int acho, aclo; int resulth, resultl; int resdsp; achi = 0x05; acli = 0xB4CB; rs = 0xFF06; rt = 0xCB00; resulth = 0x04; resultl = 0x947438CB; __asm ("mthi %2, $ac1\n\t" "mtlo %3, $ac1\n\t" "maq_s.w.phr $ac1, %4, %5\n\t" "mfhi %0, $ac1\n\t" "mflo %1, $ac1\n\t" : "=r"(acho... |
0 | int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind, const char *version, const char *serial){ int cylinders, heads, secs; uint64_t nb_sectors; s->bs = bs; s->drive_kind = kind; bdrv_get_geometry(bs, &nb_sectors); bdrv_guess_geometry(bs, &cylinders, &heads, &secs); if (cylinders < 1 || cylinders > 1... |
0 | int subch_device_load(SubchDev *s, QEMUFile *f){ SubchDev *old_s; Error *err = NULL; uint16_t old_schid = s->schid; uint16_t old_devno = s->devno; int i; s->cssid = qemu_get_byte(f); s->ssid = qemu_get_byte(f); s->schid = qemu_get_be16(f); s->devno = qemu_get_be16(f); if (s->devno != old_devno) { /* Only possible if ma... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.