label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void srt_to_ass(AVCodecContext *avctx, AVBPrint *dst, const char *in, int x1, int y1, int x2, int y2){ if (x1 >= 0 && y1 >= 0) { /* XXX: here we rescale coordinate assuming they are in DVD resolution * (720x480) since we don't have anything better */ if (x2 >= 0 && y2 >= 0 && (x2 != x1 || y2 != y1) && x2 >= x1 &... |
1 | static void mmio_basic(void){ QVirtioMMIODevice *dev; QVirtQueue *vq; QGuestAllocator *alloc; int n_size = TEST_IMAGE_SIZE / 2; uint64_t capacity; arm_test_start(); dev = qvirtio_mmio_init_device(MMIO_DEV_BASE_ADDR, MMIO_PAGE_SIZE); g_assert(dev != NULL); g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK); qvi... |
0 | int ff_twinvq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AVFrame *frame = data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; TwinVQContext *tctx = avctx->priv_data; const TwinVQModeTab *mtab = tctx->mtab; float **out = NULL; int ret; /* get output buffer */ if... |
0 | static int split_field_ref_list(Picture *dest, int dest_len, Picture *src, int src_len, int parity, int long_i){ int i = split_field_half_ref_list(dest, dest_len, src, long_i, parity); dest += i; dest_len -= i; i += split_field_half_ref_list(dest, dest_len, src + long_i, src_len - long_i, parity); return i;} |
0 | static int fourxm_read_packet(AVFormatContext *s, AVPacket *pkt){ FourxmDemuxContext *fourxm = s->priv_data; ByteIOContext *pb = s->pb; unsigned int fourcc_tag; unsigned int size, out_size; int ret = 0; unsigned int track_number; int packet_read = 0; unsigned char header[8]; int audio_frame_count; while (!packet_read) ... |
0 | SwsFunc ff_yuv2rgb_init_mmx(SwsContext *c){ int cpu_flags = av_get_cpu_flags(); if (c->srcFormat != PIX_FMT_YUV420P && c->srcFormat != PIX_FMT_YUVA420P) return NULL;#if HAVE_MMX2 if (cpu_flags & AV_CPU_FLAG_MMX2) { switch (c->dstFormat) { case PIX_FMT_RGB24: return yuv420_rgb24_MMX2; case PIX_FMT_BGR24: return yuv420_b... |
1 | void cpsr_write(CPUARMState *env, uint32_t val, uint32_t mask){ if (mask & CPSR_NZCV) { env->ZF = (~val) & CPSR_Z; env->NF = val; env->CF = (val >> 29) & 1; env->VF = (val << 3) & 0x80000000; } if (mask & CPSR_Q) env->QF = ((val & CPSR_Q) != 0); if (mask & CPSR_T) env->thumb = ((val & CPSR_T) != 0); if (mask & CPSR_IT_... |
0 | static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0){ pixel *pix = (pixel*)p_pix; int i, d; xstride >>= sizeof(pixel)-1; ystride >>= sizeof(pixel)-1; alpha <<= BIT_DEPTH - 8; beta <<= BIT_DEPTH - 8; for( i = 0; ... |
1 | static int nbd_errno_to_system_errno(int err){ switch (err) { case NBD_SUCCESS: return 0; case NBD_EPERM: return EPERM; case NBD_EIO: return EIO; case NBD_ENOMEM: return ENOMEM; case NBD_ENOSPC: return ENOSPC; case NBD_EINVAL: default: return EINVAL; }} |
1 | pcie_cap_v1_fill(uint8_t *exp_cap, uint8_t port, uint8_t type, uint8_t version){ /* capability register interrupt message number defaults to 0 */ pci_set_word(exp_cap + PCI_EXP_FLAGS, ((type << PCI_EXP_FLAGS_TYPE_SHIFT) & PCI_EXP_FLAGS_TYPE) | version); /* device capability register * table 7-12: * roll based error rep... |
1 | static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref){ AVFilterContext *ctx = inlink->dst; TInterlaceContext *tinterlace = ctx->priv; avfilter_unref_buffer(tinterlace->cur); tinterlace->cur = tinterlace->next; tinterlace->next = picref; return 0;} |
0 | static void write_odml_master(AVFormatContext *s, int stream_index){ AVIOContext *pb = s->pb; AVStream *st = s->streams[stream_index]; AVCodecContext *enc = st->codec; AVIStream *avist = st->priv_data; unsigned char tag[5]; int j; /* Starting to lay out AVI OpenDML master index. * We want to make it JUNK entry for now,... |
0 | static void cook_imlt(COOKContext *q, float* inbuffer, float* outbuffer){ int i; q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, outbuffer, inbuffer, q->mdct_tmp); for(i = 0; i < q->samples_per_channel; i++){ float tmp = outbuffer[i]; outbuffer[i] = q->mlt_window[i] * outbuffer[q->samples_per_channel + i]; outbuffer[q->sample... |
0 | static int mp3_write_trailer(struct AVFormatContext *s){ uint8_t buf[ID3v1_TAG_SIZE]; MP3Context *mp3 = s->priv_data; /* write the id3v1 tag */ if (id3v1_create_tag(s, buf) > 0) { avio_write(s->pb, buf, ID3v1_TAG_SIZE); } /* write number of frames */ if (mp3 && mp3->nb_frames_offset) { avio_seek(s->pb, mp3->nb_frames_o... |
0 | int64_t qemu_get_clock(QEMUClock *clock){ switch(clock->type) { case QEMU_TIMER_REALTIME: return get_clock() / 1000000; default: case QEMU_TIMER_VIRTUAL: if (use_icount) { return cpu_get_icount(); } else { return cpu_get_clock(); } }} |
0 | static int usb_qdev_exit(DeviceState *qdev){ USBDevice *dev = USB_DEVICE(qdev); if (dev->attached) { usb_device_detach(dev); } usb_device_handle_destroy(dev); if (dev->port) { usb_release_port(dev); } return 0;} |
0 | void scsi_req_build_sense(SCSIRequest *req, SCSISense sense){ trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag, sense.key, sense.asc, sense.ascq); memset(req->sense, 0, 18); req->sense[0] = 0xf0; req->sense[2] = sense.key; req->sense[7] = 10; req->sense[12] = sense.asc; req->sense[13] = sense.ascq; req->sens... |
0 | static int vp3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; Vp3DecodeContext *s = avctx->priv_data; GetBitContext gb; int i; int ret; init_get_bits(&gb, buf, buf_size * 8);#if CONFIG_THEORA_DECODER if (s->theora && get_bi... |
0 | void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr, hwaddr size, unsigned client){ assert(mr->terminates); cpu_physical_memory_test_and_clear_dirty(mr->ram_addr + addr, size, client);} |
0 | void qemu_ram_free_from_ptr(ram_addr_t addr){ RAMBlock *block; /* This assumes the iothread lock is taken here too. */ qemu_mutex_lock_ramlist(); QTAILQ_FOREACH(block, &ram_list.blocks, next) { if (addr == block->offset) { QTAILQ_REMOVE(&ram_list.blocks, block, next); ram_list.mru_block = NULL; ram_list.version++; g_fr... |
0 | void bdrv_io_limits_enable(BlockDriverState *bs){ qemu_co_queue_init(&bs->throttled_reqs); bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs); bs->io_limits_enabled = true;} |
0 | static void cadence_ttc_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ CadenceTimerState *s = cadence_timer_from_addr(opaque, offset); DB_PRINT("addr: %08x data %08x\n", offset, (unsigned)value); cadence_timer_sync(s); switch (offset) { case 0x00: /* clock control */ case 0x04: case 0x08... |
0 | static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev); VirtIOSCSI *s = VIRTIO_SCSI(vdev); SCSIDevice *sd = SCSI_DEVICE(dev); if (s->ctx && !s->dataplane_disabled) { if (blk_op_is_blocked(sd->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp))... |
0 | static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping, int phdr_index, target_phys_addr_t offset){ Elf64_Phdr phdr; int ret; int endian = s->dump_info.d_endian; memset(&phdr, 0, sizeof(Elf64_Phdr)); phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian); phdr.p_offset = cpu_convert_to_target64(offset,... |
0 | static void SET_TYPE(resample_one)(ResampleContext *c, void *dst0, int dst_index, const void *src0, int src_size, int index, int frac){ FELEM *dst = dst0; const FELEM *src = src0; int i; int sample_index = index >> c->phase_shift; FELEM2 val = 0; FELEM *filter = ((FELEM *)c->filter_bank) + c->filter_length * (index & c... |
0 | static void v9fs_xattrcreate(void *opaque){ int flags; int32_t fid; int64_t size; ssize_t err = 0; V9fsString name; size_t offset = 7; V9fsFidState *file_fidp; V9fsFidState *xattr_fidp; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "dsqd", &fid, &name, &size, &flags); trace_v9fs_xattrcreate(p... |
0 | uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap, uint64_t start, uint64_t count){ return hbitmap_serialization_size(bitmap->bitmap, start, count);} |
0 | static coroutine_fn int sd_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors){ SheepdogAIOCB *acb; QEMUIOVector dummy; BDRVSheepdogState *s = bs->opaque; int ret; if (!s->discard_supported) { return 0; } acb = sd_aio_setup(bs, &dummy, sector_num, nb_sectors); acb->aiocb_type = AIOCB_DISCARD_OBJ; acb->... |
0 | static void coroutine_fn qed_need_check_timer_entry(void *opaque){ BDRVQEDState *s = opaque; int ret; /* The timer should only fire when allocating writes have drained */ assert(!s->allocating_acb); trace_qed_need_check_timer_cb(s); qed_acquire(s); qed_plug_allocating_write_reqs(s); /* Ensure writes are on disk before ... |
0 | static void gen_op_update_neg_cc(void){ tcg_gen_neg_tl(cpu_cc_src, cpu_T[0]); tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);} |
0 | static int thp_probe(AVProbeData *p){ /* check file header */ if (p->buf_size < 4) return 0; if (AV_RL32(p->buf) == MKTAG('T', 'H', 'P', '\0')) return AVPROBE_SCORE_MAX; else return 0;} |
0 | static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, int64_t align, QEMUIOVector *qiov, int flags){ int64_t total_bytes, max_bytes; int ret = 0; uint64_t bytes_remaining = bytes; int max_transfer; assert(is_power_of_2(align)); assert((offset & (a... |
0 | Visitor *qmp_output_get_visitor(QmpOutputVisitor *v){ return &v->visitor;} |
0 | bool aio_dispatch(AioContext *ctx, bool dispatch_fds){ bool progress; progress = aio_bh_poll(ctx); if (dispatch_fds) { progress |= aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE); } progress |= timerlistgroup_run_timers(&ctx->tlg); return progress;} |
0 | void helper_check_iob(CPUX86State *env, uint32_t t0){ check_io(env, t0, 1);} |
0 | static void slirp_state_save(QEMUFile *f, void *opaque){ Slirp *slirp = opaque; struct ex_list *ex_ptr; for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) if (ex_ptr->ex_pty == 3) { struct socket *so; so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr, ntohs(ex_ptr->ex_fport)); if (!so) continue; qemu_put... |
0 | static inline void tlb_update_dirty(CPUTLBEntry *tlb_entry){ ram_addr_t ram_addr; void *p; if ((tlb_entry->addr_write & ~TARGET_PAGE_MASK) == io_mem_ram.ram_addr) { p = (void *)(unsigned long)((tlb_entry->addr_write & TARGET_PAGE_MASK) + tlb_entry->addend); ram_addr = qemu_ram_addr_from_host_nofail(p); if (!cpu_physica... |
0 | static IOMMUTLBEntry spapr_tce_translate_iommu(MemoryRegion *iommu, hwaddr addr, bool is_write){ sPAPRTCETable *tcet = container_of(iommu, sPAPRTCETable, iommu); uint64_t tce; IOMMUTLBEntry ret = { .target_as = &address_space_memory, .iova = 0, .translated_addr = 0, .addr_mask = ~(hwaddr)0, .perm = IOMMU_NONE, }; if ((... |
0 | int rpcit_service_call(S390CPU *cpu, uint8_t r1, uint8_t r2){ CPUS390XState *env = &cpu->env; uint32_t fh; S390PCIBusDevice *pbdev; S390PCIIOMMU *iommu; hwaddr start, end; IOMMUTLBEntry entry; MemoryRegion *mr; cpu_synchronize_state(CPU(cpu)); if (env->psw.mask & PSW_MASK_PSTATE) { program_interrupt(env, PGM_PRIVILEGED... |
0 | static int coroutine_fn qcow2_co_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum){ BDRVQcowState *s = bs->opaque; uint64_t cluster_offset; int ret; *pnum = nb_sectors; /* FIXME We can get errors here, but the bdrv_co_is_allocated interface * can't pass them on today */ qemu_co_mutex_loc... |
1 | static int vmdk_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ BDRVVmdkState *s = bs->opaque; int index_in_cluster, n; uint64_t cluster_offset; static int cid_update = 0; while (nb_sectors > 0) { index_in_cluster = sector_num & (s->cluster_sectors - 1); n = s->cluster_sectors - ind... |
1 | static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src){ PNGDecContext *psrc = src->priv_data; PNGDecContext *pdst = dst->priv_data; int ret; if (dst == src) return 0; ff_thread_release_buffer(dst, &pdst->picture); if (psrc->picture.f->data[0] && (ret = ff_thread_ref_frame(&pdst->picture, &psrc... |
1 | static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags){ AVStream *st = s->streams[stream_index]; avio_seek(s->pb, FFMAX(timestamp, 0) * st->codec->width * st->codec->height * 4, SEEK_SET); return 0;} |
0 | static int transcode_init(void){ int ret = 0, i, j, k; AVFormatContext *oc; OutputStream *ost; InputStream *ist; char error[1024] = {0}; int want_sdp = 1; for (i = 0; i < nb_filtergraphs; i++) { FilterGraph *fg = filtergraphs[i]; for (j = 0; j < fg->nb_outputs; j++) { OutputFilter *ofilter = fg->outputs[j]; if (!ofilte... |
0 | static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt){ int ret; ret = av_get_packet(s->pb, pkt, MP3_PACKET_SIZE); pkt->stream_index = 0; if (ret <= 0) { return AVERROR(EIO); } if (ret > ID3v1_TAG_SIZE && memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0) ret -= ID3v1_TAG_SIZE; /* note: we need to modify t... |
0 | static void ff_h264_idct_add_mmx(uint8_t *dst, int16_t *block, int stride){ /* Load dct coeffs */ __asm__ volatile( "movq (%0), %%mm0 \n\t" "movq 8(%0), %%mm1 \n\t" "movq 16(%0), %%mm2 \n\t" "movq 24(%0), %%mm3 \n\t" :: "r"(block) ); __asm__ volatile( /* mm1=s02+s13 mm2=s02-s13 mm4=d02+d13 mm0=d02-d13 */ IDCT4_1D( %%mm... |
0 | static void vdadec_flush(AVCodecContext *avctx){ return ff_h264_decoder.flush(avctx);} |
1 | static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb){ CPUArchState *env = cpu->env_ptr; uintptr_t ret; TranslationBlock *last_tb; int tb_exit; uint8_t *tb_ptr = itb->tc_ptr; qemu_log_mask_and_addr(CPU_LOG_EXEC, itb->pc, "Trace %p [" TARGET_FMT_lx "] %s\n", itb->tc_ptr, itb->pc, lookup_symbol... |
1 | static void ac97_class_init (ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS (klass); PCIDeviceClass *k = PCI_DEVICE_CLASS (klass); k->realize = ac97_realize; k->vendor_id = PCI_VENDOR_ID_INTEL; k->device_id = PCI_DEVICE_ID_INTEL_82801AA_5; k->revision = 0x01; k->class_id = PCI_CLASS_MULTIMEDIA_AUDIO; s... |
1 | static int adx_decode_init(AVCodecContext * avctx){ADXContext *c = avctx->priv_data;//printf("adx_decode_init\n"); fflush(stdout);c->prev[0].s1 = 0;c->prev[0].s2 = 0;c->prev[1].s1 = 0;c->prev[1].s2 = 0;c->header_parsed = 0;c->in_temp = 0;return 0;} |
1 | static int xan_huffman_decode(unsigned char *dest, int dest_len, const unsigned char *src, int src_len){ unsigned char byte = *src++; unsigned char ival = byte + 0x16; const unsigned char * ptr = src + byte*2; int ptr_len = src_len - 1 - byte*2; unsigned char val = ival; unsigned char *dest_end = dest + dest_len; GetBi... |
1 | static int init(AVCodecParserContext *s){ H264Context *h = s->priv_data; h->thread_context[0] = h; return 0;} |
1 | static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb){ int i, j, k; int coding_mode; int motion_x[6]; int motion_y[6]; int last_motion_x = 0; int last_motion_y = 0; int prior_last_motion_x = 0; int prior_last_motion_y = 0; int current_macroblock; int current_fragment; debug_vp3(" vp3: unpacking motion vecto... |
1 | static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce){ int start, i, j, w; if (sce->ics.clip_avoidance_factor < 1.0f) { for (w = 0; w < sce->ics.num_windows; w++) { start = 0; for (i = 0; i < sce->ics.max_sfb; i++) { float *swb_coeffs = sce->coeffs + start + w*128; for (j = 0; j < sce->ics.swb_sizes[i... |
1 | static void sdhci_end_transfer(SDHCIState *s){ /* Automatically send CMD12 to stop transfer if AutoCMD12 enabled */ if ((s->trnmod & SDHC_TRNS_ACMD12) != 0) { SDRequest request; uint8_t response[16]; request.cmd = 0x0C; request.arg = 0; DPRINT_L1("Automatically issue CMD%d %08x\n", request.cmd, request.arg); sdbus_do_c... |
1 | int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps, int bits_left){ int e; int bit_count_start = get_bits_count(gb_host); int header; int bits_consumed; GetBitContext gbc = *gb_host, *gb = &gbc; header = get_bits1(gb); if (header) { //enable_ps_header ps->enable_iid = get_bits1(gb); if (ps... |
1 | ff_vorbis_comment(AVFormatContext * as, AVDictionary **m, const uint8_t *buf, int size){ const uint8_t *p = buf; const uint8_t *end = buf + size; unsigned n, j; int s; if (size < 8) /* must have vendor_length and user_comment_list_length */ return -1; s = bytestream_get_le32(&p); if (end - p - 4 < s || s < 0) return -1... |
1 | static void *do_touch_pages(void *arg){ MemsetThread *memset_args = (MemsetThread *)arg; char *addr = memset_args->addr; uint64_t numpages = memset_args->numpages; uint64_t hpagesize = memset_args->hpagesize; sigset_t set, oldset; int i = 0; /* unblock SIGBUS */ sigemptyset(&set); sigaddset(&set, SIGBUS); pthread_sigma... |
0 | static int raw_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int linesize_align = 4; RawVideoContext *context = avctx->priv_data; AVFrame *frame = data; AVPicture *picture = data; frame->pict_type = avctx->coded_frame->pict_type... |
0 | static int oma_read_header(AVFormatContext *s){ int ret, framesize, jsflag, samplerate; uint32_t codec_params, channel_id; int16_t eid; uint8_t buf[EA3_HEADER_SIZE]; uint8_t *edata; AVStream *st; ID3v2ExtraMeta *extra_meta = NULL; OMAContext *oc = s->priv_data; ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta); ret = avio... |
0 | void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS]){ int i; int w_align= 1; int h_align= 1; switch(s->pix_fmt){ case PIX_FMT_YUV420P: case PIX_FMT_YUYV422: case PIX_FMT_UYVY422: case PIX_FMT_YUV422P: case PIX_FMT_YUV440P: case PIX_FMT_YUV444P: case PIX_FM... |
0 | static int decode_mb_i(AVSContext *h, int cbp_code){ GetBitContext *gb = &h->gb; unsigned pred_mode_uv; int block; uint8_t top[18]; uint8_t *left = NULL; uint8_t *d; ff_cavs_init_mb(h); /* get intra prediction modes from stream */ for (block = 0; block < 4; block++) { int nA, nB, predpred; int pos = scan3x3[block]; nA ... |
1 | static int gif_read_image(GifState *s){ int left, top, width, height, bits_per_pixel, code_size, flags; int is_interleaved, has_local_palette, y, pass, y1, linesize, n, i; uint8_t *ptr, *spal, *palette, *ptr1; left = bytestream_get_le16(&s->bytestream); top = bytestream_get_le16(&s->bytestream); width = bytestream_get_... |
1 | static int mkv_write_tags(AVFormatContext *s){ MatroskaMuxContext *mkv = s->priv_data; int i, ret; ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL); if (mkv_check_tag(s->metadata, 0)) { ret = mkv_write_tag(s, s->metadata, 0, 0, &mkv->tags); if (ret < 0) return ret; } for (i = 0; i < s->nb_streams; i++) { AVStream *s... |
1 | static int hls_delete_old_segments(HLSContext *hls) { HLSSegment *segment, *previous_segment = NULL; float playlist_duration = 0.0f; int ret = 0, path_size, sub_path_size; char *dirname = NULL, *p, *sub_path; char *path = NULL; segment = hls->segments; while (segment) { playlist_duration += segment->duration; segment =... |
1 | qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov){ BDRVQcowState *s = bs->opaque; QEMUIOVector hd_qiov; struct iovec iov; z_stream strm; int ret, out_len; uint8_t *buf, *out_buf; uint64_t cluster_offset; buf = qemu_blockalign(bs, s->cluster_size); if (bytes != s->clus... |
1 | static int fifo_put(SerialState *s, int fifo, uint8_t chr){ SerialFIFO *f = (fifo) ? &s->recv_fifo : &s->xmit_fifo; f->data[f->head++] = chr; if (f->head == UART_FIFO_LENGTH) f->head = 0; f->count++; return 1;} |
1 | static void rc4030_reset(DeviceState *dev){ rc4030State *s = RC4030(dev); int i; s->config = 0x410; /* some boards seem to accept 0x104 too */ s->revision = 1; s->invalid_address_register = 0; memset(s->dma_regs, 0, sizeof(s->dma_regs)); rc4030_dma_tt_update(s, 0, 0); s->remote_failed_address = s->memory_failed_address... |
0 | static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno){ int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS); for (y0 = 0; y0 < height; y0 += 4) for (x = 0; x < width; x++) for (y = y0; y < height && y < y0+4; y++) if ((t1->flags[y+1][x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) ... |
1 | void visit_optional(Visitor *v, bool *present, const char *name, Error **errp){ if (!error_is_set(errp) && v->optional) { v->optional(v, present, name, errp); }} |
1 | static int ws_snd_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size;// WSSNDContext *c = avctx->priv_data; int in_size, out_size; int sample = 128; int i; uint8_t *samples = data; if (!buf_size) return 0; out_size = AV_RL16(&bu... |
1 | static int mb_var_thread(AVCodecContext *c, void *arg){ MpegEncContext *s= *(void**)arg; int mb_x, mb_y; for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { for(mb_x=0; mb_x < s->mb_width; mb_x++) { int xx = mb_x * 16; int yy = mb_y * 16; uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx; int varc; in... |
1 | 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 ... |
1 | static int socket_open_listen(struct sockaddr_in *my_addr){ int server_fd, tmp; server_fd = socket(AF_INET,SOCK_STREAM,0); if (server_fd < 0) { perror ("socket"); return -1; } tmp = 1; setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp)); if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)... |
1 | static uint64_t pxa2xx_gpio_read(void *opaque, hwaddr offset, unsigned size){ PXA2xxGPIOInfo *s = (PXA2xxGPIOInfo *) opaque; uint32_t ret; int bank; if (offset >= 0x200) return 0; bank = pxa2xx_gpio_regs[offset].bank; switch (pxa2xx_gpio_regs[offset].reg) { case GPDR:/* GPIO Pin-Direction registers */ return s->dir[ban... |
1 | static void aux_slave_class_init(ObjectClass *klass, void *data){ DeviceClass *k = DEVICE_CLASS(klass); set_bit(DEVICE_CATEGORY_MISC, k->categories); k->bus_type = TYPE_AUX_BUS;} |
1 | static void vmdk_close(BlockDriverState *bs){ BDRVVmdkState *s = bs->opaque; qemu_free(s->l1_table); qemu_free(s->l2_cache); bdrv_delete(s->hd); // try to close parent image, if exist vmdk_parent_close(s->hd);} |
1 | static void *file_ram_alloc(RAMBlock *block, ram_addr_t memory, const char *path, Error **errp){ bool unlink_on_error = false; char *filename; char *sanitized_name; char *c; void *area = MAP_FAILED; int fd = -1; int64_t file_size; if (kvm_enabled() && !kvm_has_sync_mmu()) { error_setg(errp, "host lacks kvm mmu notifier... |
1 | static void qpeg_decode_inter(const uint8_t *src, uint8_t *dst, int size, int stride, int width, int height, int delta, const uint8_t *ctable, uint8_t *refdata){ int i, j; int code; int filled = 0; int orig_height; if(!refdata) refdata= dst; /* copy prev frame */ for(i = 0; i < height; i++) memcpy(dst + (i * stride), r... |
1 | static void x86_cpu_apic_create(X86CPU *cpu, Error **errp){ APICCommonState *apic; const char *apic_type = "apic"; if (kvm_apic_in_kernel()) { apic_type = "kvm-apic"; } else if (xen_enabled()) { apic_type = "xen-apic"; } cpu->apic_state = DEVICE(object_new(apic_type)); object_property_add_child(OBJECT(cpu), "lapic", OB... |
1 | bool migration_has_failed(MigrationState *s){ return (s->state == MIG_STATE_CANCELLED || s->state == MIG_STATE_ERROR);} |
1 | static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){ int frequency[512] = { 0 }; uint8_t flag[512]; int up[512]; uint8_t len_tab[257]; int bits_tab[257]; int start, end; const uint8_t *ptr = buf; int j; memset(up, -1, sizeof(up)); start = *ptr++; end = *ptr++; for (;;) { int i; for (i ... |
1 | void hmp_info_tlb(Monitor *mon, const QDict *qdict){ CPUArchState *env1 = mon_get_cpu_env(); dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1); |
1 | int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MJpegDecodeContext *s = avctx->priv_data; const uint8_t *buf_end, *buf_ptr; const uint8_t *unescaped_buf_ptr; int unescaped_buf_size; int start_code; int i, index;... |
1 | GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp){ GuestMemoryBlockList *head, **link; Error *local_err = NULL; struct dirent *de; DIR *dp; head = NULL; link = &head; dp = opendir("/sys/devices/system/memory/"); if (!dp) { error_setg_errno(errp, errno, "Can't open directory" "\"/sys/devices/system/memory/... |
1 | int qcrypto_cipher_decrypt(QCryptoCipher *cipher, const void *in, void *out, size_t len, Error **errp){ QCryptoCipherBuiltin *ctxt = cipher->opaque; return ctxt->decrypt(cipher, in, out, len, errp); |
1 | static int get_blocksize(BlockDriverState *bdrv){ uint8_t cmd[10]; uint8_t buf[8]; uint8_t sensebuf[8]; sg_io_hdr_t io_header; int ret; memset(cmd, 0, sizeof(cmd)); memset(buf, 0, sizeof(buf)); cmd[0] = READ_CAPACITY; memset(&io_header, 0, sizeof(io_header)); io_header.interface_id = 'S'; io_header.dxfer_direction = SG... |
1 | static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch){ uint32_t bit_cache; uint8_t *list[63]; uint32_t *dst; const uint32_t *codebook; int entries[6]; int i, j, m, n; int stages; unsigned mean; int x, y, width, height, level; uint32_t n1, n2, n3, n4; /* initialize list for brea... |
1 | void do_interrupt (CPUState *env){#if !defined(CONFIG_USER_ONLY) target_ulong offset; int cause = -1; const char *name; if (qemu_log_enabled() && env->exception_index != EXCP_EXT_INTERRUPT) { if (env->exception_index < 0 || env->exception_index > EXCP_LAST) name = "unknown"; else name = excp_names[env->exception_index]... |
0 | static int dxva2_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size){ const H264Context *h = avctx->priv_data; struct dxva_context *ctx = avctx->hwaccel_context; const Picture *current_picture = h->cur_pic_ptr; struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private; ... |
0 | static int wavpack_encode_block(WavPackEncodeContext *s, int32_t *samples_l, int32_t *samples_r, uint8_t *out, int out_size){ int block_size, start, end, data_size, tcount, temp, m = 0; int i, j, ret = 0, got_extra = 0, nb_samples = s->block_samples; uint32_t crc = 0xffffffffu; struct Decorr *dpp; PutByteContext pb; if... |
1 | static int mpegts_probe(AVProbeData *p){ const int size = p->buf_size; int score, fec_score, dvhs_score; int check_count = size / TS_FEC_PACKET_SIZE;#define CHECK_COUNT 10 if (check_count < CHECK_COUNT) return AVERROR_INVALIDDATA; score = analyze(p->buf, TS_PACKET_SIZE * check_count, TS_PACKET_SIZE, NULL) * CHECK_COUNT... |
1 | static inline int l1_unscale(int n, int mant, int scale_factor){ int shift, mod; int64_t val; shift = scale_factor_modshift[scale_factor]; mod = shift & 3; shift >>= 2; val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]); shift += n; /* NOTE: at this point, 1 <= shift >= 21 + 15 */ return (int)((val + (1LL <... |
1 | static int read_low_coeffs(AVCodecContext *avctx, int16_t *dst, int size, int width, ptrdiff_t stride){ PixletContext *ctx = avctx->priv_data; GetBitContext *b = &ctx->gbit; unsigned cnt1, nbits, k, j = 0, i = 0; int64_t value, state = 3; int rlen, escape, flag = 0; while (i < size) { nbits = FFMIN(ff_clz((state >> 8) ... |
1 | static void fdctrl_raise_irq(FDCtrl *fdctrl, uint8_t status0){ /* Sparc mutation */ if (fdctrl->sun4m && (fdctrl->msr & FD_MSR_CMDBUSY)) { /* XXX: not sure */ fdctrl->msr &= ~FD_MSR_CMDBUSY; fdctrl->msr |= FD_MSR_RQM | FD_MSR_DIO; fdctrl->status0 = status0; return; } if (!(fdctrl->sra & FD_SRA_INTPEND)) { qemu_set_irq(... |
1 | static void qemu_net_queue_append_iov(NetQueue *queue, NetClientState *sender, unsigned flags, const struct iovec *iov, int iovcnt, NetPacketSent *sent_cb){ NetPacket *packet; size_t max_len = 0; int i; if (queue->nq_count >= queue->nq_maxlen && !sent_cb) { return; /* drop if queue full and no callback */ } for (i = 0;... |
1 | static int ivr_read_header(AVFormatContext *s){ unsigned tag, type, len, tlen, value; int i, j, n, count, nb_streams, ret; uint8_t key[256], val[256]; AVIOContext *pb = s->pb; AVStream *st; int64_t pos, offset, temp; pos = avio_tell(pb); tag = avio_rl32(pb); if (tag == MKTAG('.','R','1','M')) { if (avio_rb16(pb) != 1) ... |
1 | static int parse_filter(const char *spec, struct USBAutoFilter *f){ enum { BUS, DEV, VID, PID, DONE }; const char *p = spec; int i; f->bus_num = -1; f->addr = -1; f->vendor_id = -1; f->product_id = -1; for (i = BUS; i < DONE; i++) { p = strpbrk(p, ":."); if (!p) break; p++; if (*p == '*') continue; switch(i) { case BUS... |
0 | static void inline xan_wc3_build_palette(XanContext *s, unsigned int *palette_data){ int i; unsigned char r, g, b; unsigned short *palette16; unsigned int *palette32; unsigned int pal_elem; /* transform the palette passed through the palette control structure * into the necessary internal format depending on colorspace... |
0 | int MPV_common_init(MpegEncContext *s){ int c_size, i; UINT8 *pict; s->dct_unquantize_h263 = dct_unquantize_h263_c; s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c; s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c; #ifdef HAVE_MMX MPV_common_init_mmx(s);#endif //setup default unquantizers (mpeg4 might change it later)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.