label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | static void test_visitor_in_wrong_type(TestInputVisitorData *data, const void *unused) { TestStruct *p = NULL; Visitor *v; strList *q = NULL; int64_t i; Error *err = NULL; /* Make sure arrays and structs cannot be confused */ v = visitor_input_test_init(data, "[]"); visit_type_TestStruct(v, NULL, &p, &err); error_free_... | 23,231 |
0 | static int buffered_close(void *opaque) { MigrationState *s = opaque; DPRINTF("closing\n"); s->xfer_limit = INT_MAX; while (!qemu_file_get_error(s->file) && s->buffer_size) { buffered_flush(s); } return migrate_fd_close(s); } | 23,232 |
0 | static int blk_mig_save_bulked_block(Monitor *mon, QEMUFile *f) { int64_t completed_sector_sum = 0; BlkMigDevState *bmds; int progress; int ret = 0; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { if (bmds->bulk_completed == 0) { if (mig_save_device_bulk(mon, f, bmds) == 1) { /* completed bulk section for t... | 23,233 |
0 | static void vfio_msi_enable(VFIOPCIDevice *vdev) { int ret, i; vfio_disable_interrupts(vdev); vdev->nr_vectors = msi_nr_vectors_allocated(&vdev->pdev); retry: vdev->msi_vectors = g_malloc0(vdev->nr_vectors * sizeof(VFIOMSIVector)); for (i = 0; i < vdev->nr_vectors; i++) { VFIOMSIVector *vector = &vdev->msi_vectors[i]; ... | 23,234 |
0 | build_madt(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info) { int madt_start = table_data->len; const MemMapEntry *memmap = guest_info->memmap; const int *irqmap = guest_info->irqmap; AcpiMultipleApicTable *madt; AcpiMadtGenericDistributor *gicd; AcpiMadtGenericMsiFrame *gic_msi; int i; madt = acpi_data_p... | 23,235 |
0 | void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val) { uint8_t *ptr; MemoryRegionSection *section; section = phys_page_find(address_space_memory.dispatch, addr >> TARGET_PAGE_BITS); if (!memory_region_is_ram(section->mr) || section->readonly) { addr = memory_region_section_addr(section, addr); if (memory_regio... | 23,236 |
0 | static void compare_pri_rs_finalize(SocketReadState *pri_rs) { CompareState *s = container_of(pri_rs, CompareState, pri_rs); if (packet_enqueue(s, PRIMARY_IN)) { trace_colo_compare_main("primary: unsupported packet in"); compare_chr_send(s, pri_rs->buf, pri_rs->packet_len, pri_rs->vnet_hdr_len); } else { /* compare con... | 23,238 |
0 | static int opt_default(const char *opt, const char *arg){ int type; const AVOption *o= NULL; int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0}; for(type=0; type<CODEC_TYPE_NB; type++){ const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_type... | 23,239 |
0 | static void test_qemu_strtoul_overflow(void) { const char *str = "99999999999999999999999999999999999999999999"; char f = 'X'; const char *endptr = &f; unsigned long res = 999; int err; err = qemu_strtoul(str, &endptr, 0, &res); g_assert_cmpint(err, ==, -ERANGE); g_assert_cmpint(res, ==, ULONG_MAX); g_assert(endptr == ... | 23,240 |
0 | int qdev_prop_parse(DeviceState *dev, const char *name, const char *value) { Property *prop; int ret; prop = qdev_prop_find(dev, name); if (!prop) { fprintf(stderr, "property \"%s.%s\" not found\n", dev->info->name, name); return -1; } if (!prop->info->parse) { fprintf(stderr, "property \"%s.%s\" has no parser\n", dev-... | 23,241 |
0 | uint32_t ldub_phys(target_phys_addr_t addr) { uint8_t val; cpu_physical_memory_read(addr, &val, 1); return val; } | 23,242 |
0 | static int get_physical_address_data(CPUState *env, target_phys_addr_t *physical, int *prot, target_ulong address, int rw, int mmu_idx) { unsigned int i; uint64_t context; int is_user = (mmu_idx == MMU_USER_IDX || mmu_idx == MMU_USER_SECONDARY_IDX); if ((env->lsu & DMMU_E) == 0) { /* DMMU disabled */ *physical = ultras... | 23,243 |
0 | static void vfio_pci_reset(DeviceState *dev) { PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, dev); VFIODevice *vdev = DO_UPCAST(VFIODevice, pdev, pdev); if (!vdev->reset_works) { return; } if (ioctl(vdev->fd, VFIO_DEVICE_RESET)) { error_report("vfio: Error unable to reset physical device " "(%04x:%02x:%02x.%x): %m\n", v... | 23,246 |
0 | void tcg_profile_snapshot(TCGProfile *prof, bool counters, bool table) { unsigned int i; for (i = 0; i < n_tcg_ctxs; i++) { const TCGProfile *orig = &tcg_ctxs[i]->prof; if (counters) { PROF_ADD(prof, orig, tb_count1); PROF_ADD(prof, orig, tb_count); PROF_ADD(prof, orig, op_count); PROF_MAX(prof, orig, op_count_max); PR... | 23,248 |
0 | static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out) { char *pix_fmts; OutputStream *ost = ofilter->ost; OutputFile *of = output_files[ost->file_index]; AVFilterContext *last_filter = out->filter_ctx; int pad_idx = out->pad_idx; int ret; char name[255]; snprintf(name, siz... | 23,252 |
1 | static void vfio_exitfn(PCIDevice *pdev) { VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); VFIOGroup *group = vdev->vbasedev.group; vfio_unregister_err_notifier(vdev); pci_device_set_intx_routing_notifier(&vdev->pdev, NULL); vfio_disable_interrupts(vdev); if (vdev->intx.mmap_timer) { timer_free(vdev->intx.m... | 23,253 |
1 | static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright, int _stride){ pixel *src = (pixel*)_src; int stride = _stride/sizeof(pixel); const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; ((pixel4*)(src+0*stride))[0]= ((pixel4*)(src+1*stride))[0]= ((pixel4... | 23,254 |
1 | static void decode_nal_sei_decoded_picture_hash(HEVCContext *s) { int cIdx, i; uint8_t hash_type; //uint16_t picture_crc; //uint32_t picture_checksum; GetBitContext *gb = &s->HEVClc->gb; hash_type = get_bits(gb, 8); for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) { if (hash_type == 0) { s... | 23,255 |
0 | static av_cold void dcadec_flush(AVCodecContext *avctx) { DCAContext *s = avctx->priv_data; ff_dca_core_flush(&s->core); ff_dca_xll_flush(&s->xll); ff_dca_lbr_flush(&s->lbr); s->core_residual_valid = 0; } | 23,257 |
0 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) { AVCodecContext *acodec, *vcodec; FLVContext *flv = s->priv_data; AVIOContext *ioc; AMFDataType amf_type; char str_val[256]; double num_val; num_val = 0; ioc = s->pb; amf_type = avio_r8(io... | 23,258 |
0 | static int check(AVIOContext *pb, int64_t pos, int64_t *out_pos) { MPADecodeHeader mh = { 0 }; int i; uint32_t header; int64_t off = 0; for (i = 0; i < SEEK_PACKETS; i++) { off = avio_seek(pb, pos + mh.frame_size, SEEK_SET); if (off < 0) break; header = avio_rb32(pb); if (ff_mpa_check_header(header) < 0 || avpriv_mpega... | 23,261 |
0 | int av_read_play(AVFormatContext *s) { if (s->iformat->read_play) return s->iformat->read_play(s); if (s->pb && s->pb->read_pause) return av_url_read_fpause(s->pb, 0); return AVERROR(ENOSYS); } | 23,262 |
0 | int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length, HEVCNAL *nal) { int i, si, di; uint8_t *dst; if (s) nal->skipped_bytes = 0; #define STARTCODE_TEST \ if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \ if (src[i + 2] != 3) { \ /* startcode, so we must be past the end */ \ length = i; \... | 23,264 |
0 | static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) { unsigned tag, type, count, off, value = 0; int i, j; int ret; uint32_t *pal; const uint8_t *rp, *gp, *bp; double *dp; if (end_buf - buf < 12) return -1; tag = tget_short(&buf, s->le); type = tget_short(&buf, s... | 23,265 |
0 | static int bit_allocation(IMCContext *q, IMCChannel *chctx, int stream_format_code, int freebits, int flag) { int i, j; const float limit = -1.e20; float highest = 0.0; int indx; int t1 = 0; int t2 = 1; float summa = 0.0; int iacc = 0; int summer = 0; int rres, cwlen; float lowest = 1.e10; int low_indx = 0; float workT... | 23,266 |
0 | static av_cold int g722_decode_init(AVCodecContext * avctx) { G722Context *c = avctx->priv_data; if (avctx->channels != 1) { av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n"); return AVERROR_INVALIDDATA; } avctx->sample_fmt = AV_SAMPLE_FMT_S16; c->band[0].scale_factor = 8; c->band[1].scale_factor = 2; c->p... | 23,267 |
0 | static int handle_packet(MpegTSContext *ts, const uint8_t *packet) { AVFormatContext *s = ts->stream; MpegTSFilter *tss; int len, pid, cc, cc_ok, afc, is_start; const uint8_t *p, *p_end; int64_t pos; pid = AV_RB16(packet + 1) & 0x1fff; if(pid && discard_pid(ts, pid)) return 0; is_start = packet[1] & 0x40; tss = ts->pid... | 23,268 |
0 | static void buffer_release(void *opaque, uint8_t *data) { *(uint8_t*)opaque = 0; } | 23,269 |
0 | static void float_to_int16_3dnow(int16_t *dst, const float *src, int len){ // not bit-exact: pf2id uses different rounding than C and SSE int i; for(i=0; i<len; i+=4) { asm volatile( "pf2id %1, %%mm0 \n\t" "pf2id %2, %%mm1 \n\t" "packssdw %%mm1, %%mm0 \n\t" "movq %%mm0, %0 \n\t" :"=m"(dst[i]) :"m"(src[i]), "m"(src[i+2]... | 23,270 |
0 | static int add_shorts_metadata(const uint8_t **buf, int count, const char *name, const char *sep, TiffContext *s) { char *ap; int i; int *sp = av_malloc(count * sizeof(int)); if (!sp) return AVERROR(ENOMEM); for (i = 0; i < count; i++) sp[i] = tget_short(buf, s->le); ap = shorts2str(sp, count, sep); av_freep(&sp); if (... | 23,271 |
0 | int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, const AVFrame *reference) { int len, nb_components, i, h, v, predictor, point_transform; int index, id; const int block_size= s->lossless ? 1 : 8; int ilv, prev_shift; /* XXX: verify len field validity */ len = get_bits(&s->gb, 16); nb_components... | 23,272 |
0 | static int is_intra_more_likely(MpegEncContext *s){ int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y; if (!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) return 1; //no previous frame available -> use spatial prediction undamaged_count=0; for(i=0; i<s->mb_num; i++){ const int mb_xy= s->mb_in... | 23,273 |
1 | I2CAdapter *omap_i2c_create(uint64_t addr) { OMAPI2C *s = g_malloc0(sizeof(*s)); I2CAdapter *i2c = (I2CAdapter *)s; uint16_t data; s->addr = addr; i2c->send = omap_i2c_send; i2c->recv = omap_i2c_recv; /* verify the mmio address by looking for a known signature */ memread(addr + OMAP_I2C_REV, &data, 2); g_assert_cmphex(... | 23,275 |
1 | 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; in... | 23,276 |
1 | static void gen_ove_cyov(DisasContext *dc, TCGv cy, TCGv ov) { if (dc->tb_flags & SR_OVE) { TCGv t0 = tcg_temp_new(); tcg_gen_or_tl(t0, cy, ov); gen_helper_ove(cpu_env, t0); tcg_temp_free(t0); } } | 23,278 |
1 | static void put_uint16(QEMUFile *f, void *pv, size_t size) { uint16_t *v = pv; qemu_put_be16s(f, v); } | 23,280 |
1 | static int vqa_decode_chunk(VqaContext *s) { unsigned int chunk_type; unsigned int chunk_size; int byte_skip; unsigned int index = 0; int i; unsigned char r, g, b; int index_shift; int res; int cbf0_chunk = -1; int cbfz_chunk = -1; int cbp0_chunk = -1; int cbpz_chunk = -1; int cpl0_chunk = -1; int cplz_chunk = -1; int ... | 23,281 |
1 | static int hls_read(URLContext *h, uint8_t *buf, int size) { HLSContext *s = h->priv_data; const char *url; int ret; int64_t reload_interval; start: if (s->seg_hd) { ret = ffurl_read(s->seg_hd, buf, size); if (ret > 0) return ret; } if (s->seg_hd) { ffurl_close(s->seg_hd); s->seg_hd = NULL; s->cur_seq_no++; } reload_in... | 23,282 |
1 | static inline void ff_h264_biweight_WxH_mmx2(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offsetd, int offsets, int w, int h) { int x, y; int offset = ((offsets + offsetd + 1) | 1) << log2_denom; asm volatile( "movd %0, %%mm3 \n\t" "movd %1, %%mm4 \n\t" "movd %2, %%mm5 \n\t" "mo... | 23,283 |
1 | static int dpx_probe(AVProbeData *p) { const uint8_t *b = p->buf; if (AV_RN32(b) == AV_RN32("SDPX") || AV_RN32(b) == AV_RN32("XPDS")) return AVPROBE_SCORE_EXTENSION + 1; return 0; } | 23,284 |
1 | static int yop_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) { YopDecContext *yop = s->priv_data; int64_t frame_pos, pos_min, pos_max; int frame_count; av_free_packet(&yop->video_packet); if (!stream_index) return -1; pos_min = s->data_offset; pos_max = avio_size(s->pb) - yop->frame_size... | 23,285 |
0 | static int film_read_packet(AVFormatContext *s, AVPacket *pkt) { FilmDemuxContext *film = s->priv_data; AVIOContext *pb = s->pb; film_sample *sample; int ret = 0; int i; int left, right; if (film->current_sample >= film->sample_count) return AVERROR(EIO); sample = &film->sample_table[film->current_sample]; /* position ... | 23,287 |
1 | void qdist_init(struct qdist *dist) { dist->entries = g_malloc(sizeof(*dist->entries)); dist->size = 1; dist->n = 0; } | 23,288 |
1 | void arm_v7m_cpu_do_interrupt(CPUState *cs) { ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; uint32_t lr; arm_log_exception(cs->exception_index); /* For exceptions we just mark as pending on the NVIC, and let that handle it. */ switch (cs->exception_index) { case EXCP_UDEF: armv7m_nvic_set_pending(env->nvic, ... | 23,289 |
1 | static void socket_sendf(int fd, const char *fmt, va_list ap) { gchar *str; size_t size, offset; str = g_strdup_vprintf(fmt, ap); size = strlen(str); offset = 0; while (offset < size) { ssize_t len; len = write(fd, str + offset, size - offset); if (len == -1 && errno == EINTR) { continue; } g_assert_no_errno(len); g_as... | 23,290 |
1 | int vhost_dev_init(struct vhost_dev *hdev, int devfd, bool force) { uint64_t features; int r; if (devfd >= 0) { hdev->control = devfd; } else { hdev->control = open("/dev/vhost-net", O_RDWR); if (hdev->control < 0) { return -errno; } } r = ioctl(hdev->control, VHOST_SET_OWNER, NULL); if (r < 0) { goto fail; } r = ioctl... | 23,291 |
1 | static inline void RENAME(hcscale_fast)(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc) { #if ARCH_X86 #if COMPILE_TEMPLATE_MMX2 int32_t *filterPos = c->hChrFilterPos; int16_t *filter = c->hChrFilter; int canMMX2BeUsed = c->canMMX2BeUsed; void *mmx2FilterCode= c-... | 23,293 |
1 | static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx) { int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, mv_scale, blks_per_mb; IVIMbInfo *mb, *ref_mb; int row_offset = band->mb_size * band->pitch; mb = tile->mbs; ref_mb = tile->ref_mbs; offs = tile->ypos * band->pitch... | 23,294 |
1 | static void decode_nal_sei_frame_packing_arrangement(HEVCContext *s) { GetBitContext *gb = &s->HEVClc->gb; int cancel, type, quincunx, content; get_ue_golomb(gb); // frame_packing_arrangement_id cancel = get_bits1(gb); // frame_packing_cancel_flag if (cancel == 0) { type = get_bits(gb, 7); // frame_packing_arrangement_... | 23,295 |
1 | static int gdb_get_spe_reg(CPUState *env, uint8_t *mem_buf, int n) { if (n < 32) { #if defined(TARGET_PPC64) stl_p(mem_buf, env->gpr[n] >> 32); #else stl_p(mem_buf, env->gprh[n]); #endif return 4; } if (n == 33) { stq_p(mem_buf, env->spe_acc); return 8; } if (n == 34) { /* SPEFSCR not implemented */ memset(mem_buf, 0, ... | 23,296 |
1 | static void virtio_pci_device_unplugged(DeviceState *d) { PCIDevice *pci_dev = PCI_DEVICE(d); VirtIOPCIProxy *proxy = VIRTIO_PCI(d); virtio_pci_stop_ioeventfd(proxy); msix_uninit_exclusive_bar(pci_dev); } | 23,297 |
1 | static int virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy) { int n; if (!proxy->ioeventfd_started) { return 0; } for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) { if (!virtio_queue_get_num(proxy->vdev, n)) { continue; } virtio_pci_set_host_notifier_fd_handler(proxy, n, false); virtio_pci_set_host_notifier_internal(proxy, n... | 23,300 |
1 | static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len) { int ret, clen; s->zstream.avail_out = len; s->zstream.next_out = buf; while (s->zstream.avail_out > 0) { if (s->zstream.avail_in == 0) { if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC) return -1; clen = qemu_get_be16(s->f); if (clen > IOBUF_SIZE... | 23,301 |
1 | void avfilter_free(AVFilterContext *filter) { int i; AVFilterLink *link; if (filter->filter->uninit) filter->filter->uninit(filter); for (i = 0; i < filter->input_count; i++) { if ((link = filter->inputs[i])) { if (link->src) link->src->outputs[link->srcpad - link->src->output_pads] = NULL; avfilter_formats_unref(&link... | 23,302 |
1 | void gtk_display_init(DisplayState *ds) { GtkDisplayState *s = g_malloc0(sizeof(*s)); gtk_init(NULL, NULL); ds->opaque = s; s->ds = ds; s->dcl.ops = &dcl_ops; s->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); #if GTK_CHECK_VERSION(3, 2, 0) s->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #else s->vbox = gtk_vbox_new(... | 23,303 |
1 | void vnc_display_init(DisplayState *ds) { VncDisplay *vs = g_malloc0(sizeof(*vs)); dcl = g_malloc0(sizeof(DisplayChangeListener)); ds->opaque = vs; dcl->idle = 1; vnc_display = vs; vs->lsock = -1; #ifdef CONFIG_VNC_WS vs->lwebsock = -1; #endif vs->ds = ds; QTAILQ_INIT(&vs->clients); vs->expires = TIME_MAX; if (keyboard... | 23,304 |
1 | static int mpegts_handle_packet(AVFormatContext *ctx, PayloadContext *data, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags) { int ret; // We don't want to use the RTP timestamps at all. If the mpegts demuxer // doesn't set any pts/dts, the generic rtpdec code shou... | 23,305 |
1 | static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove) { MonFdset *mon_fdset; MonFdsetFd *mon_fdset_fd_dup; QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) { if (mon_fdset_fd_dup->fd == dup_fd) { if (remove) { QLIST_REMOVE(mon_fdset_fd_dup, next); i... | 23,306 |
1 | static always_inline void powerpc_excp (CPUState *env, int excp_model, int excp) { target_ulong msr, new_msr, vector; int srr0, srr1, asrr0, asrr1; #if defined(TARGET_PPC64H) int lpes0, lpes1, lev; lpes0 = (env->spr[SPR_LPCR] >> 1) & 1; lpes1 = (env->spr[SPR_LPCR] >> 2) & 1; #endif if (loglevel & CPU_LOG_INT) { fprintf... | 23,310 |
1 | static void compute_default_clut(AVSubtitleRect *rect, int w, int h) { uint8_t list[256] = {0}; uint8_t list_inv[256]; int counttab[256] = {0}; int count, i, x, y; #define V(x,y) rect->data[0][(x) + (y)*rect->linesize[0]] for (y = 0; y<h; y++) { for (x = 0; x<w; x++) { int v = V(x,y) + 1; int vl = x ? V(x-1,y) + 1 : 0;... | 23,311 |
1 | static void qcow_close(BlockDriverState *bs) { BDRVQcowState *s = bs->opaque; g_free(s->l1_table); g_free(s->l2_cache); g_free(s->cluster_cache); g_free(s->cluster_data); migrate_del_blocker(s->migration_blocker); error_free(s->migration_blocker); } | 23,312 |
1 | static int pvf_read_header(AVFormatContext *s) { char buffer[32]; AVStream *st; int bps, channels, sample_rate; avio_skip(s->pb, 5); ff_get_line(s->pb, buffer, sizeof(buffer)); if (sscanf(buffer, "%d %d %d", &channels, &sample_rate, &bps) != 3) return AVERROR_INVALIDDATA; if (channels <= 0 || bps <= 0 || sample_rate <=... | 23,313 |
1 | iscsi_readv_writev_bh_cb(void *p) { IscsiAIOCB *acb = p; qemu_bh_delete(acb->bh); if (!acb->canceled) { acb->common.cb(acb->common.opaque, acb->status); } qemu_aio_release(acb); if (acb->canceled) { return; } scsi_free_scsi_task(acb->task); acb->task = NULL; } | 23,315 |
1 | static void vmmouse_reset(DeviceState *d) { VMMouseState *s = container_of(d, VMMouseState, dev.qdev); s->status = 0xffff; s->queue_size = VMMOUSE_QUEUE_SIZE; } | 23,317 |
1 | static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, enum AVPixelFormat srcFormat, enum AVPixelFormat dstFormat, int srcW, int srcH, int dstW, int dstH, int flags, struct Results *r) { static enum AVPixelFormat cur_srcFormat; static int cur_srcW, cur_srcH; static uint8_t *src[4]; static int srcStride[4]; ... | 23,318 |
1 | char *object_property_get_str(Object *obj, const char *name, Error **errp) { QObject *ret = object_property_get_qobject(obj, name, errp); QString *qstring; char *retval; if (!ret) { return NULL; } qstring = qobject_to_qstring(ret); if (!qstring) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string"); retval = ... | 23,319 |
1 | ip_input(struct mbuf *m) { Slirp *slirp = m->slirp; register struct ip *ip; int hlen; DEBUG_CALL("ip_input"); DEBUG_ARG("m = %p", m); DEBUG_ARG("m_len = %d", m->m_len); if (m->m_len < sizeof (struct ip)) { return; } ip = mtod(m, struct ip *); if (ip->ip_v != IPVERSION) { goto bad; } hlen = ip->ip_hl << 2; if (hlen<size... | 23,320 |
1 | static inline void RENAME(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW) { #ifdef HAVE_MMX if(uDest != NULL) { asm volatile( YSCALEYUV2YV121 :: "r" (chrSrc + chrDstW), "r" (uDest + chrDstW), "g" ((long)-chrDstW) : "%"REG_a ); asm volatile( YSCALEYUV2YV1... | 23,321 |
1 | static int read_dialogue(ASSContext *ass, AVBPrint *dst, const uint8_t *p, int64_t *start, int *duration) { int pos; int64_t end; int hh1, mm1, ss1, ms1; int hh2, mm2, ss2, ms2; if (sscanf(p, "Dialogue: %*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d,%n", &hh1, &mm1, &ss1, &ms1, &hh2, &mm2, &ss2, &ms2, &pos) >= 8) { /* This is not ... | 23,322 |
1 | static void quantize_bands(int (*out)[2], const float *in, const float *scaled, int size, float Q34, int is_signed, int maxval) { int i; double qc; for (i = 0; i < size; i++) { qc = scaled[i] * Q34; out[i][0] = (int)FFMIN((int)qc, maxval); out[i][1] = (int)FFMIN((int)(qc + 0.4054), maxval); if (is_signed && in[i] < 0.0... | 23,324 |
1 | av_cold int vaapi_device_init(const char *device) { int err; err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, device, NULL, 0); if (err < 0) { av_log(&vaapi_log, AV_LOG_ERROR, "Failed to create a VAAPI device\n"); return err; } return 0; } | 23,325 |
1 | static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr) { CharDriverState *chr; PtyCharDriver *s; struct termios tty; int slave_fd, len; #if defined(__OpenBSD__) || defined(__DragonFly__) char pty_name[PATH_MAX]; #define q_ptsname(x) pty_name #else char *pty_name = NULL; #define q_ptsname(x) ptsname(x) #en... | 23,326 |
1 | static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) { const AVPixFmtDescriptor *desc; SMVJpegDecodeContext *s = avctx->priv_data; AVFrame* mjpeg_data = s->picture[0]; int i, cur_frame = 0, ret = 0; cur_frame = avpkt->pts % s->frames_per_jpeg; /* Are we at the start of a b... | 23,327 |
1 | static void tpm_display_backend_drivers(void) { int i; fprintf(stderr, "Supported TPM types (choose only one):\n"); for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) { fprintf(stderr, "%12s %s\n", TpmType_lookup[be_drivers[i]->type], be_drivers[i]->desc()); } fprintf(stderr, "\n"); } | 23,328 |
0 | static void rtsp_parse_rtp_info(RTSPState *rt, const char *p) { int read = 0; char key[20], value[1024], url[1024] = ""; uint32_t seq = 0, rtptime = 0; for (;;) { p += strspn(p, SPACE_CHARS); if (!*p) break; get_word_sep(key, sizeof(key), "=", &p); if (*p != '=') break; p++; get_word_sep(value, sizeof(value), ";, ", &p... | 23,329 |
0 | static int bink_decode_plane(BinkContext *c, AVFrame *frame, BitstreamContext *bc, int plane_idx, int is_chroma) { int blk, ret; int i, j, bx, by; uint8_t *dst, *prev, *ref_start, *ref_end; int v, col[2]; const uint8_t *scan; LOCAL_ALIGNED_16(int16_t, block, [64]); LOCAL_ALIGNED_16(uint8_t, ublock, [64]); LOCAL_ALIGNED... | 23,330 |
0 | static void opt_frame_pad_right(const char *arg) { frame_padright = atoi(arg); if (frame_padright < 0) { fprintf(stderr, "Incorrect right pad size\n"); av_exit(1); } } | 23,331 |
0 | static int dcadec_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { DCAContext *s = avctx->priv_data; AVFrame *frame = data; uint8_t *input = avpkt->data; int input_size = avpkt->size; int i, ret, prev_packet = s->packet; if (input_size < MIN_PACKET_SIZE || input_size > MAX_PACKET_S... | 23,332 |
0 | static int iszero(const int16_t *c, int sz) { int n; for (n = 0; n < sz; n += 4) if (AV_RN32A(&c[n])) return 0; return 1; } | 23,333 |
0 | void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den) { AVRational new_tb; if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){ if(new_tb.num != pts_num) av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.n... | 23,334 |
1 | static void pci_bridge_region_init(PCIBridge *br) { PCIBus *parent = br->dev.bus; uint16_t cmd = pci_get_word(br->dev.config + PCI_COMMAND); pci_bridge_init_alias(br, &br->alias_pref_mem, PCI_BASE_ADDRESS_MEM_PREFETCH, "pci_bridge_pref_mem", &br->address_space_mem, parent->address_space_mem, cmd & PCI_COMMAND_MEMORY); ... | 23,335 |
1 | static void ecc_reset(void *opaque) { ECCState *s = opaque; int i; s->regs[ECC_MER] &= (ECC_MER_VER | ECC_MER_IMPL); s->regs[ECC_MER] |= ECC_MER_MRR; s->regs[ECC_MDR] = 0x20; s->regs[ECC_MFSR] = 0; s->regs[ECC_VCR] = 0; s->regs[ECC_MFAR0] = 0x07c00000; s->regs[ECC_MFAR1] = 0; s->regs[ECC_DR] = 0; s->regs[ECC_ECR0] = 0;... | 23,336 |
1 | static inline int16_t mipsdsp_add_i16(int16_t a, int16_t b, CPUMIPSState *env) { int16_t tempI; tempI = a + b; if (MIPSDSP_OVERFLOW(a, b, tempI, 0x8000)) { set_DSPControl_overflow_flag(1, 20, env); } return tempI; } | 23,337 |
1 | void cpu_loop(CPUMBState *env) { int trapnr, ret; target_siginfo_t info; while (1) { trapnr = cpu_mb_exec (env); switch (trapnr) { case 0xaa: { info.si_signo = SIGSEGV; info.si_errno = 0; /* XXX: check env->error_code */ info.si_code = TARGET_SEGV_MAPERR; info._sifields._sigfault._addr = 0; queue_signal(env, info.si_si... | 23,338 |
1 | static void RENAME(interleaveBytes)(const uint8_t *src1, const uint8_t *src2, uint8_t *dest, int width, int height, int src1Stride, int src2Stride, int dstStride) { int h; for (h=0; h < height; h++) { int w; if (width >= 16) #if COMPILE_TEMPLATE_SSE2 __asm__( "xor %%"REG_a", %%"REG_a" \n\t" "1: \n\t" PREFETCH" 64(%1, %... | 23,340 |
1 | static int dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output) { DVBSubContext *ctx = avctx->priv_data; DVBSubRegionDisplay *display; DVBSubRegionDisplay *tmp_display_list, **tmp_ptr; const uint8_t *buf_end = buf + buf_size; int region_id; int page_state;... | 23,341 |
1 | static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *last, void *dst, int last2, int w, int stride, int comp, int bits) { int i, x = 0; int Ra, Rb, Rc, Rd; int D0, D1, D2; while (x < w) { int err, pred; /* compute gradients */ Ra = x ? R(dst, x - stride) : R(last, x); Rb = R(last, x); Rc = x ... | 23,342 |
1 | static int finish_frame(AVCodecContext *avctx, AVFrame *pict) { RV34DecContext *r = avctx->priv_data; MpegEncContext *s = &r->s; int got_picture = 0; ff_er_frame_end(s); ff_MPV_frame_end(s); if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) ff_thread_report_progress(&s->current_picture_ptr->f, INT_M... | 23,343 |
0 | static int s337m_probe(AVProbeData *p) { uint64_t state = 0; int markers[3] = { 0 }; int i, sum, max, data_type, data_size, offset; uint8_t *buf; for (buf = p->buf; buf < p->buf + p->buf_size; buf++) { state = (state << 8) | *buf; if (!IS_LE_MARKER(state)) continue; if (IS_16LE_MARKER(state)) { data_type = AV_RL16(buf ... | 23,345 |
0 | static inline void RENAME(yuv2nv12X)(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrSrc, int chrFilterSize, uint8_t *dest, uint8_t *uDest, int dstW, int chrDstW, enum PixelFormat dstFormat) { yuv2nv12XinC(lumFilter, lumSrc, lumFilterSize,... | 23,346 |
1 | static int usb_bt_handle_control(USBDevice *dev, USBPacket *p, int request, int value, int index, int length, uint8_t *data) { struct USBBtState *s = (struct USBBtState *) dev->opaque; int ret; ret = usb_desc_handle_control(dev, p, request, value, index, length, data); if (ret >= 0) { switch (request) { case DeviceRequ... | 23,347 |
1 | int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame, AVFilterBufferRef **picref_ptr, AVRational *tb) { int ret; AVFilterBufferRef *picref; if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0) return ret; if (!(picref = ctx->inputs[0]->cur_buf)) return AVERROR(ENOENT); *picref_ptr = picref; ctx->inputs[... | 23,348 |
1 | static int vmxnet3_post_load(void *opaque, int version_id) { VMXNET3State *s = opaque; PCIDevice *d = PCI_DEVICE(s); vmxnet_tx_pkt_init(&s->tx_pkt, s->max_tx_frags, s->peer_has_vhdr); vmxnet_rx_pkt_init(&s->rx_pkt, s->peer_has_vhdr); if (s->msix_used) { if (!vmxnet3_use_msix_vectors(s, VMXNET3_MAX_INTRS)) { VMW_WRPRN("... | 23,349 |
1 | static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64], int qsel, int is_chroma, int is_hqa) { const int32_t *q; int val, pos = 1; memset(block, 0, 64 * sizeof(*block)); if (!is_hqa) { block[0] = get_sbits(gb, 9) * 64; q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)]; } else { q = ff_hq_quants[... | 23,350 |
0 | void dsputil_init_alpha(void) { put_pixels_tab[0][0] = put_pixels16_axp_asm; put_pixels_tab[0][1] = put_pixels16_x2_axp; put_pixels_tab[0][2] = put_pixels16_y2_axp; put_pixels_tab[0][3] = put_pixels16_xy2_axp; put_no_rnd_pixels_tab[0][0] = put_pixels16_axp_asm; put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_axp; ... | 23,351 |
1 | address_space_translate_for_iotlb(CPUState *cpu, int asidx, hwaddr addr, hwaddr *xlat, hwaddr *plen) { MemoryRegionSection *section; AddressSpaceDispatch *d = cpu->cpu_ases[asidx].memory_dispatch; section = address_space_translate_internal(d, addr, xlat, plen, false); assert(!section->mr->iommu_ops); return section; } | 23,352 |
1 | static struct pxa2xx_fir_s *pxa2xx_fir_init(target_phys_addr_t base, qemu_irq irq, struct pxa2xx_dma_state_s *dma, CharDriverState *chr) { int iomemtype; struct pxa2xx_fir_s *s = (struct pxa2xx_fir_s *) qemu_mallocz(sizeof(struct pxa2xx_fir_s)); s->base = base; s->irq = irq; s->dma = dma; s->chr = chr; pxa2xx_fir_reset... | 23,353 |
1 | static ssize_t nbd_co_receive_request(NBDRequest *req, struct nbd_request *request) { NBDClient *client = req->client; int csock = client->sock; ssize_t rc; client->recv_coroutine = qemu_coroutine_self(); if (nbd_receive_request(csock, request) < 0) { rc = -EIO; goto out; } if (request->len > NBD_BUFFER_SIZE) { LOG("le... | 23,355 |
1 | ram_addr_t migration_bitmap_find_dirty(RAMState *rs, RAMBlock *rb, ram_addr_t start, ram_addr_t *ram_addr_abs) { unsigned long base = rb->offset >> TARGET_PAGE_BITS; unsigned long nr = base + (start >> TARGET_PAGE_BITS); uint64_t rb_size = rb->used_length; unsigned long size = base + (rb_size >> TARGET_PAGE_BITS); unsi... | 23,356 |
1 | AVFrame *ff_framequeue_take(FFFrameQueue *fq) { FFFrameBucket *b; check_consistency(fq); av_assert1(fq->queued); b = bucket(fq, 0); fq->queued--; fq->tail++; fq->tail &= fq->allocated - 1; fq->total_frames_tail++; fq->total_samples_tail += b->frame->nb_samples; check_consistency(fq); return b->frame; } | 23,357 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.