label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void virtio_setup(uint64_t dev_info){ struct schib schib; int i; int r; bool found = false; bool check_devno = false; uint16_t dev_no = -1; blk_schid.one = 1; if (dev_info != -1) { check_devno = true; dev_no = dev_info & 0xffff; debug_print_int("device no. ", dev_no); blk_schid.ssid = (dev_info >> 16) & 0x3; if ... |
0 | void memory_region_init_ram(MemoryRegion *mr, const char *name, uint64_t size){ memory_region_init(mr, name, size); mr->ram = true; mr->terminates = true; mr->destructor = memory_region_destructor_ram; mr->ram_addr = qemu_ram_alloc(size, mr); mr->backend_registered = true;} |
0 | static uint64_t pchip_read(void *opaque, hwaddr addr, unsigned size){ TyphoonState *s = opaque; uint64_t ret = 0; if (addr & 4) { return s->latch_tmp; } switch (addr) { case 0x0000: /* WSBA0: Window Space Base Address Register. */ ret = s->pchip.win[0].base_addr; break; case 0x0040: /* WSBA1 */ ret = s->pchip.win[1].ba... |
0 | void cpu_x86_update_dr7(CPUX86State *env, uint32_t new_dr7){ int i; for (i = 0; i < DR7_MAX_BP; i++) { hw_breakpoint_remove(env, i); } env->dr[7] = new_dr7; for (i = 0; i < DR7_MAX_BP; i++) { hw_breakpoint_insert(env, i); }} |
0 | int ffurl_get_file_handle(URLContext *h){ if (!h->prot->url_get_file_handle) return -1; return h->prot->url_get_file_handle(h);} |
0 | static void cmd_read_toc_pma_atip(IDEState *s, uint8_t* buf){ int format, msf, start_track, len; uint64_t total_sectors = s->nb_sectors >> 2; int max_len; if (total_sectors == 0) { ide_atapi_cmd_error(s, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT); return; } max_len = ube16_to_cpu(buf + 7); format = buf[9] >> 6; msf = (bu... |
0 | av_cold void ff_rv40dsp_init(RV34DSPContext *c, DSPContext* dsp) { ff_rv34dsp_init(c, dsp); c->put_pixels_tab[0][ 0] = dsp->put_h264_qpel_pixels_tab[0][0]; c->put_pixels_tab[0][ 1] = put_rv40_qpel16_mc10_c; c->put_pixels_tab[0][ 2] = dsp->put_h264_qpel_pixels_tab[0][2]; c->put_pixels_tab[0][ 3] = put_rv40_qpel16_mc30_c... |
0 | static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length){ int i, consumed, ret = 0; s->ref = NULL; s->eos = 0; /* split the input packet into NAL units, so we know the upper bound on the * number of slices in the frame */ s->nb_nals = 0; while (length >= 4) { HEVCNAL *nal; int extract_length = 0; if ... |
0 | static always_inline void gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb, int search_pc){ DisasContext ctx, *ctxp = &ctx; opc_handler_t **table, *handler; target_ulong pc_start; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj = -1; int num_insns; int max_insns; pc_start = tb->pc; gen_opc_end = ... |
0 | static int slb_lookup (CPUPPCState *env, target_ulong eaddr, target_ulong *vsid, target_ulong *page_mask, int *attr){ target_phys_addr_t sr_base; target_ulong mask; uint64_t tmp64; uint32_t tmp; int n, ret; int slb_nr; ret = -5; sr_base = env->spr[SPR_ASR];#if defined(DEBUG_SLB) if (loglevel != 0) { fprintf(logfile, "%... |
0 | static const mon_cmd_t *monitor_parse_command(Monitor *mon, const char *cmdline, QDict *qdict){ const char *p, *typestr; int c; const mon_cmd_t *cmd; char cmdname[256]; char buf[1024]; char *key;#ifdef DEBUG monitor_printf(mon, "command='%s'\n", cmdline);#endif /* extract the command name */ p = get_command_name(cmdlin... |
0 | static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov){ BDRVQcowState *s = bs->opaque; int index_in_cluster; uint64_t cluster_offset; int ret = 0, n; struct iovec hd_iov; QEMUIOVector hd_qiov; uint8_t *buf; void *orig_buf; s->cluster_cache_offset = -1; /* di... |
0 | static void start_auth_vencrypt_subauth(VncState *vs){ switch (vs->vd->subauth) { case VNC_AUTH_VENCRYPT_TLSNONE: case VNC_AUTH_VENCRYPT_X509NONE: VNC_DEBUG("Accept TLS auth none\n"); vnc_write_u32(vs, 0); /* Accept auth completion */ start_client_init(vs); break; case VNC_AUTH_VENCRYPT_TLSVNC: case VNC_AUTH_VENCRYPT_X... |
0 | static void disas_test_b_imm(DisasContext *s, uint32_t insn){ unsigned int bit_pos, op, rt; uint64_t addr; int label_match; TCGv_i64 tcg_cmp; bit_pos = (extract32(insn, 31, 1) << 5) | extract32(insn, 19, 5); op = extract32(insn, 24, 1); /* 0: TBZ; 1: TBNZ */ addr = s->pc + sextract32(insn, 5, 14) * 4 - 4; rt = extract3... |
0 | static QObject *parse_escape(JSONParserContext *ctxt, QList **tokens, va_list *ap){ QObject *token = NULL, *obj; QList *working = qlist_copy(*tokens); if (ap == NULL) { goto out; } token = qlist_pop(working); if (token == NULL) { goto out; } if (token_is_escape(token, "%p")) { obj = va_arg(*ap, QObject *); } else if (t... |
0 | ParallelState *parallel_mm_init(target_phys_addr_t base, int it_shift, qemu_irq irq, CharDriverState *chr){ ParallelState *s; int io_sw; s = qemu_mallocz(sizeof(ParallelState)); s->irq = irq; s->chr = chr; s->it_shift = it_shift; qemu_register_reset(parallel_reset, s); io_sw = cpu_register_io_memory(parallel_mm_read_sw... |
0 | int float32_le( float32 a, float32 b STATUS_PARAM ){ flag aSign, bSign; if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { float_raise( float_flag_invalid STATUS_VAR); return 0; } aSign = extractFloat32Sign( a ); bSign = extrac... |
0 | static void ttafilter_init(TTAContext *s, TTAFilter *c, int32_t shift) { memset(c, 0, sizeof(TTAFilter)); if (s->pass) { int i; for (i = 0; i < 8; i++) c->qm[i] = sign_extend(s->crc_pass[i], 8); } c->shift = shift; c->round = shift_1[shift-1];// c->round = 1 << (shift - 1);} |
0 | USBDevice *usb_msd_init(const char *filename, BlockDriverState **pbs){ MSDState *s; BlockDriverState *bdrv; BlockDriver *drv = NULL; const char *p1; char fmt[32]; p1 = strchr(filename, ':'); if (p1++) { const char *p2; if (strstart(filename, "format=", &p2)) { int len = MIN(p1 - p2, sizeof(fmt)); pstrcpy(fmt, len, p2);... |
0 | static int buffered_rate_limit(void *opaque){ QEMUFileBuffered *s = opaque; int ret; ret = qemu_file_get_error(s->file); if (ret) { return ret; } if (s->bytes_xfer > s->xfer_limit) return 1; return 0;} |
0 | static int alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index, void **refcount_block){ BDRVQcowState *s = bs->opaque; unsigned int refcount_table_index; int ret; BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); /* Find the refcount block for the given cluster */ refcount_table_index = cluster_index >> s->re... |
0 | static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, int a_avail, int c_avail, int16_t **dc_val_ptr, int *dir_ptr){ int a, b, c, wrap, pred; int16_t *dc_val; int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int q1, q2 = 0; wrap = s->block_wrap[n]; dc_val = s->dc_val[0] + s->block_index[n]; /* B A ... |
1 | static void external_snapshot_prepare(BlkTransactionState *common, Error **errp){ BlockDriver *drv; int flags, ret; QDict *options = NULL; Error *local_err = NULL; bool has_device = false; const char *device; bool has_node_name = false; const char *node_name; bool has_snapshot_node_name = false; const char *snapshot_no... |
0 | int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen){ int i; // reserve 1 byte for terminating 0 buflen = FFMIN(buflen - 1, maxlen); for (i = 0; i < buflen; i++) if (!(buf[i] = avio_r8(s))) return i + 1; if (buflen) buf[i] = 0; for (; i < maxlen; i++) if (!avio_r8(s)) return i + 1; return maxlen;} |
0 | static int RENAME(swScale)(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]){ /* load a few things into local vars to make the code more readable? and faster */ const int srcW= c->srcW; const int dstW= c->dstW; const int dstH= c->dstH; const int chrDstW... |
1 | static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type){ int i, j, count = 0; int last, t; int A, S, T; int pos = s->pos; uint32_t crc = s->sc.crc; uint32_t crc_extra_bits = s->extra_sc.crc; int16_t *dst16 = dst; int32_t *dst32 = dst; float *dstfl = dst; s->one = s->zero =... |
1 | static void mmu_init (CPUMIPSState *env, const mips_def_t *def){ env->tlb = qemu_mallocz(sizeof(CPUMIPSTLBContext)); switch (def->mmu_type) { case MMU_TYPE_NONE: no_mmu_init(env, def); break; case MMU_TYPE_R4000: r4k_mmu_init(env, def); break; case MMU_TYPE_FMT: fixed_mmu_init(env, def); break; case MMU_TYPE_R3000: cas... |
1 | static void sample_queue_push(HintSampleQueue *queue, uint8_t *data, int size, int sample){ /* No need to keep track of smaller samples, since describing them * with immediates is more efficient. */ if (size <= 14) return; if (!queue->samples || queue->len >= queue->size) { HintSample *samples; samples = av_realloc(que... |
1 | static void gen_spr_power8_tce_address_control(CPUPPCState *env){ spr_register(env, SPR_TAR, "TAR", &spr_read_generic, &spr_write_generic, &spr_read_generic, &spr_write_generic, 0x00000000);} |
1 | static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, int n, int coded, int intra){ int level, i, last, run; int dc_pred_dir; RLTable * rl; RL_VLC_ELEM * rl_vlc; const UINT8 * scan_table; int qmul, qadd; if(intra) {/* DC coef */ if(s->partitioned_frame){ level = s->dc_val[0][ s->block_index[n] ]; if... |
1 | int load_uboot(const char *filename, target_ulong *ep, int *is_linux){ int fd; int size; uboot_image_header_t h; uboot_image_header_t *hdr = &h; uint8_t *data = NULL; fd = open(filename, O_RDONLY | O_BINARY); if (fd < 0) return -1; size = read(fd, hdr, sizeof(uboot_image_header_t)); if (size < 0) goto fail; bswap_uboot... |
1 | static int64_t alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index){ BDRVQcowState *s = bs->opaque; unsigned int refcount_table_index; int ret; BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); /* Find the refcount block for the given cluster */ refcount_table_index = cluster_index >> (s->cluster_bits - REFCO... |
1 | static int parse_vtrk(AVFormatContext *s, FourxmDemuxContext *fourxm, uint8_t *buf, int size){ AVStream *st; /* check that there is enough data */ if (size != vtrk_SIZE) { return AVERROR_INVALIDDATA; } /* allocate a new AVStream */ st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); avpriv_set_pts_info(... |
1 | void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd){ if (bs->backing_hd) { assert(bs->backing_blocker); bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker); } else if (backing_hd) { error_setg(&bs->backing_blocker, "device is used as backing hd of '%s'", bdrv_get_device_name(bs)); } bs->ba... |
1 | static void scsi_command_complete(void *opaque, int ret){ SCSIGenericReq *r = (SCSIGenericReq *)opaque; SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, r->req.dev); r->req.aiocb = NULL; s->driver_status = r->io_header.driver_status; if (s->driver_status & SG_ERR_DRIVER_SENSE) s->senselen = r->io_header.sb_len_w... |
1 | static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, int64_t offset, int64_t length, uint64_t addend, bool decrease, enum qcow2_discard_type type){ BDRVQcowState *s = bs->opaque; int64_t start, last, cluster_offset; uint16_t *refcount_block = NULL; int64_t old_table_index = -1; int ret;#ifdef DEBUG_... |
0 | int ff_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int buf_size){ GetBitContext gb; int specific_config_bitindex; init_get_bits(&gb, buf, buf_size*8); c->object_type = get_object_type(&gb); c->sample_rate = get_sample_rate(&gb, &c->sampling_index); c->chan_config = get_bits(&gb, 4); if (c->chan_confi... |
0 | void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv, int mvp_lx_flag, int LX){ HEVCLocalContext *lc = s->HEVClc; MvField *tab_mvf = s->ref->tab_mvf; int isScaledFlag_L0 = 0; int availableFlagLXA0 = 1; int availableFlagLXB0 = 1; int... |
1 | static void pc_compat_2_0(MachineState *machine){ smbios_legacy_mode = true; has_reserved_memory = false;} |
1 | static CharDriverState *qemu_chr_open_msmouse(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp){ ChardevCommon *common = backend->u.msmouse.data; MouseState *mouse; CharDriverState *chr; chr = qemu_chr_alloc(common, errp); chr->chr_write = msmouse_chr_write; chr->chr_close = msmouse_chr_close; ... |
1 | int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr){#ifdef KVM_CAP_MCE ram_addr_t ram_addr; target_phys_addr_t paddr; if ((env->mcg_cap & MCG_SER_P) && addr && (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) { if (qemu_ram_addr_from_host(addr, &ram_addr) || !kvm_physical_memory_addr_from_ram(env->kvm_sta... |
1 | static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset){ GetBitContext *gb = &v->s.gb; MpegEncContext *s = &v->s; int dc_pred_dir = 0; /* Direction of the DC prediction used */ int run_diff, i; int16_t *dc_val; int16_t *ac_val, *ac_val2; int dcdiff; int mb_pos = ... |
0 | static int can_safely_read(GetBitContext* gb, uint64_t bits) { return get_bits_left(gb) >= bits;} |
0 | static int tta_probe(AVProbeData *p){ const uint8_t *d = p->buf; if (p->buf_size < 4) return 0; if (d[0] == 'T' && d[1] == 'T' && d[2] == 'A' && d[3] == '1') return 80; return 0;} |
0 | static void qcow2_cache_table_release(BlockDriverState *bs, Qcow2Cache *c, int i, int num_tables){/* Using MADV_DONTNEED to discard memory is a Linux-specific feature */#ifdef CONFIG_LINUX BDRVQcow2State *s = bs->opaque; void *t = qcow2_cache_get_table_addr(bs, c, i); int align = getpagesize(); size_t mem_size = (size_... |
0 | static void qpi_init(void){ kqemu_comm_base = 0xff000000 | 1; qpi_io_memory = cpu_register_io_memory( qpi_mem_read, qpi_mem_write, NULL); cpu_register_physical_memory(kqemu_comm_base & ~0xfff, 0x1000, qpi_io_memory);} |
0 | tight_detect_smooth_image(VncState *vs, int w, int h){ uint errors; int compression = vs->tight.compression; int quality = vs->tight.quality; if (!vs->vd->lossy) { return 0; } if (ds_get_bytes_per_pixel(vs->ds) == 1 || vs->clientds.pf.bytes_per_pixel == 1 || w < VNC_TIGHT_DETECT_MIN_WIDTH || h < VNC_TIGHT_DETECT_MIN_HE... |
0 | static void list_formats(AVFormatContext *ctx, int type){ const struct video_data *s = ctx->priv_data; struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FMT, &vfd)) { enum AVCodecID codec_id = avpriv_fmt_v4l2codec(vfd.pixelformat); enum AVPixelFormat pix_fmt = avpri... |
0 | static CharDriverState *qemu_chr_open_pp_fd(int fd, Error **errp){ CharDriverState *chr; ParallelCharDriver *drv; if (ioctl(fd, PPCLAIM) < 0) { error_setg_errno(errp, errno, "not a parallel port"); close(fd); return NULL; } drv = g_new0(ParallelCharDriver, 1); drv->fd = fd; drv->mode = IEEE1284_MODE_COMPAT; chr = qemu_... |
0 | static QError *qerror_from_info(const char *fmt, va_list *va){ QError *qerr; qerr = qerror_new(); loc_save(&qerr->loc); qerr->error = error_obj_from_fmt_no_fail(fmt, va); qerr->err_msg = qerror_format(fmt, qerr->error); return qerr;} |
0 | static void unblock_io_signals(void){ sigset_t set; sigemptyset(&set); sigaddset(&set, SIGUSR2); sigaddset(&set, SIGIO); sigaddset(&set, SIGALRM); pthread_sigmask(SIG_UNBLOCK, &set, NULL); sigemptyset(&set); sigaddset(&set, SIGUSR1); pthread_sigmask(SIG_BLOCK, &set, NULL);} |
0 | float32 helper_fqtos(CPUSPARCState *env){ float32 ret; clear_float_exceptions(env); ret = float128_to_float32(QT1, &env->fp_status); check_ieee_exceptions(env); return ret;} |
0 | float32 float32_round_to_int( float32 a STATUS_PARAM){ flag aSign; int16 aExp; bits32 lastBitMask, roundBitsMask; int8 roundingMode; float32 z; aExp = extractFloat32Exp( a ); if ( 0x96 <= aExp ) { if ( ( aExp == 0xFF ) && extractFloat32Frac( a ) ) { return propagateFloat32NaN( a, a STATUS_VAR ); } return a; } if ( aExp... |
0 | static void do_drive_backup(DriveBackup *backup, BlockJobTxn *txn, Error **errp){ BlockDriverState *bs; BlockDriverState *target_bs; BlockDriverState *source = NULL; BdrvDirtyBitmap *bmap = NULL; AioContext *aio_context; QDict *options = NULL; Error *local_err = NULL; int flags; int64_t size; if (!backup->has_speed) { ... |
0 | static int encrypt_sectors(BDRVQcowState *s, int64_t sector_num, uint8_t *buf, int nb_sectors, bool enc, Error **errp){ union { uint64_t ll[2]; uint8_t b[16]; } ivec; int i; int ret; for(i = 0; i < nb_sectors; i++) { ivec.ll[0] = cpu_to_le64(sector_num); ivec.ll[1] = 0; if (qcrypto_cipher_setiv(s->cipher, ivec.b, G_N_E... |
0 | static void nbd_teardown_connection(BlockDriverState *bs){ NBDClientSession *client = nbd_get_client_session(bs); if (!client->ioc) { /* Already closed */ return; } /* finish any pending coroutines */ qio_channel_shutdown(client->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL); nbd_recv_coroutines_enter_all(bs); nbd_client_detac... |
0 | static int cinepak_decode_strip (CinepakContext *s, cvid_strip *strip, const uint8_t *data, int size){ const uint8_t *eod = (data + size); int chunk_id, chunk_size; /* coordinate sanity checks */ if (strip->x1 >= s->width || strip->x2 > s->width || strip->y1 >= s->height || strip->y2 > s->height || strip->x1 >= strip->... |
0 | static int coroutine_fn bdrv_driver_pwritev(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; int ret; assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); as... |
0 | static void ss10_init(int ram_size, int vga_ram_size, int boot_device, DisplayState *ds, const char **fd_filename, int snapshot, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ if (cpu_model == NULL) cpu_model = "TI SuperSparc II"; sun4m_common_init(ram_size... |
0 | static uint64_t bonito_readl(void *opaque, target_phys_addr_t addr, unsigned size){ PCIBonitoState *s = opaque; uint32_t saddr; saddr = (addr - BONITO_REGBASE) >> 2; DPRINTF("bonito_readl "TARGET_FMT_plx"\n", addr); switch (saddr) { case BONITO_INTISR: return s->regs[saddr]; default: return s->regs[saddr]; }} |
0 | static int ast_write_header(AVFormatContext *s){ ASTMuxContext *ast = s->priv_data; AVIOContext *pb = s->pb; AVCodecContext *enc; unsigned int codec_tag; if (s->nb_streams == 1) { enc = s->streams[0]->codec; } else { av_log(s, AV_LOG_ERROR, "only one stream is supported\n"); return AVERROR(EINVAL); } if (enc->codec_id ... |
0 | static int read_old_huffman_tables(HYuvContext *s){ GetBitContext gb; int i; init_get_bits(&gb, classic_shift_luma, classic_shift_luma_table_size * 8); if (read_len_table(s->len[0], &gb) < 0) return -1; init_get_bits(&gb, classic_shift_chroma, classic_shift_chroma_table_size * 8); if (read_len_table(s->len[1], &gb) < 0... |
1 | static void pc_init_isa(MachineState *machine){ has_pci_info = false; has_acpi_build = false; smbios_defaults = false; if (!machine->cpu_model) { machine->cpu_model = "486"; } x86_cpu_compat_disable_kvm_features(FEAT_KVM, KVM_FEATURE_PV_EOI); enable_compat_apic_id_mode(); pc_init1(machine, 0, 1);} |
1 | static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics, GetBitContext *gb){ const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac; const int aot = m4ac->object_type; const int sampling_index = m4ac->sampling_index; if (aot != AOT_ER_AAC_ELD) { if (get_bits1(gb)) { av_log(ac->avctx, AV_LOG_ERROR, "Reserv... |
1 | static void dvbsub_parse_region_segment(AVCodecContext *avctx, uint8_t *buf, int buf_size){ DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; uint8_t *buf_end = buf + buf_size; int region_id, object_id; DVBSubRegion *region; DVBSubObject *object; DVBSubObjectDisplay *display; int fill; if (buf_size < 10) return; ... |
1 | int ff_unlock_avcodec(const AVCodec *codec){ if (codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !codec->init) return 0; av_assert0(ff_avcodec_locked); ff_avcodec_locked = 0; atomic_fetch_add(&entangled_thread_counter, -1); if (lockmgr_cb) { if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE)) return -1; } return 0... |
1 | static inline void copy(LZOContext *c, int cnt){ register const uint8_t *src = c->in; register uint8_t *dst = c->out; if (cnt > c->in_end - src) { cnt = FFMAX(c->in_end - src, 0); c->error |= AV_LZO_INPUT_DEPLETED; } if (cnt > c->out_end - dst) { cnt = FFMAX(c->out_end - dst, 0); c->error |= AV_LZO_OUTPUT_FULL; }#if de... |
1 | static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid){ MXFDescriptor *descriptor = arg; switch(tag) { case 0x3F01: descriptor->sub_descriptors_count = avio_rb32(pb); if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID)) return -1; descriptor->sub_descriptors_refs = av... |
0 | static int fir_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs){ AudioFIRContext *s = ctx->priv; const float *src = (const float *)s->in[0]->extended_data[ch]; int index1 = (s->index + 1) % 3; int index2 = (s->index + 2) % 3; float *sum = s->sum[ch]; AVFrame *out = arg; float *block; float *dst; int n, i, ... |
0 | static int aiff_read_packet(AVFormatContext *s, AVPacket *pkt){ AVStream *st = s->streams[0]; AIFFInputContext *aiff = s->priv_data; int64_t max_size; int res, size; /* calculate size of remaining data */ max_size = aiff->data_end - avio_tell(s->pb); if (max_size <= 0) return AVERROR_EOF; /* Now for that packet */ if (... |
1 | static int get_riff(AVFormatContext *s, AVIOContext *pb){ AVIContext *avi = s->priv_data; char header[8]; int i; /* check RIFF header */ avio_read(pb, header, 4); avi->riff_end = avio_rl32(pb); /* RIFF chunk size */ avi->riff_end += avio_tell(pb); /* RIFF chunk end */ avio_read(pb, header + 4, 4); for (i = 0; avi_heade... |
1 | static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len){ struct CParam code; GetBitContext *gb = &s->gb; int i; if (!mode) { memset(decoded, 0, len * sizeof(*decoded)); return 0; } if (mode > FF_ARRAY_ELEMS(xcodes)) return AVERROR_INVALIDDATA; code = xcodes[mode - 1]; for (i = 0; i < len; i+... |
1 | static int paf_video_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt){ PAFVideoDecContext *c = avctx->priv_data; uint8_t code, *dst, *end; int i, frame, ret; if (pkt->size < 2) return AVERROR_INVALIDDATA; bytestream2_init(&c->gb, pkt->data, pkt->size); code = bytestream2_get_byte(&c->gb); if ((c... |
1 | int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix, int stride){ int in_channels, out_channels, i, o; in_channels = av_get_channel_layout_nb_channels(avr->in_channel_layout); out_channels = av_get_channel_layout_nb_channels(avr->out_channel_layout); if ( in_channels < 0 || in_channels > AVRESAMPLE_MA... |
0 | static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index){ AVPacket out_pkt = { 0 }, flush_pkt = { 0 }; AVStream *st = s->streams[stream_index]; uint8_t *data = pkt ? pkt->data : NULL; int size = pkt ? pkt->size : 0; int ret = 0, got_output = 0; if (!pkt) { av_init_packet(&flush_pkt); pkt = &flush_pk... |
1 | int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t* buf, int buf_size, int64_t pos){ int size, i; uint8_t *ppcm[4] = {0}; if (buf_size < DV_PROFILE_BYTES || !(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) || buf_size < c->sys->frame_size) { return -1; /* Broken frame, or not enough data *... |
1 | int mmu40x_get_physical_address (CPUState *env, mmu_ctx_t *ctx, target_ulong address, int rw, int access_type){ ppcemb_tlb_t *tlb; target_phys_addr_t raddr; int i, ret, zsel, zpr, pr; ret = -1; raddr = -1; pr = msr_pr; for (i = 0; i < env->nb_tlb; i++) { tlb = &env->tlb[i].tlbe; if (ppcemb_tlb_check(env, tlb, &raddr, a... |
1 | int bdrv_get_dirty(BlockDriverState *bs, int64_t sector){ int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; if (bs->dirty_bitmap != NULL && (sector << BDRV_SECTOR_BITS) <= bdrv_getlength(bs)) { return bs->dirty_bitmap[chunk]; } else { return 0; }} |
1 | static int gdv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ GDVContext *gdv = avctx->priv_data; GetByteContext *gb = &gdv->gb; PutByteContext *pb = &gdv->pb; AVFrame *frame = data; int ret, i, pal_size; const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_si... |
0 | int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *ptr , int bpp, int w, int add_rep, int xor_rep, int add_raw, int xor_raw){ int count, x; uint8_t *out = outbuf; for(x = 0; x < w; x += count) { /* see if we can encode the next set of pixels with RLE */ if((count = count_pixels(ptr, w-x, bpp, 1)) > 1) { if... |
0 | static void stream_component_close(VideoState *is, int stream_index){ AVFormatContext *ic = is->ic; AVCodecContext *avctx; if (stream_index < 0 || stream_index >= ic->nb_streams) return; avctx = ic->streams[stream_index]->codec; switch (avctx->codec_type) { case AVMEDIA_TYPE_AUDIO: packet_queue_abort(&is->audioq); SDL_... |
1 | static inline int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n){ int level, i, j, run; RLTable *rl = &ff_rl_mpeg1; uint8_t * const scantable = s->intra_scantable.permutated; const uint16_t *quant_matrix = s->inter_matrix; const int qscale = s->qscale; { OPEN_READER(re, &s->gb); i = -1; // special c... |
1 | static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe, VP8Frame *prev_frame){ VP8Context *s = avctx->priv_data; int mb_x, mb_y; s->mv_min.y = -MARGIN; s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN; for (mb_y = 0; mb_y < s->mb_height; mb_y++) { VP8Macroblock *mb = s->macroblocks_base + ((s->mb_... |
1 | static struct omap_eac_s *omap_eac_init(struct omap_target_agent_s *ta, qemu_irq irq, qemu_irq *drq, omap_clk fclk, omap_clk iclk){ struct omap_eac_s *s = (struct omap_eac_s *) g_malloc0(sizeof(struct omap_eac_s)); s->irq = irq; s->codec.rxdrq = *drq ++; s->codec.txdrq = *drq; omap_eac_reset(s); AUD_register_card("OMAP... |
1 | bool runstate_needs_reset(void){ return runstate_check(RUN_STATE_INTERNAL_ERROR) || runstate_check(RUN_STATE_SHUTDOWN) || runstate_check(RUN_STATE_GUEST_PANICKED);} |
1 | int64_t bdrv_getlength(BlockDriverState *bs){ int64_t ret = bdrv_nb_sectors(bs); return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE;} |
1 | static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc, vp9_mc_func (*mc)[2], uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, ThreadFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv, int px, int py, int pw, int ph, int bw, int bh, int w, int h, int ... |
1 | static void vc1_inv_trans_4x4_c(uint8_t *dest, int linesize, DCTELEM *block){ int i; register int t1,t2,t3,t4; DCTELEM *src, *dst; const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; src = block; dst = block; for(i = 0; i < 4; i++){ t1 = 17 * (src[0] + src[2]) + 4; t2 = 17 * (src[0] - src[2]) + 4; t3 = 22 * src[1] + 10 * sr... |
1 | long do_rt_sigreturn(CPUSH4State *regs){ struct target_rt_sigframe *frame; abi_ulong frame_addr; sigset_t blocked; target_ulong r0;#if defined(DEBUG_SIGNAL) fprintf(stderr, "do_rt_sigreturn\n");#endif frame_addr = regs->gregs[15]; if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; target_to_host_s... |
1 | int ff_draw_init(FFDrawContext *draw, enum PixelFormat format, unsigned flags){ const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[format]; const AVComponentDescriptor *c; unsigned i, nb_planes = 0; int pixelstep[MAX_PLANES] = { 0 }; if (!desc->name) return AVERROR(EINVAL); if (desc->flags & ~(PIX_FMT_PLANAR | PI... |
1 | static void pty_chr_close(struct CharDriverState *chr){ PtyCharDriver *s = chr->opaque; int fd; remove_fd_in_watch(chr); fd = g_io_channel_unix_get_fd(s->fd); g_io_channel_unref(s->fd); close(fd); if (s->timer_tag) { g_source_remove(s->timer_tag); s->timer_tag = 0; } g_free(s); qemu_chr_be_event(chr, CHR_EVENT_CLOSED);... |
0 | av_cold void ff_dct_init_mmx(DCTContext *s){#if HAVE_YASM int has_vectors = av_get_cpu_flags(); if (has_vectors & AV_CPU_FLAG_SSE && HAVE_SSE) s->dct32 = ff_dct32_float_sse; if (has_vectors & AV_CPU_FLAG_SSE2 && HAVE_SSE) s->dct32 = ff_dct32_float_sse2; if (has_vectors & AV_CPU_FLAG_AVX && HAVE_AVX) s->dct32 = ff_dct32... |
0 | int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame){ AVFrame *tmp; int ret; av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO); if (!frame->data[0]) return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF); if (av_frame_is_writable(frame)) { frame->pkt_pts = avctx->internal->pkt ? avctx->internal->pkt->pts : ... |
0 | static void block_dirty_bitmap_add_abort(BlkActionState *common){ BlockDirtyBitmapAdd *action; BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, common, common); action = common->action->u.block_dirty_bitmap_add; /* Should not be able to fail: IF the bitmap was added via .prepare(), * then the node refere... |
0 | static int cirrus_bitblt_common_patterncopy(CirrusVGAState *s, bool videosrc){ uint32_t patternsize; uint8_t *dst; uint8_t *src; dst = s->vga.vram_ptr + s->cirrus_blt_dstaddr; if (videosrc) { switch (s->vga.get_bpp(&s->vga)) { case 8: patternsize = 64; break; case 15: case 16: patternsize = 128; break; case 24: case 32... |
0 | static int nbd_handle_export_name(NBDClient *client, uint32_t length){ int rc = -EINVAL, csock = client->sock; char name[256]; /* Client sends: [20 .. xx] export name (length bytes) */ TRACE("Checking length"); if (length > 255) { LOG("Bad length received"); goto fail; } if (read_sync(csock, name, length) != length) { ... |
0 | static void tcg_out_insn_3401(TCGContext *s, AArch64Insn insn, TCGType ext, TCGReg rd, TCGReg rn, uint64_t aimm){ if (aimm > 0xfff) { assert((aimm & 0xfff) == 0); aimm >>= 12; assert(aimm <= 0xfff); aimm |= 1 << 12; /* apply LSL 12 */ } tcg_out32(s, insn | ext << 31 | aimm << 10 | rn << 5 | rd);} |
0 | static int proxy_mkdir(FsContext *fs_ctx, V9fsPath *dir_path, const char *name, FsCred *credp){ int retval; V9fsString fullname; v9fs_string_init(&fullname); v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); retval = v9fs_request(fs_ctx->private, T_MKDIR, NULL, "sddd", &fullname, credp->fc_mode, credp->fc_... |
0 | static always_inline uint64_t float_zero_divide_excp (uint64_t arg1, uint64_t arg2){ env->fpscr |= 1 << FPSCR_ZX; env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI)); /* Update the floating-point exception summary */ env->fpscr |= 1 << FPSCR_FX; if (fpscr_ze != 0) { /* Update the floating-point enabled exception summary... |
0 | void *s1d13745_init(qemu_irq gpio_int){ BlizzardState *s = (BlizzardState *) g_malloc0(sizeof(*s)); DisplaySurface *surface; s->fb = g_malloc(0x180000); s->con = graphic_console_init(blizzard_update_display, blizzard_invalidate_display, blizzard_screen_dump, NULL, s); surface = qemu_console_surface(s->con); switch (sur... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.