label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size){ int size, i; uint8_t *ppcm[4] = { 0 }; if (buf_size < DV_PROFILE_BYTES || !(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) || buf_size < c->sys->frame_size) { return -1; /* Broken frame, or not enough data */ } /* Queu... |
1 | static void handle_event(int event){ static bool logged; if (event & ~PVPANIC_PANICKED && !logged) { qemu_log_mask(LOG_GUEST_ERROR, "pvpanic: unknown event %#x.\n", event); logged = true; } if (event & PVPANIC_PANICKED) { panicked_mon_event("pause"); vm_stop(RUN_STATE_GUEST_PANICKED); return; }} |
1 | static void *iothread_run(void *opaque){ IOThread *iothread = opaque; rcu_register_thread(); my_iothread = iothread; qemu_mutex_lock(&iothread->init_done_lock); iothread->thread_id = qemu_get_thread_id(); qemu_cond_signal(&iothread->init_done_cond); qemu_mutex_unlock(&iothread->init_done_lock); while (!atomic_read(&iot... |
1 | static void omap_rtc_write(void *opaque, hwaddr addr, uint64_t value, unsigned size){ struct omap_rtc_s *s = (struct omap_rtc_s *) opaque; int offset = addr & OMAP_MPUI_REG_MASK; struct tm new_tm; time_t ti[2]; if (size != 1) { return omap_badwidth_write8(opaque, addr, value); } switch (offset) { case 0x00:/* SECONDS_R... |
1 | static void neon_store_reg(int reg, int pass, TCGv var){ tcg_gen_st_i32(var, cpu_env, neon_reg_offset(reg, pass)); dead_tmp(var);} |
1 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start){ int b, prefixes, aflag, dflag; int shift, ot; int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val; target_ulong next_eip, tval; int rex_w, rex_r; if (unlikely(loglevel & CPU_LOG_TB_OP)) tcg_gen_debug_insn_start(pc_start); s->pc = pc_star... |
1 | static void align_position(AVIOContext *pb, int64_t offset, uint64_t size){ if (avio_tell(pb) != offset + size) avio_seek(pb, offset + size, SEEK_SET);} |
1 | static int usb_serial_handle_data(USBDevice *dev, USBPacket *p){ USBSerialState *s = (USBSerialState *)dev; int ret = 0; uint8_t devep = p->devep; uint8_t *data = p->data; int len = p->len; int first_len; switch (p->pid) { case USB_TOKEN_OUT: if (devep != 2) goto fail; qemu_chr_write(s->cs, data, len); break; case USB_... |
1 | void isa_register_portio_list(ISADevice *dev, uint16_t start, const MemoryRegionPortio *pio_start, void *opaque, const char *name){ PortioList piolist; /* START is how we should treat DEV, regardless of the actual contents of the portio array. This is how the old code actually handled e.g. the FDC device. */ isa_init_i... |
1 | static inline void write_mem(IVState *s, uint64_t off, const void *buf, size_t len){ QTestState *qtest = global_qtest; global_qtest = s->qtest; qpci_memwrite(s->dev, s->mem_base + off, buf, len); global_qtest = qtest;} |
1 | static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time){ QEMUTimer **pt, *t; qemu_del_timer(ts); /* add the timer in the sorted list */ /* NOTE: this code must be signal safe because qemu_timer_expired() can be called from a signal. */ pt = &active_timers[ts->clock->type]; for(;;) { t = *pt; if (!t) break; if... |
1 | static void co_read_response(void *opaque){ BDRVSheepdogState *s = opaque; if (!s->co_recv) { s->co_recv = qemu_coroutine_create(aio_read_response); } qemu_coroutine_enter(s->co_recv, opaque);} |
1 | static void omap2_inth_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; int offset = addr; int bank_no, line_no; struct omap_intr_handler_bank_s *bank = NULL; if ((offset & 0xf80) == 0x80) { bank_no = (offset & 0x60) >> 5... |
1 | static int decode_hextile(VmncContext *c, uint8_t* dst, uint8_t* src, int w, int h, int stride){ int i, j, k; int bg = 0, fg = 0, rects, color, flags, xy, wh; const int bpp = c->bpp2; uint8_t *dst2; int bw = 16, bh = 16; uint8_t *ssrc=src; for(j = 0; j < h; j += 16) { dst2 = dst; bw = 16; if(j + 16 > h) bh = h - j; for... |
0 | static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) { int i; int index_a = qp + h->slice_alpha_c0_offset; int alpha = (alpha_table+52)[index_a]; int beta = (beta_table+52)[qp + h->slice_beta_offset]; for( i = 0; i < 8; i++, pix += stride) { const int bS_index = ... |
0 | static void arm_idct_add(UINT8 *dest, int line_size, DCTELEM *block){ j_rev_dct_ARM (block); add_pixels_clamped(block, dest, line_size);} |
0 | static inline void decode_block_intra(MadContext * t, DCTELEM * block){ MpegEncContext *s = &t->s; int level, i, j, run; RLTable *rl = &ff_rl_mpeg1; const uint8_t *scantable = s->intra_scantable.permutated; int16_t *quant_matrix = s->intra_matrix; block[0] = (128 + get_sbits(&s->gb, 8)) * quant_matrix[0]; /* The RL dec... |
1 | static void test_ivshmem_memdev(void){ IVState state; /* just for the sake of checking memory-backend property */ setup_vm_cmd(&state, "-object memory-backend-ram,size=1M,id=mb1" " -device ivshmem,x-memdev=mb1", false); qtest_quit(state.qtest);} |
1 | static av_cold void init_static(void){ if (!huff_vlc[0].bits) { INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18, &ff_mlp_huffman_tables[0][0][1], 2, 1, &ff_mlp_huffman_tables[0][0][0], 2, 1, 512); INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16, &ff_mlp_huffman_tables[1][0][1], 2, 1, &ff_mlp_huffman_tables[1][0][0], 2, 1, 512); ... |
1 | void gen_pc_load(CPUState *env, TranslationBlock *tb, unsigned long searched_pc, int pc_pos, void *puc){ env->regs[15] = gen_opc_pc[pc_pos];} |
1 | void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req){ if (virtio_should_notify(vdev, req->vq)) { event_notifier_set(virtio_queue_get_guest_notifier(req->vq)); }} |
1 | 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 && 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 | int ide_init_drive(IDEState *s, BlockDriverState *bs, const char *version, const char *serial){ int cylinders, heads, secs; uint64_t nb_sectors; s->bs = bs; bdrv_get_geometry(bs, &nb_sectors); bdrv_guess_geometry(bs, &cylinders, &heads, &secs); if (cylinders < 1 || cylinders > 16383) { error_report("cyls must be betwee... |
1 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv, int unit, bool removable, int bootindex, const char *serial, Error **errp){ const char *driver; DeviceState *dev; Error *err = NULL; driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk"; dev = qdev_create(&bus->qbus, driver); qdev_prop_set_... |
1 | static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size){ QEMUFileSocket *s = opaque; ssize_t len; for (;;) { len = read(s->fd, buf, size); if (len != -1) { break; } if (errno == EAGAIN) { yield_until_fd_readable(s->fd); } else if (errno != EINTR) { break; } } if (len == -1) { len = -errno; } retur... |
1 | DriveInfo *add_init_drive(const char *optstr){ DriveInfo *dinfo; QemuOpts *opts; MachineClass *mc; opts = drive_def(optstr); if (!opts) return NULL; mc = MACHINE_GET_CLASS(current_machine); dinfo = drive_new(opts, mc->block_default_type); if (!dinfo) { qemu_opts_del(opts); return NULL; } return dinfo;} |
1 | static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){ const int index= size2index[log2h][log2w]; const int h= 1<<log2h; int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1); uint16_t *start= (uint16_t*)f->last_picture.da... |
0 | static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb, const char *name, const char *tag, int len){ AVDictionaryEntry *t = NULL; uint8_t num; if (!(t = av_dict_get(s->metadata, tag, NULL, 0))) return 0; num = t ? atoi(t->value) : 0; avio_wb32(pb, len+8); ffio_wfourcc(pb, name); if (len==4) avio_wb32(pb... |
0 | int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len){ unsigned int ssrc, h; int payload_type, seq, ret; AVStream *st; uint32_t timestamp; int rv= 0; if (!buf) { /* return the next packets, if any */ if(s->st && s->parse_packet) { timestamp= 0; ///< Should not be used if buf is NULL, but ... |
1 | static int decode_mb_info(IVI4DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx){ int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb, mv_scale, mb_type_bits, s; IVIMbInfo *mb, *ref_mb; int row_offset = band->mb_size * band->pitch; mb = tile->mbs; ref_mb = tile->ref_mbs; offs = tile->ypo... |
1 | static int balloon_parse(const char *arg){ QemuOpts *opts; if (strcmp(arg, "none") == 0) { return 0; } if (!strncmp(arg, "virtio", 6)) { if (arg[6] == ',') { /* have params -> parse them */ opts = qemu_opts_parse(qemu_find_opts("device"), arg+7, 0); if (!opts) return -1; } else { /* create empty opts */ opts = qemu_opt... |
1 | static inline void RENAME(yuv2yuvX)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW){#ifdef HAVE_MMXif(uDest != NULL){asm volatile(YSCALEYUV2YV12X(0, CHR_MMX_FILTER_OFFSE... |
0 | int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, uint8_t *buf, int buf_size){ int ret; if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){ //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough if(*fr... |
1 | static void nbd_co_receive_reply(NBDClientSession *s, NBDRequest *request, NBDReply *reply, QEMUIOVector *qiov){ int ret; /* Wait until we're woken up by nbd_read_reply_entry. */ qemu_coroutine_yield(); *reply = s->reply; if (reply->handle != request->handle || !s->ioc) { reply->error = EIO; } else { if (qiov && reply-... |
1 | static const char *local_mapped_attr_path(FsContext *ctx, const char *path, char *buffer){ char *dir_name; char *tmp_path = strdup(path); char *base_name = basename(tmp_path); /* NULL terminate the directory */ dir_name = tmp_path; *(base_name - 1) = '\0'; snprintf(buffer, PATH_MAX, "%s/%s/%s/%s", ctx->fs_root, dir_nam... |
1 | void usb_host_info(Monitor *mon, const QDict *qdict){ libusb_device **devs; struct libusb_device_descriptor ddesc; char port[16]; int i, n; if (usb_host_init() != 0) { return; } n = libusb_get_device_list(ctx, &devs); for (i = 0; i < n; i++) { if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) { continue; } if (dd... |
1 | static void gen_mulldo(DisasContext *ctx){ TCGv_i64 t0 = tcg_temp_new_i64(); TCGv_i64 t1 = tcg_temp_new_i64(); tcg_gen_muls2_i64(t0, t1, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]); tcg_gen_mov_i64(cpu_gpr[rD(ctx->opcode)], t0); tcg_gen_sari_i64(t0, t0, 63); tcg_gen_setcond_i64(TCG_COND_NE, cpu_ov, t0, t1); tcg... |
1 | static inline target_phys_addr_t get_pgaddr (target_phys_addr_t sdr1, int sdr_sh, target_phys_addr_t hash, target_phys_addr_t mask){ return (sdr1 & ((target_ulong)(-1ULL) << sdr_sh)) | (hash & mask);} |
1 | static unsigned int mszh_decomp(const unsigned char * srcptr, int srclen, unsigned char * destptr, unsigned int destsize){ unsigned char *destptr_bak = destptr; unsigned char *destptr_end = destptr + destsize; const unsigned char *srcptr_end = srcptr + srclen; unsigned mask = *srcptr++; unsigned maskbit = 0x80; while (... |
1 | static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr){#ifdef DEBUG_UNASSIGNED printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);#endif#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE) do_unassigned_access(addr, 0, 0, 0, 1);#endif return 0;} |
1 | static int mxg_update_cache(AVFormatContext *s, unsigned int cache_size){ MXGContext *mxg = s->priv_data; unsigned int current_pos = mxg->buffer_ptr - mxg->buffer; unsigned int soi_pos; int ret; /* reallocate internal buffer */ if (current_pos > current_pos + cache_size) return AVERROR(ENOMEM); soi_pos = mxg->soi_ptr -... |
1 | vubr_set_mem_table_exec(VubrDev *dev, VhostUserMsg *vmsg){ int i; VhostUserMemory *memory = &vmsg->payload.memory; dev->nregions = memory->nregions; DPRINT("Nregions: %d\n", memory->nregions); for (i = 0; i < dev->nregions; i++) { void *mmap_addr; VhostUserMemoryRegion *msg_region = &memory->regions[i]; VubrDevRegion *... |
0 | static av_cold int dilate_init(AVFilterContext *ctx, const char *args){ OCVContext *s = ctx->priv; DilateContext *dilate = s->priv; char default_kernel_str[] = "3x3+0x0/rect"; char *kernel_str; const char *buf = args; int ret; dilate->nb_iterations = 1; if (args) kernel_str = av_get_token(&buf, "|"); if ((ret = parse_i... |
0 | static int transcode(OutputFile *output_files, int nb_output_files, InputFile *input_files, int nb_input_files){ int ret = 0, i; AVFormatContext *is, *os; AVCodecContext *codec, *icodec; OutputStream *ost; InputStream *ist; char error[1024]; int key; int want_sdp = 1; uint8_t *no_packet; int no_packet_count=0; int64_t ... |
0 | static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ DVVideoContext *s = avctx->priv_data; /* special case for last picture */ if(buf_size==0) return 0; s->sys = dv_frame_profile(buf); if (!s->sys || buf_size < s->sys->frame_size) return -1; /* NOTE: we only ac... |
0 | rdt_parse_packet (PayloadContext *rdt, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, int flags){ int seq = 1, res; ByteIOContext pb; if (rdt->audio_pkt_cnt == 0) { int pos; init_put_byte(&pb, buf, len, 0, NULL, NULL, NULL, NULL); flags = (flags & PKT_FLAG_KEY) ? 2 : 0; res = ff_rm_parse... |
0 | static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride, int *beta, int *tc, uint8_t *no_p, uint8_t *no_q){ FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride, beta, tc, no_p, no_q);} |
0 | static int http_server(void){ int server_fd, ret, rtsp_server_fd, delay, delay1; struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry; HTTPContext *c, *c_next; server_fd = socket_open_listen(&my_http_addr); if (server_fd < 0) return -1; rtsp_server_fd = socket_open_listen(&my_rtsp_addr); if (rtsp_server_fd <... |
1 | static int h264_field_start(H264Context *h, const H264SliceContext *sl, const H2645NAL *nal, int first_slice){ int i; const SPS *sps; int last_pic_structure, last_pic_droppable, ret; ret = h264_init_ps(h, sl, first_slice); if (ret < 0) return ret; sps = h->ps.sps; last_pic_droppable = h->droppable; last_pic_structure =... |
1 | void fork_start(void){ mmap_fork_start(); qemu_mutex_lock(&tb_ctx.tb_lock); cpu_list_lock();} |
1 | static int config_output(AVFilterLink *outlink){ AVFilterContext *ctx = outlink->src; LIBVMAFContext *s = ctx->priv; AVFilterLink *mainlink = ctx->inputs[0]; int ret; outlink->w = mainlink->w; outlink->h = mainlink->h; outlink->time_base = mainlink->time_base; outlink->sample_aspect_ratio = mainlink->sample_aspect_rati... |
1 | void h263_encode_mb(MpegEncContext * s, DCTELEM block[6][64], int motion_x, int motion_y){ int cbpc, cbpy, i, cbp, pred_x, pred_y; // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); if (!s->mb_intra) { /* compute cbp */ cbp = 0; for (i = 0; i < 6; i++) { if (s->block_last_index[i] >= 0) cbp |= 1 << (5 - i); } if ((cbp | ... |
0 | static int decode_band(IVI5DecContext *ctx, int plane_num, IVIBandDesc *band, AVCodecContext *avctx){ int result, i, t, idx1, idx2; IVITile *tile; band->buf = band->bufs[ctx->dst_buf]; band->ref_buf = band->bufs[ctx->ref_buf]; band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3); result = decode_band_hdr(... |
1 | static int select_reference_stream(AVFormatContext *s){ SegmentContext *seg = s->priv_data; int ret, i; seg->reference_stream_index = -1; if (!strcmp(seg->reference_stream_specifier, "auto")) { /* select first index of type with highest priority */ int type_index_map[AVMEDIA_TYPE_NB]; static const enum AVMediaType type... |
1 | static void property_get_tm(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp){ TMProperty *prop = opaque; Error *err = NULL; struct tm value; prop->get(obj, &value, &err); if (err) { goto out; } visit_start_struct(v, name, NULL, 0, &err); if (err) { goto out; } visit_type_int32(v, "tm_year", &value... |
1 | e1000e_write_lgcy_rx_descr(E1000ECore *core, uint8_t *desc, struct NetRxPkt *pkt, const E1000E_RSSInfo *rss_info, uint16_t length){ uint32_t status_flags, rss, mrq; uint16_t ip_id; struct e1000_rx_desc *d = (struct e1000_rx_desc *) desc; memset(d, 0, sizeof(*d)); assert(!rss_info->enabled); d->length = cpu_to_le16(leng... |
1 | void qemu_put_byte(QEMUFile *f, int v){ if (f->last_error) { return; } f->buf[f->buf_index] = v; f->bytes_xfer++; if (f->ops->writev_buffer) { add_to_iovec(f, f->buf + f->buf_index, 1); } f->buf_index++; if (f->buf_index == IO_BUF_SIZE) { qemu_fflush(f); }} |
1 | long do_rt_sigreturn(CPUX86State *env){ abi_ulong frame_addr; struct rt_sigframe *frame; sigset_t set; frame_addr = env->regs[R_ESP] - 4; trace_user_do_rt_sigreturn(env, frame_addr); if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; target_to_host_sigset(&set, &frame->uc.tuc_sigmask); set_sigmask... |
1 | unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur){ int i, n, r, bit; ElsRungNode *rung_node; if (ctx->err) return 0; /* decode unary prefix */ for (n = 0; n < ELS_EXPGOLOMB_LEN + 1; n++) if (ff_els_decode_bit(ctx, &ur->prefix_rung[n])) break; /* handle the error/overflow case */ if (ctx->err || n >= ... |
1 | static int sse_mb(MpegEncContext *s){ int w= 16; int h= 16; if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; if(w==16 && h==16) if(s->avctx->mb_cmp == FF_CMP_NSSE){ return s->dsp.nsse[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,... |
1 | static uint64_t alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, int n_start, int n_end, int *num, QCowL2Meta *m){ BDRVQcowState *s = bs->opaque; int l2_index, ret; uint64_t l2_offset, *l2_table, cluster_offset; int nb_clusters, i = 0; ret = get_cluster_table(bs, offset, &l2_table, &l2_offset, &l2_index); if... |
1 | static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4], const DVprofile *sys){ int size, chan, i, j, d, of, smpls, freq, quant, half_ch; uint16_t lc, rc; const uint8_t* as_pack; uint8_t *pcm, ipcm; as_pack = dv_extract_pack(frame, dv_audio_source); if (!as_pack) /* No audio ? */ return 0; smpls = as_pack[1] & 0x3... |
1 | static int transcode_init(void){ int ret = 0, i, j, k; AVFormatContext *oc; AVCodecContext *codec, *icodec; OutputStream *ost; InputStream *ist; char error[1024]; int want_sdp = 1; /* init framerate emulation */ for (i = 0; i < nb_input_files; i++) { InputFile *ifile = input_files[i]; if (ifile->rate_emu) for (j = 0; j... |
1 | static int get_aiff_header(AVFormatContext *s, int size, unsigned version){ AVIOContext *pb = s->pb; AVCodecParameters *par = s->streams[0]->codecpar; AIFFInputContext *aiff = s->priv_data; int exp; uint64_t val; int sample_rate; unsigned int num_frames; if (size & 1) size++; par->codec_type = AVMEDIA_TYPE_AUDIO; par->... |
1 | static void xen_init_pv(QEMUMachineInitArgs *args){ const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; X86CPU *cpu; CPUState *cs; DriveInfo *dinfo; int i; /* Initialize a du... |
1 | void signal_init(void){ struct sigaction act; int i; /* set all host signal handlers. ALL signals are blocked during the handlers to serialize them. */ sigfillset(&act.sa_mask); act.sa_flags = SA_SIGINFO; act.sa_sigaction = host_signal_handler; for(i = 1; i < NSIG; i++) {sigaction(i, &act, NULL); } memset(sigact_table,... |
1 | static inline void gen_bx(DisasContext *s, TCGv_i32 var){ s->is_jmp = DISAS_UPDATE; tcg_gen_andi_i32(cpu_R[15], var, ~1); tcg_gen_andi_i32(var, var, 1); store_cpu_field(var, thumb);} |
1 | static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, int buf_size, int *coded_samples, int *approx_nb_samples){ ADPCMDecodeContext *s = avctx->priv_data; int nb_samples = 0; int ch = avctx->channels; int has_coded_samples = 0; int header_size; *coded_samples = 0; *approx_nb_samples = 0; if(ch <= 0) retu... |
1 | static void serial_receive1(void *opaque, const uint8_t *buf, int size){ SerialState *s = opaque; serial_receive_byte(s, buf[0]);} |
0 | static TCGv_i32 gen_get_asi(DisasContext *dc, int insn){ int asi; if (IS_IMM) {#ifdef TARGET_SPARC64 asi = dc->asi;#else gen_exception(dc, TT_ILL_INSN); asi = 0;#endif } else { asi = GET_FIELD(insn, 19, 26); } return tcg_const_i32(asi);} |
0 | static void setup_rt_frame(int sig, struct target_sigaction *ka, target_siginfo_t *info, target_sigset_t *set, CPUSH4State *regs){ struct target_rt_sigframe *frame; abi_ulong frame_addr; int i; int err = 0; int signal; frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame)); if (!lock_user_struct(VERIFY_WRITE, f... |
0 | static void display_mouse_set(DisplayChangeListener *dcl, int x, int y, int on){ SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl); qemu_mutex_lock(&ssd->lock); ssd->ptr_x = x; ssd->ptr_y = y; if (ssd->ptr_move) { g_free(ssd->ptr_move); } ssd->ptr_move = qemu_spice_create_cursor_update(ssd, NULL, on)... |
0 | static void cpu_request_exit(void *opaque, int irq, int level){ CPUState *cpu = current_cpu; if (cpu && level) { cpu_exit(cpu); }} |
0 | int qemu_get_thread_id(void){#if defined (__linux__) return syscall(SYS_gettid);#else return getpid();#endif} |
0 | static void listflags(char *buf, int bufsize, uint32_t fbits, const char **featureset, uint32_t flags){ const char **p = &featureset[31]; char *q, *b, bit; int nc; b = 4 <= bufsize ? buf + (bufsize -= 3) - 1 : NULL; *buf = '\0'; for (q = buf, bit = 31; fbits && bufsize; --p, fbits &= ~(1 << bit), --bit) if (fbits & 1 <... |
0 | void watchdog_add_model(WatchdogTimerModel *model){ LIST_INSERT_HEAD(&watchdog_list, model, entry);} |
0 | static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){ int x, y, i; const int ring_size = s->avctx->context_model ? 3 : 2; int16_t *sample[3]; s->run_index = 0; memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer)); for (y = 0; y < h; y++) { for (i = 0;... |
0 | static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, const uint8_t *data, int32_t data_size, int32_t strip_width){ Cell curr_cell; int num_vectors; /* each plane data starts with mc_vector_count field, */ /* an optional array of motion vectors followed by the vq data */ num_vectors = b... |
0 | int qemu_savevm_state_iterate(QEMUFile *f){ SaveStateEntry *se; int ret = 1; TAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; /* Section type */ qemu_put_byte(f, QEMU_VM_SECTION_PART); qemu_put_be32(f, se->section_id); ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaq... |
0 | static void qmp_cleanup(void *datap){ QmpSerializeData *d = datap; visit_free(qmp_output_get_visitor(d->qov)); visit_free(d->qiv); g_free(d);} |
0 | void parse_numa_opts(MachineClass *mc){ int i; if (qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, NULL, NULL)) { exit(1); } assert(max_numa_nodeid <= MAX_NODES); /* No support for sparse NUMA node IDs yet: */ for (i = max_numa_nodeid - 1; i >= 0; i--) { /* Report large node IDs first, to make mistakes easier to ... |
0 | static inline uint8_t *bt_hci_event_start(struct bt_hci_s *hci, int evt, int len){ uint8_t *packet, mask; int mask_byte; if (len > 255) { fprintf(stderr, "%s: HCI event params too long (%ib)\n", __FUNCTION__, len); exit(-1); } mask_byte = (evt - 1) >> 3; mask = 1 << ((evt - 1) & 3); if (mask & bt_event_reserved_mask[ma... |
0 | uint64_t helper_efdctsidz (uint64_t val){ CPU_DoubleU u; u.ll = val; /* NaN are not treated the same way IEEE 754 does */ if (unlikely(float64_is_nan(u.d))) return 0; return float64_to_int64_round_to_zero(u.d, &env->vec_status);} |
0 | static int kvm_has_msr_star(CPUState *env){ kvm_supported_msrs(env); return has_msr_star;} |
0 | int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence){ if (whence == SEEK_SET) { /* nothing to do */ } else if (whence == SEEK_CUR) { pos += qemu_ftell(f); } else { /* SEEK_END not supported */ return -1; } if (f->is_writable) { qemu_fflush(f); f->buf_offset = pos; } else { f->buf_offset = pos; f->buf_index = 0; f->... |
0 | static void qbus_list_dev(BusState *bus, char *dest, int len){ DeviceState *dev; const char *sep = " "; int pos = 0; pos += snprintf(dest+pos, len-pos, "devices at \"%s\":", bus->name); LIST_FOREACH(dev, &bus->children, sibling) { pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, dev->info->name); if (dev->id) pos +=... |
0 | void vnc_zlib_zfree(void *x, void *addr){ qemu_free(addr);} |
0 | static target_ulong h_put_term_char(CPUState *env, sPAPREnvironment *spapr, target_ulong opcode, target_ulong *args){ target_ulong reg = args[0]; target_ulong len = args[1]; target_ulong char0_7 = args[2]; target_ulong char8_15 = args[3]; VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); uint8_t buf[16... |
0 | static void thread_pool_co_cb(void *opaque, int ret){ ThreadPoolCo *co = opaque; co->ret = ret; qemu_coroutine_enter(co->co);} |
0 | static int qemu_balloon(ram_addr_t target){ if (!balloon_event_fn) { return 0; } trace_balloon_event(balloon_opaque, target); balloon_event_fn(balloon_opaque, target); return 1;} |
0 | static bool cmd_write_dma(IDEState *s, uint8_t cmd){ bool lba48 = (cmd == WIN_WRITEDMA_EXT); if (!s->bs) { ide_abort_command(s); return true; } ide_cmd_lba48_transform(s, lba48); ide_sector_start_dma(s, IDE_DMA_WRITE); s->media_changed = 1; return false;} |
0 | static uint64_t pxa2xx_pm_read(void *opaque, hwaddr addr, unsigned size){ PXA2xxState *s = (PXA2xxState *) opaque; switch (addr) { case PMCR ... PCMD31: if (addr & 3) goto fail; return s->pm_regs[addr >> 2]; default: fail: printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); break; } return 0;} |
0 | static void ics_base_realize(DeviceState *dev, Error **errp){ ICSStateClass *icsc = ICS_BASE_GET_CLASS(dev); ICSState *ics = ICS_BASE(dev); Object *obj; Error *err = NULL; obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err); if (!obj) { error_setg(errp, "%s: required link '" ICS_PROP_XICS "' not found: %s"... |
0 | bool postcopy_ram_supported_by_host(void){ error_report("%s: No OS support", __func__); return false;} |
1 | int64_t qemu_file_get_rate_limit(QEMUFile *f){ return f->xfer_limit;} |
1 | static inline void put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb, int entry){ assert(entry >= 0); assert(entry < cb->nentries); assert(cb->lens[entry]); put_bits(pb, cb->lens[entry], cb->codewords[entry]);} |
1 | static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma, uint64_t offset, uint64_t len){ RDMALocalBlock *block; uint8_t *host_addr; uint8_t *chunk_end; if (rdma->current_index < 0) { return 0; } if (rdma->current_chunk < 0) { return 0; } block = &(rdma->local_ram_blocks.block[rdma->current_index]); host_addr = bl... |
1 | static int vmdk_open_desc_file(BlockDriverState *bs, int flags, int64_t desc_offset){ int ret; char buf[2048]; char ct[128]; BDRVVmdkState *s = bs->opaque; ret = bdrv_pread(bs->file, desc_offset, buf, sizeof(buf)); if (ret < 0) { return ret; } buf[2047] = '\0'; if (vmdk_parse_description(buf, "createType", ct, sizeof(c... |
1 | static void vc1_mc_4mv_chroma(VC1Context *v, int dir){ MpegEncContext *s = &v->s; H264ChromaContext *h264chroma = &v->h264chroma; uint8_t *srcU, *srcV; int uvmx, uvmy, uvsrc_x, uvsrc_y; int k, tx = 0, ty = 0; int mvx[4], mvy[4], intra[4], mv_f[4]; int valid_count; int chroma_ref_type = v->cur_field_type; int v_edge_pos... |
1 | void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette){unsigned i;/*writes 1 byte o much and might cause alignment issues on some architectures?for(i=0; i<num_pixels; i++)((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];*/for(i=0; i<num_pixels; i++){//FIXME slow?d... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.