label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void sysctl_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ MilkymistSysctlState *s = opaque; trace_milkymist_sysctl_memory_write(addr, value); addr >>= 2; switch (addr) { case R_GPIO_OUT: case R_GPIO_INTEN: case R_TIMER0_COUNTER: case R_TIMER1_COUNTER: case R_DBG_SCRATCHPAD: s->regs... |
0 | static void parallels_close(BlockDriverState *bs){ BDRVParallelsState *s = bs->opaque; g_free(s->catalog_bitmap);} |
1 | static int img_resize(int argc, char **argv){ Error *err = NULL; int c, ret, relative; const char *filename, *fmt, *size; int64_t n, total_size; bool quiet = false; BlockBackend *blk = NULL; QemuOpts *param; static QemuOptsList resize_options = { .name = "resize_options", .head = QTAILQ_HEAD_INITIALIZER(resize_options.... |
1 | static void qtrle_decode_24bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change){ int rle_code; int pixel_ptr; int row_inc = s->frame.linesize[0]; unsigned char r, g, b; unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; while (lines_to_change--) { CHECK_S... |
1 | static int xiph_parse_sdp_line(AVFormatContext *s, int st_index, PayloadContext *data, const char *line){ const char *p; char *value; char attr[25]; int value_size = strlen(line), attr_size = sizeof(attr), res = 0; AVCodecContext* codec = s->streams[st_index]->codec; assert(codec->id == CODEC_ID_THEORA); assert(data); ... |
1 | static int vp8_handle_packet(AVFormatContext *ctx, PayloadContext *vp8, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags){ int start_partition, end_packet; int extended_bits, part_id; int pictureid_present = 0, tl0picidx_present = 0, tid_present = 0, keyidx_present ... |
1 | static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ MpegEncContext * const s = avctx->priv_data; MJpegContext * const m = s->mjpeg_ctx; AVFrame *pict = data; const int width= s->width; const int height= s->height; AVFrame * const p= (AVFrame*)&s->current_picture; con... |
1 | static VFIOGroup *vfio_get_group(int groupid){ VFIOGroup *group; char path[32]; struct vfio_group_status status = { .argsz = sizeof(status) }; QLIST_FOREACH(group, &group_list, next) { if (group->groupid == groupid) { return group; } } group = g_malloc0(sizeof(*group)); snprintf(path, sizeof(path), "/dev/vfio/%d", grou... |
1 | static int webvtt_event_to_ass(AVBPrint *buf, const char *p){ int i, again, skip = 0; while (*p) { for (i = 0; i < FF_ARRAY_ELEMS(webvtt_tag_replace); i++) { const char *from = webvtt_tag_replace[i].from; const size_t len = strlen(from); if (!strncmp(p, from, len)) { av_bprintf(buf, "%s", webvtt_tag_replace[i].to); p +... |
0 | static int nuv_probe(AVProbeData *p) { if (p->buf_size < 12) return 0; if (!memcmp(p->buf, "NuppelVideo", 12)) return AVPROBE_SCORE_MAX; if (!memcmp(p->buf, "MythTVVideo", 12)) return AVPROBE_SCORE_MAX; return 0;} |
1 | void cache_fini(PageCache *cache){ int64_t i; g_assert(cache); g_assert(cache->page_cache); for (i = 0; i < cache->max_num_items; i++) { g_free(cache->page_cache[i].it_data); } g_free(cache->page_cache); cache->page_cache = NULL;} |
1 | int ff_rate_control_init(MpegEncContext *s){ RateControlContext *rcc= &s->rc_context; int i; const char *error = NULL; static const char * const const_names[]={ "PI", "E", "iTex", "pTex", "tex", "mv", "fCode", "iCount", "mcVar", "var", "isI", "isP", "isB", "avgQP", "qComp",/* "lastIQP", "lastPQP", "lastBQP", "nextNonBQ... |
1 | static int iec61883_read_header(AVFormatContext *context){ struct iec61883_data *dv = context->priv_data; struct raw1394_portinfo pinf[16]; rom1394_directory rom_dir; char *endptr; int inport; int nb_ports; int port = -1; int response; int i, j = 0; uint64_t guid = 0; dv->input_port = -1; dv->output_port = -1; dv->chan... |
1 | static int aio_flush_f(BlockBackend *blk, int argc, char **argv){ blk_drain_all(); return 0;} |
1 | static int idcin_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; IdcinContext *s = avctx->priv_data; const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL); s->buf = buf; s->size = buf_size; if (s->fr... |
1 | void vnc_display_open(DisplayState *ds, const char *display, Error **errp){ VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display; const char *options; int password = 0; int reverse = 0;#ifdef CONFIG_VNC_TLS int tls = 0, x509 = 0;#endif#ifdef CONFIG_VNC_SASL int sasl = 0; int saslErr;#endif#if defined(CONFIG_VNC... |
1 | bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos, bool is_read){ if (qemu_in_coroutine()) { return bdrv_co_rw_vmstate(bs, qiov, pos, is_read); } else { BdrvVmstateCo data = { .bs = bs, .qiov = qiov, .pos = pos, .is_read = is_read, .ret = -EINPROGRESS, }; Coroutine *co = qemu_coroutine_create(bdrv_c... |
1 | static void exit_program(void){ int i, j; for (i = 0; i < nb_filtergraphs; i++) { avfilter_graph_free(&filtergraphs[i]->graph); for (j = 0; j < filtergraphs[i]->nb_inputs; j++) { av_freep(&filtergraphs[i]->inputs[j]->name); av_freep(&filtergraphs[i]->inputs[j]); } av_freep(&filtergraphs[i]->inputs); for (j = 0; j < fil... |
1 | static bool scsi_target_emulate_report_luns(SCSITargetReq *r){ BusChild *kid; int i, len, n; int channel, id; bool found_lun0; if (r->req.cmd.xfer < 16) { return false; } if (r->req.cmd.buf[2] > 2) { return false; } channel = r->req.dev->channel; id = r->req.dev->id; found_lun0 = false; n = 0; QTAILQ_FOREACH(kid, &r->r... |
1 | static int check_directory_consistency(BDRVVVFATState *s,int cluster_num, const char* path){ int ret = 0; unsigned char* cluster = qemu_malloc(s->cluster_size); direntry_t* direntries = (direntry_t*)cluster; mapping_t* mapping = find_mapping_for_cluster(s, cluster_num); long_file_name lfn; int path_len = strlen(path); ... |
1 | static int rpl_read_header(AVFormatContext *s){ AVIOContext *pb = s->pb; RPLContext *rpl = s->priv_data; AVStream *vst = NULL, *ast = NULL; int total_audio_size; int error = 0; uint32_t i; int32_t audio_format, chunk_catalog_offset, number_of_chunks; AVRational fps; char line[RPL_LINE_LENGTH]; // The header for RPL/ARM... |
1 | static void h264_free_context(PayloadContext *data){#ifdef DEBUG int ii; for (ii = 0; ii < 32; ii++) { if (data->packet_types_received[ii]) av_log(NULL, AV_LOG_DEBUG, "Received %d packets of type %d\n", data->packet_types_received[ii], ii); }#endif assert(data); assert(data->cookie == MAGIC_COOKIE); // avoid stale poin... |
1 | static void mirror_iteration_done(MirrorOp *op, int ret){ MirrorBlockJob *s = op->s; struct iovec *iov; int64_t chunk_num; int i, nb_chunks, sectors_per_chunk; trace_mirror_iteration_done(s, op->sector_num, op->nb_sectors, ret); s->in_flight--; s->sectors_in_flight -= op->nb_sectors; iov = op->qiov.iov; for (i = 0; i <... |
1 | static int find_image_range(int *pfirst_index, int *plast_index, const char *path, int start_index){ char buf[1024]; int range, last_index, range1, first_index; /* find the first image */ for (first_index = start_index; first_index < start_index + 5; first_index++) { if (av_get_frame_filename(buf, sizeof(buf), path, fi... |
0 | av_cold int ff_cavs_init(AVCodecContext *avctx){ AVSContext *h = avctx->priv_data; ff_blockdsp_init(&h->bdsp, avctx); ff_h264chroma_init(&h->h264chroma, 8); ff_idctdsp_init(&h->idsp, avctx); ff_videodsp_init(&h->vdsp, 8); ff_cavsdsp_init(&h->cdsp, avctx); ff_init_scantable_permutation(h->idsp.idct_permutation, h->cdsp.... |
0 | static int filter_packet(void *log_ctx, AVPacket *pkt, AVFormatContext *fmt_ctx, AVBitStreamFilterContext *bsf_ctx){ AVCodecContext *enc_ctx = fmt_ctx->streams[pkt->stream_index]->codec; int ret = 0; while (bsf_ctx) { AVPacket new_pkt = *pkt; ret = av_bitstream_filter_filter(bsf_ctx, enc_ctx, NULL, &new_pkt.data, &new_... |
1 | static void nbd_client_close(NBDClient *client){ qemu_set_fd_handler2(client->sock, NULL, NULL, NULL, NULL); close(client->sock); client->sock = -1; if (client->close) { client->close(client); } nbd_client_put(client);} |
0 | int avio_close(AVIOContext *s){ AVIOInternal *internal; URLContext *h; if (!s) return 0; avio_flush(s); internal = s->opaque; h = internal->h; av_opt_free(internal); av_freep(&internal->protocols); av_freep(&s->opaque); av_freep(&s->buffer); av_free(s); return ffurl_close(h);} |
1 | int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx){ int i, ret = 0; jclass last_clazz = NULL; for (i = 0; jfields_mapping[i].name; i++) { int mandatory = jfields_mapping[i].mandatory; enum FFJniFieldType type = jfields_mapping[i].type; if (type == FF... |
1 | static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child, int64_t offset, unsigned int bytes, QEMUIOVector *qiov){ BlockDriverState *bs = child->bs; /* Perform I/O through a temporary buffer so that users who scribble over * their read buffer while the operation is in progress do not end up * modifying the ima... |
1 | static int img_bench(int argc, char **argv){ int c, ret = 0; const char *fmt = NULL, *filename; bool quiet = false; bool image_opts = false; bool is_write = false; int count = 75000; int depth = 64; int64_t offset = 0; size_t bufsize = 4096; int pattern = 0; size_t step = 0; int flush_interval = 0; bool drain_on_flush ... |
1 | void object_property_add_link(Object *obj, const char *name, const char *type, Object **child, Error **errp){ gchar *full_type; full_type = g_strdup_printf("link<%s>", type); object_property_add(obj, name, full_type, object_get_link_property, object_set_link_property, NULL, child, errp); g_free(full_type);} |
1 | static void process_event(JSONMessageParser *parser, QList *tokens){ GAState *s = container_of(parser, GAState, parser); QObject *obj; QDict *qdict; Error *err = NULL; int ret; g_assert(s && parser); g_debug("process_event: called"); obj = json_parser_parse_err(tokens, NULL, &err); if (err || !obj || qobject_type(obj) ... |
1 | static inline void RENAME(rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size){ uint8_t *dest = dst; const uint8_t *s = src; const uint8_t *end; const uint8_t *mm_end; end = s + src_size; __asm__ volatile(PREFETCH" %0"::"m"(*s):"memory"); mm_end = end - 31; while (s < mm_end) { __asm__ volatile( PREFETCH" 32%1... |
1 | static void slice_thread_park_workers(ThreadContext *c){ pthread_cond_wait(&c->last_job_cond, &c->current_job_lock); pthread_mutex_unlock(&c->current_job_lock);} |
0 | static av_cold int ljpeg_encode_init(AVCodecContext *avctx){ LJpegEncContext *s = avctx->priv_data; int chroma_v_shift, chroma_h_shift; if ((avctx->pix_fmt == AV_PIX_FMT_YUV420P || avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV444P) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {... |
1 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus, const char *name, int devfn, Error **errp){ PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev); PCIConfigReadFunc *config_read = pc->config_read; PCIConfigWriteFunc *config_write = pc->config_write; Error *local_err = NULL; AddressSpace *dma_as; ... |
1 | static void multiwrite_cb(void *opaque, int ret){ MultiwriteCB *mcb = opaque; if (ret < 0) { mcb->error = ret; multiwrite_user_cb(mcb); } mcb->num_requests--; if (mcb->num_requests == 0) { if (mcb->error == 0) { multiwrite_user_cb(mcb); } qemu_free(mcb); }} |
1 | qemu_irq *pl190_init(uint32_t base, qemu_irq irq, qemu_irq fiq){ pl190_state *s; qemu_irq *qi; int iomemtype; s = (pl190_state *)qemu_mallocz(sizeof(pl190_state)); iomemtype = cpu_register_io_memory(0, pl190_readfn, pl190_writefn, s); cpu_register_physical_memory(base, 0x00000fff, iomemtype); qi = qemu_allocate_irqs(pl... |
1 | static void pci_reg_write4(void *opaque, target_phys_addr_t addr, uint32_t value){ PPCE500PCIState *pci = opaque; unsigned long win; win = addr & 0xfe0; pci_debug("%s: value:%x -> win:%lx(addr:" TARGET_FMT_plx ")\n", __func__, value, win, addr); switch (win) { case PPCE500_PCI_OW1: case PPCE500_PCI_OW2: case PPCE500_PC... |
1 | static TRBCCode xhci_address_slot(XHCIState *xhci, unsigned int slotid, uint64_t pictx, bool bsr){ XHCISlot *slot; USBPort *uport; USBDevice *dev; dma_addr_t ictx, octx, dcbaap; uint64_t poctx; uint32_t ictl_ctx[2]; uint32_t slot_ctx[4]; uint32_t ep0_ctx[5]; int i; TRBCCode res; assert(slotid >= 1 && slotid <= xhci->nu... |
1 | static void encode_frame(MpegAudioContext *s, unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT], int padding){ int i, j, k, l, bit_alloc_bits, b, ch; unsigned char *sf; int q[3]; PutBitContext *p = &s->pb; /* header */ put_bits(p, 12, 0xfff); put_bits(p, 1, 1 - s->lsf); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */ put_bits(p,... |
0 | static int quantize_coefs(double *coef, int *idx, float *lpc, int order){ int i; uint8_t u_coef; const float *quant_arr = tns_tmp2_map[TNS_Q_BITS == 4]; const double iqfac_p = ((1 << (TNS_Q_BITS-1)) - 0.5)/(M_PI/2.0); const double iqfac_m = ((1 << (TNS_Q_BITS-1)) + 0.5)/(M_PI/2.0); for (i = 0; i < order; i++) { idx[i] ... |
1 | static int get_int16(QEMUFile *f, void *pv, size_t size){ int16_t *v = pv; qemu_get_sbe16s(f, v); return 0;} |
1 | static void compress_to_network(RDMACompress *comp){ comp->value = htonl(comp->value); comp->block_idx = htonl(comp->block_idx); comp->offset = htonll(comp->offset); comp->length = htonll(comp->length);} |
1 | int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter){ graph->filters = av_realloc(graph->filters, sizeof(AVFilterContext*) * ++graph->filter_count); if (!graph->filters) return AVERROR(ENOMEM); graph->filters[graph->filter_count - 1] = filter; return 0;} |
1 | av_cold int ff_rate_control_init(MpegEncContext *s){ RateControlContext *rcc = &s->rc_context; int i, res; static const char * const const_names[] = { "PI", "E", "iTex", "pTex", "tex", "mv", "fCode", "iCount", "mcVar", "var", "isI", "isP", "isB", "avgQP", "qComp",#if 0 "lastIQP", "lastPQP", "lastBQP", "nextNonBQP",#end... |
1 | void trace_event_set_vcpu_state_dynamic(CPUState *vcpu, TraceEvent *ev, bool state){ TraceEventVCPUID vcpu_id; bool state_pre; assert(trace_event_get_state_static(ev)); assert(trace_event_is_vcpu(ev)); vcpu_id = trace_event_get_vcpu_id(ev); state_pre = test_bit(vcpu_id, vcpu->trace_dstate); if (state_pre != state) { if... |
1 | static void vmsvga_value_write(void *opaque, uint32_t address, uint32_t value){ struct vmsvga_state_s *s = opaque; if (s->index >= SVGA_SCRATCH_BASE) { trace_vmware_scratch_write(s->index, value); } else if (s->index >= SVGA_PALETTE_BASE) { trace_vmware_palette_write(s->index, value); } else { trace_vmware_value_write(... |
1 | int main (int argc, char **argv){ int ret = 0, got_frame; if (argc != 4) { fprintf(stderr, "usage: %s input_file video_output_file audio_output_file\n" "API example program to show how to read frames from an input file.\n" "This program reads frames from a file, decodes them, and writes decoded\n" "video frames to a ra... |
0 | static av_cold int truemotion1_decode_init(AVCodecContext *avctx){ TrueMotion1Context *s = avctx->priv_data; s->avctx = avctx; // FIXME: it may change ?// if (avctx->bits_per_sample == 24)// avctx->pix_fmt = AV_PIX_FMT_RGB24;// else// avctx->pix_fmt = AV_PIX_FMT_RGB555; s->frame.data[0] = NULL; /* there is a vertical p... |
0 | static int h264_export_frame_props(H264Context *h){ const SPS *sps = h->ps.sps; H264Picture *cur = h->cur_pic_ptr; cur->f->interlaced_frame = 0; cur->f->repeat_pict = 0; /* Signal interlacing information externally. */ /* Prioritize picture timing SEI information over used * decoding process if it exists. */ if (sps->p... |
1 | static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt){ int network_header_length = ppkt->ip->ip_hl * 4; trace_colo_compare_main("compare icmp"); /* * Because of ppkt and spkt are both in the same connection, * The ppkt's src ip, dst ip, src port, dst port, ip_proto all are * same with spkt. In addition, IP he... |
1 | static int caca_write_header(AVFormatContext *s){ CACAContext *c = s->priv_data; AVStream *st = s->streams[0]; AVCodecContext *encctx = st->codec; int ret, bpp; c->ctx = s; if (c->list_drivers) { list_drivers(c); return AVERROR_EXIT; } if (c->list_dither) { if (!strcmp(c->list_dither, "colors")) { list_dither_color(c);... |
1 | static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment){ int i, length; segment->nb_index_entries = avio_rb32(pb); length = avio_rb32(pb); if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) || !(segment->flag_entries = av... |
1 | uint64_t hbitmap_serialization_granularity(const HBitmap *hb){ /* Must hold true so that the shift below is defined * (ld(64) == 6, i.e. 1 << 6 == 64) */ assert(hb->granularity < 64 - 6); /* Require at least 64 bit granularity to be safe on both 64 bit and 32 bit * hosts. */ return UINT64_C(64) << hb->granularity;} |
1 | void helper_store_sdr1(CPUPPCState *env, target_ulong val){ ppc_store_sdr1(env, val);} |
0 | static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size){ VP56RangeCoder *c = &s->c; int part1_size, hscale, vscale, i, j, ret; int width = s->avctx->width; int height = s->avctx->height; s->profile = (buf[0] >> 1) & 7; if (s->profile > 1) { avpriv_request_sample(s->avctx, "Unknown profile %d... |
1 | static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int src_x_offset, int src_y_offset, qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ MpegEncContext * const s = &h->s; const int mx= h->mv_ca... |
1 | static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data){ AVFrame *pic = data; int i, j; int aligned_width = FFALIGN(avctx->width, 64); uint8_t *src_line; uint8_t *dst = buf; if (buf_size < 4 * aligned_width * avctx->height) { av_log(avctx, AV_LOG_ERROR, "output buffer too small\n"); retur... |
1 | static inline void gen_st32(TCGv val, TCGv addr, int index){ tcg_gen_qemu_st32(val, addr, index); dead_tmp(val);} |
0 | int uuid_is_null(const uuid_t uu){ uuid_t null_uuid = { 0 }; return memcmp(uu, null_uuid, sizeof(uuid_t)) == 0;} |
0 | static int e1000_post_load(void *opaque, int version_id){ E1000State *s = opaque; NetClientState *nc = qemu_get_queue(s->nic); if (!(s->compat_flags & E1000_FLAG_MIT)) { s->mac_reg[ITR] = s->mac_reg[RDTR] = s->mac_reg[RADV] = s->mac_reg[TADV] = 0; s->mit_irq_level = false; } s->mit_ide = 0; s->mit_timer_on = false; /* ... |
0 | int qemu_opts_do_parse(QemuOpts *opts, const char *params, const char *firstname){ Error *err = NULL; opts_do_parse(opts, params, firstname, false, &err); if (err) { qerror_report_err(err); error_free(err); return -1; } return 0;} |
0 | static int cris_mmu_enabled(uint32_t rw_gc_cfg){return (rw_gc_cfg & 12) != 0;} |
0 | static int nut_read_packet(AVFormatContext *s, AVPacket *pkt){ NUTContext *nut = s->priv_data; StreamContext *stream; ByteIOContext *bc = &s->pb; int size, frame_code, flags, size_mul, size_lsb, stream_id; int key_frame = 0; int frame_type= 0; int64_t pts = 0; const int64_t frame_start= url_ftell(bc); if (url_feof(bc))... |
0 | void block_job_user_resume(BlockJob *job){ if (job && job->user_paused && job->pause_count > 0) { job->user_paused = false; block_job_iostatus_reset(job); block_job_resume(job); }} |
0 | static void pc_cpu_reset(void *opaque){ X86CPU *cpu = opaque; CPUX86State *env = &cpu->env; cpu_reset(CPU(cpu)); env->halted = !cpu_is_bsp(env);} |
0 | static pflash_t *ve_pflash_cfi01_register(hwaddr base, const char *name, DriveInfo *di){ DeviceState *dev = qdev_create(NULL, "cfi.pflash01"); if (di && qdev_prop_set_drive(dev, "drive", blk_bs(blk_by_legacy_dinfo(di)))) { abort(); } qdev_prop_set_uint32(dev, "num-blocks", VEXPRESS_FLASH_SIZE / VEXPRESS_FLASH_SECT_SIZE... |
0 | static bool virtio_queue_host_notifier_aio_poll(void *opaque){ EventNotifier *n = opaque; VirtQueue *vq = container_of(n, VirtQueue, host_notifier); bool progress; if (virtio_queue_empty(vq)) { return false; } progress = virtio_queue_notify_aio_vq(vq); /* In case the handler function re-enabled notifications */ virtio_... |
0 | static void qvirtio_9p_stop(void){ qtest_end(); rmdir(test_share); g_free(test_share);} |
0 | do_kernel_trap(CPUARMState *env){ uint32_t addr; uint32_t cpsr; uint32_t val; switch (env->regs[15]) { case 0xffff0fa0: /* __kernel_memory_barrier */ /* ??? No-op. Will need to do better for SMP. */ break; case 0xffff0fc0: /* __kernel_cmpxchg */ /* XXX: This only works between threads, not between processes. It's proba... |
0 | static void event_notifier_dummy_cb(EventNotifier *e){} |
0 | uint16_t cpu_inw(CPUState *env, pio_addr_t addr){ uint16_t val; val = ioport_read(1, addr); LOG_IOPORT("inw : %04"FMT_pioaddr" %04"PRIx16"\n", addr, val);#ifdef CONFIG_KQEMU if (env) env->last_io_time = cpu_get_time_fast();#endif return val;} |
0 | static NVDIMMDevice *nvdimm_get_device_by_handle(uint32_t handle){ NVDIMMDevice *nvdimm = NULL; GSList *list, *device_list = nvdimm_get_plugged_device_list(); for (list = device_list; list; list = list->next) { NVDIMMDevice *nvd = list->data; int slot = object_property_get_int(OBJECT(nvd), PC_DIMM_SLOT_PROP, NULL); if ... |
0 | int avio_check(const char *url, int flags){ URLContext *h; int ret = ffurl_alloc(&h, url, flags, NULL); if (ret) return ret; if (h->prot->url_check) { ret = h->prot->url_check(h, flags); } else { ret = ffurl_connect(h, NULL); if (ret >= 0) ret = flags; } ffurl_close(h); return ret;} |
0 | int x86_cpu_handle_mmu_fault(CPUState *cs, vaddr addr, int is_write1, int mmu_idx){ X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; uint64_t ptep, pte; target_ulong pde_addr, pte_addr; int error_code = 0; int is_dirty, prot, page_size, is_write, is_user; hwaddr paddr; uint64_t rsvd_mask = PG_HI_RSVD_MASK; uint... |
0 | int kvmppc_reset_htab(int shift_hint){ uint32_t shift = shift_hint; if (!kvm_enabled()) { /* Full emulation, tell caller to allocate htab itself */ return 0; } if (kvm_check_extension(kvm_state, KVM_CAP_PPC_ALLOC_HTAB)) { int ret; ret = kvm_vm_ioctl(kvm_state, KVM_PPC_ALLOCATE_HTAB, &shift); if (ret == -ENOTTY) { /* At... |
0 | static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom){ AVStream *st; MOVStreamContext *sc; int ret; st = av_new_stream(c->fc, c->fc->nb_streams); if (!st) return AVERROR(ENOMEM); sc = av_mallocz(sizeof(MOVStreamContext)); if (!sc) return AVERROR(ENOMEM); st->priv_data = sc; st->codec->codec_type = CO... |
0 | static void FUNCC(pred8x8_horizontal_add)(uint8_t *pix, const int *block_offset, const int16_t *block, ptrdiff_t stride){ int i; for(i=0; i<4; i++) FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);} |
0 | void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum){ s->update_checksum= update_checksum; s->checksum= s->update_checksum(checksum, NULL, 0); s->checksum_ptr= s->buf_ptr;} |
0 | static av_cold int hap_init(AVCodecContext *avctx){ HapContext *ctx = avctx->priv_data; int ratio; int corrected_chunk_count; int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); if (ret < 0) { av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n", avctx->width, avctx->height); return ret; } if (av... |
0 | static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index, const uint8_t *buf, int size, int64_t pts){ MpegMuxContext *s = ctx->priv_data; AVStream *st = ctx->streams[stream_index]; StreamInfo *stream = st->priv_data; int len; while (size > 0) { /* set pts */ if (stream->start_pts == -1) { stream->start_p... |
0 | static int decode_i_block(FourXContext *f, int16_t *block){ int code, i, j, level, val; if (get_bits_left(&f->gb) < 2){ av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb)); return -1; } /* DC coef */ val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3); if (val >> 4... |
0 | static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y, const uint8_t **buf, int buf_size){ MpegEncContext *s = &s1->mpeg_enc_ctx; AVCodecContext *avctx= s->avctx; const int field_pic= s->picture_structure != PICT_FRAME; const int lowres= s->avctx->lowres; s->resync_mb_x= s->resync_mb_y= -1; if (mb_y >= s->mb_height){... |
0 | static inline void RENAME(rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,long width, long height,long lumStride, long chromStride, long srcStride){long y;const long chromWidth= width>>1;#ifdef HAVE_MMXfor(y=0; y<height-2; y+=2){long i;for(i=0; i<2; i++){asm volatile("mov %2, %%"REG_a"\n\t"... |
0 | static int paf_vid_decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt){ PAFVideoDecContext *c = avctx->priv_data; uint8_t code, *dst, *src, *end; int i, frame, ret; c->pic.reference = 3; if ((ret = avctx->reget_buffer(avctx, &c->pic)) < 0) return ret; bytestream2_init(&c->gb, pkt->data, pkt->size);... |
0 | static int file_read(URLContext *h, unsigned char *buf, int size){ FileContext *c = h->priv_data; int r = read(c->fd, buf, size); return (-1 == r)?AVERROR(errno):r;} |
1 | static void realview_init(ram_addr_t ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUState *env; ram_addr_t ram_offset; DeviceState *dev; qemu_irq *irqp; qemu_irq pic[64]; PCIBus *pci_bus; NICInfo *nd; int n; int done_sm... |
1 | int ff_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len){ int len1; len1 = len; ts->pkt = pkt; ts->stop_parse = 0; for(;;) { if (ts->stop_parse>0) break; if (len < TS_PACKET_SIZE) return -1; if (buf[0] != 0x47) { buf++; len--; } else { handle_packet(ts, buf); buf += TS_PACKET_SIZE; len ... |
1 | static int mszh_decomp(unsigned char * srcptr, int srclen, unsigned char * destptr){ unsigned char *destptr_bak = destptr; unsigned char mask = 0; unsigned char maskbit = 0; unsigned int ofs, cnt; while (srclen > 0) { if (maskbit == 0) { mask = *(srcptr++); maskbit = 8; srclen--; continue; } if ((mask & (1 << (--maskbi... |
1 | int ff_split_xiph_headers(uint8_t *extradata, int extradata_size, int first_header_size, uint8_t *header_start[3], int header_len[3]){ int i, j; if (AV_RB16(extradata) == first_header_size) { for (i=0; i<3; i++) { header_len[i] = AV_RB16(extradata); extradata += 2; header_start[i] = extradata; extradata += header_len[i... |
1 | static int vp3_decode_init(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; int i; s->avctx = avctx; s->width = avctx->width; s->height = avctx->height; avctx->pix_fmt = PIX_FMT_YUV420P; avctx->has_b_frames = 0; dsputil_init(&s->dsp, avctx); /* initialize to an impossible value which will force a recalcu... |
1 | uint16_t qpci_io_readw(QPCIDevice *dev, void *data){ uintptr_t addr = (uintptr_t)data; if (addr < QPCI_PIO_LIMIT) { return dev->bus->pio_readw(dev->bus, addr); } else { uint16_t val; dev->bus->memread(dev->bus, addr, &val, sizeof(val)); return le16_to_cpu(val); }} |
0 | int avfilter_config_links(AVFilterContext *filter){ int (*config_link)(AVFilterLink *); unsigned i; int ret; for (i = 0; i < filter->nb_inputs; i ++) { AVFilterLink *link = filter->inputs[i]; AVFilterLink *inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL; if (!link) continue; link->current_pts = AV_NOPTS_VAL... |
0 | static inline void RENAME(bgr24ToY)(uint8_t *dst, uint8_t *src, long width){#ifdef HAVE_MMXasm volatile("mov %2, %%"REG_a"\n\t""movq "MANGLE(bgr2YCoeff)", %%mm6\n\t""movq "MANGLE(w1111)", %%mm5\n\t""pxor %%mm7, %%mm7\n\t""lea (%%"REG_a", %%"REG_a", 2), %%"REG_b"\n\t"ASMALIGN16"1:\n\t"PREFETCH" 64(%0, %%"REG_b")\n\t""mo... |
0 | static inline int decode_subframe(FLACContext *s, int channel){ int type, wasted = 0; int i, tmp; s->curr_bps = s->bps; if (channel == 0) { if (s->decorrelation == RIGHT_SIDE) s->curr_bps++; } else { if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE) s->curr_bps++; } if (s->curr_bps > 32) { ff_log_missi... |
0 | static void unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb){ int bit = 0; int current_superblock = 0; int current_run = 0; int decode_fully_flags = 0; int decode_partial_blocks = 0; int i, j; int current_fragment; debug_vp3(" vp3: unpacking superblock coding\n"); if (s->keyframe) { debug_vp3(" keyframe-- all... |
0 | static int svq1_decode_delta_block(MpegEncContext *s, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y){ uint32_t block_type; int result = 0; /* get block type */ block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); /* reset motion vectors */ if (block_type ==... |
0 | int ff_h263_decode_mb(MpegEncContext *s, DCTELEM block[6][64]){ int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; INT16 *mot_val; static INT8 quant_tab[4] = { -1, -2, 1, 2 }; s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0; if(s->mb_x==0) PRINT_MB_TYPE("\n"); if (s->pict_type == P_TYPE || s->pict_type==S_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.