label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void print_samplesref(AVFilterBufferRef *samplesref){ const AVFilterBufferRefAudioProps *props = samplesref->audio; const int n = props->nb_samples * av_get_channel_layout_nb_channels(props->channel_layout); const uint16_t *p = (uint16_t*)samplesref->data[0]; const uint16_t *p_end = p + n; while (p < p_end) { fp... |
1 | static void test_media_insert(void){ uint8_t dir; /* Insert media in drive. DSKCHK should not be reset until a step pulse * is sent. */ qmp_discard_response("{'execute':'change', 'arguments':{" " 'device':'floppy0', 'target': '%s' }}", test_image); qmp_discard_response(""); /* ignore event (FIXME open -> open transitio... |
1 | void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable){ int64_t bitmap_size; if (enable) { if (bs->dirty_tracking == 0) { int64_t i; uint8_t test; bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS); bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK; bitmap_size++; bs->dirty_bitmap = qemu_mallocz(bitmap_size); bs-... |
1 | static void quorum_aio_finalize(QuorumAIOCB *acb){ BDRVQuorumState *s = acb->common.bs->opaque; int i, ret = 0; if (acb->vote_ret) { ret = acb->vote_ret; } acb->common.cb(acb->common.opaque, ret); if (acb->is_read) { for (i = 0; i < s->num_children; i++) { qemu_vfree(acb->qcrs[i].buf); qemu_iovec_destroy(&acb->qcrs[i].... |
1 | static int h261_decode_gob_header(H261Context *h){ unsigned int val; MpegEncContext * const s = &h->s; /* Check for GOB Start Code */ val = show_bits(&s->gb, 15); if(val) return -1; /* We have a GBSC */ skip_bits(&s->gb, 16); h->gob_number = get_bits(&s->gb, 4); /* GN */ s->qscale = get_bits(&s->gb, 5); /* GQUANT */ /*... |
1 | static int vhost_user_set_u64(struct vhost_dev *dev, int request, uint64_t u64){ VhostUserMsg msg = { .request = request, .flags = VHOST_USER_VERSION, .u64 = u64, .size = sizeof(m.u64), }; vhost_user_write(dev, &msg, NULL, 0); return 0;} |
1 | static int read_rle_sgi(uint8_t *out_buf, SgiState *s){ uint8_t *dest_row; unsigned int len = s->height * s->depth * 4; GetByteContext g_table = s->g; unsigned int y, z; unsigned int start_offset; /* size of RLE offset and length tables */ if (len * 2 > bytestream2_get_bytes_left(&s->g)) { return AVERROR_INVALIDDATA; }... |
0 | static inline void RENAME(uyvyToY)(uint8_t *dst, const uint8_t *src, long width, uint32_t *unused){#if COMPILE_TEMPLATE_MMX __asm__ volatile( "mov %0, %%"REG_a" \n\t" "1: \n\t" "movq (%1, %%"REG_a",2), %%mm0 \n\t" "movq 8(%1, %%"REG_a",2), %%mm1 \n\t" "psrlw $8, %%mm0 \n\t" "psrlw $8, %%mm1 \n\t" "packuswb %%mm1, %%mm0... |
0 | static inline void RENAME(yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, long width, long height, long lumStride, long chromStride, long dstStride){ //FIXME interpolate chroma RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);} |
0 | static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride, int is4tap){ LOAD_PIXELS int a, f1, f2; const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; a = 3*(q0 - p0); if (is4tap) a += clip_int8(p1 - q1); a = clip_int8(a); // We deviate from the spec here with c(a+3) >> 3 // since that's what libvpx does. f1 =... |
0 | static int theora_decode_init(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; GetBitContext gb; int ptype; uint8_t *p= avctx->extradata; int op_bytes, i; s->theora = 1; if (!avctx->extradata_size) { av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n"); return -1; } for(i=0;i<3;i++) { op_bytes = *(p++)<<8... |
0 | static av_cold int pcm_encode_init(AVCodecContext *avctx){ avctx->frame_size = 0; switch (avctx->codec->id) { case AV_CODEC_ID_PCM_ALAW: pcm_alaw_tableinit(); break; case AV_CODEC_ID_PCM_MULAW: pcm_ulaw_tableinit(); break; default: break; } avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); avctx-... |
0 | static void write_packet(AVFormatContext *s, AVPacket *pkt, OutputStream *ost){ AVStream *st = ost->st; int ret; /* * Audio encoders may split the packets -- #frames in != #packets out. * But there is no reordering, so we can limit the number of output packets * by simply dropping them here. * Counting encoded video fr... |
0 | void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag, int is_mpeg12){ int mb_x, mb_y; const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;#if CONFIG_MPEG_XVMC_DECODER if(s->avctx->xvmc_acceleration){ ff_xvmc_decode_mb(s);//xvmc uses pblocks return; }#endif mb_x = s->mb_x; mb_y = s->mb_y;... |
0 | void ff_aac_apply_tns(SingleChannelElement *sce){ const int mmm = FFMIN(sce->ics.tns_max_bands, sce->ics.max_sfb); float *coef = sce->pcoeffs; TemporalNoiseShaping *tns = &sce->tns; int w, filt, m, i; int bottom, top, order, start, end, size, inc; float *lpc, tmp[TNS_MAX_ORDER+1]; for (w = 0; w < sce->ics.num_windows; ... |
1 | void qcow2_free_clusters(BlockDriverState *bs, int64_t offset, int64_t size){ int ret; BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_FREE); ret = update_refcount(bs, offset, size, -1); if (ret < 0) { fprintf(stderr, "qcow2_free_clusters failed: %s\n", strerror(-ret)); abort(); }} |
1 | static void do_video_stats(AVOutputStream *ost, AVInputStream *ist, int frame_size){ static FILE *fvstats=NULL; static INT64 total_size = 0; struct tm *today; time_t today2; char filename[40]; AVCodecContext *enc; int frame_number; INT64 ti; double ti1, bitrate, avg_bitrate; if (!fvstats) { today2 = time(NULL); today =... |
1 | static int scsi_handle_rw_error(SCSIDiskReq *r, int error, int type){ int is_read = (type == SCSI_REQ_STATUS_RETRY_READ); SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); BlockErrorAction action = bdrv_get_on_error(s->bs, is_read); if (action == BLOCK_ERR_IGNORE) { bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE... |
1 | static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc, GIOCondition condition, gpointer user_data){ QIOTask *task = user_data; QIOChannelWebsock *wioc = QIO_CHANNEL_WEBSOCK( qio_task_get_source(task)); Error *err = NULL; int ret; ret = qio_channel_websock_handshake_read(wioc, &err); if (ret < 0) { trace_qio_... |
1 | static int find_debugfs(char *debugfs){ char type[100]; FILE *fp; fp = fopen("/proc/mounts", "r"); if (fp == NULL) { return 0; } while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n", debugfs, type) == 2) { if (strcmp(type, "debugfs") == 0) { break; } } fclose(fp); if (strcmp(type, "debugfs") != 0) { return 0;... |
1 | void qemu_input_event_send(QemuConsole *src, InputEvent *evt){ QemuInputHandlerState *s; if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { qemu_input_event_trace(src, evt); /* pre processing */ if (graphic_rotate && (evt->kind == INPUT_EVENT_KIND_ABS)) { qemu_input_transform_abs_rotate(evt); /* send... |
1 | static int qemu_chr_fe_write_buffer(CharDriverState *s, const uint8_t *buf, int len, int *offset){ int res = 0; *offset = 0; qemu_mutex_lock(&s->chr_write_lock); while (*offset < len) { do { res = s->chr_write(s, buf + *offset, len - *offset); if (res == -1 && errno == EAGAIN) { g_usleep(100); } } while (res == -1 && e... |
1 | VLANClientState *qdev_get_vlan_client(DeviceState *dev, NetCanReceive *can_receive, NetReceive *receive, NetReceiveIOV *receive_iov, NetCleanup *cleanup, void *opaque){ NICInfo *nd = dev->nd; assert(nd); return qemu_new_vlan_client(nd->vlan, nd->model, nd->name, can_receive, receive, receive_iov, cleanup, opaque);} |
1 | static int send_sub_rect_nojpeg(VncState *vs, int x, int y, int w, int h, int bg, int fg, int colors, VncPalette *palette){ int ret; if (colors == 0) { if (tight_detect_smooth_image(vs, w, h)) { ret = send_gradient_rect(vs, x, y, w, h); ret = send_full_color_rect(vs, x, y, w, h); } } else if (colors == 1) { ret = send_... |
1 | static int guess_disk_lchs(IDEState *s, int *pcylinders, int *pheads, int *psectors){ uint8_t *buf; int ret, i, heads, sectors, cylinders; struct partition *p; uint32_t nr_sects; buf = qemu_memalign(512, 512); if (buf == NULL) return -1; ret = bdrv_read(s->bs, 0, buf, 1); if (ret < 0) { qemu_free(buf); return -1; } /* ... |
1 | USBDevice *usb_host_device_open(USBBus *bus, const char *devname){ struct USBAutoFilter filter; USBDevice *dev; char *p; dev = usb_create(bus, "usb-host"); if (strstr(devname, "auto:")) { if (parse_filter(devname, &filter) < 0) { goto fail; } } else { p = strchr(devname, '.'); if (p) { filter.bus_num = strtoul(devname,... |
1 | static void xlnx_dp_set_dpdma(Object *obj, const char *name, Object *val, Error **errp){ XlnxDPState *s = XLNX_DP(obj); if (s->console) { DisplaySurface *surface = qemu_console_surface(s->console); XlnxDPDMAState *dma = XLNX_DPDMA(val); xlnx_dpdma_set_host_data_location(dma, DP_GRAPHIC_DMA_CHANNEL, surface_data(surface... |
0 | static int ff_interleave_new_audio_packet(AVFormatContext *s, AVPacket *pkt, int stream_index, int flush){ AVStream *st = s->streams[stream_index]; AudioInterleaveContext *aic = st->priv_data; int size = FFMIN(av_fifo_size(aic->fifo), *aic->samples * aic->sample_size); if (!size || (!flush && size == av_fifo_size(aic->... |
0 | static int alloc_tables(H264Context *h){ MpegEncContext * const s = &h->s; const int big_mb_num= s->mb_stride * (s->mb_height+1); int x,y; CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t)) CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) CHECKED_ALLOCZ(h->slice_table_base , (b... |
0 | static int decode_nal_sei_frame_packing_arrangement(HEVCContext *s){ GetBitContext *gb = &s->HEVClc->gb; get_ue_golomb(gb); // frame_packing_arrangement_id s->sei_frame_packing_present = !get_bits1(gb); if (s->sei_frame_packing_present) { s->frame_packing_arrangement_type = get_bits(gb, 7); s->quincunx_subsampling = ge... |
0 | static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx){ int hdr_size, width, height, flags; int version; const uint8_t *ptr; hdr_size = AV_RB16(buf); av_dlog(avctx, "header size %d\n", hdr_size); if (hdr_size > data_size) { av_log(avctx, AV_LOG_ERROR, "error, ... |
0 | static int svq1_decode_frame(AVCodecContext *avctx, void *data, int *data_size, UINT8 *buf, int buf_size){ MpegEncContext *s=avctx->priv_data; uint8_t *current, *previous; intresult, i, x, y, width, height; AVFrame *pict = data; /* initialize bit buffer */ init_get_bits(&s->gb,buf,buf_size); /* decode frame header */ s... |
1 | static int decode_blocks(SnowContext *s){ int x, y; int w= s->b_width; int h= s->b_height; int res; for(y=0; y<h; y++){ for(x=0; x<w; x++){ if ((res = decode_q_branch(s, 0, x, y)) < 0) return res; } } return 0;} |
1 | static int s390x_write_all_elf64_notes(const char *note_name, WriteCoreDumpFunction f, S390CPU *cpu, int id, void *opaque){ Note note; const NoteFuncDesc *nf; int note_size; int ret = -1; for (nf = note_func; nf->note_contents_func; nf++) { memset(¬e, 0, sizeof(note)); note.hdr.n_namesz = cpu_to_be32(sizeof(note.nam... |
1 | static int decode_unit(SCPRContext *s, PixelModel *pixel, unsigned step, unsigned *rval){ GetByteContext *gb = &s->gb; RangeCoder *rc = &s->rc; unsigned totfr = pixel->total_freq; unsigned value, x = 0, cumfr = 0, cnt_x = 0; int i, j, ret, c, cnt_c; if ((ret = s->get_freq(rc, totfr, &value)) < 0) return ret; while (x <... |
0 | void slirp_select_fill(int *pnfds, fd_set *readfds, fd_set *writefds, fd_set *xfds){} |
0 | int tcp_socket_incoming(const char *address, uint16_t port){ char address_and_port[128]; Error *local_err = NULL; combine_addr(address_and_port, 128, address, port); int fd = inet_listen(address_and_port, NULL, 0, SOCK_STREAM, 0, &local_err); if (local_err != NULL) { qerror_report_err(local_err); error_free(local_err);... |
0 | static void paio_cancel(BlockDriverAIOCB *blockacb){ struct qemu_paiocb *acb = (struct qemu_paiocb *)blockacb; int active = 0; mutex_lock(&lock); if (!acb->active) { TAILQ_REMOVE(&request_list, acb, node); acb->ret = -ECANCELED; } else if (acb->ret == -EINPROGRESS) { active = 1; } mutex_unlock(&lock); if (active) { /* ... |
0 | static void machine_initfn(Object *obj){ MachineState *ms = MACHINE(obj); object_property_add_str(obj, "accel", machine_get_accel, machine_set_accel, NULL); object_property_set_description(obj, "accel", "Accelerator list", NULL); object_property_add_bool(obj, "kernel-irqchip", machine_get_kernel_irqchip, machine_set_ke... |
0 | static ssize_t flush_buf(VirtIOSerialPort *port, const uint8_t *buf, size_t len){ VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port); ssize_t ret; ret = qemu_chr_write(vcon->chr, buf, len); trace_virtio_console_flush_buf(port->id, len, ret); return ret;} |
0 | static uint64_t l2x0_priv_read(void *opaque, target_phys_addr_t offset, unsigned size){ uint32_t cache_data; l2x0_state *s = (l2x0_state *)opaque; offset &= 0xfff; if (offset >= 0x730 && offset < 0x800) { return 0; /* cache ops complete */ } switch (offset) { case 0: return CACHE_ID; case 0x4: /* aux_ctrl values affect... |
0 | static int qcow_create2(const char *filename, int64_t total_size, const char *backing_file, const char *backing_format, int flags){ int fd, header_size, backing_filename_len, l1_size, i, shift, l2_bits; int backing_format_len = 0; QCowHeader header; uint64_t tmp, offset; QCowCreateState s1, *s = &s1; QCowExtension ext_... |
0 | static void do_branch(DisasContext *dc, int32_t offset, uint32_t insn, int cc, TCGv r_cond){ unsigned int cond = GET_FIELD(insn, 3, 6), a = (insn & (1 << 29)); target_ulong target = dc->pc + offset; if (cond == 0x0) { /* unconditional not taken */ if (a) { dc->pc = dc->npc + 4; dc->npc = dc->pc + 4; } else { dc->pc = d... |
0 | static void prodsum(float *tgt, float *src, int len, int n){ unsigned int x; float *p1, *p2; double sum; while (n >= 0) { p1 = (p2 = src) - n; for (sum=0, x=len; x--; sum += (*p1++) * (*p2++)); tgt[n--] = sum; }} |
0 | void cpu_tlb_update_dirty(CPUState *env){ int i; for(i = 0; i < CPU_TLB_SIZE; i++) tlb_update_dirty(&env->tlb_table[0][i]); for(i = 0; i < CPU_TLB_SIZE; i++) tlb_update_dirty(&env->tlb_table[1][i]);#if (NB_MMU_MODES >= 3) for(i = 0; i < CPU_TLB_SIZE; i++) tlb_update_dirty(&env->tlb_table[2][i]);#endif#if (NB_MMU_MODES ... |
0 | long do_rt_sigreturn(CPUMIPSState *env){ struct target_rt_sigframe *frame; abi_ulong frame_addr; sigset_t blocked;#if defined(DEBUG_SIGNAL) fprintf(stderr, "do_rt_sigreturn\n");#endif frame_addr = env->active_tc.gpr[29]; if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; target_to_host_sigset(&blo... |
0 | static void spr_read_decr (DisasContext *ctx, int gprn, int sprn){ if (use_icount) { gen_io_start(); } gen_helper_load_decr(cpu_gpr[gprn], cpu_env); if (use_icount) { gen_io_end(); gen_stop_exception(ctx); }} |
0 | bool memory_region_is_logging(MemoryRegion *mr){ return mr->dirty_log_mask;} |
0 | static void mv88w8618_eth_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ mv88w8618_eth_state *s = opaque; switch (offset) { case MP_ETH_SMIR: s->smir = value; break; case MP_ETH_PCXR: s->vlan_header = ((value >> MP_ETH_PCXR_2BSM_BIT) & 1) * 2; break; case MP_ETH_SDCMR: if (value & MP_ETH... |
0 | softusb_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ MilkymistSoftUsbState *s = opaque; trace_milkymist_softusb_memory_write(addr, value); addr >>= 2; switch (addr) { case R_CTRL: s->regs[addr] = value; break; default: error_report("milkymist_softusb: write access to unknown register 0x"... |
0 | void r4k_invalidate_tlb (CPUState *env, int idx, int use_extra){ r4k_tlb_t *tlb; target_ulong addr; target_ulong end; uint8_t ASID = env->CP0_EntryHi & 0xFF; target_ulong mask; tlb = &env->tlb->mmu.r4k.tlb[idx]; /* The qemu TLB is flushed when the ASID changes, so no need to flush these entries again. */ if (tlb->G == ... |
0 | static int vc1_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ VC1Context *v = avctx->priv_data; MpegEncContext *s = &v->s; AVFrame *pict = data; uint8_t *buf2 = NULL; /* no supplementary picture */ if (buf_size == 0) { /* special case for last picture */ if (s->low_delay==0... |
0 | void qmp_guest_set_user_password(const char *username, const char *password, bool crypted, Error **errp){ NET_API_STATUS nas; char *rawpasswddata = NULL; size_t rawpasswdlen; wchar_t *user, *wpass; USER_INFO_1003 pi1003 = { 0, }; if (crypted) { error_setg(errp, QERR_UNSUPPORTED); return; } rawpasswddata = (char *)g_bas... |
0 | static void cpu_exec_nocache(CPUState *cpu, int max_cycles, TranslationBlock *orig_tb, bool ignore_icount){ TranslationBlock *tb; /* Should never happen. We only end up here when an existing TB is too long. */ if (max_cycles > CF_COUNT_MASK) max_cycles = CF_COUNT_MASK; tb = tb_gen_code(cpu, orig_tb->pc, orig_tb->cs_bas... |
0 | static void virtio_scsi_migration_state_changed(Notifier *notifier, void *data){ VirtIOSCSI *s = container_of(notifier, VirtIOSCSI, migration_state_notifier); MigrationState *mig = data; if (migration_in_setup(mig)) { if (!s->dataplane_started) { return; } virtio_scsi_dataplane_stop(s); s->dataplane_disabled = true; } ... |
0 | static void hpet_reset(void *opaque){ HPETState *s = opaque; int i; static int count = 0; for (i = 0; i < HPET_NUM_TIMERS; i++) { HPETTimer *timer = &s->timer[i]; hpet_del_timer(timer); timer->tn = i; timer->cmp = ~0ULL; timer->config = HPET_TN_PERIODIC_CAP | HPET_TN_SIZE_CAP; /* advertise availability of ioapic inti2 ... |
0 | static void aio_epoll_update(AioContext *ctx, AioHandler *node, bool is_new){} |
0 | int inet_listen_opts(QemuOpts *opts, int port_offset){ struct addrinfo ai,*res,*e; const char *addr; char port[33]; char uaddr[INET6_ADDRSTRLEN+1]; char uport[33]; int slisten,rc,to,try_next; memset(&ai,0, sizeof(ai)); ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; ai.ai_family = PF_UNSPEC; ai.ai_socktype = SOCK_STREAM; if ... |
0 | static uint64_t iack_read(void *opaque, target_phys_addr_t addr, unsigned size){ return pic_read_irq(isa_pic);} |
0 | static void sd_set_status(SDState *sd){ switch (sd->state) { case sd_inactive_state: sd->mode = sd_inactive; break; case sd_idle_state: case sd_ready_state: case sd_identification_state: sd->mode = sd_card_identification_mode; break; case sd_standby_state: case sd_transfer_state: case sd_sendingdata_state: case sd_rece... |
0 | void init_clocks(void){ QEMUClockType type; for (type = 0; type < QEMU_CLOCK_MAX; type++) { qemu_clock_init(type); }#ifdef CONFIG_PRCTL_PR_SET_TIMERSLACK prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);#endif} |
0 | static void FUNC(sao_band_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride, SAOParams *sao, int *borders, int width, int height, int c_idx, int class){ pixel *dst = (pixel *)_dst; pixel *src = (pixel *)_src; int offset_table[32] = { 0 }; int k, y, x; int chroma = !!c_idx; int shift = BIT_DEPTH - 5; int *sao_offse... |
1 | static void vhost_scsi_realize(DeviceState *dev, Error **errp){ VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev); VHostSCSI *s = VHOST_SCSI(dev); Error *err = NULL; int vhostfd = -1; int ret; if (!vs->conf.wwpn) { error_setg(errp, "vhost-scsi: missing wwpn"); return; } if (vs->conf.vhostfd) { vhostfd = monitor_handle_fd_... |
1 | static void update_refcount_discard(BlockDriverState *bs, uint64_t offset, uint64_t length){ BDRVQcowState *s = bs->opaque; Qcow2DiscardRegion *d, *p, *next; QTAILQ_FOREACH(d, &s->discards, next) { uint64_t new_start = MIN(offset, d->offset); uint64_t new_end = MAX(offset + length, d->offset + d->bytes); if (new_end - ... |
1 | static void qcow2_close(BlockDriverState *bs){ BDRVQcowState *s = bs->opaque; g_free(s->l1_table); /* else pre-write overlap checks in cache_destroy may crash */ s->l1_table = NULL; if (!(bs->open_flags & BDRV_O_INCOMING)) { qcow2_cache_flush(bs, s->l2_table_cache); qcow2_cache_flush(bs, s->refcount_block_cache); qcow2... |
1 | static void pred4x4_vertical_vp8_c(uint8_t *src, const uint8_t *topright, int stride){ const int lt= src[-1-1*stride]; LOAD_TOP_EDGE LOAD_TOP_RIGHT_EDGE uint32_t v = PACK_4U8((lt + 2*t0 + t1 + 2) >> 2, (t0 + 2*t1 + t2 + 2) >> 2, (t1 + 2*t2 + t3 + 2) >> 2, (t2 + 2*t3 + t4 + 2) >> 2); AV_WN32A(src+0*stride, v); AV_WN32A(... |
1 | static void end_frame(AVFilterLink *link){ CropContext *crop = link->dst->priv; crop->var_values[N] += 1.0; avfilter_unref_buffer(link->cur_buf); avfilter_end_frame(link->dst->outputs[0]);} |
1 | static void vfio_listener_release(VFIOContainer *container){ memory_listener_unregister(&container->iommu_data.listener);} |
1 | static int coroutine_fn nfs_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors, QEMUIOVector *iov){ NFSClient *client = bs->opaque; NFSRPC task; char *buf = NULL; nfs_co_init_task(client, &task); buf = g_malloc(nb_sectors * BDRV_SECTOR_SIZE); qemu_iovec_to_buf(iov, 0, buf, nb_sectors * BDRV_SECTOR_SIZE)... |
1 | static void rocker_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->init = pci_rocker_init; k->exit = pci_rocker_uninit; k->vendor_id = PCI_VENDOR_ID_REDHAT; k->device_id = PCI_DEVICE_ID_REDHAT_ROCKER; k->revision = ROCKER_PCI_REVISION; k... |
1 | static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev, uint32_t node, Error **errp){ Error *local_err = NULL; sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev); PCDIMMDevice *dimm = PC_DIMM(dev); PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); MemoryRegion *mr = ddc->get_memory_region(dimm); ui... |
1 | int bdrv_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ BlockDriver *drv = bs->drv; if (!bs->drv) return -ENOMEDIUM; if (bs->read_only) return -EACCES; if (bdrv_check_request(bs, sector_num, nb_sectors)) return -EIO; return drv->bdrv_write(bs, sector_num, buf, nb_sectors);} |
1 | void scsi_req_cancel_async(SCSIRequest *req, Notifier *notifier){ trace_scsi_req_cancel(req->dev->id, req->lun, req->tag); if (notifier) { notifier_list_add(&req->cancel_notifiers, notifier); scsi_req_ref(req); scsi_req_dequeue(req); req->io_canceled = true; if (req->aiocb) { blk_aio_cancel_async(req->aiocb); } else { ... |
1 | static int alac_decode_frame(AVCodecContext *avctx, void *outbuffer, int *outputsize, AVPacket *avpkt){ const uint8_t *inbuffer = avpkt->data; int input_buffer_size = avpkt->size; ALACContext *alac = avctx->priv_data; int channels; unsigned int outputsamples; int hassize; unsigned int readsamplesize; int isnotcompresse... |
1 | static bool scsi_block_is_passthrough(SCSIDiskState *s, uint8_t *buf){ switch (buf[0]) { case VERIFY_10: case VERIFY_12: case VERIFY_16: /* Check if BYTCHK == 0x01 (data-out buffer contains data * for the number of logical blocks specified in the length * field). For other modes, do not use scatter/gather operation. */... |
1 | static void test_smram_lock(void){ QPCIBus *pcibus; QPCIDevice *pcidev; QDict *response; pcibus = qpci_init_pc(NULL); g_assert(pcibus != NULL); pcidev = qpci_device_find(pcibus, 0); g_assert(pcidev != NULL); /* check open is settable */ smram_set_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN, false); g_assert(smram_test_bit... |
1 | void do_mullwo (void){ int64_t res = (int64_t)Ts0 * (int64_t)Ts1; if (likely((int32_t)res == res)) { xer_ov = 0; } else { xer_ov = 1; xer_so = 1; } T0 = (int32_t)res;} |
1 | static int vfio_msix_setup(VFIOPCIDevice *vdev, int pos, Error **errp){ int ret; vdev->msix->pending = g_malloc0(BITS_TO_LONGS(vdev->msix->entries) * sizeof(unsigned long)); ret = msix_init(&vdev->pdev, vdev->msix->entries, vdev->bars[vdev->msix->table_bar].region.mem, vdev->msix->table_bar, vdev->msix->table_offset, v... |
1 | static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet){ libx265Context *ctx = avctx->priv_data; x265_picture x265pic; x265_picture x265pic_out = { { 0 } }; x265_nal *nal; uint8_t *dst; int payload = 0; int nnal; int ret; int i; x265_picture_init(ctx->params, &x265pic)... |
1 | static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ CFHDContext *s = avctx->priv_data; GetByteContext gb; ThreadFrame frame = { .f = data }; AVFrame *pic = data; int ret = 0, i, j, planes, plane, got_buffer = 0; int16_t *coeff_data; s->coded_format = AV_PIX_FMT_YUV422P10; init_fr... |
1 | static av_cold int dnxhd_decode_init_thread_copy(AVCodecContext *avctx){ DNXHDContext *ctx = avctx->priv_data; // make sure VLC tables will be loaded when cid is parsed ctx->cid = -1; ctx->rows = av_mallocz_array(avctx->thread_count, sizeof(RowContext)); if (!ctx->rows) return AVERROR(ENOMEM); return 0;} |
1 | void do_POWER_divo (void){ int64_t tmp; if ((Ts0 == INT32_MIN && Ts1 == -1) || Ts1 == 0) { T0 = (long)((-1) * (T0 >> 31)); env->spr[SPR_MQ] = 0; xer_ov = 1; xer_so = 1; } else { tmp = ((uint64_t)T0 << 32) | env->spr[SPR_MQ]; env->spr[SPR_MQ] = tmp % T1; tmp /= Ts1; if (tmp > (int64_t)INT32_MAX || tmp < (int64_t)INT32_M... |
1 | void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp){ int64_t value; if (!error_is_set(errp)) { if (v->type_uint64) { v->type_uint64(v, obj, name, errp); } else { value = *obj; v->type_int(v, &value, name, errp); *obj = value; } }} |
1 | SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter){SwsContext *c;int i;int usesFilter;SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};#ifdef ARCH_X86if(gCpuCaps.hasMMX)asm volatile("emms\n\t"::: "memory");#endifif(swScal... |
1 | static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx){ if (hc->current + 1 >= hc->length) { av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n"); return AVERROR_INVALIDDATA; } if(!get_bits1(gb)){ //Leaf int val, i1, i2; i1 = ctx->v1->table ? get_vlc2(gb, ctx->v1->table, SMKTREE_BITS, 3) : 0; ... |
1 | char *qemu_find_file(int type, const char *name){ int len; const char *subdir; char *buf; /* Try the name as a straight path first */ if (access(name, R_OK) == 0) { return g_strdup(name); } switch (type) { case QEMU_FILE_TYPE_BIOS: subdir = ""; break; case QEMU_FILE_TYPE_KEYMAP: subdir = "keymaps/"; break; default: abo... |
1 | static inline void decode_block_intra(MadContext *s, int16_t * block){ int level, i, j, run; RLTable *rl = &ff_rl_mpeg1; const uint8_t *scantable = s->scantable.permutated; int16_t *quant_matrix = s->quant_matrix; block[0] = (128 + get_sbits(&s->gb, 8)) * quant_matrix[0]; /* The RL decoder is derived from mpeg1_decode_... |
1 | static int overlay_opencl_blend(FFFrameSync *fs){ AVFilterContext *avctx = fs->parent; AVFilterLink *outlink = avctx->outputs[0]; OverlayOpenCLContext *ctx = avctx->priv; AVFrame *input_main, *input_overlay; AVFrame *output; cl_mem mem; cl_int cle, x, y; size_t global_work[2]; int kernel_arg = 0; int err, plane; err = ... |
0 | static int oggvorbis_encode_frame(AVCodecContext *avccontext, unsigned char *packets, int buf_size, void *data){ OggVorbisContext *context = avccontext->priv_data ; float **buffer ; ogg_packet op ; signed char *audio = data ; int l, samples = OGGVORBIS_FRAME_SIZE ; buffer = vorbis_analysis_buffer(&context->vd, samples)... |
0 | static int mpegps_read_header(AVFormatContext *s){ MpegDemuxContext *m = s->priv_data; char buffer[7]; int64_t last_pos = avio_tell(s->pb); m->header_state = 0xff; s->ctx_flags |= AVFMTCTX_NOHEADER; avio_get_str(s->pb, 6, buffer, sizeof(buffer)); if (!memcmp("IMKH", buffer, 4)) { m->imkh_cctv = 1; } else if (!memcmp("S... |
1 | static int read_access_unit(AVCodecContext *avctx, void* data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MLPDecodeContext *m = avctx->priv_data; GetBitContext gb; unsigned int length, substr; unsigned int substream_start; unsigned int header_size = 4; unsigned i... |
1 | static int ipmi_register_netfn(IPMIBmcSim *s, unsigned int netfn, const IPMINetfn *netfnd){ if ((netfn & 1) || (netfn > MAX_NETFNS) || (s->netfns[netfn / 2])) { return -1; } s->netfns[netfn / 2] = netfnd; return 0;} |
1 | static int nbd_establish_connection(BlockDriverState *bs){ BDRVNBDState *s = bs->opaque; int sock; int ret; off_t size; size_t blocksize; if (s->host_spec[0] == '/') { sock = unix_socket_outgoing(s->host_spec); } else { sock = tcp_socket_outgoing_spec(s->host_spec); } /* Failed to establish connection */ if (sock < 0) ... |
1 | void memory_region_destroy(MemoryRegion *mr){ assert(QTAILQ_EMPTY(&mr->subregions)); mr->destructor(mr); memory_region_clear_coalescing(mr); g_free((char *)mr->name); g_free(mr->ioeventfds);} |
0 | static av_cold int aac_decode_init(AVCodecContext * avccontext) { AACContext * ac = avccontext->priv_data; int i; ac->avccontext = avccontext; if (avccontext->extradata_size <= 0 || decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size)) return -1; avccontext->sample_fmt = SAMPLE_FMT_S16; a... |
0 | static void read_info_chunk(AVFormatContext *s, int64_t size){ AVIOContext *pb = s->pb; unsigned int i; unsigned int nb_entries = avio_rb32(pb); for (i = 0; i < nb_entries; i++) { char key[32]; char value[1024]; avio_get_str(pb, INT_MAX, key, sizeof(key)); avio_get_str(pb, INT_MAX, value, sizeof(value)); av_dict_set(&s... |
0 | static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts){ AVFrame *decoded_frame, *filtered_frame = NULL; void *buffer_to_free = NULL; int i, ret = 0; float quality = 0;#if CONFIG_AVFILTER int frame_available = 1;#endif int duration=0; int64_t *best_effort_timesta... |
0 | static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom){ AVStream *st; MOVStreamContext *sc; unsigned i, entries; if (c->fc->nb_streams < 1) return 0; st = c->fc->streams[c->fc->nb_streams-1]; sc = st->priv_data; avio_rb32(pb); // version + flags entries = avio_rb32(pb); if (entries >= UINT_MAX / sizeof(... |
0 | static int decode_frame(AVCodecContext * avctx,void *data, int *data_size,uint8_t * buf, int buf_size){ MPADecodeContext *s = avctx->priv_data; uint32_t header; uint8_t *buf_ptr; int len, out_size; OUT_INT *out_samples = data; buf_ptr = buf; while (buf_size > 0) {len = s->inbuf_ptr - s->inbuf;if (s->frame_size == 0) { ... |
0 | static av_cold void rv34_init_tables(void){ int i, j, k; for(i = 0; i < NUM_INTRA_TABLES; i++){ for(j = 0; j < 2; j++){ rv34_gen_vlc(rv34_table_intra_cbppat [i][j], CBPPAT_VLC_SIZE, &intra_vlcs[i].cbppattern[j], NULL, 19*i + 0 + j); rv34_gen_vlc(rv34_table_intra_secondpat[i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].second... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.