label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | void os_mem_prealloc(int fd, char *area, size_t memory){ int ret; struct sigaction act, oldact; sigset_t set, oldset; memset(&act, 0, sizeof(act)); act.sa_handler = &sigbus_handler; act.sa_flags = 0; ret = sigaction(SIGBUS, &act, &oldact); if (ret) { perror("os_mem_prealloc: failed to install signal handler"); exit(1);... |
0 | int usb_handle_packet(USBDevice *dev, USBPacket *p){ int ret; if (dev == NULL) { return USB_RET_NODEV; } assert(dev->addr == p->devaddr); assert(dev->state == USB_STATE_DEFAULT); assert(p->state == USB_PACKET_SETUP); if (p->devep == 0) { /* control pipe */ switch (p->pid) { case USB_TOKEN_SETUP: ret = do_token_setup(de... |
0 | build_rsdp(GArray *rsdp_table, BIOSLinker *linker, unsigned rsdt_tbl_offset){ AcpiRsdpDescriptor *rsdp = acpi_data_push(rsdp_table, sizeof *rsdp); unsigned rsdt_pa_size = sizeof(rsdp->rsdt_physical_address); unsigned rsdt_pa_offset = (char *)&rsdp->rsdt_physical_address - rsdp_table->data; bios_linker_loader_alloc(link... |
0 | static inline uint32_t vmsvga_fifo_read_raw(struct vmsvga_state_s *s){ uint32_t cmd = s->fifo[CMD(stop) >> 2]; s->cmd->stop = cpu_to_le32(CMD(stop) + 4); if (CMD(stop) >= CMD(max)) s->cmd->stop = s->cmd->min; return cmd;} |
0 | static void rv40_loop_filter(RV34DecContext *r, int row){ MpegEncContext *s = &r->s; int mb_pos, mb_x; int i, j, k; uint8_t *Y, *C; int alpha, beta, betaY, betaC; int q; int mbtype[4]; ///< current macroblock and its neighbours types /** * flags indicating that macroblock can be filtered with strong filter * it is set ... |
0 | static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs){ BlockDriverState *old_bs = child->bs; if (old_bs) { if (old_bs->quiesce_counter && child->role->drained_end) { child->role->drained_end(child); } QLIST_REMOVE(child, next_parent); } child->bs = new_bs; if (new_bs) { QLIST_INSERT_HEAD(&new_bs->p... |
0 | void qemu_ram_free(ram_addr_t addr){ RAMBlock *block; /* This assumes the iothread lock is taken here too. */ qemu_mutex_lock_ramlist(); QTAILQ_FOREACH(block, &ram_list.blocks, next) { if (addr == block->offset) { QTAILQ_REMOVE(&ram_list.blocks, block, next); ram_list.mru_block = NULL; ram_list.version++; if (block->fl... |
0 | static int block_job_finish_sync(BlockJob *job, void (*finish)(BlockJob *, Error **errp), Error **errp){ BlockDriverState *bs = job->bs; Error *local_err = NULL; int ret; assert(bs->job == job); block_job_ref(job); finish(job, &local_err); if (local_err) { error_propagate(errp, local_err); block_job_unref(job); return ... |
0 | static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent){ char desc[DESC_SIZE]; uint32_t cid; const char *p_name, *cid_str; size_t cid_str_size; BDRVVmdkState *s = bs->opaque; if (bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE) != DESC_SIZE) { return 0; } if (parent) { cid_str = "parentCID"; cid_str_size =... |
0 | int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg){ if (!s->chr_ioctl) return -ENOTSUP; return s->chr_ioctl(s, cmd, arg);} |
0 | static void e1000_pre_save(void *opaque){ E1000State *s = opaque; NetClientState *nc = qemu_get_queue(s->nic); /* If the mitigation timer is active, emulate a timeout now. */ if (s->mit_timer_on) { e1000_mit_timer(s); } /* * If link is down and auto-negotiation is supported and ongoing, * complete auto-negotiation imme... |
0 | START_TEST(invalid_array_comma){ QObject *obj = qobject_from_json("[32,}"); fail_unless(obj == NULL);} |
0 | static void handle_control_message(VirtIOSerial *vser, void *buf, size_t len){ struct VirtIOSerialPort *port; struct virtio_console_control cpkt, *gcpkt; uint8_t *buffer; size_t buffer_len; gcpkt = buf; if (len < sizeof(cpkt)) { /* The guest sent an invalid control packet */ return; } cpkt.event = lduw_p(&gcpkt->event)... |
0 | static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack* track){ offset_t pos = url_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "stbl"); mov_write_stsd_tag(pb, track); mov_write_stts_tag(pb, track); if (track->enc->codec_type == CODEC_TYPE_VIDEO && track->hasKeyframes < track->entry) mov_write_stss_tag(pb, tra... |
0 | static void gen_mtpr(int rb, int regno){ TCGv tmp; int data; if (rb == 31) { tmp = tcg_const_i64(0); } else { tmp = cpu_ir[rb]; } /* The basic registers are data only, and unknown registers are read-zero, write-ignore. */ data = cpu_pr_data(regno); if (data != 0) { if (data & PR_BYTE) { tcg_gen_st8_i64(tmp, cpu_env, da... |
0 | void qemu_unregister_reset(QEMUResetHandler *func, void *opaque){ QEMUResetEntry *re; TAILQ_FOREACH(re, &reset_handlers, entry) { if (re->func == func && re->opaque == opaque) { TAILQ_REMOVE(&reset_handlers, re, entry); qemu_free(re); return; } }} |
0 | static void blizzard_reg_write(void *opaque, uint8_t reg, uint16_t value){ BlizzardState *s = (BlizzardState *) opaque; switch (reg) { case 0x04:/* PLL M-Divider */ s->pll = (value & 0x3f) + 1; break; case 0x06:/* PLL Lock Range Control */ s->pll_range = value & 3; break; case 0x08:/* PLL Lock Synthesis Control 0 */ s-... |
0 | uint64_t qcrypto_pbkdf2_count_iters(QCryptoHashAlgorithm hash, const uint8_t *key, size_t nkey, const uint8_t *salt, size_t nsalt, Error **errp){ uint8_t out[32]; uint64_t iterations = (1 << 15); unsigned long long delta_ms, start_ms, end_ms; while (1) { if (qcrypto_pbkdf2_get_thread_cpu(&start_ms, errp) < 0) { return ... |
0 | static int pci_device_hot_remove(Monitor *mon, const char *pci_addr){ PCIDevice *d; int dom, bus; unsigned slot; Error *local_err = NULL; if (pci_read_devaddr(mon, pci_addr, &dom, &bus, &slot)) { return -1; } d = pci_find_device(pci_find_root_bus(dom), bus, PCI_DEVFN(slot, 0)); if (!d) { monitor_printf(mon, "slot %d em... |
0 | void hmp_info_memdev(Monitor *mon, const QDict *qdict){ Error *err = NULL; MemdevList *memdev_list = qmp_query_memdev(&err); MemdevList *m = memdev_list; StringOutputVisitor *ov; char *str; int i = 0; while (m) { ov = string_output_visitor_new(false); visit_type_uint16List(string_output_get_visitor(ov), NULL, &m->value... |
0 | static void apply_motion_8x8(RoqContext *ri, int x, int y, unsigned char mv, signed char mean_x, signed char mean_y){ int mx, my, i, j, hw; unsigned char *pa, *pb; mx = x + 8 - (mv >> 4) - mean_x; my = y + 8 - (mv & 0xf) - mean_y; pa = ri->current_frame.data[0] + (y * ri->y_stride) + x; pb = ri->last_frame.data[0] + (m... |
0 | void ff_avg_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h){ if (h&3) ff_avg_dirac_pixels16_c(dst, src, stride, h); else ff_avg_pixels16_sse2(dst, src[0], stride, h);} |
0 | int ff_ape_write_tag(AVFormatContext *s){ AVDictionaryEntry *e = NULL; int64_t start, end; int size, count = 0; if (!s->pb->seekable) return 0; start = avio_tell(s->pb); // header avio_write(s->pb, "APETAGEX", 8); // id avio_wl32 (s->pb, APE_TAG_VERSION); // version avio_wl32(s->pb, 0); // reserve space for size avio_w... |
1 | static void gen_cp0 (CPUMIPSState *env, DisasContext *ctx, uint32_t opc, int rt, int rd){ const char *opn = "ldst"; switch (opc) { case OPC_MFC0: if (rt == 0) { /* Treat as NOP. */ return; } gen_mfc0(env, ctx, cpu_gpr[rt], rd, ctx->opcode & 0x7); opn = "mfc0"; break; case OPC_MTC0: { TCGv t0 = tcg_temp_new(); gen_load_... |
1 | static inline uint64_t v4l2_get_pts(V4L2Buffer *avbuf){ V4L2m2mContext *s = buf_to_m2mctx(avbuf); AVRational v4l2_timebase = { 1, USEC_PER_SEC }; int64_t v4l2_pts; /* convert pts back to encoder timebase */ v4l2_pts = avbuf->buf.timestamp.tv_sec * USEC_PER_SEC + avbuf->buf.timestamp.tv_usec; return av_rescale_q(v4l2_pt... |
1 | static int parallels_create(const char *filename, QemuOpts *opts, Error **errp){ int64_t total_size, cl_size; uint8_t tmp[BDRV_SECTOR_SIZE]; Error *local_err = NULL; BlockBackend *file; uint32_t bat_entries, bat_sectors; ParallelsHeader header; int ret; total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, ... |
1 | static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size){ QEMUFileStdio *s = opaque; return fwrite(buf, 1, size, s->stdio_file);} |
1 | void *address_space_map(AddressSpace *as, hwaddr addr, hwaddr *plen, bool is_write){ hwaddr len = *plen; hwaddr done = 0; hwaddr l, xlat, base; MemoryRegion *mr, *this_mr; ram_addr_t raddr; if (len == 0) { return NULL; } l = len; mr = address_space_translate(as, addr, &xlat, &l, is_write); if (!memory_access_is_direct(... |
1 | void ff_aac_search_for_pred(AACEncContext *s, SingleChannelElement *sce){ int sfb, i, count = 0, cost_coeffs = 0, cost_pred = 0; const int pmax = FFMIN(sce->ics.max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]); float *O34 = &s->scoefs[128*0], *P34 = &s->scoefs[128*1]; float *SENT = &s->scoefs[128*2], *S34 = &s->scoef... |
0 | static void new_subtitle_stream(AVFormatContext *oc, int file_idx){ AVStream *st; OutputStream *ost; AVCodec *codec=NULL; AVCodecContext *subtitle_enc; enum CodecID codec_id = CODEC_ID_NONE; if(!subtitle_stream_copy){ if (subtitle_codec_name) { codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,... |
0 | static int compile_kernel_file(GPUEnv *gpu_env, const char *build_options){ cl_int status; char *temp, *source_str = NULL; size_t source_str_len = 0; int i, ret = 0; for (i = 0; i < gpu_env->kernel_code_count; i++) { if (!gpu_env->kernel_code[i].is_compiled) source_str_len += strlen(gpu_env->kernel_code[i].kernel_strin... |
0 | static void read_ttag(AVFormatContext *s, int taglen, const char *key){ char *q, dst[512]; int len, dstlen = sizeof(dst) - 1; unsigned genre; dst[0] = 0; if (taglen < 1) return; taglen--; /* account for encoding type byte */ switch (get_byte(s->pb)) { /* encoding type */ case 0: /* ISO-8859-1 (0 - 255 maps directly int... |
0 | static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s){ Jpeg2000CodingStyle *codsty = s->codsty; Jpeg2000QuantStyle *qntsty = s->qntsty; uint8_t *properties = s->properties; for (;;) { int len, ret = 0; uint16_t marker; int oldpos; if (bytestream2_get_bytes_left(&s->g) < 2) { av_log(s->avctx, AV_LOG_ERROR, "M... |
0 | static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb){ int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi; int num_blocks = s->coded_fragment_list_index; for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) { i = blocks_decoded = num_blocks_at_qpi = 0; bit = get_bits1(gb); do { run_leng... |
1 | static void v9fs_mkdir(void *opaque){ V9fsPDU *pdu = opaque; size_t offset = 7; int32_t fid; struct stat stbuf; V9fsQID qid; V9fsString name; V9fsFidState *fidp; gid_t gid; int mode; int err = 0; v9fs_string_init(&name); err = pdu_unmarshal(pdu, offset, "dsdd", &fid, &name, &mode, &gid); if (err < 0) { trace_v9fs_mkdir... |
1 | static void kvmppc_host_cpu_class_init(ObjectClass *oc, void *data){ PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc); uint32_t vmx = kvmppc_get_vmx(); uint32_t dfp = kvmppc_get_dfp(); /* Now fix up the class with information we can query from the host */ if (vmx != -1) { /* Only override when we know what the host support... |
1 | static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque){ const uint8_t *first_buf; int first_buf_index = 0, i; /* This is probably being paranoid, but handle cases of zero size vectors. */ for (i = 0; i < qiov->ni... |
1 | void ppc_slb_invalidate_all (CPUPPCState *env){ target_phys_addr_t sr_base; uint64_t tmp64; int n, do_invalidate; do_invalidate = 0; sr_base = env->spr[SPR_ASR]; for (n = 0; n < env->slb_nr; n++) { tmp64 = ldq_phys(sr_base); if (slb_is_valid(tmp64)) { slb_invalidate(&tmp64); stq_phys(sr_base, tmp64); /* XXX: given the ... |
1 | static int dirac_header(AVFormatContext *s, int idx){ struct ogg *ogg = s->priv_data; struct ogg_stream *os = ogg->streams + idx; AVStream *st = s->streams[idx]; dirac_source_params source; GetBitContext gb; // already parsed the header if (st->codec->codec_id == AV_CODEC_ID_DIRAC) return 0; init_get_bits(&gb, os->buf ... |
0 | static int targa_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int buf_size, void *data){ AVFrame *p = data; int bpp, picsize, datasize; uint8_t *out; if(avctx->width > 0xffff || avctx->height > 0xffff) { av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n"); return -1; } picsize = avpicture_get_size... |
0 | static void sdp_parse_fmtp(AVStream *st, const char *p){ char attr[256]; /* Vorbis setup headers can be up to 12KB and are sent base64 * encoded, giving a 12KB * (4/3) = 16KB FMTP line. */ char value[16384]; int i; RTSPStream *rtsp_st = st->priv_data; AVCodecContext *codec = st->codec; RTPPayloadData *rtp_payload_data ... |
1 | static int h261_decode_gob(H261Context *h){ MpegEncContext * const s = &h->s; int v; ff_set_qscale(s, s->qscale); /* check for empty gob */ v= show_bits(&s->gb, 15); if(get_bits_count(&s->gb) + 15 > s->gb.size_in_bits){ v>>= get_bits_count(&s->gb) + 15 - s->gb.size_in_bits; } if(v==0){ h261_decode_mb_skipped(h, 0, 33);... |
1 | static int parse_playlist(URLContext *h, const char *url){ HLSContext *s = h->priv_data; AVIOContext *in; int ret = 0, is_segment = 0, is_variant = 0, bandwidth = 0; int64_t duration = 0; char line[1024]; const char *ptr; if ((ret = avio_open2(&in, url, AVIO_FLAG_READ, &h->interrupt_callback, NULL)) < 0) return ret; re... |
1 | static int dc1394_read_header(AVFormatContext *c, AVFormatParameters * ap){ dc1394_data* dc1394 = c->priv_data; AVStream* vst; nodeid_t* camera_nodes; int res; struct dc1394_frame_format *fmt; struct dc1394_frame_rate *fps; for (fmt = dc1394_frame_formats; fmt->width; fmt++) if (fmt->pix_fmt == ap->pix_fmt && fmt->widt... |
1 | static void bdrv_aio_bh_cb(void *opaque){ BlockDriverAIOCBSync *acb = opaque; if (!acb->is_write) qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); qemu_vfree(acb->bounce); acb->common.cb(acb->common.opaque, acb->ret); qemu_bh_delete(acb->bh); acb->bh = NULL; qemu_aio_release(acb);} |
1 | static int send_sub_rect_jpeg(VncState *vs, int x, int y, int w, int h, int bg, int fg, int colors, VncPalette *palette){ int ret; if (colors == 0) { if (tight_detect_smooth_image(vs, w, h)) { int quality = tight_conf[vs->tight.quality].jpeg_quality; ret = send_jpeg_rect(vs, x, y, w, h, quality); ret = send_full_color_... |
1 | static uint64_t htonll(uint64_t v){ union { uint32_t lv[2]; uint64_t llv; } u; u.lv[0] = htonl(v >> 32); u.lv[1] = htonl(v & 0xFFFFFFFFULL); return u.llv;} |
1 | void op_addo (void){ target_ulong tmp; tmp = T0; T0 += T1; if ((T0 >> 31) ^ (T1 >> 31) ^ (tmp >> 31)) { CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW); } RETURN();} |
1 | static av_cold int adpcm_decode_init(AVCodecContext * avctx){ ADPCMDecodeContext *c = avctx->priv_data; unsigned int max_channels = 2; switch(avctx->codec->id) { case CODEC_ID_ADPCM_EA_R1: case CODEC_ID_ADPCM_EA_R2: case CODEC_ID_ADPCM_EA_R3: case CODEC_ID_ADPCM_EA_XAS: max_channels = 6; break; } if(avctx->channels > m... |
1 | static void test_qemu_strtol_max(void){ const char *str = g_strdup_printf("%ld", LONG_MAX); char f = 'X'; const char *endptr = &f; long res = 999; int err; err = qemu_strtol(str, &endptr, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, LONG_MAX); g_assert(endptr == str + strlen(str));} |
1 | static int build_vlc(AVCodecContext *avctx, VLC *vlc, const uint32_t *table){ Node nodes[512]; uint32_t bits[256]; int16_t lens[256]; uint8_t xlat[256]; int cur_node, i, j, pos = 0; ff_free_vlc(vlc); for (i = 0; i < 256; i++) { nodes[i].count = table[i]; nodes[i].sym = i; nodes[i].n0 = -2; nodes[i].l = i; nodes[i].r = ... |
0 | static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos){ int size[5]; int i, j, k, a, prev, a2; EncBlockInfo* b; size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24; do { b = blks; for (i=0; i<5; i++) { if (!qnos[i]) continue; qnos[i]--; size[i] = 0; for (j=0; j<6; j++, b++) { for (a=0; a<4; a++) { if (b->a... |
0 | static int vtenc_cm_to_avpacket( AVCodecContext *avctx, CMSampleBufferRef sample_buffer, AVPacket *pkt, ExtraSEI *sei){ VTEncContext *vtctx = avctx->priv_data; int status; bool is_key_frame; bool add_header; size_t length_code_size; size_t header_size = 0; size_t in_buf_size; size_t out_buf_size; size_t sei_nalu_size =... |
0 | AVFormatContext *avformat_alloc_context(void){ AVFormatContext *ic; ic = av_malloc(sizeof(AVFormatContext)); if (!ic) return ic; avformat_get_context_defaults(ic); ic->av_class = &av_format_context_class; return ic;} |
0 | offset_t url_filesize(URLContext *h){ offset_t pos, size; size= url_seek(h, 0, AVSEEK_SIZE); if(size<0){ pos = url_seek(h, 0, SEEK_CUR); size = url_seek(h, -1, SEEK_END)+1; url_seek(h, pos, SEEK_SET); } return size;} |
0 | static av_noinline void FUNC(hl_decode_mb)(const H264Context *h, H264SliceContext *sl){ const int mb_x = sl->mb_x; const int mb_y = sl->mb_y; const int mb_xy = sl->mb_xy; const int mb_type = h->cur_pic.mb_type[mb_xy]; uint8_t *dest_y, *dest_cb, *dest_cr; int linesize, uvlinesize /*dct_offset*/; int i, j; const int *blo... |
0 | static int rtp_read(URLContext *h, uint8_t *buf, int size){ RTPContext *s = h->priv_data; struct sockaddr_storage from; socklen_t from_len; int len, fd_max, n; fd_set rfds; struct timeval tv;#if 0 for(;;) { from_len = sizeof(from); len = recvfrom (s->rtp_fd, buf, size, 0, (struct sockaddr *)&from, &from_len); if (len <... |
0 | static int load_apply_palette(FFFrameSync *fs){ AVFilterContext *ctx = fs->parent; AVFilterLink *inlink = ctx->inputs[0]; PaletteUseContext *s = ctx->priv; AVFrame *master, *second, *out; int ret; // writable for error diffusal dithering ret = ff_framesync_dualinput_get_writable(fs, &master, &second); if (ret < 0) retu... |
1 | static void test_parse_invalid_path(void){ g_test_trap_subprocess ("/logging/parse_invalid_path/subprocess", 0, 0); g_test_trap_assert_passed(); g_test_trap_assert_stdout(""); g_test_trap_assert_stderr("Bad logfile format: /tmp/qemu-%d%d.log\n");} |
1 | void bdrv_iterate_format(void (*it)(void *opaque, const char *name), void *opaque){ BlockDriver *drv; int count = 0; const char **formats = NULL; QLIST_FOREACH(drv, &bdrv_drivers, list) { if (drv->format_name) { bool found = false; int i = count; while (formats && i && !found) { found = !strcmp(formats[--i], drv->forma... |
1 | static int ea_read_header(AVFormatContext *s, AVFormatParameters *ap){ EaDemuxContext *ea = s->priv_data; AVStream *st; if (!process_ea_header(s)) return AVERROR(EIO); if (ea->video_codec) { /* initialize the video decoder stream */ st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); ea->video_stream_in... |
1 | static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, int buf_size, void *data){ AC3EncodeContext *s = avctx->priv_data; const SampleType *samples = data; int ret; if (s->bit_alloc.sr_code == 1) adjust_frame_size(s); deinterleave_input_samples(s, samples); apply_mdct(s); compute_rematrixing_strategy(... |
1 | static void rm_read_audio_stream_info(AVFormatContext *s, AVStream *st, int read_all){ RMContext *rm = s->priv_data; ByteIOContext *pb = &s->pb; char buf[256]; uint32_t version; int i; /* ra type header */ version = get_be32(pb); /* version */ if (((version >> 16) & 0xff) == 3) { int64_t startpos = url_ftell(pb); /* ve... |
1 | static void term_init(void){#if HAVE_TERMIOS_H if(!run_as_daemon){ struct termios tty; tcgetattr (0, &tty); oldtty = tty; atexit(term_exit); tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP |INLCR|IGNCR|ICRNL|IXON); tty.c_oflag |= OPOST; tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); tty.c_cflag &= ~(CSIZE|PARENB); tty.c_cfl... |
1 | static int tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st){ RTSPState *rt = s->priv_data; AVFormatContext *rtpctx = rtsp_st->transport_priv; uint8_t *buf, *ptr; int size; uint8_t *interleave_header, *interleaved_packet; size = avio_close_dyn_buf(rtpctx->pb, &buf); ptr = buf; while (size > 4) { uint32_t packet... |
1 | static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id){ VirtIOBlock *s = opaque; if (version_id != 2) return -EINVAL; virtio_load(&s->vdev, f); while (qemu_get_sbyte(f)) { VirtIOBlockReq *req = virtio_blk_alloc_request(s); qemu_get_buffer(f, (unsigned char*)&req->elem, sizeof(req->elem)); req->next = s->... |
1 | static TRBCCode xhci_disable_ep(XHCIState *xhci, unsigned int slotid, unsigned int epid){ XHCISlot *slot; XHCIEPContext *epctx; int i; trace_usb_xhci_ep_disable(slotid, epid); assert(slotid >= 1 && slotid <= xhci->numslots); assert(epid >= 1 && epid <= 31); slot = &xhci->slots[slotid-1]; if (!slot->eps[epid-1]) { DPRIN... |
1 | static void parse_mb_skip(Wmv2Context *w){ int mb_x, mb_y; MpegEncContext *const s = &w->s; uint32_t *const mb_type = s->current_picture_ptr->mb_type; w->skip_type = get_bits(&s->gb, 2); switch (w->skip_type) { case SKIP_TYPE_NONE: for (mb_y = 0; mb_y < s->mb_height; mb_y++) for (mb_x = 0; mb_x < s->mb_width; mb_x++) m... |
1 | static void qemu_chr_free_common(CharDriverState *chr){ g_free(chr->filename); g_free(chr->label); if (chr->logfd != -1) { close(chr->logfd); qemu_mutex_destroy(&chr->chr_write_lock); g_free(chr); |
1 | void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec, int is_asi, int size){ CPUState *saved_env; int fault_type; /* XXX: hack to restore env in all cases, even if not called from generated code */ saved_env = env; env = cpu_single_env;#ifdef DEBUG_UNASSIGNED if (is_asi) printf("Unassigned mem %... |
1 | int coroutine_fn bdrv_co_flush(BlockDriverState *bs){ int ret; BdrvTrackedRequest req; if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs) || bdrv_is_sg(bs)) { return 0; } tracked_request_begin(&req, bs, 0, 0, BDRV_TRACKED_FLUSH); int current_gen = bs->write_gen; /* Wait until any previous flushes are completed *... |
1 | static int modify_current_stream(HTTPContext *c, char *rates){ int i; FFStream *req = c->stream; int action_required = 0; for (i = 0; i < req->nb_streams; i++) { AVCodecContext *codec = &req->streams[i]->codec; switch(rates[i]) { case 0: c->switch_feed_streams[i] = req->feed_streams[i]; break; case 1: c->switch_feed_st... |
1 | static int cirrus_bitblt_cputovideo(CirrusVGAState * s){ int w; if (blit_is_unsafe(s, true)) { return 0; } s->cirrus_blt_mode &= ~CIRRUS_BLTMODE_MEMSYSSRC; s->cirrus_srcptr = &s->cirrus_bltbuf[0]; s->cirrus_srcptr_end = &s->cirrus_bltbuf[0]; if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {if (s->cirrus_blt_mode &... |
1 | static void vfio_amd_xgbe_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); VFIOAmdXgbeDeviceClass *vcxc = VFIO_AMD_XGBE_DEVICE_CLASS(klass); vcxc->parent_realize = dc->realize; dc->realize = amd_xgbe_realize; dc->desc = "VFIO AMD XGBE"; dc->vmsd = &vfio_platform_amd_xgbe_vmstate;} |
1 | static int hls_window(AVFormatContext *s, int last){ HLSContext *hls = s->priv_data; HLSSegment *en; int target_duration = 0; int ret = 0; AVIOContext *out = NULL; AVIOContext *sub_out = NULL; char temp_filename[1024]; int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->nb_entries); int version = 3; cons... |
1 | static inline void RENAME(nv12ToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused){ RENAME(nvXXtoUV)(dstU, dstV, src1, width);} |
1 | void blk_eject(BlockBackend *blk, bool eject_flag){ BlockDriverState *bs = blk_bs(blk); char *id; /* blk_eject is only called by qdevified devices */ assert(!blk->legacy_dev); if (bs) { bdrv_eject(bs, eject_flag); id = blk_get_attached_dev_id(blk); qapi_event_send_device_tray_moved(blk_name(blk), id, eject_flag, &error... |
1 | static void megasas_scsi_realize(PCIDevice *dev, Error **errp){ DeviceState *d = DEVICE(dev); MegasasState *s = MEGASAS(dev); MegasasBaseClass *b = MEGASAS_DEVICE_GET_CLASS(s); uint8_t *pci_conf; int i, bar_type; Error *err = NULL; int ret; pci_conf = dev->config; /* PCI latency timer = 0 */ pci_conf[PCI_LATENCY_TIMER]... |
1 | int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info){ int handle = 0; int n; if (arch_info->exception == 1) { if (arch_info->dr6 & (1 << 14)) { if (cpu_single_env->singlestep_enabled) handle = 1; } else { for (n = 0; n < 4; n++) if (arch_info->dr6 & (1 << n)) switch ((arch_info->dr7 >> (16 + n*4)) & 0x3) { case 0x... |
1 | static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt){ MpegTSContext *ts = s->priv_data; int ret, i; ts->pkt = pkt; ret = handle_packets(ts, 0); if (ret < 0) { /* flush pes data left */ for (i = 0; i < NB_PID_MAX; i++) { if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) { PESContext *pes = ts->pids[i]->u.p... |
1 | static int qemu_savevm_state(QEMUFile *f){ SaveStateEntry *se; int len, ret; int64_t cur_pos, len_pos, total_len_pos; qemu_put_be32(f, QEMU_VM_FILE_MAGIC); qemu_put_be32(f, QEMU_VM_FILE_VERSION); total_len_pos = qemu_ftell(f); qemu_put_be64(f, 0); /* total size */ for(se = first_se; se != NULL; se = se->next) {if (se->... |
1 | static void cmv_decode_inter(CmvContext * s, const uint8_t *buf, const uint8_t *buf_end){ const uint8_t *raw = buf + (s->avctx->width*s->avctx->height/16); int x,y,i; i = 0; for(y=0; y<s->avctx->height/4; y++) for(x=0; x<s->avctx->width/4 && buf+i<buf_end; x++) { if (buf[i]==0xFF) { unsigned char *dst = s->frame.data[0... |
1 | int bdrv_open(BlockDriverState *bs, const char *filename, QDict *options, int flags, BlockDriver *drv, Error **errp){ int ret; /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ char tmp_filename[PATH_MAX + 1]; BlockDriverState *file = NULL; QDict *file_options = NULL; const char *drvname; Error *loc... |
1 | static int qdm2_parse_packet(AVFormatContext *s, PayloadContext *qdm, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, int flags){ int res = AVERROR_INVALIDDATA, n; const uint8_t *end = buf + len, *p = buf; if (len > 0) { if (len < 2) return AVERROR_INVALIDDATA; /* configuration block */ i... |
1 | av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact){ int mm_flags = av_get_cpu_flags(); if (EXTERNAL_MMX(mm_flags)) { c->ac3_exponent_min = ff_ac3_exponent_min_mmx; c->ac3_max_msb_abs_int16 = ff_ac3_max_msb_abs_int16_mmx; c->ac3_lshift_int16 = ff_ac3_lshift_int16_mmx; c->ac3_rshift_int32 = ff_ac3_rshift_in... |
0 | void tcg_context_init(TCGContext *s){ int op, total_args, n; TCGOpDef *def; TCGArgConstraint *args_ct; int *sorted_args; memset(s, 0, sizeof(*s)); s->nb_globals = 0; /* Count total number of arguments and allocate the corresponding space */ total_args = 0; for(op = 0; op < NB_OPS; op++) { def = &tcg_op_defs[op]; n = de... |
0 | void macio_nvram_setup_bar(MacIONVRAMState *s, MemoryRegion *bar, target_phys_addr_t mem_base){ memory_region_add_subregion(bar, mem_base, &s->mem);} |
0 | int qemu_input_key_value_to_scancode(const KeyValue *value, bool down, int *codes){ int keycode = qemu_input_key_value_to_number(value); int count = 0; if (value->type == KEY_VALUE_KIND_QCODE && value->u.qcode == Q_KEY_CODE_PAUSE) { /* specific case */ int v = down ? 0 : 0x80; codes[count++] = 0xe1; codes[count++] = 0x... |
0 | static void coroutine_fn verify_self(void *opaque){ g_assert(qemu_coroutine_self() == opaque);} |
0 | void net_set_boot_mask(int net_boot_mask){ int i; /* Only the first four NICs may be bootable */ net_boot_mask = net_boot_mask & 0xF; for (i = 0; i < nb_nics; i++) { if (net_boot_mask & (1 << i)) { net_boot_mask &= ~(1 << i); } } if (net_boot_mask) { fprintf(stderr, "Cannot boot from non-existent NIC\n"); exit(1); }} |
0 | void msix_reset(PCIDevice *dev){ if (!(dev->cap_present & QEMU_PCI_CAP_MSIX)) return; msix_free_irq_entries(dev); dev->config[dev->msix_cap + MSIX_CONTROL_OFFSET] &= ~dev->wmask[dev->msix_cap + MSIX_CONTROL_OFFSET]; memset(dev->msix_table_page, 0, MSIX_PAGE_SIZE); msix_mask_all(dev, dev->msix_entries_nr);} |
0 | static void pl110_write(void *opaque, hwaddr offset, uint64_t val, unsigned size){ pl110_state *s = (pl110_state *)opaque; int n; /* For simplicity invalidate the display whenever a control register is written to. */ s->invalidate = 1; if (offset >= 0x200 && offset < 0x400) { /* Palette. */ n = (offset - 0x200) >> 2; s... |
0 | static int process_input(void){ InputFile *ifile; AVFormatContext *is; InputStream *ist; AVPacket pkt; int ret, i, j; int file_index; /* select the stream that we must read now */ file_index = select_input_file(); /* if none, if is finished */ if (file_index == -2) { poll_filters() ; return AVERROR(EAGAIN); } if (file_... |
0 | static inline void gen_intermediate_code_internal(AlphaCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUAlphaState *env = &cpu->env; DisasContext ctx, *ctxp = &ctx; target_ulong pc_start; target_ulong pc_mask; uint32_t insn; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj = -1; ExitStatu... |
0 | uint64_t helper_fctiwz(CPUPPCState *env, uint64_t arg){ CPU_DoubleU farg; farg.ll = arg; if (unlikely(float64_is_signaling_nan(farg.d))) { /* sNaN conversion */ farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI); } else if (unlikely(float64_is_quiet_nan(farg.d) || float64_is_infinity(f... |
0 | POWERPC_FAMILY(POWER8E)(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc); dc->fw_name = "PowerPC,POWER8"; dc->desc = "POWER8E"; dc->props = powerpc_servercpu_properties; pcc->pvr_match = ppc_pvr_match_power8; pcc->pcr_mask = PCR_COMPAT_2_05 | PCR_COMPAT_2_06... |
0 | static void patch_instruction(VAPICROMState *s, CPUX86State *env, target_ulong ip){ target_phys_addr_t paddr; VAPICHandlers *handlers; uint8_t opcode[2]; uint32_t imm32; if (smp_cpus == 1) { handlers = &s->rom_state.up; } else { handlers = &s->rom_state.mp; } pause_all_vcpus(); cpu_memory_rw_debug(env, ip, opcode, size... |
0 | void tlb_fill(unsigned long addr, int is_write, int is_user, void *retaddr){ TranslationBlock *tb; CPUState *saved_env; unsigned long pc; int ret; /* XXX: hack to restore env in all cases, even if not called from generated code */ saved_env = env; env = cpu_single_env; { unsigned long tlb_addrr, tlb_addrw; int index; i... |
0 | static inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { int nza, nzb; int ctx = 0; if( cat == 0 ) { nza = h->left_cbp&0x100; nzb = h-> top_cbp&0x100; } else if( cat == 1 || cat == 2 ) { nza = h->non_zero_count_cache[scan8[idx] - 1]; nzb = h->non_zero_count_cache[scan8[idx] - 8]; } else if( cat == 3 ) ... |
0 | static void add_flagname_to_bitmaps(const char *flagname, uint32_t *features, uint32_t *ext_features, uint32_t *ext2_features, uint32_t *ext3_features, uint32_t *kvm_features){ int i; int found = 0; for ( i = 0 ; i < 32 ; i++ ) if (feature_name[i] && !strcmp (flagname, feature_name[i])) { *features |= 1 << i; found = 1... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.