label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static int get_nb_samples(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int *coded_samples){ ADPCMDecodeContext *s = avctx->priv_data; int nb_samples = 0; int ch = avctx->channels; int has_coded_samples = 0; int header_size; *coded_samples = 0; switch (avctx->codec->id) { /* constant, only check buf_size */ ... |
1 | static int64_t calculate_mode_score(CinepakEncContext *s, CinepakMode mode, int h, int v1_size, int v4_size, int v4, strip_info *info){ //score = FF_LAMBDA_SCALE * error + lambda * bits int x; int entry_size = s->pix_fmt == AV_PIX_FMT_YUV420P ? 6 : 4; int mb_count = s->w * h / MB_AREA; mb_info *mb; int64_t score1, scor... |
1 | static inline int GET_TOK(TM2Context *ctx,int type) { if(ctx->tok_ptrs[type] >= ctx->tok_lens[type]) { av_log(ctx->avctx, AV_LOG_ERROR, "Read token from stream %i out of bounds (%i>=%i)\n", type, ctx->tok_ptrs[type], ctx->tok_lens[type]); return 0; } if(type <= TM2_MOT) return ctx->deltas[type][ctx->tokens[type][ctx->t... |
1 | int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st){ RTSPState *rt = s->priv_data; AVStream *st = NULL; int reordering_queue_size = rt->reordering_queue_size; if (reordering_queue_size < 0) { if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay) reordering_queue_size = 0; else reorde... |
1 | static void chassis_control(IPMIBmcSim *ibs, uint8_t *cmd, unsigned int cmd_len, uint8_t *rsp, unsigned int *rsp_len, unsigned int max_rsp_len){ IPMIInterface *s = ibs->parent.intf; IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); IPMI_CHECK_CMD_LEN(3); switch (cmd[2] & 0xf) { case 0: /* power down */ rsp[2] = k->d... |
1 | static FFPsyWindowInfo psy_lame_window(FFPsyContext *ctx, const float *audio, const float *la, int channel, int prev_type){ AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data; AacPsyChannel *pch = &pctx->ch[channel]; int grouping = 0; int uselongblock = 1; int attacks[AAC_NUM_BLOCKS_SHORT + 1] = { 0 }; float c... |
1 | static int dca_decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int lfe_samples; int num_core_channels = 0; int i; int xch_present = 0; int16_t *samples = data; DCAContext *s = avctx->priv_data; int channels; s->dca_buffer_s... |
1 | static int rtl8139_can_receive(VLANClientState *nc){ RTL8139State *s = DO_UPCAST(NICState, nc, nc)->opaque; int avail; /* Receive (drop) packets if card is disabled. */ if (!s->clock_enabled) return 1; if (!rtl8139_receiver_enabled(s)) return 1; if (rtl8139_cp_receiver_enabled(s)) { /* ??? Flow control not implemented ... |
1 | unsigned int qemu_get_be16(QEMUFile *f){ unsigned int v; v = qemu_get_byte(f) << 8; v |= qemu_get_byte(f); return v;} |
1 | void migration_fd_process_incoming(QEMUFile *f){ Coroutine *co = qemu_coroutine_create(process_incoming_migration_co); migrate_decompress_threads_create(); qemu_file_set_blocking(f, false); qemu_coroutine_enter(co, f);} |
1 | void ff_xvmc_decode_mb(MpegEncContext *s){ XvMCMacroBlock *mv_block; struct xvmc_pix_fmt *render; int i, cbp, blocks_per_mb; const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; if (s->encoding) { av_log(s->avctx, AV_LOG_ERROR, "XVMC doesn't support encoding!!!\n"); return; } // from MPV_decode_mb(), update DC predictor... |
0 | static inline int mpeg2_fast_decode_block_non_intra(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 int qscale = s->qscale; OPEN_READER(re, &s->gb); i = -1; // special case for first coefficient, no need to add... |
0 | int ffio_close_null_buf(AVIOContext *s){ DynBuffer *d = s->opaque; int size; avio_flush(s); size = d->size; av_free(d); av_free(s); return size;} |
0 | static 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_t *filte... |
0 | static void stereo_processing(PSContext *ps, INTFLOAT (*l)[32][2], INTFLOAT (*r)[32][2], int is34){ int e, b, k; INTFLOAT (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11; INTFLOAT (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12; INTFLOAT (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21; INTFLOAT (*H22)[PS... |
0 | int coroutine_fn bdrv_co_preadv(BlockDriverState *bs, int64_t offset, unsigned int bytes, QEMUIOVector *qiov, BdrvRequestFlags flags){ BlockDriver *drv = bs->drv; BdrvTrackedRequest req; uint64_t align = bs->request_alignment; uint8_t *head_buf = NULL; uint8_t *tail_buf = NULL; QEMUIOVector local_qiov; bool use_local_q... |
0 | static void vfio_add_kvm_msi_virq(VFIOMSIVector *vector, MSIMessage *msg, bool msix){ int virq; if ((msix && !VFIO_ALLOW_KVM_MSIX) || (!msix && !VFIO_ALLOW_KVM_MSI) || !msg) { return; } if (event_notifier_init(&vector->kvm_interrupt, 0)) { return; } virq = kvm_irqchip_add_msi_route(kvm_state, *msg); if (virq < 0) { eve... |
0 | void bios_linker_loader_add_pointer(BIOSLinker *linker, const char *dest_file, const char *src_file, void *pointer, uint8_t pointer_size){ BiosLinkerLoaderEntry entry; const BiosLinkerFileEntry *file = bios_linker_find_file(linker, dest_file); ptrdiff_t offset = (gchar *)pointer - file->blob->data; assert(offset >= 0);... |
0 | yuv2yuvX_altivec_real(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, int dstW, int chrDstW){ const ve... |
0 | static int fmod_init_out (HWVoiceOut *hw, audsettings_t *as){ int bits16, mode, channel; FMODVoiceOut *fmd = (FMODVoiceOut *) hw; audsettings_t obt_as = *as; mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0); fmd->fmod_sample = FSOUND_Sample_Alloc ( FSOUND_FREE, /* index */ conf.nb_samples, /* length */ mode,... |
0 | void blk_dev_change_media_cb(BlockBackend *blk, bool load){ if (blk->dev_ops && blk->dev_ops->change_media_cb) { bool tray_was_closed = !blk_dev_is_tray_open(blk); blk->dev_ops->change_media_cb(blk->dev_opaque, load); if (tray_was_closed) { /* tray open */ qapi_event_send_device_tray_moved(blk_name(blk), true, &error_a... |
0 | static void chr_read(void *opaque, const void *buf, size_t size){ VirtIORNG *vrng = opaque; size_t len; int offset; if (!is_guest_ready(vrng)) { return; } offset = 0; while (offset < size) { if (!pop_an_elem(vrng)) { break; } len = iov_from_buf(vrng->elem.in_sg, vrng->elem.in_num, 0, buf + offset, size - offset); offse... |
0 | void cpu_loop(CPUX86State *env){ CPUState *cs = CPU(x86_env_get_cpu(env)); int trapnr; abi_ulong pc; target_siginfo_t info; for(;;) { cpu_exec_start(cs); trapnr = cpu_x86_exec(cs); cpu_exec_end(cs); switch(trapnr) { case 0x80: /* linux syscall from int $0x80 */ env->regs[R_EAX] = do_syscall(env, env->regs[R_EAX], env->... |
0 | void kqemu_flush(CPUState *env, int global){ LOG_INT("kqemu_flush:\n"); nb_pages_to_flush = KQEMU_FLUSH_ALL;} |
0 | static inline void gen_evmergelohi(DisasContext *ctx){ if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; }#if defined(TARGET_PPC64) TCGv t0 = tcg_temp_new(); TCGv t1 = tcg_temp_new(); tcg_gen_shri_tl(t0, cpu_gpr[rB(ctx->opcode)], 32); tcg_gen_shli_tl(t1, cpu_gpr[rA(ctx->opcode)], 32); tcg... |
0 | gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUMIPSState *env = &cpu->env; DisasContext ctx; target_ulong pc_start; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj = -1; int num_insns; int max_insns; int insn_bytes; int is_slot; if (search_pc) qemu_lo... |
0 | static inline void gen_movs(DisasContext *s, int ot){ gen_string_movl_A0_ESI(s); gen_op_ld_T0_A0(ot + s->mem_index); gen_string_movl_A0_EDI(s); gen_op_st_T0_A0(ot + s->mem_index); gen_op_movl_T0_Dshift[ot]();#ifdef TARGET_X86_64 if (s->aflag == 2) { gen_op_addq_ESI_T0(); gen_op_addq_EDI_T0(); } else#endif if (s->aflag)... |
0 | static int udp_read(URLContext *h, uint8_t *buf, int size){ UDPContext *s = h->priv_data; int ret; int avail;#if HAVE_PTHREADS if (s->fifo) { pthread_mutex_lock(&s->mutex); do { avail = av_fifo_size(s->fifo); if (avail) { // >=size) { uint8_t tmp[4]; pthread_mutex_unlock(&s->mutex); av_fifo_generic_read(s->fifo, tmp, 4... |
0 | static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector, MSIMessage msg){ VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); VirtQueue *vq = virtio_vector_first_queue(vdev, vector); int ret, index, unmasked = 0; while (vq) { index = v... |
0 | static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val){ VirtIOPCIProxy *proxy = opaque; VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); hwaddr pa; switch (addr) { case VIRTIO_PCI_GUEST_FEATURES: /* Guest does not negotiate properly? We have to assume nothing. */ if (val & (1 << VIRTIO_F_BAD... |
0 | void tcg_register_helper(void *func, const char *name){ TCGContext *s = &tcg_ctx; GHashTable *table = s->helpers; if (table == NULL) { /* Use g_direct_hash/equal for direct pointer comparisons on func. */ table = g_hash_table_new(NULL, NULL); s->helpers = table; } g_hash_table_insert(table, (gpointer)func, (gpointer)na... |
0 | static void nvdimm_init(Object *obj){ object_property_add(obj, "label-size", "int", nvdimm_get_label_size, nvdimm_set_label_size, NULL, NULL, NULL);} |
0 | char *g_strdup_vprintf(const char *format, va_list ap){ char ch, *s; size_t len; __coverity_string_null_sink__(format); __coverity_string_size_sink__(format); ch = *format; ch = *(char *)ap; s = __coverity_alloc_nosize__(); __coverity_writeall__(s); __coverity_mark_as_afm_allocated__(s, AFM_free); return len;} |
0 | static void randomize_loopfilter_buffers(int bidx, int lineoff, int str, int bit_depth, int dir, int* E, int* F, int* H, int* I, uint8_t *buf0, uint8_t *buf1){ uint32_t mask = (1 << bit_depth) - 1; int off = dir ? lineoff : lineoff * 16; int istride = dir ? 1 : 16; int jstride = dir ? str : 1; int i, j; for (i = 0; i <... |
0 | static av_cold int bmp_encode_close(AVCodecContext *avctx){ av_frame_free(&avctx->coded_frame); return 0;} |
1 | static void pci_grackle_class_init(ObjectClass *klass, void *data){ SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(klass); k->init = pci_grackle_init_device; dc->no_user = 1;} |
1 | static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; DNXHDContext *ctx = avctx->priv_data; ThreadFrame frame = { .f = data }; AVFrame *picture = data; int first_field = 1; int ret; ff_dlog(avctx, "frame size %d\n... |
1 | static void vtd_realize(DeviceState *dev, Error **errp){ PCMachineState *pcms = PC_MACHINE(qdev_get_machine()); PCIBus *bus = pcms->bus; IntelIOMMUState *s = INTEL_IOMMU_DEVICE(dev); X86IOMMUState *x86_iommu = X86_IOMMU_DEVICE(dev); VTD_DPRINTF(GENERAL, ""); x86_iommu->type = TYPE_INTEL; if (!vtd_decide_config(s, errp)... |
1 | static inline void menelaus_rtc_start(struct menelaus_s *s){ s->rtc.next =+ qemu_get_clock(rt_clock); qemu_mod_timer(s->rtc.hz, s->rtc.next);} |
1 | static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...){ int trig; OSSVoiceOut *oss = (OSSVoiceOut *) hw; switch (cmd) { case VOICE_ENABLE: { va_list ap; int poll_mode; va_start (ap, cmd); poll_mode = va_arg (ap, int); va_end (ap); ldebug ("enabling voice\n"); if (poll_mode && oss_poll_out (hw)) { poll_mode = 0; } hw->po... |
1 | void op_ddiv (void){ if (T1 != 0) { env->LO = (int64_t)T0 / (int64_t)T1; env->HI = (int64_t)T0 % (int64_t)T1; } RETURN();} |
1 | static void decompress_data_with_multi_threads(QEMUFile *f, void *host, int len){ int idx, thread_count; thread_count = migrate_decompress_threads(); while (true) { for (idx = 0; idx < thread_count; idx++) { if (!decomp_param[idx].start) { qemu_get_buffer(f, decomp_param[idx].compbuf, len); decomp_param[idx].des = host... |
1 | static int config_input(AVFilterLink *link){ AVFilterContext *ctx = link->dst; CropContext *s = ctx->priv; const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(link->format); int ret; const char *expr; double res; s->var_values[VAR_E] = M_E; s->var_values[VAR_PHI] = M_PHI; s->var_values[VAR_PI] = M_PI; s->var_value... |
1 | int av_opt_set_dict(void *obj, AVDictionary **options){ AVDictionaryEntry *t = NULL; AVDictionary *tmp = NULL; int ret = 0; while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) { ret = av_opt_set(obj, t->key, t->value, 0); if (ret == AVERROR_OPTION_NOT_FOUND) av_dict_set(&tmp, t->key, t->value, 0); else if... |
0 | static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, int nbits){ int i, n, n4, ret; n = 1 << nbits; n4 = n >> 2; mdct->nbits = nbits; ret = fft_init(avctx, mdct, nbits - 2); if (ret) return ret; mdct->window = ff_ac3_window; FF_ALLOC_OR_GOTO(avctx, mdct->xcos1, n4 * sizeof(*mdct->xcos1), mdct_alloc... |
0 | static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx){ static const VAConfigAttrib default_config_attributes[] = { { .type = VAConfigAttribRTFormat, .value = VA_RT_FORMAT_YUV420 }, { .type = VAConfigAttribEncPackedHeaders, .value = (VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_SLICE) }, }; V... |
1 | 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 dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds, uint8_t *buffer, uint32_t count){ uint32_t type, i; int ret; size_t new_size; uint32_t chunk_count; int64_t offset = 0; type = buff_read_uint32(buffer, offset); /* skip data that is not a valid MISH block (invalid magic or too small) */ if (type != 0x6... |
1 | static int png_decode_idat(PNGDecContext *s, int length){ int ret; s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb)); s->zstream.next_in = (unsigned char *)s->gb.buffer; bytestream2_skip(&s->gb, length); /* decode one line if possible */ while (s->zstream.avail_in > 0) { ret = inflate(&s->zstream,... |
1 | FWCfgState *fw_cfg_init_io_dma(uint32_t iobase, uint32_t dma_iobase, AddressSpace *dma_as){ DeviceState *dev; SysBusDevice *sbd; FWCfgIoState *ios; FWCfgState *s; bool dma_requested = dma_iobase && dma_as; dev = qdev_create(NULL, TYPE_FW_CFG_IO); if (!dma_requested) { qdev_prop_set_bit(dev, "dma_enabled", false); } fw_... |
1 | static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; Mpeg1Context *s = avctx->priv_data; AVFrame *picture = data; MpegEncContext *s2 = &s->mpeg_enc_ctx; av_dlog(avctx, "fill_buffer\n"); if (buf_size == 0 || (buf_... |
1 | av_cold void ff_fft_fixed_init_arm(FFTContext *s){ int cpu_flags = av_get_cpu_flags(); if (have_neon(cpu_flags)) { s->fft_permutation = FF_FFT_PERM_SWAP_LSBS; s->fft_calc = ff_fft_fixed_calc_neon;#if CONFIG_MDCT if (!s->inverse && s->mdct_bits >= 5) { s->mdct_permutation = FF_MDCT_PERM_INTERLEAVE; s->mdct_calc = ff_mdc... |
0 | static bool timer_expired_ns(QEMUTimer *timer_head, int64_t current_time){ return timer_head && (timer_head->expire_time <= current_time);} |
0 | void syscall_init(void){ IOCTLEntry *ie; const argtype *arg_type; int size; int i;#define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);#define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);#include "syscall_types.h"#un... |
0 | static CharDriverState *qemu_chr_open_stdio(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp){ ChardevStdio *opts = backend->u.stdio; CharDriverState *chr; struct sigaction act; if (is_daemonized()) { error_setg(errp, "cannot use stdio with -daemonize"); return NULL; } if (stdio_in_use) { error... |
0 | static inline void gen_op_eval_bg(TCGv dst, TCGv_i32 src){ gen_mov_reg_N(cpu_tmp0, src); gen_mov_reg_V(dst, src); tcg_gen_xor_tl(dst, dst, cpu_tmp0); gen_mov_reg_Z(cpu_tmp0, src); tcg_gen_or_tl(dst, dst, cpu_tmp0); tcg_gen_xori_tl(dst, dst, 0x1);} |
0 | START_TEST(qstring_destroy_test){ QString *qstring = qstring_from_str("destroy test"); QDECREF(qstring);} |
0 | static av_cold int aac_decode_init(AVCodecContext *avctx){ AACContext *ac = avctx->priv_data; float output_scale_factor; ac->avctx = avctx; ac->oc[1].m4ac.sample_rate = avctx->sample_rate; if (avctx->extradata_size > 0) { if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac, avctx->extradata, avctx->extradat... |
0 | static void test_validate_union_anon(TestInputVisitorData *data, const void *unused){ UserDefAnonUnion *tmp = NULL; Visitor *v; Error *errp = NULL; v = validate_test_init(data, "42"); visit_type_UserDefAnonUnion(v, &tmp, NULL, &errp); g_assert(!error_is_set(&errp)); qapi_free_UserDefAnonUnion(tmp);} |
0 | int qemu_input_key_value_to_qcode(const KeyValue *value){ if (value->type == KEY_VALUE_KIND_QCODE) { return value->u.qcode; } else { assert(value->type == KEY_VALUE_KIND_NUMBER); return qemu_input_key_number_to_qcode(value->u.number); }} |
0 | void tcg_cpu_address_space_init(CPUState *cpu, AddressSpace *as){ /* We only support one address space per cpu at the moment. */ assert(cpu->as == as); if (cpu->cpu_ases) { /* We've already registered the listener for our only AS */ return; } cpu->cpu_ases = g_new0(CPUAddressSpace, 1); cpu->cpu_ases[0].cpu = cpu; cpu->... |
0 | static struct iovec *lock_iovec(int type, abi_ulong target_addr, int count, int copy){ struct target_iovec *target_vec; struct iovec *vec; abi_ulong total_len, max_len; int i; int err = 0; if (count == 0) { errno = 0; return NULL; } if (count < 0 || count > IOV_MAX) { errno = EINVAL; return NULL; } vec = calloc(count, ... |
0 | static void imx_gpt_compute_next_timeout(IMXGPTState *s, bool event){ uint32_t timeout = TIMER_MAX; uint32_t count = 0; long long limit; if (!(s->cr & GPT_CR_EN)) { /* if not enabled just return */ return; } if (event) { /* This is a timer event */ if ((s->cr & GPT_CR_FRR) && (s->next_timeout != TIMER_MAX)) { /* * if w... |
0 | ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr, Error **errp){ return qemu_ram_alloc_from_ptr(size, NULL, mr, errp);} |
0 | bool write_list_to_cpustate(ARMCPU *cpu){ int i; bool ok = true; for (i = 0; i < cpu->cpreg_array_len; i++) { uint32_t regidx = kvm_to_cpreg_id(cpu->cpreg_indexes[i]); uint64_t v = cpu->cpreg_values[i]; const ARMCPRegInfo *ri; ri = get_arm_cp_reginfo(cpu->cp_regs, regidx); if (!ri) { ok = false; continue; } if (ri->typ... |
0 | static int trap_msix(S390PCIBusDevice *pbdev, uint64_t offset, uint8_t pcias){ if (pbdev->msix.available && pbdev->msix.table_bar == pcias && offset >= pbdev->msix.table_offset && offset <= pbdev->msix.table_offset + (pbdev->msix.entries - 1) * PCI_MSIX_ENTRY_SIZE) { return 1; } else { return 0; }} |
0 | static bool local_is_mapped_file_metadata(FsContext *fs_ctx, const char *name){ return !strcmp(name, VIRTFS_META_DIR);} |
0 | static void cpu_pre_save(void *opaque){ ARMCPU *cpu = opaque; if (!write_cpustate_to_list(cpu)) { /* This should never fail. */ abort(); } cpu->cpreg_vmstate_array_len = cpu->cpreg_array_len; memcpy(cpu->cpreg_vmstate_indexes, cpu->cpreg_indexes, cpu->cpreg_array_len * sizeof(uint64_t)); memcpy(cpu->cpreg_vmstate_value... |
0 | static void gen_arith (CPUState *env, DisasContext *ctx, uint32_t opc, int rd, int rs, int rt){ const char *opn = "arith"; TCGv t0 = tcg_temp_local_new(TCG_TYPE_TL); TCGv t1 = tcg_temp_local_new(TCG_TYPE_TL); if (rd == 0 && opc != OPC_ADD && opc != OPC_SUB && opc != OPC_DADD && opc != OPC_DSUB) { /* If no destination, ... |
0 | static int proxy_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name, int flags, FsCred *credp, V9fsFidOpenState *fs){ V9fsString fullname; v9fs_string_init(&fullname); v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); fs->fd = v9fs_request(fs_ctx->private, T_CREATE, NULL, "sdddd", &fullname, fla... |
0 | void memory_region_add_subregion_overlap(MemoryRegion *mr, hwaddr offset, MemoryRegion *subregion, int priority){ subregion->may_overlap = true; subregion->priority = priority; memory_region_add_subregion_common(mr, offset, subregion);} |
0 | void hd_geometry_guess(BlockBackend *blk, uint32_t *pcyls, uint32_t *pheads, uint32_t *psecs, int *ptrans){ int cylinders, heads, secs, translation; if (guess_disk_lchs(blk, &cylinders, &heads, &secs) < 0) { /* no LCHS guess: use a standard physical disk geometry */ guess_chs_for_size(blk, pcyls, pheads, psecs); transl... |
0 | int net_init_vde(QemuOpts *opts, Monitor *mon, const char *name, VLANState *vlan){ const char *sock; const char *group; int port, mode; sock = qemu_opt_get(opts, "sock"); group = qemu_opt_get(opts, "group"); port = qemu_opt_get_number(opts, "port", 0); mode = qemu_opt_get_number(opts, "mode", 0700); if (net_vde_init(vl... |
0 | int read_ffserver_streams(AVFormatContext *s, const char *filename){ int i; AVFormatContext *ic; ic = av_open_input_file(filename, FFM_PACKET_SIZE); if (!ic) return -EIO; /* copy stream format */ s->nb_streams = ic->nb_streams; for(i=0;i<ic->nb_streams;i++) { AVStream *st; st = av_mallocz(sizeof(AVFormatContext)); memc... |
0 | void ff_restore_parser_state(AVFormatContext *s, AVParserState *state){ int i; AVStream *st; AVParserStreamState *ss; ff_read_frame_flush(s); if (!state) return; avio_seek(s->pb, state->fpos, SEEK_SET); // copy context structures s->cur_st = state->cur_st; s->packet_buffer = state->packet_buffer; s->raw_packet_buffer =... |
0 | int ff_img_read_header(AVFormatContext *s1){ VideoDemuxData *s = s1->priv_data; int first_index = 1, last_index = 1; AVStream *st; enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE; s1->ctx_flags |= AVFMTCTX_NOHEADER; st = avformat_new_stream(s1, NULL); if (!st) { return AVERROR(ENOMEM); } if (s->pixel_format && (pix_fmt = ... |
0 | static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){ int i; OPEN_READER(re, &s->gb); for (i = 0; i < count; i++) { unsigned int index; int code, n; UPDATE_CACHE(re, &s->gb); index = SHOW_UBITS(re, &s->gb, VLC_BITS); code = s->vlc[4].table[index][0]; n = s->vlc[4].table[index... |
0 | static int dnxhd_init_rc(DNXHDEncContext *ctx){ CHECKED_ALLOCZ(ctx->mb_rc, 8160*ctx->m.avctx->qmax*sizeof(RCEntry)); if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) CHECKED_ALLOCZ(ctx->mb_cmp, ctx->m.mb_num*sizeof(RCCMPEntry)); ctx->frame_bits = (ctx->cid_table->coding_unit_size - 640 - 4) * 8; ctx->qscale = 1; ctx... |
0 | static int mpeg1_decode_picture(AVCodecContext *avctx, UINT8 *buf, int buf_size){ Mpeg1Context *s1 = avctx->priv_data; MpegEncContext *s = &s1->mpeg_enc_ctx; int ref, f_code; init_get_bits(&s->gb, buf, buf_size); ref = get_bits(&s->gb, 10); /* temporal ref */ s->pict_type = get_bits(&s->gb, 3); dprintf("pict_type=%d nu... |
0 | static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){ ParseContext *pc= &s->parse_context; int i; uint32_t state; state= pc->state; i=0; if(!pc->frame_start_found){ for(i=0; i<buf_size; i++){ state= (state<<8) | buf[i]; if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){ i++; p... |
0 | static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom){ int i; int64_t creation_time; int version = avio_r8(pb); /* version */ avio_rb24(pb); /* flags */ if (version == 1) { creation_time = avio_rb64(pb); avio_rb64(pb); } else { creation_time = avio_rb32(pb); avio_rb32(pb); /* modification time */ } mov... |
0 | static int decode_packet(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000ResLevel *rlevel, int precno, int layno, uint8_t *expn, int numgbits){ int bandno, cblkny, cblknx, cblkno, ret; if (!(ret = get_bits(s, 1))){ j2k_flush(s); return 0; } else if (ret < 0) return ret; for (bandno = 0; bandno < rlevel-... |
0 | static void avc_luma_vt_and_aver_dst_8x8_msa(const uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride){ int32_t loop_cnt; int16_t filt_const0 = 0xfb01; int16_t filt_const1 = 0x1414; int16_t filt_const2 = 0x1fb; v16u8 dst0, dst1, dst2, dst3; v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10; v1... |
0 | int main (int argc, char **argv){ int ret = 0, got_frame; if (argc != 4 && argc != 5) { fprintf(stderr, "usage: %s [-refcount=<old|new_norefcount|new_refcount>] " "input_file video_output_file audio_output_file\n" "API example program to show how to read frames from an input file.\n" "This program reads frames from a f... |
0 | void ff_celp_lp_synthesis_filterf(float *out, const float* filter_coeffs, const float* in, int buffer_length, int filter_length){ int i,n; // Avoids a +1 in the inner loop. filter_length++; for (n = 0; n < buffer_length; n++) { out[n] = in[n]; for (i = 1; i < filter_length; i++) out[n] -= filter_coeffs[i-1] * out[n-i];... |
0 | static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags){ BinkDemuxContext *bink = s->priv_data; AVStream *vst = s->streams[0]; if (!s->pb->seekable) return -1; /* seek to the first frame */ if (avio_seek(s->pb, vst->index_entries[0].pos, SEEK_SET) < 0) return -1; bink->video_pts = 0; me... |
0 | static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, UINT8 *buf, int buf_size){ DVVideoDecodeContext *s = avctx->priv_data; int sct, dsf, apt, ds, nb_dif_segs, vs, width, height, i, packet_size; unsigned size; UINT8 *buf_ptr; const UINT16 *mb_pos_ptr; AVPicture *picture; /* parse id */ ini... |
0 | static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap){ AudioData *s = s1->priv_data; AVStream *st; int ret; if (!ap || ap->sample_rate <= 0 || ap->channels <= 0) return -1; st = av_new_stream(s1, 0); if (!st) { return -ENOMEM; } s->sample_rate = ap->sample_rate; s->channels = ap->channels; ret = aud... |
0 | char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms){ snprintf(buf, buf_size, "%s%s%s%s%s", perms & AV_PERM_READ ? "r" : "", perms & AV_PERM_WRITE ? "w" : "", perms & AV_PERM_PRESERVE ? "p" : "", perms & AV_PERM_REUSE ? "u" : "", perms & AV_PERM_REUSE2 ? "U" : ""); return buf;} |
0 | static void gif_copy_img_rect(const uint32_t *src, uint32_t *dst, int linesize, int l, int t, int w, int h){ const int y_start = t * linesize; const uint32_t *src_px, *src_pr, *src_py = src + y_start, *dst_py = dst + y_start; const uint32_t *src_pb = src_py + t * linesize; uint32_t *dst_px; for (; src_py < src_pb; src_... |
0 | static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ AlacEncodeContext *s = avctx->priv_data; int out_bytes, max_frame_size, ret; s->frame_size = frame->nb_samples; if (frame->nb_samples < DEFAULT_FRAME_SIZE) max_frame_size = get_max_frame_size(s->frame_size, ... |
0 | static int bmdma_rw_buf(IDEDMA *dma, int is_write){ BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma); IDEState *s = bmdma_active_if(bm); struct { uint32_t addr; uint32_t size; } prd; int l, len; for(;;) { l = s->io_buffer_size - s->io_buffer_index; if (l <= 0) break; if (bm->cur_prd_len == 0) { /* end of table (with a ... |
0 | static void gen_dmfc0 (DisasContext *ctx, int reg, int sel){ const char *rn = "invalid"; switch (reg) { case 0: switch (sel) { case 0: gen_op_mfc0_index(); rn = "Index"; break; case 1:// gen_op_dmfc0_mvpcontrol(); /* MT ASE */ rn = "MVPControl";// break; case 2:// gen_op_dmfc0_mvpconf0(); /* MT ASE */ rn = "MVPConf0";/... |
0 | static void create_cpu(const char *cpu_model, qemu_irq *cbus_irq, qemu_irq *i8259_irq){ CPUMIPSState *env; MIPSCPU *cpu; int i; if (cpu_model == NULL) {#ifdef TARGET_MIPS64 cpu_model = "20Kc";#else cpu_model = "24Kf";#endif } for (i = 0; i < smp_cpus; i++) { cpu = cpu_mips_init(cpu_model); if (cpu == NULL) { fprintf(st... |
0 | void qed_release(BDRVQEDState *s){ aio_context_release(bdrv_get_aio_context(s->bs));} |
0 | int v9fs_co_readlink(V9fsPDU *pdu, V9fsPath *path, V9fsString *buf){ int err; ssize_t len; V9fsState *s = pdu->s; if (v9fs_request_cancelled(pdu)) { return -EINTR; } buf->data = g_malloc(PATH_MAX); v9fs_path_read_lock(s); v9fs_co_run_in_worker( { len = s->ops->readlink(&s->ctx, path, buf->data, PATH_MAX - 1); if (len >... |
0 | int nbd_receive_negotiate(QIOChannel *ioc, const char *name, uint16_t *flags, QCryptoTLSCreds *tlscreds, const char *hostname, QIOChannel **outioc, off_t *size, Error **errp){ char buf[256]; uint64_t magic, s; int rc; bool zeroes = true; TRACE("Receiving negotiation tlscreds=%p hostname=%s.", tlscreds, hostname ? hostn... |
0 | void spapr_events_fdt_skel(void *fdt, uint32_t epow_irq){ uint32_t epow_irq_ranges[] = {cpu_to_be32(epow_irq), cpu_to_be32(1)}; uint32_t epow_interrupts[] = {cpu_to_be32(epow_irq), 0}; _FDT((fdt_begin_node(fdt, "event-sources"))); _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0))); _FDT((fdt_property_cell(fdt, ... |
0 | static void vfio_put_device(VFIOPCIDevice *vdev){ QLIST_REMOVE(vdev, next); vdev->vbasedev.group = NULL; trace_vfio_put_device(vdev->vbasedev.fd); close(vdev->vbasedev.fd); g_free(vdev->vbasedev.name); if (vdev->msix) { g_free(vdev->msix); vdev->msix = NULL; }} |
0 | static int open_self_cmdline(void *cpu_env, int fd){ int fd_orig = -1; bool word_skipped = false; fd_orig = open("/proc/self/cmdline", O_RDONLY); if (fd_orig < 0) { return fd_orig; } while (true) { ssize_t nb_read; char buf[128]; char *cp_buf = buf; nb_read = read(fd_orig, buf, sizeof(buf)); if (nb_read < 0) { int e = ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.