label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static int parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers){ int i; HEVCLocalContext *lc = s->HEVClc; GetBitContext *gb = &lc->gb; decode_profile_tier_level(s, &ptl->general_PTL); ptl->general_PTL.level_idc = get_bits(gb, 8); for (i = 0; i < max_num_sub_layers - 1; i++) { ptl->sub_layer_profile_present_flag[... |
0 | static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, int n, int coded, const uint8_t *scan_table){ int level, i, last, run, run_diff; int dc_pred_dir; RLTable *rl; RL_VLC_ELEM *rl_vlc; int qmul, qadd; if (s->mb_intra) { qmul=1; qadd=0;/* DC coef */ set_stat(ST_DC); level = msmpeg4_decode_dc(s, n,... |
0 | static void ff_h264_idct8_add4_mmx2(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){ int i; for(i=0; i<16; i+=4){ int nnz = nnzc[ scan8[i] ]; if(nnz){ if(nnz==1 && block[i*16]) ff_h264_idct8_dc_add_mmx2(dst + block_offset[i], block + i*16, stride); else ff_h264_idct8_add_mmx ... |
0 | static void filter_channel(MLPDecodeContext *m, unsigned int substr, unsigned int channel){ SubStream *s = &m->substream[substr]; int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER]; int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER]; FilterParams *fir = &m->channel_params[channel].filter_params[FIR]; FilterParams *iir = &m->chan... |
0 | static void update(Real288_internal *glob){ float buffer1[40], temp1[37]; float buffer2[8], temp2[11]; memcpy(buffer1 , glob->output + 20, 20*sizeof(*buffer1)); memcpy(buffer1 + 20, glob->output , 20*sizeof(*buffer1)); do_hybrid_window(36, 40, 35, buffer1, temp1, glob->st1a, glob->st1b, syn_window); if (eval_lpc_coeffs... |
1 | static void fw_cfg_data_mem_write(void *opaque, hwaddr addr, uint64_t value, unsigned size){ FWCfgState *s = opaque; uint8_t buf[8]; unsigned i; switch (size) { case 1: buf[0] = value; break; case 2: stw_he_p(buf, value); break; case 4: stl_he_p(buf, value); break; case 8: stq_he_p(buf, value); break; default: abort();... |
1 | static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, const uint8_t *buf, int buf_size, int first_field){ static const uint8_t header_prefix[] = { 0x00, 0x00, 0x02, 0x80, 0x01 }; static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 }; static const uint8_t header_prefixhr1[] = { 0x00, 0x0... |
1 | static void raw_aio_writev_scrubbed(void *opaque, int ret){ RawScrubberBounce *b = opaque; if (ret < 0) { b->cb(b->opaque, ret); } else { b->cb(b->opaque, ret + 512); } qemu_iovec_destroy(&b->qiov); qemu_free(b);} |
1 | static inline uint32_t mipsdsp_sat32_sub(int32_t a, int32_t b, CPUMIPSState *env){ int32_t temp; temp = a - b; if (MIPSDSP_OVERFLOW(a, -b, temp, 0x80000000)) { if (a > 0) { temp = 0x7FFFFFFF; } else { temp = 0x80000000; } set_DSPControl_overflow_flag(1, 20, env); } return temp & 0xFFFFFFFFull;} |
0 | int avconv_parse_options(int argc, char **argv){ OptionParseContext octx; uint8_t error[128]; int ret; memset(&octx, 0, sizeof(octx)); /* split the commandline into an internal representation */ ret = split_commandline(&octx, argc, argv, options, groups); if (ret < 0) { av_log(NULL, AV_LOG_FATAL, "Error splitting the a... |
0 | static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len){ unsigned int ssrc, h; int payload_type, seq, ret, flags = 0; int ext; AVStream *st; uint32_t timestamp; int rv= 0; ext = buf[0] & 0x10; payload_type = buf[1] & 0x7f; if (buf[1] & 0x80) flags |= RTP_FLAG_MARKER; seq = A... |
1 | static inline void scale_mv(AVSContext *h, int *d_x, int *d_y, cavs_vector *src, int distp){ int den = h->scale_den[FFMAX(src->ref, 0)]; *d_x = (src->x * distp * den + 256 + FF_SIGNBIT(src->x)) >> 9; *d_y = (src->y * distp * den + 256 + FF_SIGNBIT(src->y)) >> 9;} |
1 | static int kvm_get_xsave(CPUState *env){#ifdef KVM_CAP_XSAVE struct kvm_xsave* xsave; int ret, i; uint16_t cwd, swd, twd, fop; if (!kvm_has_xsave()) { return kvm_get_fpu(env); } xsave = qemu_memalign(4096, sizeof(struct kvm_xsave)); ret = kvm_vcpu_ioctl(env, KVM_GET_XSAVE, xsave); if (ret < 0) { qemu_free(xsave); retur... |
1 | int qemu_acl_insert(qemu_acl *acl, int deny, const char *match, int index){ qemu_acl_entry *entry; qemu_acl_entry *tmp; int i = 0; if (index <= 0) return -1; if (index > acl->nentries) { return qemu_acl_append(acl, deny, match); } entry = g_malloc(sizeof(*entry)); entry->match = g_strdup(match); entry->deny = deny; QTA... |
1 | PPC_OP(subfc){ T0 = T1 - T0; if (T0 <= T1) { xer_ca = 1; } else { xer_ca = 0; } RETURN();} |
1 | static uint16_t nvme_rw(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd, NvmeRequest *req){ NvmeRwCmd *rw = (NvmeRwCmd *)cmd; uint32_t nlb = le32_to_cpu(rw->nlb) + 1; uint64_t slba = le64_to_cpu(rw->slba); uint64_t prp1 = le64_to_cpu(rw->prp1); uint64_t prp2 = le64_to_cpu(rw->prp2); uint8_t lba_index = NVME_ID_NS_FLBAS_IN... |
1 | uint64_t HELPER(neon_sub_saturate_u64)(uint64_t src1, uint64_t src2){ uint64_t res; if (src1 < src2) { env->QF = 1; res = 0; } else { res = src1 - src2; } return res;} |
1 | void memory_global_sync_dirty_bitmap(MemoryRegion *address_space){ AddressSpace *as = memory_region_to_address_space(address_space); FlatRange *fr; FOR_EACH_FLAT_RANGE(fr, &as->current_map) { MEMORY_LISTENER_UPDATE_REGION(fr, as, Forward, log_sync); }} |
1 | static int lvf_probe(AVProbeData *p){ if (AV_RL32(p->buf) == MKTAG('L', 'V', 'F', 'F')) return AVPROBE_SCORE_EXTENSION; return 0;} |
1 | static inline int decode_subframe(FLACContext *s, int channel){ int32_t *decoded = s->decoded[channel]; int type, wasted = 0; int bps = s->flac_stream_info.bps; int i, tmp, ret; if (channel == 0) { if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) bps++; } else { if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CH... |
1 | static void icp_set_cppr(struct icp_state *icp, int server, uint8_t cppr){ struct icp_server_state *ss = icp->ss + server; uint8_t old_cppr; uint32_t old_xisr; old_cppr = CPPR(ss); ss->xirr = (ss->xirr & ~CPPR_MASK) | (cppr << 24); if (cppr < old_cppr) { if (XISR(ss) && (cppr <= ss->pending_priority)) { old_xisr = XISR... |
1 | static av_cold int opus_decode_init(AVCodecContext *avctx){ OpusContext *c = avctx->priv_data; int ret, i, j; avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; avctx->sample_rate = 48000; c->fdsp = avpriv_float_dsp_alloc(0); if (!c->fdsp) return AVERROR(ENOMEM); /* find out the channel configuration */ ret = ff_opus_parse_extrad... |
1 | static void nvme_rw_cb(void *opaque, int ret){ NvmeRequest *req = opaque; NvmeSQueue *sq = req->sq; NvmeCtrl *n = sq->ctrl; NvmeCQueue *cq = n->cq[sq->cqid]; block_acct_done(blk_get_stats(n->conf.blk), &req->acct); if (!ret) { req->status = NVME_SUCCESS; } else { req->status = NVME_INTERNAL_DEV_ERROR; } if (req->has_sg... |
1 | int find_itlb_entry(CPUState * env, target_ulong address, int use_asid, int update){ int e, n; e = find_tlb_entry(env, address, env->itlb, ITLB_SIZE, use_asid); if (e == MMU_DTLB_MULTIPLE)e = MMU_ITLB_MULTIPLE; else if (e == MMU_DTLB_MISS && update) {e = find_tlb_entry(env, address, env->utlb, UTLB_SIZE, use_asid);if (... |
1 | static void s390_msi_ctrl_write(void *opaque, hwaddr addr, uint64_t data, unsigned int size){ S390PCIBusDevice *pbdev; uint32_t io_int_word; uint32_t fid = data >> ZPCI_MSI_VEC_BITS; uint32_t vec = data & ZPCI_MSI_VEC_MASK; uint64_t ind_bit; uint32_t sum_bit; uint32_t e = 0; DPRINTF("write_msix data 0x%" PRIx64 " fid %... |
1 | void net_slirp_redir(const char *redir_str){ struct slirp_config_str *config; if (QTAILQ_EMPTY(&slirp_stacks)) { config = qemu_malloc(sizeof(*config)); pstrcpy(config->str, sizeof(config->str), redir_str); config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY; config->next = slirp_configs; slirp_configs = config; return... |
1 | static unsigned int get_video_format_idx(AVCodecContext *avctx){ unsigned int ret_idx = 0; unsigned int idx; unsigned int num_formats = sizeof(ff_schro_video_format_info) / sizeof(ff_schro_video_format_info[0]); for (idx = 1; idx < num_formats; ++idx) { const SchroVideoFormatInfo *vf = &ff_schro_video_format_info[idx];... |
0 | static void compute_pts_dts(AVStream *st, int64_t *ppts, int64_t *pdts, int64_t timestamp){ int frame_delay; int64_t pts, dts; if (st->codec.codec_type == CODEC_TYPE_VIDEO && st->codec.max_b_frames != 0) { frame_delay = (st->codec.frame_rate_base * 90000LL) / st->codec.frame_rate; if (timestamp == 0) { /* specific case... |
0 | static void close_connection(HTTPContext *c){ HTTPContext **cp, *c1; int i, nb_streams; AVFormatContext *ctx; URLContext *h; AVStream *st; /* remove connection from list */ cp = &first_http_ctx; while ((*cp) != NULL) { c1 = *cp; if (c1 == c) { *cp = c->next; } else { cp = &c1->next; } } /* remove references, if any (XX... |
1 | static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2){ MpegEncContext *s = avctx->priv_data; int mb_count, mb_pos, left, start_mb_x; init_get_bits(&s->gb, buf, buf_size*8); if(s->codec_id ==CODEC_ID_RV10) mb_count = rv10_decode_picture_header(s); else mb_count = rv20_deco... |
1 | static void video_encode_example(const char *filename, int codec_id){ AVCodec *codec; AVCodecContext *c= NULL; int i, ret, x, y, got_output; FILE *f; AVFrame *picture; AVPacket pkt; uint8_t endcode[] = { 0, 0, 1, 0xb7 }; printf("Encode video file %s\n", filename); /* find the mpeg1 video encoder */ codec = avcodec_find... |
1 | static void usb_host_handle_reset(USBDevice *udev){ USBHostDevice *s = USB_HOST_DEVICE(udev); trace_usb_host_reset(s->bus_num, s->addr); if (udev->configuration == 0) { return; } usb_host_release_interfaces(s); libusb_reset_device(s->dh); usb_host_claim_interfaces(s, 0); usb_host_ep_update(s);} |
1 | static int matroska_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags){ MatroskaDemuxContext *matroska = s->priv_data; MatroskaTrack *tracks = matroska->tracks.elem; AVStream *st = s->streams[stream_index]; int i, index, index_sub, index_min; /* Parse the CUES now since we need the index data... |
1 | static int mp_pacl_setxattr(FsContext *ctx, const char *path, const char *name, void *value, size_t size, int flags){ char *buffer; int ret; buffer = rpath(ctx, path); ret = lsetxattr(buffer, MAP_ACL_ACCESS, value, size, flags); g_free(buffer); return ret;} |
1 | static inline void qemu_assert(int cond, const char *msg){ if (!cond) { fprintf (stderr, "badness: %s\n", msg); abort(); }} |
1 | static inline int pic_is_unused(MpegEncContext *s, Picture *pic){ if (pic->f.buf[0] == NULL) return 1; if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF)) return 1; return 0;} |
1 | static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, int64_t offset, unsigned int bytes, QEMUIOVector *qiov, BdrvRequestFlags flags){ BdrvTrackedRequest req; /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); uint8_t *head_buf... |
0 | static void vmd_decode(VmdVideoContext *s){ int i; unsigned int *palette32; unsigned char r, g, b; /* point to the start of the encoded data */ unsigned char *p = s->buf + 16; unsigned char *pb; unsigned char meth; unsigned char *dp; /* pointer to current frame */ unsigned char *pp; /* pointer to previous frame */ unsi... |
1 | static int oss_ctl_in (HWVoiceIn *hw, int cmd, ...){ OSSVoiceIn *oss = (OSSVoiceIn *) hw; switch (cmd) { case VOICE_ENABLE: { va_list ap; int poll_mode; va_start (ap, cmd); poll_mode = va_arg (ap, int); va_end (ap); if (poll_mode && oss_poll_in (hw)) { poll_mode = 0; } hw->poll_mode = poll_mode; } break; case VOICE_DIS... |
1 | static int parse_uint32(DeviceState *dev, Property *prop, const char *str){ uint32_t *ptr = qdev_get_prop_ptr(dev, prop); const char *fmt; /* accept both hex and decimal */ fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx32 : "%" PRIu32; if (sscanf(str, fmt, ptr) != 1) return -EINVAL; return 0;} |
1 | void OPPROTO op_lmsw_T0(void){ /* only 4 lower bits of CR0 are modified */ T0 = (env->cr[0] & ~0xf) | (T0 & 0xf); helper_movl_crN_T0(0);} |
1 | static int slirp_guestfwd(SlirpState *s, const char *config_str, int legacy_format){ struct in_addr server = { .s_addr = 0 }; struct GuestFwd *fwd; const char *p; char buf[128]; char *end; int port; p = config_str; if (legacy_format) { if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) { goto fail_syntax; } } else { if (g... |
1 | void visit_start_list(Visitor *v, const char *name, Error **errp){ if (!error_is_set(errp)) { v->start_list(v, name, errp); }} |
0 | static void av_always_inline filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h) { const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8); const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset; const int alpha = alpha_table[index_a]; const int beta = be... |
0 | static int decode_info_header(NUTContext *nut){ AVFormatContext *s = nut->avf; AVIOContext *bc = s->pb; uint64_t tmp, chapter_start, chapter_len; unsigned int stream_id_plus1, count; int chapter_id, i; int64_t value, end; char name[256], str_value[1024], type_str[256]; const char *type; int *event_flags; AVChapter *cha... |
0 | static void mp3_update_xing(AVFormatContext *s){ MP3Context *mp3 = s->priv_data; int i; /* replace "Xing" identification string with "Info" for CBR files. */ if (!mp3->has_variable_bitrate) { avio_seek(s->pb, mp3->xing_offset, SEEK_SET); ffio_wfourcc(s->pb, "Info"); } avio_seek(s->pb, mp3->xing_offset + 8, SEEK_SET); a... |
1 | static void sh7750_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t mem_value){ SH7750State *s = opaque; uint16_t temp; switch (addr) {/* SDRAM controller */ case SH7750_BCR1_A7: case SH7750_BCR4_A7: case SH7750_WCR1_A7: case SH7750_WCR2_A7: case SH7750_WCR3_A7: case SH7750_MCR_A7:ignore_access("long write", ... |
1 | int nbd_receive_negotiate(QIOChannel *ioc, const char *name, QCryptoTLSCreds *tlscreds, const char *hostname, QIOChannel **outioc, NBDExportInfo *info, Error **errp){ char buf[256]; uint64_t magic; int rc; bool zeroes = true; trace_nbd_receive_negotiate(tlscreds, hostname ? hostname : "<null>"); rc = -EINVAL; if (outio... |
1 | static int check_refcounts_l1(BlockDriverState *bs, uint16_t *refcount_table, int refcount_table_size, int64_t l1_table_offset, int l1_size, int check_copied){ BDRVQcowState *s = bs->opaque; uint64_t *l1_table, l2_offset, l1_size2; int i, refcount, ret; int errors = 0; l1_size2 = l1_size * sizeof(uint64_t); /* Mark L1 ... |
1 | static void mpeg_decode_sequence_extension(MpegEncContext *s){ int horiz_size_ext, vert_size_ext; int bit_rate_ext, vbv_buf_ext, low_delay; int frame_rate_ext_n, frame_rate_ext_d; skip_bits(&s->gb, 8); /* profil and level */ skip_bits(&s->gb, 1); /* progressive_sequence */ skip_bits(&s->gb, 2); /* chroma_format */ hori... |
1 | static void do_audio_out(AVFormatContext *s, OutputStream *ost, AVFrame *frame){ AVCodecContext *enc = ost->enc_ctx; AVPacket pkt; int got_packet = 0; av_init_packet(&pkt); pkt.data = NULL; pkt.size = 0; if (!check_recording_time(ost)) return; if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0) frame->pts = ost-... |
1 | static void put_int16(QEMUFile *f, void *pv, size_t size){ int16_t *v = pv; qemu_put_sbe16s(f, v);} |
1 | static void rtas_set_tce_bypass(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ VIOsPAPRBus *bus = spapr->vio_bus; VIOsPAPRDevice *dev; uint32_t unit, enable; if (nargs != 2) { rtas_st(rets, 0, -3); return; } unit = rtas_ld(args, 0); enable = rtas_ld(args, ... |
1 | static int vp3_decode_end(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; int i; av_free(s->superblock_coding); av_free(s->all_fragments); av_free(s->coeffs); av_free(s->coded_fragment_list); av_free(s->superblock_fragments); av_free(s->superblock_macroblocks); av_free(s->macroblock_fragments); av_free(... |
1 | static uint32_t timer_int_route(struct HPETTimer *timer){ uint32_t route; route = (timer->config & HPET_TN_INT_ROUTE_MASK) >> HPET_TN_INT_ROUTE_SHIFT; return route;} |
0 | static int virtio_net_load_device(VirtIODevice *vdev, QEMUFile *f, int version_id){ VirtIONet *n = VIRTIO_NET(vdev); int i, link_down; qemu_get_buffer(f, n->mac, ETH_ALEN); n->vqs[0].tx_waiting = qemu_get_be32(f); virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f), virtio_has_feature(vdev, VIRTIO_F_VERSION_1)); if (version... |
0 | static inline void t_gen_mov_preg_TN(DisasContext *dc, int r, TCGv tn){if (r < 0 || r > 15)fprintf(stderr, "wrong register write $p%d\n", r);if (r == PR_BZ || r == PR_WZ || r == PR_DZ)return;else if (r == PR_SRS)tcg_gen_andi_tl(cpu_PR[r], tn, 3);else {if (r == PR_PID) tcg_gen_helper_0_1(helper_tlb_flush_pid, tn);if (dc... |
0 | void stl_phys_notdirty(AddressSpace *as, hwaddr addr, uint32_t val){ uint8_t *ptr; MemoryRegion *mr; hwaddr l = 4; hwaddr addr1; mr = address_space_translate(as, addr, &addr1, &l, true); if (l < 4 || !memory_access_is_direct(mr, true)) { io_mem_write(mr, addr1, val, 4); } else { addr1 += memory_region_get_ram_addr(mr) ... |
0 | static void tty_serial_init(int fd, int speed, int parity, int data_bits, int stop_bits){ struct termios tty; speed_t spd;#if 0 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n", speed, parity, data_bits, stop_bits);#endif tcgetattr (fd, &tty); oldtty = tty;#define check_speed(val) if (speed <= val) { spd ... |
0 | BlockBackend *blk_new_with_bs(Error **errp){ BlockBackend *blk; BlockDriverState *bs; blk = blk_new(errp); if (!blk) { return NULL; } bs = bdrv_new_root(); blk->root = bdrv_root_attach_child(bs, "root", &child_root); blk->root->opaque = blk; bs->blk = blk; return blk;} |
0 | static void *source_return_path_thread(void *opaque){ MigrationState *ms = opaque; QEMUFile *rp = ms->rp_state.from_dst_file; uint16_t header_len, header_type; const int max_len = 512; uint8_t buf[max_len]; uint32_t tmp32, sibling_error; ram_addr_t start = 0; /* =0 to silence warning */ size_t len = 0, expected_len; in... |
0 | static int bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVQEDState *s = bs->opaque; QEDHeader le_header; int64_t file_size; int ret; s->bs = bs; qemu_co_queue_init(&s->allocating_write_reqs); ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header)); if (ret < 0) { return ret; }... |
0 | static void put_pixels_x2_mmx(UINT8 *block, const UINT8 *pixels, int line_size, int h){#if 0 UINT8 *p; const UINT8 *pix; p = block; pix = pixels; MOVQ_ZERO(mm7); MOVQ_WONE(mm4); JUMPALIGN(); do { __asm __volatile("movq%1, %%mm0\n\t""movq1%1, %%mm1\n\t""movq%%mm0, %%mm2\n\t""movq%%mm1, %%mm3\n\t""punpcklbw %%mm7, %%mm0\... |
0 | static void pc_dimm_post_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ PCMachineState *pcms = PC_MACHINE(hotplug_dev); if (object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)) { nvdimm_acpi_hotplug(&pcms->acpi_nvdimm_state); }} |
0 | static VFIOINTp *vfio_init_intp(VFIODevice *vbasedev, struct vfio_irq_info info){ int ret; VFIOPlatformDevice *vdev = container_of(vbasedev, VFIOPlatformDevice, vbasedev); SysBusDevice *sbdev = SYS_BUS_DEVICE(vdev); VFIOINTp *intp; intp = g_malloc0(sizeof(*intp)); intp->vdev = vdev; intp->pin = info.index; intp->flags ... |
0 | static void set_guest_connected(VirtIOSerialPort *port, int guest_connected){ VirtConsole *vcon = VIRTIO_CONSOLE(port); if (!vcon->chr) { return; } qemu_chr_fe_set_open(vcon->chr, guest_connected);} |
0 | static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo){ BDRVRawState *s = bs->opaque; if (s->offset || s->has_size) { return -ENOTSUP; } return bdrv_probe_geometry(bs->file->bs, geo);} |
0 | static void empty_slot_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ DPRINTF("write 0x%x to " TARGET_FMT_plx "\n", (unsigned)val, addr);} |
0 | static int nbd_co_readv_1(NbdClientSession *client, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int offset){ struct nbd_request request = { .type = NBD_CMD_READ }; struct nbd_reply reply; ssize_t ret; request.from = sector_num * 512; request.len = nb_sectors * 512; nbd_coroutine_start(client, &request); ret... |
0 | static void *legacy_s390_alloc(size_t size){ void *mem; mem = mmap((void *) 0x800000000ULL, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, -1, 0); return mem == MAP_FAILED ? NULL : mem;} |
0 | static CharDriverState *chr_open(const char *subtype, void (*set_fe_open)(struct CharDriverState *, int)){ CharDriverState *chr; SpiceCharDriver *s; chr = g_malloc0(sizeof(CharDriverState)); s = g_malloc0(sizeof(SpiceCharDriver)); s->chr = chr; s->active = false; s->sin.subtype = g_strdup(subtype); chr->opaque = s; chr... |
0 | static void do_drive_backup(const char *job_id, const char *device, const char *target, bool has_format, const char *format, enum MirrorSyncMode sync, bool has_mode, enum NewImageMode mode, bool has_speed, int64_t speed, bool has_bitmap, const char *bitmap, bool has_on_source_error, BlockdevOnError on_source_error, boo... |
0 | static int advanced_decode_i_mbs(VC9Context *v){ int i, x, y, cbpcy, mqdiff, absmq, mquant, ac_pred, condover, current_mb = 0, over_flags_mb = 0; for (y=0; y<v->height_mb; y++) { for (x=0; x<v->width_mb; x++) { if (v->ac_pred_plane[i]) ac_pred = get_bits(&v->gb, 1); if (condover == 3 && v->over_flags_plane) over_flags_... |
0 | static int coroutine_fn cow_read(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, int nb_sectors){ BDRVCowState *s = bs->opaque; int ret, n; while (nb_sectors > 0) { ret = cow_co_is_allocated(bs, sector_num, nb_sectors, &n); if (ret < 0) { return ret; } if (ret) { ret = bdrv_pread(bs->file, s->cow_sectors_offset... |
0 | static void migration_end(void){ if (migration_bitmap) { memory_global_dirty_log_stop(); g_free(migration_bitmap); migration_bitmap = NULL; } XBZRLE_cache_lock(); if (XBZRLE.cache) { cache_fini(XBZRLE.cache); g_free(XBZRLE.encoded_buf); g_free(XBZRLE.current_buf); XBZRLE.cache = NULL; XBZRLE.encoded_buf = NULL; XBZRLE.... |
0 | static unsigned int dec_btst_r(DisasContext *dc){TCGv l0;DIS(fprintf (logfile, "btst $r%u, $r%u\n", dc->op1, dc->op2));cris_cc_mask(dc, CC_MASK_NZ);l0 = tcg_temp_local_new(TCG_TYPE_TL);cris_alu(dc, CC_OP_BTST, l0, cpu_R[dc->op2], cpu_R[dc->op1], 4);cris_update_cc_op(dc, CC_OP_FLAGS, 4);t_gen_mov_preg_TN(dc, PR_CCS, l0)... |
0 | event_thread(void *arg){ unsigned char atr[MAX_ATR_LEN]; int atr_len = MAX_ATR_LEN; VEvent *event = NULL; unsigned int reader_id; while (1) { const char *reader_name; event = vevent_wait_next_vevent(); if (event == NULL) { break; } reader_id = vreader_get_id(event->reader); if (reader_id == VSCARD_UNDEFINED_READER_ID &... |
0 | int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, int nb_clusters){ BDRVQcow2State *s = bs->opaque; uint64_t cluster_index, refcount; uint64_t i; int ret; assert(nb_clusters >= 0); if (nb_clusters == 0) { return 0; } do { /* Check how many clusters there are free */ cluster_index = offset >> s->cluster... |
0 | static int bochs_open(BlockDriverState *bs, const char *filename, int flags){ BDRVBochsState *s = bs->opaque; int fd, i; struct bochs_header bochs; struct bochs_header_v1 header_v1; fd = open(filename, O_RDWR | O_BINARY); if (fd < 0) { fd = open(filename, O_RDONLY | O_BINARY); if (fd < 0) return -1; } bs->read_only = 1... |
0 | build_rsdp(GArray *rsdp_table, GArray *linker, unsigned rsdt){ AcpiRsdpDescriptor *rsdp = acpi_data_push(rsdp_table, sizeof *rsdp); bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, 16, true /* fseg memory */); memcpy(&rsdp->signature, "RSD PTR ", sizeof(rsdp->signature)); memcpy(rsdp->oem_id, ACPI_BUILD_APPNAME6,... |
0 | static void kqemu_record_pc(unsigned long pc){ unsigned long h; PCRecord **pr, *r; h = pc / PC_REC_SIZE; h = h ^ (h >> PC_REC_HASH_BITS); h &= (PC_REC_HASH_SIZE - 1); pr = &pc_rec_hash[h]; for(;;) { r = *pr; if (r == NULL) break; if (r->pc == pc) { r->count++; return; } pr = &r->next; } r = malloc(sizeof(PCRecord)); r-... |
0 | int bdrv_has_zero_init_1(BlockDriverState *bs){ return 1;} |
0 | int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl){ int mb_xy; int partition_count; unsigned int mb_type, cbp; int dct8x8_allowed= h->pps.transform_8x8_mode; int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2; const int pixel_shift = h->pixel_shift; mb_xy = sl->mb_xy... |
0 | static uint64_t xilinx_spips_read(void *opaque, hwaddr addr, unsigned size){ XilinxSPIPS *s = opaque; uint32_t mask = ~0; uint32_t ret; addr >>= 2; switch (addr) { case R_CONFIG: mask = 0x0002FFFF; break; case R_INTR_STATUS: ret = s->regs[addr] & IXR_ALL; s->regs[addr] = 0; DB_PRINT("addr=" TARGET_FMT_plx " = %x\n", ad... |
0 | struct omap_intr_handler_s *omap2_inth_init(target_phys_addr_t base, int size, int nbanks, qemu_irq **pins, qemu_irq parent_irq, qemu_irq parent_fiq, omap_clk fclk, omap_clk iclk){ struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) g_malloc0(sizeof(struct omap_intr_handler_s) + sizeof(struct omap_intr_handl... |
0 | static int microblaze_load_dtb(target_phys_addr_t addr, uint32_t ramsize, const char *kernel_cmdline, const char *dtb_filename){ int fdt_size;#ifdef CONFIG_FDT void *fdt = NULL; int r; if (dtb_filename) { fdt = load_device_tree(dtb_filename, &fdt_size); } if (!fdt) { return 0; } if (kernel_cmdline) { r = qemu_devtree_s... |
0 | static int delta_decode(int8_t *dst, const uint8_t *src, int src_size, int8_t val, const int8_t *table){ int n = src_size; int8_t *dst0 = dst; while (n--) { uint8_t d = *src++; val = av_clip(val + table[d & 0x0f], -127, 128); *dst++ = val; val = av_clip(val + table[d >> 4] , -127, 128); *dst++ = val; } return dst-dst0;... |
1 | static void virtio_rng_device_realize(DeviceState *dev, Error **errp){ VirtIODevice *vdev = VIRTIO_DEVICE(dev); VirtIORNG *vrng = VIRTIO_RNG(dev); Error *local_err = NULL; if (!vrng->conf.period_ms > 0) { error_set(errp, QERR_INVALID_PARAMETER_VALUE, "period", "a positive number"); return; } if (vrng->conf.rng == NULL)... |
1 | static void tmu2_start(MilkymistTMU2State *s){ int pbuffer_attrib[6] = { GLX_PBUFFER_WIDTH, 0, GLX_PBUFFER_HEIGHT, 0, GLX_PRESERVED_CONTENTS, True }; GLXPbuffer pbuffer; GLuint texture; void *fb; hwaddr fb_len; void *mesh; hwaddr mesh_len; float m; trace_milkymist_tmu2_start(); /* Create and set up a suitable OpenGL co... |
1 | static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win){ int i, j; INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3; INTFLOAT tmp[18], *tmp1, *in1; for (i = 17; i >= 1; i--) in[i] += in[i-1]; for (i = 17; i >= 3; i -= 2) in[i] += in[i-2]; for (j = 0; j < 2; j++) { tmp1 = tmp + j; in1 = in + j; t2 = in1[2*... |
1 | void ff_jref_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block){ ff_j_rev_dct(block); ff_put_pixels_clamped(block, dest, line_size);} |
1 | static void e1000_reset(void *opaque){ E1000State *d = opaque; qemu_del_timer(d->autoneg_timer); memset(d->phy_reg, 0, sizeof d->phy_reg); memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init); memset(d->mac_reg, 0, sizeof d->mac_reg); memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init); d->rxbuf_min_shift = 1; mem... |
1 | void qtest_add_func(const char *str, void (*fn)){ gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); g_test_add_func(path, fn);} |
1 | void palette8torgb16(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette){unsigned i;for(i=0; i<num_pixels; i++)((uint16_t *)dst)[i] = ((uint16_t *)palette)[ src[i] ];} |
1 | static void ppc_spapr_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; int i; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); target_phys_addr_t rma_allo... |
1 | void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **errp){ int fd = monitor_get_fd(cur_mon, fdname, errp); if (fd == -1) { return; } s->file = qemu_fdopen(fd, "wb"); migrate_fd_connect(s);} |
1 | static int dvvideo_init(AVCodecContext *avctx){ DVVideoContext *s = avctx->priv_data; DSPContext dsp; static int done=0; int i, j; if (!done) { VLC dv_vlc; uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; uint8_t new_dv_vlc_len[NB_DV_VLC*2]; uint8_t new_dv_vlc_run[NB_DV_VLC*2]; int16_t new_dv_vlc_level[NB_DV_VLC*2]; done = 1; dv... |
1 | static uint64_t memory_region_dispatch_read1(MemoryRegion *mr, hwaddr addr, unsigned size){ uint64_t data = 0; if (!memory_region_access_valid(mr, addr, size, false)) { return -1U; /* FIXME: better signalling */ } if (!mr->ops->read) { return mr->ops->old_mmio.read[bitops_ffsl(size)](mr->opaque, addr); } /* FIXME: supp... |
1 | static int cine_read_header(AVFormatContext *avctx){ AVIOContext *pb = avctx->pb; AVStream *st; unsigned int version, compression, offImageHeader, offSetup, offImageOffsets, biBitCount, length, CFA; int vflip; char *description; uint64_t i; st = avformat_new_stream(avctx, NULL); if (!st) return AVERROR(ENOMEM); st->cod... |
1 | QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap){ /* Send QMP request */ socket_sendf(s->qmp_fd, fmt, ap); /* Receive reply */ return qtest_qmp_receive(s);} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.