label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | DISAS_INSN(scc){ int l1; int cond; TCGv reg; l1 = gen_new_label(); cond = (insn >> 8) & 0xf; reg = DREG(insn, 0); tcg_gen_andi_i32(reg, reg, 0xffffff00); /* This is safe because we modify the reg directly, with no other values live. */ gen_jmpcc(s, cond ^ 1, l1); tcg_gen_ori_i32(reg, reg, 0xff); gen_set_label(l1);} |
0 | static int usb_host_scan(void *opaque, USBScanFunc *func){ Monitor *mon = cur_mon; FILE *f = NULL; DIR *dir = NULL; int ret = 0; const char *fs_type[] = {"unknown", "proc", "dev", "sys"}; char devpath[PATH_MAX]; /* only check the host once */ if (!usb_fs_type) { dir = opendir(USBSYSBUS_PATH "/devices"); if (dir) { /* d... |
0 | static int scsi_cd_initfn(SCSIDevice *dev){ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); s->qdev.blocksize = 2048; s->qdev.type = TYPE_ROM; s->features |= 1 << SCSI_DISK_F_REMOVABLE; if (!s->product) { s->product = g_strdup("QEMU CD-ROM"); } return scsi_initfn(&s->qdev);} |
0 | static void msix_table_mmio_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ PCIDevice *dev = opaque; int vector = addr / PCI_MSIX_ENTRY_SIZE; bool was_masked; was_masked = msix_is_masked(dev, vector); pci_set_long(dev->msix_table + addr, val); msix_handle_mask_update(dev, vector, was_masked);... |
0 | static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs){ Error **errp = opaque; if (!error_is_set(errp) && bdrv_key_required(bs)) { error_set(errp, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs), bdrv_get_encrypted_filename(bs)); }} |
0 | void virtio_scsi_dataplane_stop(VirtIOSCSI *s){ BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s))); VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus); VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); int i; /* Better luck next time. */ if (s->dataplane_fenced) { s->dataplane_fenced = false; return; } if (!s->dataplane_star... |
0 | static void spitz_common_init(int ram_size, int vga_ram_size, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, enum spitz_model_e model, int arm_id){ uint32_t spitz_ram = 0x04000000; uint32_t spitz_rom = 0x00800000; struct pxa2xx_state_s *cpu; struct scoop_info_s *... |
0 | static void run_test(void){ unsigned int remaining; int i; while (atomic_read(&n_ready_threads) != n_rw_threads + n_rz_threads) { cpu_relax(); } atomic_mb_set(&test_start, true); do { remaining = sleep(duration); } while (remaining); atomic_mb_set(&test_stop, true); for (i = 0; i < n_rw_threads; i++) { qemu_thread_join... |
1 | static void leon3_generic_hw_init(MachineState *machine){ ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; SPARCCPU *cpu; CPUSPARCState *env; MemoryRegion *address_space_mem = get_system_memory(); MemoryRegion *ram = g_new(Memor... |
1 | static int assign_intx(AssignedDevice *dev, Error **errp){ AssignedIRQType new_type; PCIINTxRoute intx_route; bool intx_host_msi; int r; Error *local_err = NULL; /* Interrupt PIN 0 means don't use INTx */ if (assigned_dev_pci_read_byte(&dev->dev, PCI_INTERRUPT_PIN) == 0) { pci_device_set_intx_routing_notifier(&dev->dev... |
1 | static void gen_tlbwe_40x(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } switch (rB(ctx->opcode)) { case 0: gen_helper_4xx_tlbwe_hi(cpu_env, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ct... |
1 | void do_sraw (void){ int32_t ret; if (likely(!(T1 & 0x20UL))) { if (likely((uint32_t)T1 != 0)) { ret = (int32_t)T0 >> (T1 & 0x1fUL); if (likely(ret >= 0 || ((int32_t)T0 & ((1 << T1) - 1)) == 0)) { xer_ca = 0; } else { xer_ca = 1; } } else { ret = T0; xer_ca = 0; } } else { ret = (-1) * ((uint32_t)T0 >> 31); if (likely(... |
1 | int qemu_sem_timedwait(QemuSemaphore *sem, int ms){ int rc; struct timespec ts;#if defined(__APPLE__) || defined(__NetBSD__) compute_abs_deadline(&ts, ms); pthread_mutex_lock(&sem->lock); --sem->count; while (sem->count < 0) { rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts); if (rc == ETIMEDOUT) { break; } if ... |
1 | static void spatial_compose97i_dy(dwt_compose_t *cs, DWTELEM *buffer, int width, int height, int stride){ int y = cs->y; DWTELEM *b0= cs->b0; DWTELEM *b1= cs->b1; DWTELEM *b2= cs->b2; DWTELEM *b3= cs->b3; DWTELEM *b4= buffer + mirror(y+3, height-1)*stride; DWTELEM *b5= buffer + mirror(y+4, height-1)*stride; if(stride =... |
1 | static int nbd_co_receive_request(NBDRequestData *req, NBDRequest *request, Error **errp){ NBDClient *client = req->client; int valid_flags; g_assert(qemu_in_coroutine()); assert(client->recv_coroutine == qemu_coroutine_self()); if (nbd_receive_request(client->ioc, request, errp) < 0) { return -EIO; } trace_nbd_co_rece... |
1 | void register_cp_regs_for_features(ARMCPU *cpu){ /* Register all the coprocessor registers based on feature bits */ CPUARMState *env = &cpu->env; if (arm_feature(env, ARM_FEATURE_M)) { /* M profile has no coprocessor registers */ return; } define_arm_cp_regs(cpu, cp_reginfo); if (!arm_feature(env, ARM_FEATURE_V8)) { /*... |
1 | static void pci_nic_uninit(PCIDevice *pci_dev){ EEPRO100State *s = DO_UPCAST(EEPRO100State, dev, pci_dev); vmstate_unregister(&pci_dev->qdev, s->vmstate, s); eeprom93xx_free(&pci_dev->qdev, s->eeprom); qemu_del_nic(s->nic);} |
1 | void helper_mtc0_status(CPUMIPSState *env, target_ulong arg1){ MIPSCPU *cpu = mips_env_get_cpu(env); uint32_t val, old; uint32_t mask = env->CP0_Status_rw_bitmask; if (env->insn_flags & ISA_MIPS32R6) { if (extract32(env->CP0_Status, CP0St_KSU, 2) == 0x3) { mask &= ~(3 << CP0St_KSU); } mask &= ~(0x00180000 & arg1); } va... |
1 | void av_register_all(void){ static int initialized; if (initialized) return; initialized = 1; avcodec_init(); avcodec_register_all(); /* (de)muxers */ REGISTER_DEMUXER (AAC, aac); REGISTER_MUXDEMUX (AC3, ac3); REGISTER_MUXER (ADTS, adts); REGISTER_MUXDEMUX (AIFF, aiff); REGISTER_MUXDEMUX (AMR, amr); REGISTER_DEMUXER (A... |
1 | static void vfio_pci_size_rom(VFIODevice *vdev){ uint32_t orig, size = cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK); off_t offset = vdev->config_offset + PCI_ROM_ADDRESS; char name[32]; if (vdev->pdev.romfile || !vdev->pdev.rom_bar) { return; } /* * Use the same size ROM BAR as the physical device. The contents * will g... |
1 | void OPPROTO op_POWER_sraq (void){ env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL)); if (T1 & 0x20UL) T0 = -1L; else T0 = Ts0 >> T1; RETURN();} |
0 | static int shorten_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; ShortenContext *s = avctx->priv_data; int i, input_buf_size = 0; int16_t *samples = data; int ret; /* allocate internal bitstream buffer */ if(s->max_framesi... |
1 | void pci_cmd646_ide_init(PCIBus *bus, DriveInfo **hd_table, int secondary_ide_enabled){ PCIDevice *dev; dev = pci_create(bus, -1, "CMD646 IDE"); qdev_prop_set_uint32(&dev->qdev, "secondary", secondary_ide_enabled); qdev_init(&dev->qdev); pci_ide_create_devs(dev, hd_table);} |
1 | static av_cold int avisynth_load_library(void) { avs_library = av_mallocz(sizeof(AviSynthLibrary)); if (!avs_library) return AVERROR_UNKNOWN; avs_library->library = LoadLibrary(AVISYNTH_LIB); if (!avs_library->library) goto init_fail;#define LOAD_AVS_FUNC(name, continue_on_fail) \{ \ avs_library->name = (void*)GetProcA... |
1 | static int mjpegb_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ MJpegDecodeContext *s = avctx->priv_data; uint8_t *buf_end, *buf_ptr; AVFrame *picture = data; GetBitContext hgb; /* for the header */ uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs; uint32... |
1 | static int dv_write_header(AVFormatContext *s){ s->priv_data = dv_init_mux(s); if (!s->priv_data) { av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n" "Make sure that you supply exactly two streams:\n" " video: 25fps or 29.97fps, audio: 2ch/48Khz/PCM\n" " (50Mbps allows an optional second audio stream)\n"); return... |
1 | static void print_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp){ StringOutputVisitor *sov = DO_UPCAST(StringOutputVisitor, visitor, v); static const char suffixes[] = { 'B', 'K', 'M', 'G', 'T' }; uint64_t div, val; char *out; int i; if (!sov->human) { out = g_strdup_printf("%llu", (long long) *ob... |
0 | static void avc_h_loop_filter_chroma422_msa(uint8_t *src, int32_t stride, int32_t alpha_in, int32_t beta_in, int8_t *tc0){ int32_t col, tc_val; int16_t out0, out1, out2, out3; v16u8 alpha, beta, res; alpha = (v16u8) __msa_fill_b(alpha_in); beta = (v16u8) __msa_fill_b(beta_in); for (col = 0; col < 4; col++) { tc_val = (... |
0 | static int test_vector_dmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp, const double *v1, const double *src0, double scale){ LOCAL_ALIGNED(32, double, cdst, [LEN]); LOCAL_ALIGNED(32, double, odst, [LEN]); int ret; memcpy(cdst, v1, LEN * sizeof(*v1)); memcpy(odst, v1, LEN * sizeof(*v1)); cdsp->vector_dmac_s... |
0 | static av_always_inline int cmp_inline(MpegEncContext *s, const int x, const int y, const int subx, const int suby, const int size, const int h, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, int qpel, int chroma){ MotionEstContext * const c= &s->me; const int stride= c->stride; const ... |
1 | static void do_video_out(AVFormatContext *s, OutputStream *ost, InputStream *ist, AVFrame *in_picture){ int nb_frames, i, ret, format_video_sync; AVFrame *final_picture; AVCodecContext *enc; double sync_ipts; double duration = 0; int frame_size = 0; float quality = same_quant ? in_picture->quality : ost->st->codec->glo... |
1 | ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size){ FdMigrationState *s = opaque; ssize_t ret; do { ret = s->write(s, data, size); } while (ret == -1 && ((s->get_error(s)) == EINTR)); if (ret == -1) ret = -(s->get_error(s)); if (ret == -EAGAIN) { qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_f... |
1 | static void do_sdl_resize(int new_width, int new_height, int bpp){ int flags; // printf("resizing to %d %d\n", w, h); flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_RESIZABLE; if (gui_fullscreen) flags |= SDL_FULLSCREEN; if (gui_noframe) flags |= SDL_NOFRAME; width = new_width; height = new_height; real_screen = S... |
1 | static int wavpack_decode_block(AVCodecContext *avctx, int block_no, AVFrame *frame, const uint8_t *buf, int buf_size){ WavpackContext *wc = avctx->priv_data; ThreadFrame tframe = { .f = frame }; WavpackFrameContext *s; GetByteContext gb; void *samples_l = NULL, *samples_r = NULL; int ret; int got_terms = 0, got_weight... |
0 | static int http_connect(URLContext *h, const char *path, const char *hoststr){ HTTPContext *s = h->priv_data; int post, err, ch; char line[1024], *q; /* send http header */ post = h->flags & URL_WRONLY; snprintf(s->buffer, sizeof(s->buffer), "%s %s HTTP/1.0\r\n" "User-Agent: %s\r\n" "Accept: */*\r\n" "Host: %s\r\n" "\r... |
0 | static void decodeplane8(uint8_t *dst, const uint8_t *const buf, int buf_size, int bps, int plane){ GetBitContext gb; int i, b; init_get_bits(&gb, buf, buf_size * 8); for(i = 0; i < (buf_size * 8 + bps - 1) / bps; i++) { for (b = 0; b < bps; b++) { dst[ i*bps + b ] |= get_bits1(&gb) << plane; } }} |
0 | static void mpeg_decode_sequence_extension(MpegEncContext *s){ int horiz_size_ext, vert_size_ext; int bit_rate_ext; int level, profile; skip_bits(&s->gb, 1); /* profil and level esc*/ profile= get_bits(&s->gb, 3); level= get_bits(&s->gb, 4); s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */ s->chr... |
0 | static int init(AVFilterContext *ctx, const char *args){ EvalContext *eval = ctx->priv; char *args1 = av_strdup(eval->exprs); char *expr, *buf; int ret, i; if (!args1) { av_log(ctx, AV_LOG_ERROR, "Channels expressions list is empty\n"); ret = args ? AVERROR(ENOMEM) : AVERROR(EINVAL); goto end; } /* parse expressions */... |
0 | static void vc1_loop_filter_iblk(MpegEncContext *s, int pq){ int i, j; if(!s->first_slice_line) s->dsp.vc1_loop_filter(s->dest[0], 1, s->linesize, 16, pq); s->dsp.vc1_loop_filter(s->dest[0] + 8*s->linesize, 1, s->linesize, 16, pq); for(i = !s->mb_x*8; i < 16; i += 8) s->dsp.vc1_loop_filter(s->dest[0] + i, s->linesize, ... |
0 | static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n){ return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4);} |
0 | static inline void RENAME(hScale)(int16_t *dst, int dstW, const uint8_t *src, int srcW, int xInc, const int16_t *filter, const int16_t *filterPos, long filterSize){#if COMPILE_TEMPLATE_MMX assert(filterSize % 4 == 0 && filterSize>0); if (filterSize==4) { // Always true for upscaling, sometimes for down, too. x86_reg co... |
0 | static void draw_curves(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *out){ AudioNEqualizerContext *s = ctx->priv; char *colors, *color, *saveptr = NULL; int ch, i, n; colors = av_strdup(s->colors); if (!colors) return; memset(out->data[0], 0, s->h * out->linesize[0]); for (ch = 0; ch < inlink->channels; ch++) {... |
1 | static void set_sar(TiffContext *s, unsigned tag, unsigned num, unsigned den){ int offset = tag == TIFF_YRES ? 2 : 0; s->res[offset++] = num; s->res[offset] = den; if (s->res[0] && s->res[1] && s->res[2] && s->res[3]) av_reduce(&s->avctx->sample_aspect_ratio.num, &s->avctx->sample_aspect_ratio.den, s->res[2] * (uint64_... |
1 | CPUX86State *cpu_x86_init(const char *cpu_model){ X86CPU *cpu; CPUX86State *env; static int inited; cpu = X86_CPU(object_new(TYPE_X86_CPU)); env = &cpu->env; env->cpu_model_str = cpu_model; /* init various static tables used in TCG mode */ if (tcg_enabled() && !inited) { inited = 1; optimize_flags_init();#ifndef CONFIG... |
1 | static int glyph_enu_free(void *opaque, void *elem){ av_free(elem); return 0;} |
1 | static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce){ int off = sce->sf_idx[0], diff; int i, w; for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { for (i = 0; i < sce->ics.max_sfb; i++) { if (!sce->zeroes[w*16 + i]) { diff = sce->sf_idx[w*16 + i] - off + ... |
1 | static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter){ int pid; pid = filter->pid; if (filter->type == MPEGTS_SECTION) av_freep(&filter->u.section_filter.section_buf); av_free(filter); ts->pids[pid] = NULL; |
1 | static void blk_mig_reset_dirty_cursor(void){ BlkMigDevState *bmds; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { bmds->cur_dirty = 0; }} |
1 | void ppc_tlb_invalidate_all (CPUPPCState *env){ switch (env->mmu_model) { case POWERPC_MMU_SOFT_6xx: case POWERPC_MMU_SOFT_74xx: ppc6xx_tlb_invalidate_all(env); break; case POWERPC_MMU_SOFT_4xx: case POWERPC_MMU_SOFT_4xx_Z: ppc4xx_tlb_invalidate_all(env); break; case POWERPC_MMU_REAL_4xx: cpu_abort(env, "No TLB for Pow... |
0 | static int ffm_is_avail_data(AVFormatContext *s, int size){ FFMContext *ffm = s->priv_data; int64_t pos, avail_size; int len; len = ffm->packet_end - ffm->packet_ptr; if (size <= len) return 1; pos = url_ftell(s->pb); if (!ffm->write_index) { if (pos == ffm->file_size); return AVERROR_EOF; avail_size = ffm->file_size -... |
0 | static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOVAtom atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = st->priv_data; unsigned int i, entries; get_byte(pb); /* version */ get_be24(pb); /* flags */ entries = get_be32(pb); dprintf(c->fc, "track[%i].stsc.entries = %i\n", c->fc... |
0 | static int siff_read_packet(AVFormatContext *s, AVPacket *pkt){ SIFFContext *c = s->priv_data; if (c->has_video) { unsigned int size; if (c->cur_frame >= c->frames) return AVERROR_EOF; if (c->curstrm == -1) { c->pktsize = avio_rl32(s->pb) - 4; c->flags = avio_rl16(s->pb); c->gmcsize = (c->flags & VB_HAS_GMC) ? 4 : 0; i... |
0 | static int packed_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH){ VScalerContext *inst = desc->instance; int dstW = desc->dst->width; int chrSliceY = sliceY >> desc->dst->v_chr_sub_sample; int lum_fsize = inst[0].filter_size; int chr_fsize = inst[1].filter_size; uint16_t *lum_filter = inst[0].... |
0 | WINDOW_FUNC(eight_short){ const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128; const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128; const float *in = audio + 448; float *out = sce->ret; for (int w = 0; w < 8; w++) { dsp->vector_fmul (out, in, w ? pwind... |
0 | static int udp_read_packet(AVFormatContext *s, AVPacket *pkt){ AVFormatContext *ic; AVStream *st; RTSPStream *rtsp_st; fd_set rfds; int fd1, fd2, fd_max, n, i, ret; char buf[RTP_MAX_PACKET_LENGTH]; struct timeval tv; for(;;) { if (rtsp_abort_req) return -EIO; FD_ZERO(&rfds); fd_max = -1; for(i = 0; i < s->nb_streams; i... |
0 | static void apply_unsharp( uint8_t *dst, int dst_stride, const uint8_t *src, int src_stride, int width, int height, FilterParam *fp){ uint32_t **sc = fp->sc; uint32_t sr[MAX_MATRIX_SIZE - 1], tmp1, tmp2; int32_t res; int x, y, z; const uint8_t *src2 = NULL; //silence a warning if (!fp->amount) { if (dst_stride == src_s... |
1 | static off_t read_uint32(BlockDriverState *bs, int64_t offset){uint32_t buffer;if (bdrv_pread(bs->file, offset, &buffer, 4) < 4)return 0;return be32_to_cpu(buffer);} |
1 | static void gen_tlbre_40x(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } switch (rB(ctx->opcode)) { case 0: gen_helper_4xx_tlbre_hi(cpu_gpr[rD(ctx->opcode)], cpu_env, cpu_gpr[rA(ct... |
1 | int aio_bh_poll(AioContext *ctx){ QEMUBH *bh, **bhp, *next; int ret; ctx->walking_bh++; ret = 0; for (bh = ctx->first_bh; bh; bh = next) { /* Make sure that fetching bh happens before accessing its members */ smp_read_barrier_depends(); next = bh->next; /* The atomic_xchg is paired with the one in qemu_bh_schedule. The... |
1 | static void libschroedinger_handle_first_access_unit(AVCodecContext *avctx){ SchroDecoderParams *p_schro_params = avctx->priv_data; SchroDecoder *decoder = p_schro_params->decoder; p_schro_params->format = schro_decoder_get_video_format(decoder); /* Tell FFmpeg about sequence details. */ if (av_image_check_size(p_schro... |
1 | static av_cold int atrac1_decode_end(AVCodecContext * avctx) { AT1Ctx *q = avctx->priv_data; av_freep(&q->out_samples[0]); ff_mdct_end(&q->mdct_ctx[0]); ff_mdct_end(&q->mdct_ctx[1]); ff_mdct_end(&q->mdct_ctx[2]); return 0;} |
1 | static double block_angle(int x, int y, int cx, int cy, MotionVector *shift){ double a1, a2, diff; a1 = atan2(y - cy, x - cx); a2 = atan2(y - cy + shift->y, x - cx + shift->x); diff = a2 - a1; return (diff > M_PI) ? diff - 2 * M_PI : (diff < -M_PI) ? diff + 2 * M_PI : diff;} |
1 | static void panicked_mon_event(const char *action){ QObject *data; data = qobject_from_jsonf("{ 'action': %s }", action); monitor_protocol_event(QEVENT_GUEST_PANICKED, data); qobject_decref(data);} |
0 | int inet_aton (const char * str, struct in_addr * add){ const char * pch = str; unsigned int add1 = 0, add2 = 0, add3 = 0, add4 = 0; add1 = atoi(pch); pch = strpbrk(pch,"."); if (pch == 0 || ++pch == 0) return 0; add2 = atoi(pch); pch = strpbrk(pch,"."); if (pch == 0 || ++pch == 0) return 0; add3 = atoi(pch); pch = str... |
1 | static int cirrus_bitblt_videotovideo_patterncopy(CirrusVGAState * s){ return cirrus_bitblt_common_patterncopy(s, s->vram_ptr + (s->cirrus_blt_srcaddr & ~7));} |
1 | static void cdg_load_palette(CDGraphicsContext *cc, uint8_t *data, int low){ uint8_t r, g, b; uint16_t color; int i; int array_offset = low ? 0 : 8; uint32_t *palette = (uint32_t *) cc->frame.data[1]; for (i = 0; i < 8; i++) { color = (data[2 * i] << 6) + (data[2 * i + 1] & 0x3F); r = ((color >> 8) & 0x000F) * 17; g = ... |
1 | static void load_elf_image(const char *image_name, int image_fd, struct image_info *info, char **pinterp_name, char bprm_buf[BPRM_BUF_SIZE]){ struct elfhdr *ehdr = (struct elfhdr *)bprm_buf; struct elf_phdr *phdr; abi_ulong load_addr, load_bias, loaddr, hiaddr, error; int i, retval; const char *errmsg; /* First of all,... |
1 | void omap_clk_init(struct omap_mpu_state_s *mpu){ struct clk **i, *j, *k; int count; int flag; if (cpu_is_omap310(mpu)) flag = CLOCK_IN_OMAP310; else if (cpu_is_omap1510(mpu)) flag = CLOCK_IN_OMAP1510; else if (cpu_is_omap2410(mpu) || cpu_is_omap2420(mpu)) flag = CLOCK_IN_OMAP242X; else if (cpu_is_omap2430(mpu)) flag =... |
1 | static void ohci_pci_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->init = usb_ohci_initfn_pci; k->vendor_id = PCI_VENDOR_ID_APPLE; k->device_id = PCI_DEVICE_ID_APPLE_IPID_USB; k->class_id = PCI_CLASS_SERIAL_USB; dc->desc = "Apple USB C... |
1 | int av_opt_set(void *obj, const char *name, const char *val, int search_flags){ int ret; void *dst, *target_obj; const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj); if (!o || !target_obj) return AVERROR_OPTION_NOT_FOUND; if (!val && (o->type != AV_OPT_TYPE_STRING && o->type != AV_OPT_TYPE_P... |
1 | static struct omap_lpg_s *omap_lpg_init(MemoryRegion *system_memory, hwaddr base, omap_clk clk){ struct omap_lpg_s *s = (struct omap_lpg_s *) g_malloc0(sizeof(struct omap_lpg_s)); s->tm = timer_new_ms(QEMU_CLOCK_VIRTUAL, omap_lpg_tick, s); omap_lpg_reset(s); memory_region_init_io(&s->iomem, NULL, &omap_lpg_ops, s, "oma... |
1 | static void pred4x4_horizontal_vp8_c(uint8_t *src, const uint8_t *topright, int stride){ const int lt= src[-1-1*stride]; LOAD_LEFT_EDGE AV_WN32A(src+0*stride, ((lt + 2*l0 + l1 + 2) >> 2)*0x01010101); AV_WN32A(src+1*stride, ((l0 + 2*l1 + l2 + 2) >> 2)*0x01010101); AV_WN32A(src+2*stride, ((l1 + 2*l2 + l3 + 2) >> 2)*0x010... |
1 | static void restart_coroutine(void *opaque){ Coroutine *co = opaque; DPRINTF("co=%p", co); qemu_coroutine_enter(co, NULL);} |
1 | PPC_OP(test_ctrz_false){ T0 = (regs->ctr == 0 && (T0 & PARAM(1)) == 0); RETURN();} |
1 | static int packed_16bpc_bswap(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[]){ int i, j; int srcstr = srcStride[0] >> 1; int dststr = dstStride[0] >> 1; uint16_t *dstPtr = (uint16_t *) dst[0]; const uint16_t *srcPtr = (const uint16_t *) src[0]; for (i... |
1 | int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, BlockCompletionFunc *completion_cb, void *opaque){ Error *local_err = NULL; int err; bdrv_add_key(bs, NULL, &local_err); if (!local_err) { if (completion_cb) completion_cb(opaque, 0); return 0; } /* Need a key for @bs */ if (monitor_ctrl_mode(mon)) { q... |
1 | static void slavio_timer_get_out(SLAVIO_TIMERState *s){ int out; int64_t diff, ticks, count; uint32_t limit; // There are three clock tick units: CPU ticks, register units // (nanoseconds), and counter ticks (500 ns). if (s->mode == 1 && s->stopped)ticks = s->stop_time; elseticks = qemu_get_clock(vm_clock) - s->tick_of... |
1 | void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx){ X86CPU *cpu = x86_env_get_cpu(env); CPUState *cs = CPU(cpu); /* test if maximum index reached */ if (index & 0x80000000) { if (index > env->cpuid_xlevel) { if (env->cpuid_xlevel2 > 0) { /* H... |
1 | static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm){ pcibus_t start = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr; pcibus_t end = d->pci.io_regions[QXL_RAM_RANGE_INDEX].size + start; QXLMode *mode = d->modes->modes + modenr; uint64_t devmem = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr; QXLMemSlot slot = ... |
1 | static int aac_parse_packet(AVFormatContext *ctx, PayloadContext *data, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags){ int ret; if (rtp_parse_mp4_au(data, buf)) return -1; buf += data->au_headers_length_bytes + 2; len -= data->au_headers_length_bytes + 2; /* XXX... |
1 | static int decode_header(SnowContext *s){ int plane_index, tmp; uint8_t kstate[32]; memset(kstate, MID_STATE, sizeof(kstate)); s->keyframe= get_rac(&s->c, kstate); if(s->keyframe || s->always_reset){ ff_snow_reset_contexts(s); s->spatial_decomposition_type= s->qlog= s->qbias= s->mv_scale= s->block_max_depth= 0; } if(s-... |
1 | void alpha_translate_init(void){#define DEF_VAR(V) { &cpu_##V, #V, offsetof(CPUAlphaState, V) } typedef struct { TCGv *var; const char *name; int ofs; } GlobalVar; static const GlobalVar vars[] = { DEF_VAR(pc), DEF_VAR(lock_addr), DEF_VAR(lock_st_addr), DEF_VAR(lock_value), DEF_VAR(unique),#ifndef CONFIG_USER_ONLY DEF_... |
1 | static void RENAME(mix6to2)(SAMPLE **out, const SAMPLE **in, COEFF *coeffp, integer len){ int i; for(i=0; i<len; i++) { INTER t = in[2][i]*coeffp[0*6+2] + in[3][i]*coeffp[0*6+3]; out[0][i] = R(t + in[0][i]*(INTER)coeffp[0*6+0] + in[4][i]*(INTER)coeffp[0*6+4]); out[1][i] = R(t + in[1][i]*(INTER)coeffp[1*6+1] + in[5][i]*... |
1 | static QPCIDevice *get_device(void){ QPCIDevice *dev; QPCIBus *pcibus; pcibus = qpci_init_pc(); dev = NULL; qpci_device_foreach(pcibus, 0x1af4, 0x1110, save_fn, &dev); g_assert(dev != NULL); return dev;} |
1 | void do_nego (void){ if (likely(T0 != INT32_MIN)) { xer_ov = 0; T0 = -Ts0; } else { xer_ov = 1; xer_so = 1; }} |
1 | static int nbd_co_writev_1(NbdClientSession *client, int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int offset){ struct nbd_request request; struct nbd_reply reply; ssize_t ret; request.type = NBD_CMD_WRITE; if (!bdrv_enable_write_cache(client->bs) && (client->nbdflags & NBD_FLAG_SEND_FUA)) { request.type |= N... |
1 | void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down){ InputEvent *evt; evt = qemu_input_event_new_key(key, down); if (QTAILQ_EMPTY(&kbd_queue)) { qemu_input_event_send(src, evt); qemu_input_event_sync(); qapi_free_InputEvent(evt); } else { qemu_input_queue_event(&kbd_queue, src, evt); qemu_input_q... |
1 | int av_strerror(int errnum, char *errbuf, size_t errbuf_size){ int ret = 0, i; struct error_entry *entry = NULL; for (i = 0; i < FF_ARRAY_ELEMS(error_entries); i++) { if (errnum == error_entries[i].num) { entry = &error_entries[i]; break; } } if (entry) { av_strlcpy(errbuf, entry->str, errbuf_size); } else {#if HAVE_ST... |
1 | int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp){ blk->root = bdrv_root_attach_child(bs, "root", &child_root, blk->perm, blk->shared_perm, blk, errp); if (blk->root == NULL) { return -EPERM; } bdrv_ref(bs); notifier_list_notify(&blk->insert_bs_notifiers, blk); if (blk->public.throttle_group_memb... |
1 | void rgb15tobgr24(const uint8_t *src, uint8_t *dst, long src_size){const uint16_t *end;uint8_t *d = (uint8_t *)dst;const uint16_t *s = (uint16_t *)src;end = s + src_size/2;while(s < end){register uint16_t bgr;bgr = *s++;*d++ = (bgr&0x7C00)>>7;*d++ = (bgr&0x3E0)>>2;*d++ = (bgr&0x1F)<<3;}} |
1 | int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx){ struct xvmc_pix_fmt *last, *next, *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; const int mb_block_count = 4 + (1 << s->chroma_format); assert(avctx); if (!render || render->xvmc_id != AV_XVMC_ID || !render->data_blocks || !render->mv_bl... |
1 | static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset, uint64_t *cur_bytes){ BDRVQcowState *s = bs->opaque; QCowL2Meta *old_alloc; uint64_t bytes = *cur_bytes; QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { uint64_t start = guest_offset; uint64_t end = start + bytes; uint64_t old_st... |
1 | void scsi_req_data(SCSIRequest *req, int len){ trace_scsi_req_data(req->dev->id, req->lun, req->tag, len); req->bus->ops->complete(req->bus, SCSI_REASON_DATA, req->tag, len);} |
1 | static int compute_mask(int step, uint32_t *mask){ int i, z, ret = 0; int counter_size = sizeof(uint32_t) * (2 * step + 1); uint32_t *temp1_counter, *temp2_counter, **counter; temp1_counter = av_mallocz(counter_size); if (!temp1_counter) { ret = AVERROR(ENOMEM); goto end; } temp2_counter = av_mallocz(counter_size); if ... |
1 | static int encode_end(AVCodecContext *avctx){ FFV1Context *s = avctx->priv_data; common_end(s); return 0;} |
1 | static void vga_isa_realizefn(DeviceState *dev, Error **errp){ ISADevice *isadev = ISA_DEVICE(dev); ISAVGAState *d = ISA_VGA(dev); VGACommonState *s = &d->state; MemoryRegion *vga_io_memory; const MemoryRegionPortio *vga_ports, *vbe_ports; vga_common_init(s, OBJECT(dev), true); s->legacy_address_space = isa_address_spa... |
1 | static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp){ SubStream *s = &m->substream[substr]; unsigned int mat, ch; const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP ? MAX_MATRICES_MLP : MAX_MATRICES_TRUEHD; if (m->matrix_changed++ > 1) { av_log(m->avctx, AV_L... |
1 | int spapr_tce_dma_write(VIOsPAPRDevice *dev, uint64_t taddr, const void *buf, uint32_t size){#ifdef DEBUG_TCE fprintf(stderr, "spapr_tce_dma_write taddr=0x%llx size=0x%x\n", (unsigned long long)taddr, size);#endif /* Check for bypass */ if (dev->flags & VIO_PAPR_FLAG_DMA_BYPASS) { cpu_physical_memory_write(taddr, buf, ... |
1 | static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix, int64_t *highest_cluster, uint16_t *refcount_table, int64_t nb_clusters){ BDRVQcowState *s = bs->opaque; int64_t i; int refcount1, refcount2, ret; for (i = 0, *highest_cluster = 0; i < nb_clusters; i++) { refcount1 = get_refcou... |
1 | int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len){ uint32_t *hc = (uint32_t*)buf; struct kvm_ppc_pvinfo pvinfo; if (!kvmppc_get_pvinfo(env, &pvinfo)) { memcpy(buf, pvinfo.hcall, buf_len); return 0; } /* * Fallback to always fail hypercalls regardless of endianness: * * tdi 0,r0,72 (becomes b .+8 in ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.