label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt) { int ret; // copy to ensure we do not change avpkt AVPacket tmp = *avpkt; if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) { av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n"); re... | 13,834 |
0 | static void evalPrimary(Parser *p){ double d, d2=NAN; char *next= p->s; int i; /* number */ d= strtod(p->s, &next); if(next != p->s){ push(p, d); p->s= next; return; } /* named constants */ for(i=0; p->const_name[i]; i++){ if(strmatch(p->s, p->const_name[i])){ push(p, p->const_value[i]); p->s+= strlen(p->const_name[i])... | 13,835 |
1 | void do_POWER_dozo (void) { if (Ts1 > Ts0) { T2 = T0; T0 = T1 - T0; if (((~T2) ^ T1 ^ (-1)) & ((~T2) ^ T0) & (1 << 31)) { xer_so = 1; xer_ov = 1; } else { xer_ov = 0; } } else { T0 = 0; xer_ov = 0; } } | 13,837 |
1 | static void test_i440fx_defaults(gconstpointer opaque) { const TestData *s = opaque; QPCIBus *bus; QPCIDevice *dev; uint32_t value; bus = test_start_get_bus(s); dev = qpci_device_find(bus, QPCI_DEVFN(0, 0)); g_assert(dev != NULL); /* 3.2.2 */ g_assert_cmpint(qpci_config_readw(dev, PCI_VENDOR_ID), ==, 0x8086); /* 3.2.3 ... | 13,838 |
1 | BlockInfoList *qmp_query_block(Error **errp) { BlockInfoList *head = NULL, **p_next = &head; BlockBackend *blk; Error *local_err = NULL; for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { BlockInfoList *info = g_malloc0(sizeof(*info)); bdrv_query_info(blk, &info->value, &local_err); if (local_err) { error_propagate... | 13,839 |
1 | static int asf_write_header(AVFormatContext *s) { ASFContext *asf = s->priv_data; s->packet_size = PACKET_SIZE; s->max_interleave_delta = 0; asf->nb_packets = 0; asf->index_ptr = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK); asf->nb_index_memory_alloc = ASF_INDEX_BLOCK; asf->maximum_packet = 0; /* the data-chunk-size ... | 13,840 |
1 | static int mp3_write_xing(AVFormatContext *s) { MP3Context *mp3 = s->priv_data; AVCodecContext *codec = s->streams[mp3->audio_stream_idx]->codec; int32_t header; MPADecodeHeader mpah; int srate_idx, i, channels; int bitrate_idx; int best_bitrate_idx = -1; int best_bitrate_error = INT_MAX; int xing_offset; int ver = 0; ... | 13,841 |
1 | static int mkv_write_trailer(AVFormatContext *s) { MatroskaMuxContext *mkv = s->priv_data; AVIOContext *pb = s->pb; int64_t currentpos, cuespos; int ret; // check if we have an audio packet cached if (mkv->cur_audio_pkt.size > 0) { ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt, 0); av_free_packet(&mkv->cur_aud... | 13,842 |
1 | static int quantize(CinepakEncContext *s, int h, AVPicture *pict, int v1mode, int size, int v4, strip_info *info) { int x, y, i, j, k, x2, y2, x3, y3, plane, shift; int entry_size = s->pix_fmt == AV_PIX_FMT_YUV420P ? 6 : 4; int *codebook = v1mode ? info->v1_codebook : info->v4_codebook; int64_t total_error = 0; uint8_t... | 13,843 |
1 | void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size) { if (!f->ops->writev_buffer) { qemu_put_buffer(f, buf, size); return; } if (f->last_error) { return; } f->bytes_xfer += size; add_to_iovec(f, buf, size); } | 13,844 |
1 | static int handle_alloc(BlockDriverState *bs, uint64_t guest_offset, uint64_t *host_offset, uint64_t *bytes, QCowL2Meta **m) { BDRVQcowState *s = bs->opaque; int l2_index; uint64_t *l2_table; uint64_t entry; unsigned int nb_clusters; int ret; uint64_t alloc_cluster_offset; trace_qcow2_handle_alloc(qemu_coroutine_self()... | 13,845 |
1 | static uint32_t parse_peak(const uint8_t *peak) { int64_t val = 0; int64_t scale = 1; if (!peak) return 0; peak += strspn(peak, " \t"); if (peak[0] == '1' && peak[1] == '.') return UINT32_MAX; else if (!(peak[0] == '0' && peak[1] == '.')) return 0; peak += 2; while (av_isdigit(*peak)) { int digit = *peak - '0'; if (sca... | 13,846 |
1 | void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height) { const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); if (!desc || desc->flags & PIX_FMT_HWACCEL) if (desc->flags & PIX_FMT_PAL || desc->fl... | 13,847 |
1 | static void gen_ld (CPUMIPSState *env, DisasContext *ctx, uint32_t opc, int rt, int base, int16_t offset) { const char *opn = "ld"; TCGv t0, t1; if (rt == 0 && env->insn_flags & (INSN_LOONGSON2E | INSN_LOONGSON2F)) { /* Loongson CPU uses a load to zero register for prefetch. We emulate it as a NOP. On other CPU we must... | 13,848 |
1 | static void gxf_read_index(AVFormatContext *s, int pkt_len) { AVIOContext *pb = s->pb; AVStream *st = s->streams[0]; uint32_t fields_per_map = avio_rl32(pb); uint32_t map_cnt = avio_rl32(pb); int i; pkt_len -= 8; if (s->flags & AVFMT_FLAG_IGNIDX) { avio_skip(pb, pkt_len); return; } if (map_cnt > 1000) { av_log(s, AV_LO... | 13,849 |
1 | static void draw_char(AVCodecContext *avctx, int c, int a) { XbinContext *s = avctx->priv_data; if (s->y > avctx->height - s->font_height) return; ff_draw_pc_font(s->frame.data[0] + s->y * s->frame.linesize[0] + s->x, s->frame.linesize[0], s->font, s->font_height, c, a & 0x0F, a >> 4); s->x += FONT_WIDTH; if (s->x >= a... | 13,850 |
1 | static int xwma_read_header(AVFormatContext *s) { int64_t size; int ret; uint32_t dpds_table_size = 0; uint32_t *dpds_table = 0; unsigned int tag; AVIOContext *pb = s->pb; AVStream *st; XWMAContext *xwma = s->priv_data; int i; /* The following code is mostly copied from wav.c, with some * minor alterations. */ /* check... | 13,851 |
1 | static int openfile(char *name, int flags, int growable, QDict *opts) { Error *local_err = NULL; if (qemuio_bs) { fprintf(stderr, "file open already, try 'help close'\n"); return 1; } if (growable) { if (bdrv_open(&qemuio_bs, name, NULL, opts, flags | BDRV_O_PROTOCOL, NULL, &local_err)) { fprintf(stderr, "%s: can't ope... | 13,852 |
1 | static int cirrus_bitblt_videotovideo_copy(CirrusVGAState * s) { if (blit_is_unsafe(s)) return 0; return cirrus_do_copy(s, s->cirrus_blt_dstaddr - s->vga.start_addr, s->cirrus_blt_srcaddr - s->vga.start_addr, s->cirrus_blt_width, s->cirrus_blt_height); } | 13,853 |
1 | static void vpb_sic_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = vpb_sic_init; dc->no_user = 1; dc->vmsd = &vmstate_vpb_sic; } | 13,854 |
1 | static int nvenc_upload_frame(AVCodecContext *avctx, const AVFrame *frame, NvencSurface *nvenc_frame) { NvencContext *ctx = avctx->priv_data; NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs; NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs; int res; NVENCSTATUS nv_status; if (avctx->pix_fmt == AV_PIX_F... | 13,856 |
1 | void QEMU_NORETURN do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec, int unused, int size) { env->trap_arg0 = addr; env->trap_arg1 = is_write; dynamic_excp(EXCP_MCHK, 0); } | 13,858 |
1 | static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale){ int16_t rem[64]; DCTELEM d1[64]; const int *qmat; const uint8_t *scantable= s->intra_scantable.scantable; const uint8_t *perm_scantable= s->intra_scantable.permutated; // unsigne... | 13,860 |
1 | void *g_realloc(void * mem, size_t n_bytes) { __coverity_negative_sink__(n_bytes); mem = realloc(mem, n_bytes == 0 ? 1 : n_bytes); if (!mem) __coverity_panic__(); return mem; } | 13,861 |
1 | av_cold void ff_dsputil_init(DSPContext* c, AVCodecContext *avctx) { int i; ff_check_alignment(); #if CONFIG_ENCODERS if (avctx->bits_per_raw_sample == 10) { c->fdct = ff_jpeg_fdct_islow_10; c->fdct248 = ff_fdct248_islow_10; } else { if(avctx->dct_algo==FF_DCT_FASTINT) { c->fdct = ff_fdct_ifast; c->fdct248 = ff_fdct_if... | 13,862 |
0 | static int mpc7_decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPCContext *c = avctx->priv_data; GetBitContext gb; uint8_t *bits; int i, ch; int mb = -1; Band *bands = c->bands; int off; int bits_used, bits_avail; memset(... | 13,863 |
0 | void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { const int mb_xy= mb_x + mb_y*h->mb_stride; const int mb_type = h->cur_pic.mb_type[mb_xy]; const int mvy_limit = IS_INTERLACED(mb_type... | 13,864 |
0 | static void show_streams(WriterContext *w, AVFormatContext *fmt_ctx) { int i; writer_print_section_header(w, SECTION_ID_STREAMS); for (i = 0; i < fmt_ctx->nb_streams; i++) if (selected_streams[i]) show_stream(w, fmt_ctx, i, 0); writer_print_section_footer(w); } | 13,865 |
0 | static av_always_inline void h264_loop_filter_strength_iteration_mmx2(int16_t bS[2][4][4], uint8_t nnz[40], int8_t ref[2][40], int16_t mv[2][40][2], int bidir, int edges, int step, int mask_mv, int dir) { const x86_reg d_idx = dir ? -8 : -1; DECLARE_ALIGNED(8, const uint64_t, mask_dir) = dir ? 0 : 0xffffffffffffffffULL... | 13,866 |
0 | static void intra_predict_hor_dc_8x8_msa(uint8_t *src, int32_t stride) { uint8_t lp_cnt; uint32_t src0 = 0, src1 = 0; uint64_t out0, out1; for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) { src0 += src[lp_cnt * stride - 1]; src1 += src[(4 + lp_cnt) * stride - 1]; } src0 = (src0 + 2) >> 2; src1 = (src1 + 2) >> 2; out0 = src0 * 0x... | 13,868 |
0 | static int config_out_props(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; AVFilterLink *inlink = outlink->src->inputs[0]; const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format); TInterlaceContext *tinterlace = ctx->priv; int i; tinterlace->vsub = desc->log2_chroma_h; outlink->w = inlink->... | 13,870 |
1 | static void rv40_v_weak_loop_filter(uint8_t *src, const int stride, const int filter_p1, const int filter_q1, const int alpha, const int beta, const int lim_p0q0, const int lim_q1, const int lim_p1) { rv40_weak_loop_filter(src, 1, stride, filter_p1, filter_q1, alpha, beta, lim_p0q0, lim_q1, lim_p1); } | 13,871 |
1 | static int open_output_file(OptionsContext *o, const char *filename) { AVFormatContext *oc; int i, j, err; AVOutputFormat *file_oformat; OutputFile *of; OutputStream *ost; InputStream *ist; AVDictionary *unused_opts = NULL; AVDictionaryEntry *e = NULL; if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) { ... | 13,872 |
1 | static void vapic_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->no_user = 1; dc->reset = vapic_reset; dc->vmsd = &vmstate_vapic; dc->realize = vapic_realize; } | 13,873 |
0 | AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max) { AVProbeData lpd = *pd; AVInputFormat *fmt1 = NULL, *fmt; int score, id3 = 0; if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) { int id3len = ff_id3v2_tag_len(lpd.buf); if (lpd.buf_size > id3len + 16) { lpd.buf ... | 13,874 |
1 | static void v4l2_free_buffer(void *opaque, uint8_t *unused) { V4L2Buffer* avbuf = opaque; V4L2m2mContext *s = buf_to_m2mctx(avbuf); atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel); if (s->reinit) { if (!atomic_load(&s->refcount)) sem_post(&s->refsync); return; } if (avbuf->context->streamon) { ff_v4l2_... | 13,875 |
1 | static int64_t wav_seek_tag(AVIOContext *s, int64_t offset, int whence) { return avio_seek(s, offset + (offset & 1), whence); } | 13,876 |
1 | static void ahci_start_dma(IDEDMA *dma, IDEState *s, BlockCompletionFunc *dma_cb) { #ifdef DEBUG_AHCI AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma); #endif DPRINTF(ad->port_no, "\n"); s->io_buffer_offset = 0; dma_cb(s, 0); } | 13,877 |
1 | rdt_new_context (void) { PayloadContext *rdt = av_mallocz(sizeof(PayloadContext)); avformat_open_input(&rdt->rmctx, "", &ff_rdt_demuxer, NULL); return rdt; } | 13,878 |
1 | static void qpci_pc_config_writeb(QPCIBus *bus, int devfn, uint8_t offset, uint8_t value) { outl(0xcf8, (1 << 31) | (devfn << 8) | offset); outb(0xcfc, value); } | 13,879 |
1 | static void hpet_set_timer(HPETTimer *t) { uint64_t diff; uint32_t wrap_diff; /* how many ticks until we wrap? */ uint64_t cur_tick = hpet_get_ticks(); /* whenever new timer is being set up, make sure wrap_flag is 0 */ t->wrap_flag = 0; diff = hpet_calculate_diff(t, cur_tick); /* hpet spec says in one-shot 32-bit mode,... | 13,880 |
1 | static uint32_t set_allocation_state(sPAPRDRConnector *drc, sPAPRDRAllocationState state) { sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state); if (state == SPAPR_DR_ALLOCATION_STATE_USABLE) { /* if there's no resource/device associated ... | 13,881 |
1 | int chr_baum_init(QemuOpts *opts, CharDriverState **_chr) { BaumDriverState *baum; CharDriverState *chr; brlapi_handle_t *handle; #ifdef CONFIG_SDL SDL_SysWMinfo info; #endif int tty; baum = g_malloc0(sizeof(BaumDriverState)); baum->chr = chr = g_malloc0(sizeof(CharDriverState)); chr->opaque = baum; chr->chr_write = ba... | 13,882 |
1 | static av_cold int ipvideo_decode_init(AVCodecContext *avctx) { IpvideoContext *s = avctx->priv_data; s->avctx = avctx; s->is_16bpp = avctx->bits_per_coded_sample == 16; avctx->pix_fmt = s->is_16bpp ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_PAL8; ff_hpeldsp_init(&s->hdsp, avctx->flags); s->last_frame = av_frame_alloc(); s->seco... | 13,883 |
1 | static int vvfat_open(BlockDriverState *bs, QDict *options, int flags) { BDRVVVFATState *s = bs->opaque; int cyls, heads, secs; bool floppy; const char *dirname; QemuOpts *opts; Error *local_err = NULL; int ret; #ifdef DEBUG vvv = s; #endif DLOG(if (stderr == NULL) { stderr = fopen("vvfat.log", "a"); setbuf(stderr, NUL... | 13,884 |
1 | static int v4l2_try_start(AVCodecContext *avctx) { V4L2m2mContext *s = avctx->priv_data; V4L2Context *const capture = &s->capture; V4L2Context *const output = &s->output; struct v4l2_selection selection; int ret; /* 1. start the output process */ if (!output->streamon) { ret = ff_v4l2_context_set_status(output, VIDIOC_... | 13,885 |
1 | 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, ret; if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0) return ret; #if CONFIG_THEORA_DECODER ... | 13,887 |
1 | static void sysbus_fdc_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->props = sysbus_fdc_properties; set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); } | 13,889 |
1 | static void gmc_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture) { uint8_t *ptr; int linesize, uvlinesize; const int a = s->sprite_warping_accuracy; int ox, oy; linesize = s->linesize; uvlinesize = s->uvlinesize; ptr = ref_picture[0]; ox = s->sprite_offset[0][0] + s-... | 13,891 |
0 | static av_cold int Faac_encode_init(AVCodecContext *avctx) { FaacAudioContext *s = avctx->priv_data; faacEncConfigurationPtr faac_cfg; unsigned long samples_input, max_bytes_output; /* number of channels */ if (avctx->channels < 1 || avctx->channels > 6) return -1; s->faac_handle = faacEncOpen(avctx->sample_rate, avctx... | 13,892 |
0 | av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse) { int n = 1 << nbits; int i; s->nbits = nbits; s->inverse = inverse; ff_init_ff_cos_tabs(nbits+2); s->costab = ff_cos_tabs[nbits+2]; s->csc2 = av_malloc(n/2 * sizeof(FFTSample)); if (ff_rdft_init(&s->rdft, nbits, inverse == DCT_III) < 0) {... | 13,894 |
0 | static int mov_read_mdhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom) { AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = st->priv_data; int version = get_byte(pb); char language[4] = {0}; unsigned lang; if (version > 1) return -1; /* unsupported */ get_be24(pb); /* flags */ if (version == 1... | 13,895 |
1 | static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_ELEM_ID], GetBitContext *gb) { int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index; skip_bits(gb, 2); // object_type sampling_index = get_bits(gb, 4); if (ac->m4ac.sampling_index != sampling_index) av_log(ac->av... | 13,898 |
1 | static inline abi_ulong do_shmat(int shmid, abi_ulong shmaddr, int shmflg) { abi_long raddr; void *host_raddr; struct shmid_ds shm_info; int i,ret; /* find out the length of the shared memory segment */ ret = get_errno(shmctl(shmid, IPC_STAT, &shm_info)); if (is_error(ret)) { /* can't get length, bail out */ return ret... | 13,900 |
1 | static void gif_fill_rect(AVFrame *picture, uint32_t color, int l, int t, int w, int h) { const int linesize = picture->linesize[0] / sizeof(uint32_t); const uint32_t *py = (uint32_t *)picture->data[0] + t * linesize; const uint32_t *pr, *pb = py + (t + h) * linesize; uint32_t *px; for (; py < pb; py += linesize) { px ... | 13,901 |
1 | void helper_divl_EAX_T0(void) { unsigned int den, q, r; uint64_t num; num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32); den = T0; if (den == 0) { raise_exception(EXCP00_DIVZ); } #ifdef BUGGY_GCC_DIV64 r = div32(&q, num, den); #else q = (num / den); r = (num % den); #endif EAX = (uint32_t)q; EDX = (uint32_t)r; ... | 13,902 |
0 | static int mmap_init(AVFormatContext *ctx) { int i, res; struct video_data *s = ctx->priv_data; struct v4l2_requestbuffers req = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .count = desired_video_buffers, .memory = V4L2_MEMORY_MMAP }; res = ioctl(s->fd, VIDIOC_REQBUFS, &req); if (res < 0) { if (errno == EINVAL) { av_log(ctx... | 13,903 |
1 | static void adx_decode(ADXContext *c, int16_t *out, const uint8_t *in, int ch) { ADXChannelState *prev = &c->prev[ch]; GetBitContext gb; int scale = AV_RB16(in); int i; int s0, s1, s2, d; init_get_bits(&gb, in + 2, (18 - 2) * 8); s1 = prev->s1; s2 = prev->s2; for (i = 0; i < 32; i++) { d = get_sbits(&gb, 4); s0 = (BASE... | 13,904 |
1 | void ide_exec_cmd(IDEBus *bus, uint32_t val) { uint16_t *identify_data; IDEState *s; int n; int lba48 = 0; #if defined(DEBUG_IDE) printf("ide: CMD=%02x\n", val); #endif s = idebus_active_if(bus); /* ignore commands to non existent slave */ if (s != bus->ifs && !s->bs) return; /* Only DEVICE RESET is allowed while BSY o... | 13,907 |
1 | av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc) { #undef FUNC #define FUNC(a, depth) a ## _ ## depth ## _c #define ADDPX_DSP(depth) \ c->h264_add_pixels4_clear = FUNC(ff_h264_add_pixels4, depth);\ c->h264_add_pixels8_clear = FUNC(ff_h264_add_pixels8, depth) if (bit_dept... | 13,908 |
1 | static void gen_slbia(DisasContext *ctx) { #if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); #else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } gen_helper_slbia(cpu_env); #endif } | 13,909 |
1 | int nbd_client_init(BlockDriverState *bs, QIOChannelSocket *sioc, const char *export, QCryptoTLSCreds *tlscreds, const char *hostname, Error **errp) { NbdClientSession *client = nbd_get_client_session(bs); int ret; /* NBD handshake */ logout("session init %s\n", export); qio_channel_set_blocking(QIO_CHANNEL(sioc), true... | 13,910 |
1 | static inline void rgtc_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block, const int *color_tab) { uint8_t indices[16]; int x, y; decompress_indices(indices, block + 2); /* Only one or two channels are stored at most, since it only used to * compress specular (black and white) or normal (red and green... | 13,911 |
1 | int sclp_service_call(uint64_t sccb, uint32_t code) { int r = 0; SCCB work_sccb; hwaddr sccb_len = sizeof(SCCB); /* first some basic checks on program checks */ if (cpu_physical_memory_is_io(sccb)) { r = -PGM_ADDRESSING; goto out; } if (sccb & ~0x7ffffff8ul) { r = -PGM_SPECIFICATION; goto out; } /* * we want to work on... | 13,912 |
1 | unsigned avutil_version(void) { av_assert0(AV_PIX_FMT_VDA_VLD == 81); //check if the pix fmt enum has not had anything inserted or removed by mistake av_assert0(AV_SAMPLE_FMT_DBLP == 9); av_assert0(AVMEDIA_TYPE_ATTACHMENT == 4); av_assert0(AV_PICTURE_TYPE_BI == 7); av_assert0(LIBAVUTIL_VERSION_MICRO >= 100); av_assert0... | 13,913 |
1 | static CharDriverState *qemu_chr_open_tty_fd(int fd, ChardevCommon *backend, Error **errp) { CharDriverState *chr; tty_serial_init(fd, 115200, 'N', 8, 1); chr = qemu_chr_open_fd(fd, fd, backend, errp); chr->chr_ioctl = tty_serial_ioctl; chr->chr_close = qemu_chr_close_tty; return chr; | 13,916 |
1 | static int vhost_user_set_owner(struct vhost_dev *dev) { VhostUserMsg msg = { .request = VHOST_USER_SET_OWNER, .flags = VHOST_USER_VERSION, }; vhost_user_write(dev, &msg, NULL, 0); return 0; } | 13,917 |
1 | static int mxf_read_source_clip(MXFStructuralComponent *source_clip, ByteIOContext *pb, int tag) { switch(tag) { case 0x0202: source_clip->duration = get_be64(pb); break; case 0x1201: source_clip->start_position = get_be64(pb); break; case 0x1101: /* UMID, only get last 16 bytes */ url_fskip(pb, 16); get_buffer(pb, sou... | 13,918 |
1 | static void adlib_realizefn (DeviceState *dev, Error **errp) { AdlibState *s = ADLIB(dev); PortioList *port_list = g_new(PortioList, 1); struct audsettings as; if (glob_adlib) { error_setg (errp, "Cannot create more than 1 adlib device"); return; } glob_adlib = s; #ifdef HAS_YMF262 if (YMF262Init (1, 14318180, s->freq)... | 13,919 |
1 | static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst, int width, int height, int stride, const uint8_t *src, int src_size) { int i = 0; int read = 0; uint32_t length; uint32_t offset = 1; int esc_count = src[0]; GetBitContext gb; lag_rac rac; rac.avctx = l->avctx; l->zeros = 0; if (esc_count < 4) { length... | 13,920 |
0 | static void check_pred16x16(H264PredContext *h, uint8_t *buf0, uint8_t *buf1, int codec, int chroma_format, int bit_depth) { if (chroma_format == 1) { int pred_mode; declare_func(void, uint8_t *src, ptrdiff_t stride); for (pred_mode = 0; pred_mode < 9; pred_mode++) { if (check_pred_func(h->pred16x16[pred_mode], "16x16"... | 13,921 |
0 | int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size) { if (size < 0 || avpkt->size < 0 || size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE) { av_log(avctx, AV_LOG_ERROR, "Size %d invalid\n", size); return AVERROR(EINVAL); } if (avctx) { av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buff... | 13,922 |
0 | static int sort_stt(FFV1Context *s, uint8_t stt[256]) { int i, i2, changed, print = 0; do { changed = 0; for (i = 12; i < 244; i++) { for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) { #define COST(old, new) \ s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \ s->rc_stat[old][1] * -log2((new) / 256.0) #define COST2(ol... | 13,923 |
0 | static void dvbsub_parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size) { DVBSubContext *ctx = avctx->priv_data; const uint8_t *buf_end = buf + buf_size; const uint8_t *block; int object_id; DVBSubObject *object; DVBSubObjectDisplay *display; int top_field_len, bottom_field_len; int coding_meth... | 13,924 |
0 | static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet) { SVQ1EncContext *const s = avctx->priv_data; AVFrame *const p = avctx->coded_frame; int i, ret; if (!pkt->data && (ret = av_new_packet(pkt, s->y_block_width * s->y_block_height * MAX_MB_BYTES * 3 + FF_MIN_BUFFER_SI... | 13,925 |
0 | static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, unsigned src_size) { const uint8_t *s = src; const uint8_t *end; #ifdef HAVE_MMX const uint8_t *mm_end; #endif uint16_t *d = (uint16_t *)dst; end = s + src_size; #ifdef HAVE_MMX mm_end = end - 15; #if 1 //is faster only if multiplies are reasonable ... | 13,926 |
0 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size) { MDECContext * const a = avctx->priv_data; AVFrame *picture = data; AVFrame * const p= (AVFrame*)&a->picture; int i; /* special case for last picture */ if (buf_size == 0) { return 0; } if(p->data[0]) avctx->release_... | 13,927 |
1 | void OPPROTO op_srli_T0 (void) { T0 = T0 >> PARAM1; RETURN(); } | 13,928 |
1 | static void bdrv_qed_invalidate_cache(BlockDriverState *bs) { BDRVQEDState *s = bs->opaque; bdrv_qed_close(bs); memset(s, 0, sizeof(BDRVQEDState)); bdrv_qed_open(bs, NULL, bs->open_flags, NULL); } | 13,929 |
1 | void syscall_init(void) { IOCTLEntry *ie; const argtype *arg_type; int size; int i; #define STRUCT(name, ...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def); #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def); #include "syscall_types.h" #u... | 13,930 |
1 | static void null_end_frame(AVFilterLink *inlink) { } | 13,931 |
1 | void qemu_init_vcpu(void *_env) { CPUState *env = _env; int r; env->nr_cores = smp_cores; env->nr_threads = smp_threads; if (kvm_enabled()) { r = kvm_init_vcpu(env); if (r < 0) { fprintf(stderr, "kvm_init_vcpu failed: %s\n", strerror(-r)); exit(1); } qemu_kvm_init_cpu_signals(env); } else { qemu_tcg_init_cpu_signals();... | 13,932 |
1 | static void migrate_finish_set_state(MigrationState *s, int new_state) { if (atomic_cmpxchg(&s->state, MIG_STATE_ACTIVE, new_state) == new_state) { trace_migrate_set_state(new_state); } } | 13,933 |
1 | static void ohci_reset(OHCIState *ohci) { OHCIPort *port; int i; ohci->ctl = 0; ohci->old_ctl = 0; ohci->status = 0; ohci->intr_status = 0; ohci->intr = OHCI_INTR_MIE; ohci->hcca = 0; ohci->ctrl_head = ohci->ctrl_cur = 0; ohci->bulk_head = ohci->bulk_cur = 0; ohci->per_cur = 0; ohci->done = 0; ohci->done_count = 7; /* ... | 13,934 |
1 | static int qxl_init_primary(PCIDevice *dev) { PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev); VGACommonState *vga = &qxl->vga; PortioList *qxl_vga_port_list = g_new(PortioList, 1); int rc; qxl->id = 0; qxl_init_ramsize(qxl); vga->vram_size_mb = qxl->vga.vram_size >> 20; vga_common_init(vga, OBJECT(dev), true); v... | 13,935 |
1 | static void nbd_trip(void *opaque) { NBDClient *client = opaque; NBDExport *exp = client->exp; NBDRequest *req; struct nbd_request request; struct nbd_reply reply; ssize_t ret; uint32_t command; TRACE("Reading request."); if (client->closing) { return; } req = nbd_request_get(client); ret = nbd_co_receive_request(req, ... | 13,936 |
1 | bool memory_region_is_unassigned(MemoryRegion *mr) { return mr != &io_mem_ram && mr != &io_mem_rom && mr != &io_mem_notdirty && !mr->rom_device && mr != &io_mem_watch; } | 13,937 |
1 | static void setup_rt_frame(int sig, struct target_sigaction *ka, target_siginfo_t *info, target_sigset_t *set, CPUState *env) { fprintf(stderr, "setup_rt_frame: not implemented\n"); } | 13,939 |
1 | static unsigned int virtqueue_get_head(VirtQueue *vq, unsigned int idx) { unsigned int head; /* Grab the next descriptor number they're advertising, and increment * the index we've seen. */ head = vring_avail_ring(vq, idx % vq->vring.num); /* If their number is silly, that's a fatal mistake. */ if (head >= vq->vring.nu... | 13,940 |
1 | int kvm_has_sync_mmu(void) { #ifdef KVM_CAP_SYNC_MMU KVMState *s = kvm_state; return kvm_check_extension(s, KVM_CAP_SYNC_MMU); #else return 0; #endif } | 13,941 |
1 | static void ff_wmv2_idct_add_c(uint8_t *dest, int line_size, DCTELEM *block) { ff_wmv2_idct_c(block); add_pixels_clamped_c(block, dest, line_size); } | 13,942 |
0 | static void vc1_decode_b_blocks(VC1Context *v) { MpegEncContext *s = &v->s; /* select codingmode used for VLC tables selection */ switch(v->c_ac_table_index){ case 0: v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA; break; case 1: v->codingset = CS_HIGH_MOT_INTRA; break; case 2: v->codingset = ... | 13,944 |
0 | static float ppp_pvq_search_c(float *X, int *y, int K, int N) { int i, y_norm = 0; float res = 0.0f, xy_norm = 0.0f; for (i = 0; i < N; i++) res += FFABS(X[i]); res = K/(res + FLT_EPSILON); for (i = 0; i < N; i++) { y[i] = lrintf(res*X[i]); y_norm += y[i]*y[i]; xy_norm += y[i]*X[i]; K -= FFABS(y[i]); } while (K) { int ... | 13,945 |
0 | uint32_t do_arm_semihosting(CPUARMState *env) { ARMCPU *cpu = arm_env_get_cpu(env); CPUState *cs = CPU(cpu); target_ulong args; target_ulong arg0, arg1, arg2, arg3; char * s; int nr; uint32_t ret; uint32_t len; #ifdef CONFIG_USER_ONLY TaskState *ts = cs->opaque; #else CPUARMState *ts = env; #endif nr = env->regs[0]; ar... | 13,946 |
0 | static int openfile(char *name, int flags, QDict *opts) { Error *local_err = NULL; BlockDriverState *bs; if (qemuio_blk) { error_report("file open already, try 'help close'"); QDECREF(opts); return 1; } qemuio_blk = blk_new_open(name, NULL, opts, flags, &local_err); if (!qemuio_blk) { error_reportf_err(local_err, "can'... | 13,947 |
0 | static void *worker_thread(void *opaque) { ThreadPool *pool = opaque; qemu_mutex_lock(&pool->lock); pool->pending_threads--; do_spawn_thread(pool); while (!pool->stopping) { ThreadPoolElement *req; int ret; do { pool->idle_threads++; qemu_mutex_unlock(&pool->lock); ret = qemu_sem_timedwait(&pool->sem, 10000); qemu_mute... | 13,948 |
0 | void qemu_aio_wait(void) { int ret; if (qemu_bh_poll()) return; do { AioHandler *node; fd_set rdfds, wrfds; int max_fd = -1; walking_handlers = 1; FD_ZERO(&rdfds); FD_ZERO(&wrfds); /* fill fd sets */ LIST_FOREACH(node, &aio_handlers, node) { /* If there aren't pending AIO operations, don't invoke callbacks. * Otherwise... | 13,949 |
0 | void hotplug_handler_post_plug(HotplugHandler *plug_handler, DeviceState *plugged_dev, Error **errp) { HotplugHandlerClass *hdc = HOTPLUG_HANDLER_GET_CLASS(plug_handler); if (hdc->post_plug) { hdc->post_plug(plug_handler, plugged_dev, errp); } } | 13,950 |
0 | static void kvm_openpic_realize(DeviceState *dev, Error **errp) { SysBusDevice *d = SYS_BUS_DEVICE(dev); KVMOpenPICState *opp = KVM_OPENPIC(dev); KVMState *s = kvm_state; int kvm_openpic_model; struct kvm_create_device cd = {0}; int ret, i; if (!kvm_check_extension(s, KVM_CAP_DEVICE_CTRL)) { error_setg(errp, "Kernel is... | 13,952 |
0 | static int get_free_io_mem_idx(void) { int i; for (i = 0; i<IO_MEM_NB_ENTRIES; i++) if (!io_mem_used[i]) { io_mem_used[i] = 1; return i; } return -1; } | 13,953 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.