label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static void ff_h264_idct_add8_sse2(uint8_t **dest, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){ int i; for(i=16; i<16+8; i+=2){ if(nnzc[ scan8[i+0] ]|nnzc[ scan8[i+1] ]) ff_x264_add8x4_idct_sse2 (dest[(i&4)>>2] + block_offset[i], block + i*16, stride); else if(block[i*16]|block[i*16+16... |
0 | static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOVAtom atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = st->priv_data; int entries, i, j; get_be32(pb); // version + flags entries = get_be32(pb); if (entries >= UINT_MAX / sizeof(*sc->drefs)) return -1; sc->drefs = av_mallocz(... |
0 | void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4]){ vector signed short CY, CRV, CBU, CGU, CGV, OY, Y0; int64_t crv __attribute__ ((aligned(16))) = inv_table[0]; int64_t cbu __attribute__ ((aligned(16))) = inv_table[1]; int64_t cgu __attribute__ ((aligned(16))) = inv_table[2]; int64_t cgv __attrib... |
1 | void mipsnet_init (int base, qemu_irq irq, NICInfo *nd){ MIPSnetState *s; qemu_check_nic_model(nd, "mipsnet"); s = qemu_mallocz(sizeof(MIPSnetState)); register_ioport_write(base, 36, 1, mipsnet_ioport_write, s); register_ioport_read(base, 36, 1, mipsnet_ioport_read, s); register_ioport_write(base, 36, 2, mipsnet_ioport... |
1 | static inline void hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2, int dstWidth, const uint8_t *src1, const uint8_t *src2, int srcW, int xInc){ int i; unsigned int xpos=0; for (i=0;i<dstWidth;i++) { register unsigned int xx=xpos>>16; register unsigned int xalpha=(xpos&0xFFFF)>>9; dst1[i]=(src1[xx]*(xalpha^1... |
1 | static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce, float *audio){ int i; float *output = sce->ret_buf; apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio); if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output); else for (... |
1 | TPMVersion tpm_tis_get_tpm_version(Object *obj){ TPMState *s = TPM(obj); return tpm_backend_get_tpm_version(s->be_driver); |
1 | vmxnet3_indicate_packet(VMXNET3State *s){ struct Vmxnet3_RxDesc rxd; bool is_head = true; uint32_t rxd_idx; uint32_t rx_ridx; struct Vmxnet3_RxCompDesc rxcd; uint32_t new_rxcd_gen = VMXNET3_INIT_GEN; hwaddr new_rxcd_pa = 0; hwaddr ready_rxcd_pa = 0; struct iovec *data = vmxnet_rx_pkt_get_iovec(s->rx_pkt); size_t bytes_... |
0 | static void sp804_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ sp804_state *s = (sp804_state *)opaque; if (offset < 0x20) { arm_timer_write(s->timer[0], offset, value); return; } if (offset < 0x40) { arm_timer_write(s->timer[1], offset - 0x20, value); return; } /* Technically we could ... |
0 | static void cmd_start_stop_unit(IDEState *s, uint8_t* buf){ int sense; bool start = buf[4] & 1; bool loej = buf[4] & 2; /* load on start, eject on !start */ int pwrcnd = buf[4] & 0xf0; if (pwrcnd) { /* eject/load only happens for power condition == 0 */ return; } if (loej) { if (!start && !s->tray_open && s->tray_locke... |
0 | void migration_tls_channel_connect(MigrationState *s, QIOChannel *ioc, const char *hostname, Error **errp){ QCryptoTLSCreds *creds; QIOChannelTLS *tioc; creds = migration_tls_get_creds( s, QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT, errp); if (!creds) { return; } if (s->parameters.tls_hostname) { hostname = s->parameters.tls_ho... |
0 | void bdrv_add_before_write_notifier(BlockDriverState *bs, NotifierWithReturn *notifier){ notifier_with_return_list_add(&bs->before_write_notifiers, notifier);} |
0 | static int qemu_savevm_state(Monitor *mon, QEMUFile *f){ int ret; if (qemu_savevm_state_blocked(mon)) { ret = -EINVAL; goto out; } ret = qemu_savevm_state_begin(f, 0, 0); if (ret < 0) goto out; do { ret = qemu_savevm_state_iterate(f); if (ret < 0) goto out; } while (ret == 0); ret = qemu_savevm_state_complete(f);out: i... |
0 | static void s390_virtio_net_realize(VirtIOS390Device *s390_dev, Error **errp){ DeviceState *qdev = DEVICE(s390_dev); VirtIONetS390 *dev = VIRTIO_NET_S390(s390_dev); DeviceState *vdev = DEVICE(&dev->vdev); Error *err = NULL; virtio_net_set_config_size(&dev->vdev, s390_dev->host_features); virtio_net_set_netclient_name(&... |
0 | static void nvdimm_build_ssdt(GSList *device_list, GArray *table_offsets, GArray *table_data, BIOSLinker *linker, GArray *dsm_dma_arrea){ Aml *ssdt, *sb_scope, *dev; int mem_addr_offset, nvdimm_ssdt; acpi_add_table(table_offsets, table_data); ssdt = init_aml_allocator(); acpi_data_push(ssdt->buf, sizeof(AcpiTableHeader... |
0 | static av_cold int eightsvx_decode_init(AVCodecContext *avctx){ EightSvxContext *esc = avctx->priv_data; if (avctx->channels < 1 || avctx->channels > 2) { av_log(avctx, AV_LOG_ERROR, "8SVX does not support more than 2 channels\n"); return AVERROR_INVALIDDATA; } switch (avctx->codec->id) { case AV_CODEC_ID_8SVX_FIB: esc... |
0 | static av_cold int opus_encode_init(AVCodecContext *avctx){ int i, ch, ret; OpusEncContext *s = avctx->priv_data; s->avctx = avctx; s->channels = avctx->channels; /* Opus allows us to change the framesize on each packet (and each packet may * have multiple frames in it) but we can't change the codec's frame size on * r... |
0 | static void scsi_destroy(SCSIDevice *s){ scsi_device_purge_requests(s, SENSE_CODE(NO_SENSE)); blockdev_mark_auto_del(s->conf.bs);} |
0 | static void init_event_facility_class(ObjectClass *klass, void *data){ SysBusDeviceClass *sbdc = SYS_BUS_DEVICE_CLASS(klass); DeviceClass *dc = DEVICE_CLASS(sbdc); SCLPEventFacilityClass *k = EVENT_FACILITY_CLASS(dc); dc->reset = reset_event_facility; dc->vmsd = &vmstate_event_facility; set_bit(DEVICE_CATEGORY_MISC, dc... |
0 | static void set_pixel_format(VncState *vs, int bits_per_pixel, int depth, int big_endian_flag, int true_color_flag, int red_max, int green_max, int blue_max, int red_shift, int green_shift, int blue_shift){ int host_big_endian_flag;#ifdef WORDS_BIGENDIAN host_big_endian_flag = 1;#else host_big_endian_flag = 0;#endif if... |
0 | void do_info_vnc(Monitor *mon){ if (vnc_display == NULL || vnc_display->display == NULL) monitor_printf(mon, "VNC server disabled\n"); else { monitor_printf(mon, "VNC server active on: "); monitor_print_filename(mon, vnc_display->display); monitor_printf(mon, "\n");if (vnc_display->clients == NULL) monitor_printf(mon, ... |
0 | void qemu_chr_generic_open(CharDriverState *s){ if (s->open_timer == NULL) { s->open_timer = qemu_new_timer_ms(rt_clock, qemu_chr_fire_open_event, s); qemu_mod_timer(s->open_timer, qemu_get_clock_ms(rt_clock) - 1); }} |
0 | static int pci_piix4_ide_initfn(PCIDevice *dev){ PCIIDEState *d = DO_UPCAST(PCIIDEState, dev, dev); pci_config_set_vendor_id(d->dev.config, PCI_VENDOR_ID_INTEL); pci_config_set_device_id(d->dev.config, PCI_DEVICE_ID_INTEL_82371AB); return pci_piix_ide_initfn(d);} |
0 | static void block_job_defer_to_main_loop_bh(void *opaque){ BlockJobDeferToMainLoopData *data = opaque; AioContext *aio_context; /* Prevent race with block_job_defer_to_main_loop() */ aio_context_acquire(data->aio_context); /* Fetch BDS AioContext again, in case it has changed */ aio_context = blk_get_aio_context(data->... |
0 | static void virtio_blk_handle_read(VirtIOBlockReq *req){ uint64_t sector; sector = virtio_ldq_p(VIRTIO_DEVICE(req->dev), &req->out.sector); bdrv_acct_start(req->dev->bs, &req->acct, req->qiov.size, BDRV_ACCT_READ); trace_virtio_blk_handle_read(req, sector, req->qiov.size / 512); if (sector & req->dev->sector_mask) { vi... |
0 | envlist_unsetenv(envlist_t *envlist, const char *env){struct envlist_entry *entry;size_t envname_len;if ((envlist == NULL) || (env == NULL))return (EINVAL);/* env is not allowed to contain '=' */if (strchr(env, '=') != NULL)return (EINVAL);/* * Find out the requested entry and remove * it from the list. */envname_len =... |
0 | static int ehci_state_fetchitd(EHCIState *ehci, int async){ uint32_t entry; EHCIitd itd; assert(!async); entry = ehci_get_fetch_addr(ehci, async); get_dwords(NLPTR_GET(entry),(uint32_t *) &itd, sizeof(EHCIitd) >> 2); ehci_trace_itd(ehci, entry, &itd); if (ehci_process_itd(ehci, &itd) != 0) { return -1; } put_dwords(NLP... |
0 | static int decode_b_mbs(VC9Context *v){ int x, y, current_mb = 0 , last_mb = v->height_mb*v->width_mb, i /* MB / B postion information */; int direct_b_bit = 0, skip_mb_bit = 0; int ac_pred; int b_mv1 = 0, b_mv2 = 0, b_mv_type = 0; int mquant, mqdiff; /* MB quant stuff */ int tt_block; /* Block transform type */ for (y... |
0 | static int ram_save_iterate(QEMUFile *f, void *opaque){ int ret; int i; int64_t t0; int total_sent = 0; qemu_mutex_lock_ramlist(); if (ram_list.version != last_version) { reset_ram_globals(); } ram_control_before_iterate(f, RAM_CONTROL_ROUND); t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); i = 0; while ((ret = qemu_file_... |
0 | static void *file_ram_alloc(RAMBlock *block, ram_addr_t memory, const char *path, Error **errp){ char *filename; char *sanitized_name; char *c; void *area; int fd; uint64_t hpagesize; Error *local_err = NULL; hpagesize = gethugepagesize(path, &local_err); if (local_err) { error_propagate(errp, local_err); goto error; }... |
0 | static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque){ RawAIOCB *acb; acb = raw_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque); if (!acb) return NULL; if (qemu_paio_read(&acb->aiocb) < 0) { raw_aio_remov... |
1 | void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags){ int i, shift, sp1, sp2, sp3, sp4; const int32_t *src; int32_t *dst; int tmp[64]; int t0, t1, t2, t3, t4, t5, t6, t7, t8; /* apply the InvHaar8 to all columns */#define COMPENSATE(x) (x) src = in; dst = tmp; for (i = 0;... |
0 | av_cold void ff_flacdsp_init_x86(FLACDSPContext *c, enum AVSampleFormat fmt, int bps){#if HAVE_YASM int cpu_flags = av_get_cpu_flags(); if (EXTERNAL_SSE4(cpu_flags)) { if (bps > 16 && CONFIG_FLAC_DECODER) c->lpc = ff_flac_lpc_32_sse4; } if (EXTERNAL_XOP(cpu_flags)) { if (bps > 16) c->lpc = ff_flac_lpc_32_xop; }#endif} |
1 | static void up_heap(uint32_t val, uint32_t *heap, uint32_t *weights){ uint32_t initial_val = heap[val]; while (weights[initial_val] < weights[heap[val >> 1]]) { heap[val] = heap[val >> 1]; val >>= 1; } heap[val] = initial_val;} |
1 | static int vmstate_size(void *opaque, VMStateField *field){ int size = field->size; if (field->flags & VMS_VBUFFER) { size = *(int32_t *)(opaque+field->size_offset); if (field->flags & VMS_MULTIPLY) { size *= field->size; } } return size;} |
1 | void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block){ int i; /* IDCT8 on each line */ for(i=0; i<4; i++) { idctRowCondDC_8(block + i*8); } /* IDCT4 and store */ for(i=0;i<8;i++) { idct4col_add(dest + i, line_size, block + i); }} |
1 | int net_handle_fd_param(Monitor *mon, const char *param){ if (!qemu_isdigit(param[0])) { int fd; fd = monitor_get_fd(mon, param); if (fd == -1) { error_report("No file descriptor named %s found", param); return -1; } return fd; } else { return strtol(param, NULL, 0); }} |
1 | static int tee_write_trailer(AVFormatContext *avf){ TeeContext *tee = avf->priv_data; AVFormatContext *avf2; int ret_all = 0, ret; unsigned i; for (i = 0; i < tee->nb_slaves; i++) { avf2 = tee->slaves[i].avf; if ((ret = av_write_trailer(avf2)) < 0) if (!ret_all) ret_all = ret; if (!(avf2->oformat->flags & AVFMT_NOFILE)... |
1 | static int write_trailer(AVFormatContext *s){ NUTContext *nut= s->priv_data; AVIOContext *bc= s->pb; while(nut->header_count<3) write_headers(s, bc); avio_flush(bc); ff_nut_free_sp(nut); av_freep(&nut->stream); av_freep(&nut->time_base); return 0;} |
1 | static void vmgenid_set_guid_test(void){ QemuUUID expected, measured; gchar *cmd; g_assert(qemu_uuid_parse(VGID_GUID, &expected) == 0); cmd = g_strdup_printf("-machine accel=tcg -device vmgenid,id=testvgid," "guid=%s", VGID_GUID); qtest_start(cmd); /* Read the GUID from accessing guest memory */ read_guid_from_memory(&... |
1 | static int rtp_write(URLContext *h, const uint8_t *buf, int size){ RTPContext *s = h->priv_data; int ret; URLContext *hd; if (RTP_PT_IS_RTCP(buf[1])) { /* RTCP payload type */ hd = s->rtcp_hd; } else { /* RTP payload type */ hd = s->rtp_hd; } ret = ffurl_write(hd, buf, size); return ret;} |
1 | static unsigned int dec_addi_acr(DisasContext *dc){TCGv t0;DIS(fprintf (logfile, "addi.%c $r%u, $r%u, $acr\n", memsize_char(memsize_zz(dc)), dc->op2, dc->op1));cris_cc_mask(dc, 0);t0 = tcg_temp_new(TCG_TYPE_TL);tcg_gen_shl_tl(t0, cpu_R[dc->op2], tcg_const_tl(dc->zzsize));tcg_gen_add_tl(cpu_R[R_ACR], cpu_R[dc->op1], t0)... |
1 | int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad){ AVFilterLink **newlinks; AVFilterPad *newpads; unsigned i; idx = FFMIN(idx, *count); newpads = av_realloc_array(*pads, *count + 1, sizeof(AVFilterPad)); newlinks = av_realloc_array(*links... |
1 | sbappend(struct socket *so, struct mbuf *m){int ret = 0;DEBUG_CALL("sbappend");DEBUG_ARG("so = %p", so);DEBUG_ARG("m = %p", m);DEBUG_ARG("m->m_len = %d", m->m_len);/* Shouldn't happen, but... e.g. foreign host closes connection */if (m->m_len <= 0) {m_free(m);return;}/* * If there is urgent data, call sosendoob * if no... |
1 | static int xan_decode_chroma(AVCodecContext *avctx, unsigned chroma_off){ XanContext *s = avctx->priv_data; uint8_t *U, *V; int val, uval, vval; int i, j; const uint8_t *src, *src_end; const uint8_t *table; int mode, offset, dec_size; if (!chroma_off) return 0; if (chroma_off + 4 >= bytestream2_get_bytes_left(&s->gb)) ... |
1 | void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f, int mb_x, int mb_y){ int mbedge_lim, bedge_lim, hev_thresh; int filter_level = f->filter_level; int inner_limit = f->inner_limit; int inner_filter = f->inner_filter; int linesize = s->linesize; int uvlinesize = s->uvlinesize; static const uint8_t hev_... |
1 | static void migrate_check_parameter(QTestState *who, const char *parameter, const char *value){ QDict *rsp, *rsp_return; const char *result; rsp = wait_command(who, "{ 'execute': 'query-migrate-parameters' }"); rsp_return = qdict_get_qdict(rsp, "return"); result = g_strdup_printf("%" PRId64, qdict_get_try_int(rsp_retur... |
1 | int ff_h264_decode_extradata(H264Context *h, const uint8_t *buf, int size){ AVCodecContext *avctx = h->s.avctx; if (!buf || size <= 0) return -1; if (buf[0] == 1) { int i, cnt, nalsize; const unsigned char *p = buf; h->is_avc = 1; if (size < 7) { av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); return -1; } /* sps and ... |
1 | static void spr_write_hdecr(DisasContext *ctx, int sprn, int gprn){ if (ctx->tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_helper_store_hdecr(cpu_env, cpu_gpr[gprn]); if (ctx->tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_stop_exception(ctx); }} |
1 | static int ioreq_parse(struct ioreq *ioreq){ struct XenBlkDev *blkdev = ioreq->blkdev; uintptr_t mem; size_t len; int i; xen_be_printf(&blkdev->xendev, 3, "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n", ioreq->req.operation, ioreq->req.nr_segments, ioreq->req.handle, ioreq->req.id, ioreq->req.sector_nu... |
1 | static void test_qemu_strtoul_full_empty(void){ const char *str = ""; unsigned long res = 999; int err; err = qemu_strtoul(str, NULL, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, 0);} |
1 | static void xen_sysdev_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = xen_sysdev_init; dc->props = xen_sysdev_properties; dc->bus_type = TYPE_XENSYSBUS;} |
1 | static int vqf_read_header(AVFormatContext *s){ VqfContext *c = s->priv_data; AVStream *st = avformat_new_stream(s, NULL); int chunk_tag; int rate_flag = -1; int header_size; int read_bitrate = 0; int size; uint8_t comm_chunk[12]; if (!st) return AVERROR(ENOMEM); avio_skip(s->pb, 12); header_size = avio_rb32(s->pb); st... |
1 | int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset){ return do_sendv_recvv(sockfd, iov, len, iov_offset, 1);} |
1 | static int gdb_handle_vcont(GDBState *s, const char *p){ int res, idx, signal = 0; char cur_action; char *newstates; unsigned long tmp; CPUState *cpu;#ifdef CONFIG_USER_ONLY int max_cpus = 1; /* global variable max_cpus exists only in system mode */ CPU_FOREACH(cpu) { max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_in... |
1 | static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost){ AVFormatContext *s = of->ctx; AVStream *st = ost->st; int ret; if (!of->header_written) { AVPacket tmp_pkt; /* the muxer is not initialized yet, buffer the packet */ if (!av_fifo_space(ost->muxing_queue)) { int new_size = FFMIN(2 * av_fifo_size... |
1 | void bdrv_commit_all(void){ BlockDriverState *bs; QTAILQ_FOREACH(bs, &bdrv_states, list) { bdrv_commit(bs); }} |
1 | static int event_qdev_exit(DeviceState *qdev){ SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev); SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event); if (child->exit) { child->exit(event); } return 0;} |
0 | static av_cold int amr_wb_encode_init(AVCodecContext *avctx){ AMRWBContext *s = avctx->priv_data; if (avctx->sample_rate != 16000) { av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n"); return AVERROR(ENOSYS); } if (avctx->channels != 1) { av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); return AVE... |
0 | static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { MpegEncContext * const s = &h->s; int mb_y_firstrow = s->picture_structure == PICT_BOTTOM_FIELD; int mb_xy, mb_type; int qp, qp0, qp1, qpc, qpc0, qpc1, qp_t... |
1 | static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename){ int i, err; AVFormatContext *ic = avformat_alloc_context(); ic->interrupt_callback = int_cb; err = avformat_open_input(&ic, filename, NULL, NULL); if (err < 0) return err; /* copy stream format */ for(i=0;i<ic->nb_streams;i++... |
1 | VirtIODevice *virtio_balloon_init(DeviceState *dev){ VirtIOBalloon *s; s = (VirtIOBalloon *)virtio_common_init("virtio-balloon", VIRTIO_ID_BALLOON, 8, sizeof(VirtIOBalloon)); s->vdev.get_config = virtio_balloon_get_config; s->vdev.set_config = virtio_balloon_set_config; s->vdev.get_features = virtio_balloon_get_feature... |
1 | static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output){ AVFrame *decoded_frame, *f; AVCodecContext *avctx = ist->dec_ctx; int i, ret, err = 0; if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc())) return AVERROR(ENOMEM); if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc())... |
1 | static void test_port(int port){ struct qhc uhci; g_assert(port > 0); qusb_pci_init_one(qs->pcibus, &uhci, QPCI_DEVFN(0x1d, 0), 4); uhci_port_test(&uhci, port - 1, UHCI_PORT_CCS);} |
1 | rgb16_32ToUV_c_template(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width, enum PixelFormat origin, int shr, int shg, int shb, int shp, int maskr, int maskg, int maskb, int rsh, int gsh, int bsh, int S){ const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh, rv = RV << rsh, gv = GV << gsh, bv = BV << bsh, ... |
1 | void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict){ Error *err = NULL; qmp_block_set_io_throttle(qdict_get_str(qdict, "device"), qdict_get_int(qdict, "bps"), qdict_get_int(qdict, "bps_rd"), qdict_get_int(qdict, "bps_wr"), qdict_get_int(qdict, "iops"), qdict_get_int(qdict, "iops_rd"), qdict_get_int(qdict, ... |
1 | void qemu_system_shutdown_request(void){ trace_qemu_system_shutdown_request(); replay_shutdown_request(); shutdown_requested = 1; qemu_notify_event();} |
1 | size_t mptsas_config_ioc_0(MPTSASState *s, uint8_t **data, int address){ PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s); return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_IOC, 0x01, "*l*lwwb*b*b*blww", pcic->vendor_id, pcic->device_id, pcic->revision, pcic->subsystem_vendor_id, pcic->subsystem_id);} |
1 | static uint32_t sh_serial_ioport_read(void *opaque, uint32_t offs){ sh_serial_state *s = opaque; uint32_t ret = ~0;#if 0 switch(offs) { case 0x00: ret = s->smr; break; case 0x04: ret = s->brr;break; case 0x08: ret = s->scr; break; case 0x14: ret = 0; break; }#endif if (s->feat & SH_SERIAL_FEAT_SCIF) { switch(offs) { ca... |
1 | void ide_dma_cb(void *opaque, int ret){ IDEState *s = opaque; int n; int64_t sector_num; bool stay_active = false; if (ret < 0) { int op = BM_STATUS_DMA_RETRY; if (s->dma_cmd == IDE_DMA_READ) op |= BM_STATUS_RETRY_READ; else if (s->dma_cmd == IDE_DMA_TRIM) op |= BM_STATUS_RETRY_TRIM; if (ide_handle_rw_error(s, -ret, op... |
1 | static void icp_realize(DeviceState *dev, Error **errp){ ICPState *icp = ICP(dev); ICPStateClass *icpc = ICP_GET_CLASS(dev); PowerPCCPU *cpu; CPUPPCState *env; Object *obj; Error *err = NULL; obj = object_property_get_link(OBJECT(dev), ICP_PROP_XICS, &err); if (!obj) { error_setg(errp, "%s: required link '" ICP_PROP_XI... |
1 | static inline void gen_st8(TCGv val, TCGv addr, int index){ tcg_gen_qemu_st8(val, addr, index); dead_tmp(val);} |
0 | static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx, InputStream *ist, int in_program){ AVStream *stream = ist->st; AVCodecParameters *par; AVCodecContext *dec_ctx; char val_str[128]; const char *s; AVRational sar, dar; AVBPrint pbuf; const AVCodecDescriptor *cd; int ret = 0; const char *p... |
0 | static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale, int filter_type, int kaiser_beta){ int ph, i; double x, y, w; double *tab = av_malloc_array(tap_count+1, sizeof(*tab)); const int center= (tap_count-1)/2; if (!tab) return AVERROR(ENOMEM); /* i... |
1 | e1000e_write_ps_rx_descr(E1000ECore *core, uint8_t *desc, struct NetRxPkt *pkt, const E1000E_RSSInfo *rss_info, size_t ps_hdr_len, uint16_t(*written)[MAX_PS_BUFFERS]){ int i; union e1000_rx_desc_packet_split *d = (union e1000_rx_desc_packet_split *) desc; memset(d, 0, sizeof(*d)); d->wb.middle.length0 = cpu_to_le16((*w... |
1 | static void print_track_chunks(FILE *out, struct Tracks *tracks, int main, const char *type){ int i, j; struct Track *track = tracks->tracks[main]; for (i = 0; i < track->chunks; i++) { for (j = main + 1; j < tracks->nb_tracks; j++) { if (tracks->tracks[j]->is_audio == track->is_audio && track->offsets[i].duration != t... |
1 | void vncws_handshake_read(void *opaque){ VncState *vs = opaque; uint8_t *handshake_end; long ret; buffer_reserve(&vs->ws_input, 4096); ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096); if (!ret) { if (vs->csock == -1) { vnc_disconnect_finish(vs); } return; } vs->ws_input.offset += ret; handshake_end = (ui... |
1 | void helper_rfmci(CPUPPCState *env){ do_rfi(env, env->spr[SPR_BOOKE_MCSRR0], SPR_BOOKE_MCSRR1, ~((target_ulong)0x3FFF0000), 0);} |
1 | static int get_phys_addr_lpae(CPUARMState *env, target_ulong address, int access_type, int is_user, hwaddr *phys_ptr, int *prot, target_ulong *page_size_ptr){ CPUState *cs = CPU(arm_env_get_cpu(env)); /* Read an LPAE long-descriptor translation table. */ MMUFaultType fault_type = translation_fault; uint32_t level = 1; ... |
1 | av_cold void ff_diracdsp_init(DiracDSPContext *c){ c->dirac_hpel_filter = dirac_hpel_filter; c->add_rect_clamped = add_rect_clamped_c; c->put_signed_rect_clamped[0] = put_signed_rect_clamped_8bit_c; c->put_signed_rect_clamped[1] = put_signed_rect_clamped_10bit_c; c->add_dirac_obmc[0] = add_obmc8_c; c->add_dirac_obmc[1]... |
1 | static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){ int count, y, x, i, j, split, best_mean, best_score, best_count; int best_vector[6]; int block_sum[7]= {0, 0, 0, 0, 0, 0}; int w= 2<<((level+2)>>1); int h= 2<<((level+1)>>1... |
1 | void object_property_set_link(Object *obj, Object *value, const char *name, Error **errp){ object_property_set_str(obj, object_get_canonical_path(value), name, errp);} |
1 | static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i){ BDRVQcowState *s = bs->opaque; int ret = 0; if (!c->entries[i].dirty || !c->entries[i].offset) { return 0; } trace_qcow2_cache_entry_flush(qemu_coroutine_self(), c == s->l2_table_cache, i); if (c->depends) { ret = qcow2_cache_flush_dependen... |
0 | USBBus *usb_bus_new(DeviceState *host){ USBBus *bus; bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL)); bus->busnr = next_usb_bus++; TAILQ_INIT(&bus->free); TAILQ_INIT(&bus->used); TAILQ_INSERT_TAIL(&busses, bus, next); return bus;} |
0 | sPAPRTCETable *spapr_tce_new_table(DeviceState *owner, uint32_t liobn){ sPAPRTCETable *tcet; char tmp[32]; if (spapr_tce_find_by_liobn(liobn)) { error_report("Attempted to create TCE table with duplicate" " LIOBN 0x%x", liobn); return NULL; } tcet = SPAPR_TCE_TABLE(object_new(TYPE_SPAPR_TCE_TABLE)); tcet->liobn = liobn... |
0 | bool arm_regime_using_lpae_format(CPUARMState *env, ARMMMUIdx mmu_idx){ return regime_using_lpae_format(env, mmu_idx);} |
0 | static int usb_hub_initfn(USBDevice *dev){ USBHubState *s = DO_UPCAST(USBHubState, dev, dev); USBHubPort *port; int i; s->dev.speed = USB_SPEED_FULL; for (i = 0; i < NUM_PORTS; i++) { port = &s->ports[i]; usb_register_port(usb_bus_from_device(dev), &port->port, s, i, &s->dev, usb_hub_attach); port->wPortStatus = PORT_S... |
0 | static void horizontal_filter(unsigned char *first_pixel, int stride, int *bounding_values){ unsigned char *end; int filter_value; for (end= first_pixel + 8*stride; first_pixel < end; first_pixel += stride) { filter_value = (first_pixel[-2] - first_pixel[ 1]) +3*(first_pixel[ 0] - first_pixel[-1]); filter_value = bound... |
0 | build_dmar_q35(GArray *table_data, BIOSLinker *linker){ int dmar_start = table_data->len; AcpiTableDmar *dmar; AcpiDmarHardwareUnit *drhd; AcpiDmarRootPortATS *atsr; uint8_t dmar_flags = 0; X86IOMMUState *iommu = x86_iommu_get_default(); AcpiDmarDeviceScope *scope = NULL; /* Root complex IOAPIC use one path[0] only */ ... |
0 | static void spapr_dr_connector_class_init(ObjectClass *k, void *data){ DeviceClass *dk = DEVICE_CLASS(k); sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); dk->reset = reset; dk->realize = realize; dk->unrealize = unrealize; drck->set_isolation_state = set_isolation_state; drck->set_allocation_state = set_allo... |
0 | static void smbios_validate_table(void){ if (smbios_type4_count && smbios_type4_count != smp_cpus) { fprintf(stderr, "Number of SMBIOS Type 4 tables must match cpu count.\n"); exit(1); }} |
0 | static int xen_pt_bar_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry, uint32_t *val, uint32_t dev_value, uint32_t valid_mask){ XenPTRegInfo *reg = cfg_entry->reg; XenPTRegion *base = NULL; PCIDevice *d = &s->dev; const PCIIORegion *r; uint32_t writable_mask = 0; uint32_t bar_emu_mask = 0; uint32_t bar_ro_mask... |
0 | static void v9fs_write(void *opaque){ ssize_t err; int32_t fid; uint64_t off; uint32_t count; int32_t len = 0; int32_t total = 0; size_t offset = 7; V9fsFidState *fidp; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; QEMUIOVector qiov_full; QEMUIOVector qiov; offset += pdu_unmarshal(pdu, offset, "dqd", &fid, &off, &count... |
0 | void machine_register_compat_props(MachineState *machine){ MachineClass *mc = MACHINE_GET_CLASS(machine); int i; GlobalProperty *p; if (!mc->compat_props) { return; } for (i = 0; i < mc->compat_props->len; i++) { p = g_array_index(mc->compat_props, GlobalProperty *, i); /* Machine compat_props must never cause errors: ... |
0 | static int win_chr_pipe_init(CharDriverState *chr, const char *filename, Error **errp){ WinCharState *s = chr->opaque; OVERLAPPED ov; int ret; DWORD size; char openname[CHR_MAX_FILENAME_SIZE]; s->fpipe = TRUE; s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL); if (!s->hsend) { error_setg(errp, "Failed CreateEvent"); goto... |
0 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus, const char *name, int devfn, Error **errp){ PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev); PCIConfigReadFunc *config_read = pc->config_read; PCIConfigWriteFunc *config_write = pc->config_write; Error *local_err = NULL; DeviceState *dev = DEV... |
0 | int floatx80_lt(floatx80 a, floatx80 b, float_status *status){ flag aSign, bSign; if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { float_raise(float_flag_invalid, status); return 0;... |
0 | int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, const char *tag){ while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { bs = bs->file; } if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { return bs->drv->bdrv_debug_breakpoint(bs, event, tag); } return -ENOTSUP;} |
0 | static target_ulong h_add_logical_lan_buffer(PowerPCCPU *cpu, sPAPRMachineState *spapr, target_ulong opcode, target_ulong *args){ target_ulong reg = args[0]; target_ulong buf = args[1]; VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); target_long ... |
0 | static void openrisc_pic_cpu_handler(void *opaque, int irq, int level){ OpenRISCCPU *cpu = (OpenRISCCPU *)opaque; CPUState *cs = CPU(cpu); int i; uint32_t irq_bit = 1 << irq; if (irq > 31 || irq < 0) { return; } if (level) { cpu->env.picsr |= irq_bit; } else { cpu->env.picsr &= ~irq_bit; } for (i = 0; i < 32; i++) { if... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.