label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void gdb_accept(void *opaque){ GDBState *s; struct sockaddr_in sockaddr; socklen_t len; int val, fd; for(;;) { len = sizeof(sockaddr); fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len); if (fd < 0 && errno != EINTR) { perror("accept"); return; } else if (fd >= 0) { break; } } /* set short latency */ ... |
0 | bool desc_ring_set_size(DescRing *ring, uint32_t size){ int i; if (size < 2 || size > 0x10000 || (size & (size - 1))) { DPRINTF("ERROR: ring[%d] size (%d) not a power of 2 " "or in range [2, 64K]\n", ring->index, size); return false; } for (i = 0; i < ring->size; i++) { if (ring->info[i].buf) { g_free(ring->info[i].buf... |
0 | kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ){ kern_return_t kernResult; mach_port_t masterPort; CFMutableDictionaryRef classesToMatch; kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort ); if ( KERN_SUCCESS != kernResult ) { printf( "IOMasterPort returned %d\n", kernResult ); } classesToMatch ... |
0 | static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is64){ TCGReg datalo, datahi, addrlo; TCGReg addrhi __attribute__((unused)); TCGMemOpIdx oi; TCGMemOp opc;#if defined(CONFIG_SOFTMMU) int mem_index; TCGMemOp s_bits; tcg_insn_unit *label_ptr[2];#endif datalo = *args++; datahi = (TCG_TARGET_REG_BITS == ... |
0 | static int create_header32(DumpState *s){ int ret = 0; DiskDumpHeader32 *dh = NULL; KdumpSubHeader32 *kh = NULL; size_t size; int endian = s->dump_info.d_endian; uint32_t block_size; uint32_t sub_hdr_size; uint32_t bitmap_blocks; uint32_t status = 0; uint64_t offset_note; /* write common header, the version of kdump-co... |
0 | static int mov_read_header(AVFormatContext *s){ MOVContext *mov = s->priv_data; AVIOContext *pb = s->pb; int err; MOVAtom atom = { AV_RL32("root") }; int i; mov->fc = s; /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */ if (pb->seekable) atom.size = avio_size(pb); else atom... |
0 | static uint32_t bitband_readb(void *opaque, target_phys_addr_t offset){ uint8_t v; cpu_physical_memory_read(bitband_addr(opaque, offset), &v, 1); return (v & (1 << ((offset >> 2) & 7))) != 0;} |
0 | static int imc_decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; IMCContext *q = avctx->priv_data; int stream_format_code; int imc_hdr, i, j; int flag; int bits, summer; int counter, bitscount; LOCAL_ALIGNED_16(uint16_t, buf1... |
0 | void av_register_all(void){ static int initialized; if (initialized) return; initialized = 1; avcodec_register_all(); /* (de)muxers */ REGISTER_MUXER (A64, a64); REGISTER_DEMUXER (AAC, aac); REGISTER_MUXDEMUX (AC3, ac3); REGISTER_MUXER (ADTS, adts); REGISTER_DEMUXER (AEA, aea); REGISTER_MUXDEMUX (AIFF, aiff); REGISTER_... |
0 | static void av_always_inline filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, const int16_t bS[7], int bsi, int qp, int intra ) { const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8); int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset; int alpha = alpha_table[index_a]; int beta = beta_table[... |
0 | static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt){ int i; AVCodec *enc= avcodec_find_encoder(AV_CODEC_ID_SNOW); for(i=0; i<3; i++){ int is_chroma= !!i; int w= ((width + 4*BLOCK-1) & (~(2*BLOCK-1)))>>is_chroma; int h= ((height + 4*BLOCK-1... |
0 | double av_expr_eval(AVExpr *e, const double *const_values, void *opaque){ Parser p; p.const_values = const_values; p.opaque = opaque; return eval_expr(&p, e);} |
0 | static void cirrus_bitblt_cputovideo_next(CirrusVGAState * s){ int copy_count; uint8_t *end_ptr; if (s->cirrus_srccounter > 0) { if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) { cirrus_bitblt_common_patterncopy(s, false); the_end: s->cirrus_srccounter = 0; cirrus_bitblt_reset(s); } else { /* at least one scan lin... |
0 | static coroutine_fn int nbd_negotiate(NBDClient *client, Error **errp){ char buf[8 + 8 + 8 + 128]; int ret; const uint16_t myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_WRITE_ZEROES); bool oldStyle; /* Old style negotiation header without options [ 0 .. 7] ... |
0 | static void intel_hda_update_irq(IntelHDAState *d){ bool msi = msi_enabled(&d->pci); int level; intel_hda_update_int_sts(d); if (d->int_sts & (1U << 31) && d->int_ctl & (1U << 31)) { level = 1; } else { level = 0; } dprint(d, 2, "%s: level %d [%s]\n", __FUNCTION__, level, msi ? "msi" : "intx"); if (msi) { if (level) { ... |
0 | static void tcg_out_ext8s(TCGContext *s, int dest, int src, int rexw){ /* movsbl */ assert(src < 4 || TCG_TARGET_REG_BITS == 64); tcg_out_modrm(s, OPC_MOVSBL + P_REXB_RM + rexw, dest, src);} |
0 | static void *bamboo_load_device_tree(target_phys_addr_t addr, uint32_t ramsize, target_phys_addr_t initrd_base, target_phys_addr_t initrd_size, const char *kernel_cmdline){ void *fdt = NULL;#ifdef CONFIG_FDT uint32_t mem_reg_property[] = { 0, 0, ramsize }; char *filename; int fdt_size; int ret; filename = qemu_find_fil... |
0 | static uint64_t lan9118_16bit_mode_read(void *opaque, target_phys_addr_t offset, unsigned size){ switch (size) { case 2: return lan9118_readw(opaque, offset); case 4: return lan9118_readl(opaque, offset, size); } hw_error("lan9118_read: Bad size 0x%x\n", size); return 0;} |
0 | static int local_lremovexattr(FsContext *ctx, const char *path, const char *name){ if ((ctx->fs_sm == SM_MAPPED) && (strncmp(name, "user.virtfs.", 12) == 0)) { /* * Don't allow fetch of user.virtfs namesapce * in case of mapped security */ errno = EACCES; return -1; } return lremovexattr(rpath(ctx, path), name);} |
0 | static void nvic_writel(NVICState *s, uint32_t offset, uint32_t value, MemTxAttrs attrs){ ARMCPU *cpu = s->cpu; switch (offset) { case 0xd04: /* Interrupt Control State. */ if (value & (1 << 31)) { armv7m_nvic_set_pending(s, ARMV7M_EXCP_NMI); } if (value & (1 << 28)) { armv7m_nvic_set_pending(s, ARMV7M_EXCP_PENDSV); } ... |
0 | static int start_auth_vencrypt(VncState *vs){ /* Send VeNCrypt version 0.2 */ vnc_write_u8(vs, 0); vnc_write_u8(vs, 2); vnc_read_when(vs, protocol_client_vencrypt_init, 2); return 0;} |
0 | 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"; break; case 1: CP0_CHECK(ctx->insn_flags & ASE_MT); gen_helper... |
0 | static int avi_read_idx1(AVFormatContext *s, int size){ AVIContext *avi = s->priv_data; AVIOContext *pb = s->pb; int nb_index_entries, i; AVStream *st; AVIStream *ast; unsigned int index, tag, flags, pos, len, first_packet = 1; unsigned last_pos= -1; int64_t idx1_pos, first_packet_pos = 0, data_offset = 0; nb_index_ent... |
0 | nvdimm_build_structure_memdev(GArray *structures, DeviceState *dev){ NvdimmNfitMemDev *nfit_memdev; uint64_t addr = object_property_get_int(OBJECT(dev), PC_DIMM_ADDR_PROP, NULL); uint64_t size = object_property_get_int(OBJECT(dev), PC_DIMM_SIZE_PROP, NULL); int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_P... |
0 | static void apic_reset(void *opaque){ APICState *s = opaque; int bsp = cpu_is_bsp(s->cpu_env); s->apicbase = 0xfee00000 | (bsp ? MSR_IA32_APICBASE_BSP : 0) | MSR_IA32_APICBASE_ENABLE; apic_init_ipi(s); if (bsp) { /* * LINT0 delivery mode on CPU #0 is set to ExtInt at initialization * time typically by BIOS, so PIC inte... |
0 | static void mipsnet_cleanup(NetClientState *nc){ MIPSnetState *s = qemu_get_nic_opaque(nc); s->nic = NULL;} |
0 | int virtio_set_status(VirtIODevice *vdev, uint8_t val){ VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); trace_virtio_set_status(vdev, val); if (virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) { if (!(vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) && val & VIRTIO_CONFIG_S_FEATURES_OK) { int ret = virtio_validate_featur... |
0 | START_TEST(unterminated_string){ QObject *obj = qobject_from_json("\"abc"); fail_unless(obj == NULL);} |
0 | qio_channel_socket_accept(QIOChannelSocket *ioc, Error **errp){ QIOChannelSocket *cioc; cioc = QIO_CHANNEL_SOCKET(object_new(TYPE_QIO_CHANNEL_SOCKET)); cioc->fd = -1; cioc->remoteAddrLen = sizeof(ioc->remoteAddr); cioc->localAddrLen = sizeof(ioc->localAddr);#ifdef WIN32 QIO_CHANNEL(cioc)->event = CreateEvent(NULL, FALS... |
0 | static av_cold int encode_init_ls(AVCodecContext *ctx){ ctx->coded_frame = av_frame_alloc(); if (!ctx->coded_frame) return AVERROR(ENOMEM); ctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; ctx->coded_frame->key_frame = 1; if (ctx->pix_fmt != AV_PIX_FMT_GRAY8 && ctx->pix_fmt != AV_PIX_FMT_GRAY16 && ctx->pix_fmt != AV_PI... |
1 | static int mov_flush_fragment(AVFormatContext *s){ MOVMuxContext *mov = s->priv_data; int i, first_track = -1; int64_t mdat_size = 0; if (!(mov->flags & FF_MOV_FLAG_FRAGMENT)) return 0; if (mov->fragments == 0) { int64_t pos = avio_tell(s->pb); uint8_t *buf; int buf_size, moov_size; for (i = 0; i < mov->nb_streams; i++... |
0 | void dsputil_init_mmi(void){ clear_blocks = clear_blocks_mmi; put_pixels_tab[1][0] = put_pixels8_mmi; put_no_rnd_pixels_tab[1][0] = put_pixels8_mmi; put_pixels_tab[0][0] = put_pixels16_mmi; put_no_rnd_pixels_tab[0][0] = put_pixels16_mmi; get_pixels = get_pixels_mmi;} |
1 | static void usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused){ struct endp_data *endp = priv; USBRedirDevice *dev = endp->dev; struct buf_packet *bufp; int i = 0; qemu_put_be32(f, endp->bufpq_size); QTAILQ_FOREACH(bufp, &endp->bufpq, next) { DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size... |
1 | void palette8tobgr15(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette){long i;for(i=0; i<num_pixels; i++)((uint16_t *)dst)[i] = bswap_16(((uint16_t *)palette)[ src[i] ]);} |
1 | static inline int16_t mipsdsp_sat_add_i16(int16_t a, int16_t b, CPUMIPSState *env){ int16_t tempS; tempS = a + b; if (MIPSDSP_OVERFLOW(a, b, tempS, 0x8000)) { if (a > 0) { tempS = 0x7FFF; } else { tempS = 0x8000; } set_DSPControl_overflow_flag(1, 20, env); } return tempS;} |
1 | static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt){ /* FIXME - also support UYVY output? */ return ff_vf_next_config(vf, width * vf->priv->scalew, height / vf->priv->scaleh - vf->priv->skipline, d_width, d_height, flags, IMGFMT_YV12);} |
1 | void av_register_input_format(AVInputFormat *format){ AVInputFormat **p = last_iformat; format->next = NULL; while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format)) p = &(*p)->next; last_iformat = &format->next;} |
1 | static int dnxhd_decode_row(AVCodecContext *avctx, void *data, int rownb, int threadnb){ const DNXHDContext *ctx = avctx->priv_data; uint32_t offset = ctx->mb_scan_index[rownb]; RowContext *row = ctx->rows + threadnb; int x; row->last_dc[0] = row->last_dc[1] = row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels ... |
1 | static inline int onenand_prog_main(OneNANDState *s, int sec, int secn, void *src){ int result = 0; if (secn > 0) { uint32_t size = (uint32_t)secn * 512; const uint8_t *sp = (const uint8_t *)src; uint8_t *dp = 0; if (s->blk_cur) { dp = g_malloc(size); if (!dp || blk_read(s->blk_cur, sec, dp, secn) < 0) { result = 1; } ... |
1 | static gboolean ga_channel_listen_accept(GIOChannel *channel, GIOCondition condition, gpointer data){ GAChannel *c = data; int ret, client_fd; bool accepted = false; struct sockaddr_un addr; socklen_t addrlen = sizeof(addr); g_assert(channel != NULL); client_fd = qemu_accept(g_io_channel_unix_get_fd(channel), (struct s... |
1 | static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame){ AVCodecInternal *avci = avctx->internal; DecodeSimpleContext *ds = &avci->ds; AVPacket *pkt = ds->in_pkt; // copy to ensure we do not change pkt AVPacket tmp; int got_frame, actual_got_frame, did_split; int ret; if (!pkt->data && !avci->draining)... |
1 | static void pool_release_buffer(void *opaque, uint8_t *data){ BufferPoolEntry *buf = opaque; AVBufferPool *pool = buf->pool; add_to_pool(buf); if (!avpriv_atomic_int_add_and_fetch(&pool->refcount, -1)) buffer_pool_free(pool);} |
1 | static int nbd_negotiate_options(NBDClient *client){ uint32_t flags; bool fixedNewstyle = false; /* Client sends: [ 0 .. 3] client flags [ 0 .. 7] NBD_OPTS_MAGIC [ 8 .. 11] NBD option [12 .. 15] Data length ... Rest of request [ 0 .. 7] NBD_OPTS_MAGIC [ 8 .. 11] Second NBD option [12 .. 15] Data length ... Rest of requ... |
1 | static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val){ int index = IS_USER(s); s->is_mem = 1; switch(opsize) { case OS_BYTE: tcg_gen_qemu_st8(val, addr, index); break; case OS_WORD: tcg_gen_qemu_st16(val, addr, index); break; case OS_LONG: case OS_SINGLE: tcg_gen_qemu_st32(val, addr, index); br... |
1 | void blk_mig_init(void){ QSIMPLEQ_INIT(&block_mig_state.bmds_list); QSIMPLEQ_INIT(&block_mig_state.blk_list); qemu_mutex_init(&block_mig_state.lock); register_savevm_live(NULL, "block", 0, 1, &savevm_block_handlers, &block_mig_state);} |
1 | qcrypto_tls_session_check_certificate(QCryptoTLSSession *session, Error **errp){ int ret; unsigned int status; const gnutls_datum_t *certs; unsigned int nCerts, i; time_t now; gnutls_x509_crt_t cert = NULL; now = time(NULL); if (now == ((time_t)-1)) { error_setg_errno(errp, errno, "Cannot get current time"); return -1;... |
1 | static inline int32_t mipsdsp_add_i32(int32_t a, int32_t b, CPUMIPSState *env){ int32_t temp; temp = a + b; if (MIPSDSP_OVERFLOW(a, b, temp, 0x80000000)) { set_DSPControl_overflow_flag(1, 20, env); } return temp;} |
1 | static void qtrle_decode_8bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change){ int rle_code; int pixel_ptr; int row_inc = s->frame.linesize[0]; unsigned char pi1, pi2, pi3, pi4; /* 4 palette indexes */ unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; w... |
1 | static inline void libopenjpeg_copyto16(AVFrame *picture, opj_image_t *image) { int *comp_data; uint16_t *img_ptr; int index, x, y; int adjust[4]; for (x = 0; x < image->numcomps; x++) adjust[x] = FFMAX(FFMIN(av_pix_fmt_desc_get(picture->format)->comp[x].depth_minus1 + 1 - image->comps[x].prec, 8), 0); for (index = 0; ... |
1 | static int filter_frame(AVFilterLink *inlink, AVFrame *buf){ AVFilterContext *ctx = inlink->dst; VolumeContext *vol = inlink->dst->priv; AVFilterLink *outlink = inlink->dst->outputs[0]; int nb_samples = buf->nb_samples; AVFrame *out_buf; int64_t pos; AVFrameSideData *sd = av_frame_get_side_data(buf, AV_FRAME_DATA_REPLA... |
0 | static int hnm_read_packet(AVFormatContext *s, AVPacket *pkt){ Hnm4DemuxContext *hnm = s->priv_data; AVIOContext *pb = s->pb; int ret = 0; uint32_t superchunk_size, chunk_size; uint16_t chunk_id; if (hnm->currentframe == hnm->frames || pb->eof_reached) return AVERROR_EOF; if (hnm->superchunk_remaining == 0) { /* parse ... |
0 | static int flv_write_packet(AVFormatContext *s, AVPacket *pkt){ AVIOContext *pb = s->pb; AVCodecContext *enc = s->streams[pkt->stream_index]->codec; FLVContext *flv = s->priv_data; unsigned ts; int size= pkt->size; uint8_t *data= NULL; int flags, flags_size;// av_log(s, AV_LOG_DEBUG, "type:%d pts: %"PRId64" size:%d\n",... |
0 | static int avi_write_idx1(AVFormatContext *s){ AVIOContext *pb = s->pb; AVIContext *avi = s->priv_data; int64_t idx_chunk; int i; char tag[5]; if (pb->seekable) { AVIStream *avist; AVIIentry *ie = 0, *tie; int empty, stream_id = -1; idx_chunk = ff_start_tag(pb, "idx1"); for (i = 0; i < s->nb_streams; i++) { avist = s->... |
0 | static int vc1_decode_p_mb_intfr(VC1Context *v){ MpegEncContext *s = &v->s; GetBitContext *gb = &s->gb; int i; int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int cbp = 0; /* cbp decoding stuff */ int mqdiff, mquant; /* MB quantization */ int ttmb = v->ttfrm; /* MB Transform type */ int mb_has_coeffs = 1; /* last_flag *... |
0 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; ZmbvContext * const c = avctx->priv_data; int zret = Z_OK; // Zlib return code int len = buf_size; int hi_ver, lo_ver, ret; if (c->pic.data[0]) avctx->release_buffer... |
0 | static int idcin_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; IdcinContext *s = avctx->priv_data; const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL); AVFrame *frame = data; int ret; s->buf = bu... |
1 | static int sunrast_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; SUNRASTContext * const s = avctx->priv_data; AVFrame *picture = data; AVFrame * const p = &s->picture; unsigned int w, h, depth, type, maptype, maplength, stride, x, y, len, alen; uint... |
1 | static void nand_command(NANDFlashState *s){ unsigned int offset; switch (s->cmd) { case NAND_CMD_READ0: s->iolen = 0; break; case NAND_CMD_READID: s->ioaddr = s->io; s->iolen = 0; nand_pushio_byte(s, s->manf_id); nand_pushio_byte(s, s->chip_id); nand_pushio_byte(s, 'Q'); /* Don't-care byte (often 0xa5) */ if (nand_fla... |
1 | static void readline_hist_add(ReadLineState *rs, const char *cmdline){ char *hist_entry, *new_entry; int idx; if (cmdline[0] == '\0')return; new_entry = NULL; if (rs->hist_entry != -1) {/* We were editing an existing history entry: replace it */hist_entry = rs->history[rs->hist_entry];idx = rs->hist_entry;if (strcmp(hi... |
1 | static int flush_blks(QEMUFile *f){ BlkMigBlock *blk; int ret = 0; DPRINTF("%s Enter submitted %d read_done %d transferred %d\n", __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done, block_mig_state.transferred); blk_mig_lock(); while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) { if (qemu... |
1 | static int bitplane_decoding(BitPlane *bp, VC9Context *v){ GetBitContext *gb = &v->s.gb; int imode, x, y, code, use_vertical_tile, tile_w, tile_h; uint8_t invert, *planep = bp->data; invert = get_bits(gb, 1); imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2); bp->is_raw = 0; switch (imode) { case IMODE_R... |
1 | static void sx1_init(MachineState *machine, const int version){ struct omap_mpu_state_s *mpu; MemoryRegion *address_space = get_system_memory(); MemoryRegion *flash = g_new(MemoryRegion, 1); MemoryRegion *flash_1 = g_new(MemoryRegion, 1); MemoryRegion *cs = g_new(MemoryRegion, 4); static uint32_t cs0val = 0x00213090; s... |
0 | static void avc_luma_mid_16w_msa(const uint8_t *src, 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_mid_8w_msa(src, src_stride, dst, dst_stride, height); src += 8; dst += 8; }} |
0 | static int mpeg_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ int i, j, k, cbp, val, mb_type, motion_type; const int mb_block_count = 4 + (1 << s->chroma_format); av_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y); assert(s->mb_skipped == 0); if (s->mb_skip_run-- != 0) { if (s->pict_type == AV_PICTURE... |
0 | AVFilterBufferRef *avfilter_get_audio_buffer(AVFilterLink *link, int perms, enum AVSampleFormat sample_fmt, int size, int64_t channel_layout, int planar){ AVFilterBufferRef *ret = NULL; if (link->dstpad->get_audio_buffer) ret = link->dstpad->get_audio_buffer(link, perms, sample_fmt, size, channel_layout, planar); if (!... |
0 | bool qemu_log_in_addr_range(uint64_t addr){ if (debug_regions) { int i = 0; for (i = 0; i < debug_regions->len; i++) { Range *range = &g_array_index(debug_regions, Range, i); if (addr >= range->begin && addr <= range->end - 1) { return true; } } return false; } else { return true; }} |
0 | static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s){ int64_t rt = qemu_get_clock(rt_clock); if (s->rtsr & (1 << 12)) s->last_swcr += (rt - s->last_sw) / 10; s->last_sw = rt;} |
0 | static int net_socket_connect_init(NetClientState *peer, const char *model, const char *name, const char *host_str){ socket_connect_data *c = g_new0(socket_connect_data, 1); int fd = -1; Error *local_error = NULL; c->peer = peer; c->model = g_strdup(model); c->name = g_strdup(name); c->saddr = socket_parse(host_str, &l... |
0 | int css_do_hsch(SubchDev *sch){ SCSW *s = &sch->curr_status.scsw; PMCW *p = &sch->curr_status.pmcw; int ret; if (!(p->flags & (PMCW_FLAGS_MASK_DNV | PMCW_FLAGS_MASK_ENA))) { ret = -ENODEV; goto out; } if (((s->ctrl & SCSW_CTRL_MASK_STCTL) == SCSW_STCTL_STATUS_PEND) || (s->ctrl & (SCSW_STCTL_PRIMARY | SCSW_STCTL_SECONDA... |
0 | static void xilinx_spips_flush_txfifo(XilinxSPIPS *s){ for (;;) { int i; uint8_t rx; uint8_t tx = 0; for (i = 0; i < num_effective_busses(s); ++i) { if (!i || s->snoop_state == SNOOP_STRIPING) { if (fifo8_is_empty(&s->tx_fifo)) { s->regs[R_INTR_STATUS] |= IXR_TX_FIFO_UNDERFLOW; xilinx_spips_update_ixr(s); return; } els... |
0 | void memory_region_set_skip_dump(MemoryRegion *mr){ mr->skip_dump = true;} |
0 | static int no_init_out (HWVoiceOut *hw, audsettings_t *as){ audio_pcm_init_info (&hw->info, as); hw->samples = 1024; return 0;} |
0 | static void __attribute__((constructor)) init_cpuid_cache(void){ int max = __get_cpuid_max(0, NULL); int a, b, c, d; unsigned cache = 0; if (max >= 1) { __cpuid(1, a, b, c, d); if (d & bit_SSE2) { cache |= CACHE_SSE2; }#ifdef CONFIG_AVX2_OPT if (c & bit_SSE4_1) { cache |= CACHE_SSE4; } /* We must check that AVX is not ... |
0 | static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size, int parse_extradata){ MpegEncContext *const s = &h->s; AVCodecContext *const avctx = s->avctx; H264Context *hx; ///< thread context int buf_index; int context_count; int next_avc; int pass = !(avctx->active_thread_type & FF_THREAD_FRAME); int... |
0 | static void gen_exception_return(DisasContext *s, TCGv_i32 pc){ TCGv_i32 tmp; store_reg(s, 15, pc); tmp = load_cpu_field(spsr); gen_set_cpsr(tmp, CPSR_ERET_MASK); tcg_temp_free_i32(tmp); s->is_jmp = DISAS_JUMP;} |
0 | void object_property_add_link(Object *obj, const char *name, const char *type, Object **child, void (*check)(Object *, const char *, Object *, Error **), ObjectPropertyLinkFlags flags, Error **errp){ Error *local_err = NULL; LinkProperty *prop = g_malloc(sizeof(*prop)); gchar *full_type; prop->child = child; prop->chec... |
0 | void ioinst_handle_csch(S390CPU *cpu, uint64_t reg1){ int cssid, ssid, schid, m; SubchDev *sch; int ret = -ENODEV; int cc; if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) { program_interrupt(&cpu->env, PGM_OPERAND, 2); return; } trace_ioinst_sch_id("csch", cssid, ssid, schid); sch = css_find_subch(m,... |
0 | static void curl_multi_read(BDRVCURLState *s){ int msgs_in_queue; /* Try to find done transfers, so we can free the easy * handle again. */ do { CURLMsg *msg; msg = curl_multi_info_read(s->multi, &msgs_in_queue); if (!msg) break; if (msg->msg == CURLMSG_NONE) break; switch (msg->msg) { case CURLMSG_DONE: { CURLState *s... |
0 | static void init_blk_migration(Monitor *mon, QEMUFile *f){ BlkMigDevState *bmds; BlockDriverState *bs; int64_t sectors; block_mig_state.submitted = 0; block_mig_state.read_done = 0; block_mig_state.transferred = 0; block_mig_state.total_sector_sum = 0; block_mig_state.prev_progress = -1; block_mig_state.bulk_completed ... |
0 | static void init_proc_970MP (CPUPPCState *env){ gen_spr_ne_601(env); gen_spr_7xx(env); /* Time base */ gen_tbl(env); /* Hardware implementation registers */ /* XXX : not implemented */ spr_register(env, SPR_HID0, "HID0", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, &spr_write_clear, 0x60000000); /* XXX : not implemen... |
0 | static void platform_mmio_write(ReadWriteHandler *handler, pcibus_t addr, uint32_t val, int len){ DPRINTF("Warning: attempted write of 0x%x to physical " "address 0x" TARGET_FMT_plx " in xen platform mmio space\n", val, addr);} |
0 | int pci_piix3_xen_ide_unplug(DeviceState *dev){ PCIIDEState *pci_ide; DriveInfo *di; int i; IDEDevice *idedev; pci_ide = PCI_IDE(dev); for (i = 0; i < 4; i++) { di = drive_get_by_index(IF_IDE, i); if (di != NULL && !di->media_cd) { BlockBackend *blk = blk_by_legacy_dinfo(di); DeviceState *ds = blk_get_attached_dev(blk)... |
0 | static void shift_history(DCAEncContext *c, const int32_t *input){ int k, ch; for (k = 0; k < 512; k++) for (ch = 0; ch < c->channels; ch++) { const int chi = c->channel_order_tab[ch]; c->history[k][ch] = input[k * c->channels + chi]; }} |
0 | static void init_vlcs(){ static int done = 0; if (!done) { done = 1; init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, vlc_dc_lum_bits, 1, 1, vlc_dc_lum_code, 2, 2); init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12, vlc_dc_chroma_bits, 1, 1, vlc_dc_chroma_code, 2, 2); init_vlc(&mv_vlc, MV_VLC_BITS, 17, &mbMotionVectorTable[0][1], 2, 1, &... |
0 | static void png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type, uint8_t *src, uint8_t *last, int size, int bpp){ int i, p, r, g, b, a; switch (filter_type) { case PNG_FILTER_VALUE_NONE: memcpy(dst, src, size); break; case PNG_FILTER_VALUE_SUB: for (i = 0; i < bpp; i++) dst[i] = src[i]; if (bpp == 4) { p =... |
1 | av_cold int ff_mpv_common_init(MpegEncContext *s){ int i; int nb_slices = (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1; if (s->encoding && s->avctx->slices) nb_slices = s->avctx->slices; if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence) s->mb_height ... |
1 | int ff_socket(int af, int type, int proto){ int fd;#ifdef SOCK_CLOEXEC fd = socket(af, type | SOCK_CLOEXEC, proto); if (fd == -1 && errno == EINVAL)#endif { fd = socket(af, type, proto);#if HAVE_FCNTL if (fd != -1) fcntl(fd, F_SETFD, FD_CLOEXEC);#endif } return fd;} |
1 | static int nuv_header(AVFormatContext *s){ NUVContext *ctx = s->priv_data; AVIOContext *pb = s->pb; char id_string[12]; double aspect, fps; int is_mythtv, width, height, v_packs, a_packs; AVStream *vst = NULL, *ast = NULL; avio_read(pb, id_string, 12); is_mythtv = !memcmp(id_string, "MythTVVideo", 12); avio_skip(pb, 5)... |
1 | static int qcow2_update_ext_header(BlockDriverState *bs, const char *backing_file, const char *backing_fmt){ size_t backing_file_len = 0; size_t backing_fmt_len = 0; BDRVQcowState *s = bs->opaque; QCowExtension ext_backing_fmt = {0, 0}; int ret; /* Backing file format doesn't make sense without a backing file */ if (ba... |
1 | static int img_dd(int argc, char **argv){ int ret = 0; char *arg = NULL; char *tmp; BlockDriver *drv = NULL, *proto_drv = NULL; BlockBackend *blk1 = NULL, *blk2 = NULL; QemuOpts *opts = NULL; QemuOptsList *create_opts = NULL; Error *local_err = NULL; bool image_opts = false; int c, i; const char *out_fmt = "raw"; const... |
1 | static int imx_eth_can_receive(NetClientState *nc){ IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); FEC_PRINTF("\n"); return s->regs[ENET_RDAR] ? 1 : 0;} |
1 | static int dfa_probe(AVProbeData *p){ if (p->buf_size < 4 || AV_RL32(p->buf) != MKTAG('D', 'F', 'I', 'A')) return 0; return AVPROBE_SCORE_MAX;} |
0 | static void ohci_sof(OHCIState *ohci){ ohci->sof_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); timer_mod(ohci->eof_timer, ohci->sof_time + usb_frame_time); ohci_set_interrupt(ohci, OHCI_INTR_SF);} |
0 | static CPAccessResult pmreg_access(CPUARMState *env, const ARMCPRegInfo *ri, bool isread){ /* Performance monitor registers user accessibility is controlled * by PMUSERENR. */ if (arm_current_el(env) == 0 && !env->cp15.c9_pmuserenr) { return CP_ACCESS_TRAP; } return CP_ACCESS_OK;} |
0 | static target_ulong h_enter(PowerPCCPU *cpu, sPAPRMachineState *spapr, target_ulong opcode, target_ulong *args){ CPUPPCState *env = &cpu->env; target_ulong flags = args[0]; target_ulong pte_index = args[1]; target_ulong pteh = args[2]; target_ulong ptel = args[3]; unsigned apshift, spshift; target_ulong raddr; target_u... |
0 | static void init_excp_602 (CPUPPCState *env){#if !defined(CONFIG_USER_ONLY) env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100; env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200; env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300; env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400; env->excp_vectors[POWERPC_EXCP_EXTERNAL... |
0 | static void unplug_nic(PCIBus *b, PCIDevice *d){ if (pci_get_word(d->config + PCI_CLASS_DEVICE) == PCI_CLASS_NETWORK_ETHERNET) { qdev_unplug(&(d->qdev), NULL); }} |
0 | static inline int handle_cpu_signal(uintptr_t pc, unsigned long address, int is_write, sigset_t *old_set, void *puc){ TranslationBlock *tb; int ret; if (cpu_single_env) { env = cpu_single_env; /* XXX: find a correct solution for multithread */ }#if defined(DEBUG_SIGNAL) qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08... |
0 | static char *qemu_rbd_parse_clientname(const char *conf, char *clientname){ const char *p = conf; while (*p) { int len; const char *end = strchr(p, ':'); if (end) { len = end - p; } else { len = strlen(p); } if (strncmp(p, "id=", 3) == 0) { len -= 3; strncpy(clientname, p + 3, len); clientname[len] = '\0'; return clien... |
0 | int float64_le_quiet( float64 a, float64 b STATUS_PARAM ){ flag aSign, bSign; if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { float_raise( float_flag_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.