label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf, QDict *options, Error **errp){ QemuOpts *opts; SocketAddress *gsconf = NULL; SocketAddressList *curr = NULL; QDict *backing_options = NULL; Error *local_err = NULL; char *str = NULL; const char *ptr; size_t num_servers; int i, type; /* create opts info f... |
1 | static int try_seek_hole(BlockDriverState *bs, off_t start, off_t *data, off_t *hole){#if defined SEEK_HOLE && defined SEEK_DATA BDRVRawState *s = bs->opaque; *hole = lseek(s->fd, start, SEEK_HOLE); if (*hole == -1) { return -errno; } if (*hole > start) { *data = start; } else { /* On a hole. We need another syscall to... |
1 | static int net_client_init(const char *str){ const char *p; char *q; char device[64]; char buf[1024]; int vlan_id, ret; VLANState *vlan; p = str; q = device; while (*p != '\0' && *p != ',') { if ((q - device) < sizeof(device) - 1) *q++ = *p; p++; } *q = '\0'; if (*p == ',') p++; vlan_id = 0; if (get_param_value(buf, si... |
1 | static void kvm_io_ioeventfd_add(MemoryListener *listener, MemoryRegionSection *section, bool match_data, uint64_t data, EventNotifier *e){ int fd = event_notifier_get_fd(e); int r; r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space, data, true, int128_get64(section->size), match_data); if (r < 0) { abo... |
0 | void opt_input_file(const char *filename){ AVFormatContext *ic; AVFormatParameters params, *ap = ¶ms; int err, i, ret, rfps; /* get default parameters from command line */ memset(ap, 0, sizeof(*ap)); ap->sample_rate = audio_sample_rate; ap->channels = audio_channels; ap->frame_rate = frame_rate; ap->width = frame_w... |
1 | static inline bool regime_is_secure(CPUARMState *env, ARMMMUIdx mmu_idx){ switch (mmu_idx) { case ARMMMUIdx_S12NSE0: case ARMMMUIdx_S12NSE1: case ARMMMUIdx_S1NSE0: case ARMMMUIdx_S1NSE1: case ARMMMUIdx_S1E2: case ARMMMUIdx_S2NS: return false; case ARMMMUIdx_S1E3: case ARMMMUIdx_S1SE0: case ARMMMUIdx_S1SE1: return true;... |
1 | static int parse_iplconvkernel(IplConvKernel **kernel, char *buf, void *log_ctx){ char shape_filename[128] = "", shape_str[32] = "rect"; int cols = 0, rows = 0, anchor_x = 0, anchor_y = 0, shape = CV_SHAPE_RECT; int *values = NULL, ret; sscanf(buf, "%dx%d+%dx%d/%32[^=]=%127s", &cols, &rows, &anchor_x, &anchor_y, shape_... |
1 | static uint32_t pci_up_read(void *opaque, uint32_t addr){ PIIX4PMState *s = opaque; uint32_t val = s->pci0_status.up; PIIX4_DPRINTF("pci_up_read %x\n", val); return val;} |
1 | static int amovie_request_frame(AVFilterLink *outlink){ MovieContext *movie = outlink->src->priv; int ret; if (movie->is_done) return AVERROR_EOF; if ((ret = amovie_get_samples(outlink)) < 0) return ret; avfilter_filter_samples(outlink, avfilter_ref_buffer(movie->samplesref, ~0)); avfilter_unref_buffer(movie->samplesre... |
1 | inline static void RENAME(hcscale)(uint16_t *dst, long dstWidth, uint8_t *src1, uint8_t *src2, int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter, int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode, int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter, int32_t *mmx2FilterPos, uint... |
1 | static void virtio_blk_rw_complete(void *opaque, int ret){ VirtIOBlockReq *next = opaque; while (next) { VirtIOBlockReq *req = next; next = req->mr_next; trace_virtio_blk_rw_complete(req, ret); if (req->qiov.nalloc != -1) { /* If nalloc is != 1 req->qiov is a local copy of the original * external iovec. It was allocate... |
1 | static void qmp_input_type_str(Visitor *v, const char *name, char **obj, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true)); if (!qstr) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null", "string"); return; } *obj = g_strdup(qstri... |
1 | static int wavpack_decode_block(AVCodecContext *avctx, int block_no, void *data, int *got_frame_ptr, const uint8_t *buf, int buf_size){ WavpackContext *wc = avctx->priv_data; WavpackFrameContext *s; void *samples = data; int samplecount; int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, ... |
1 | int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int flags){ int bps, blkalign, bytespersec, frame_size; int hdrsize; int64_t hdrstart = avio_tell(pb); int waveformatextensible; uint8_t temp[256]; uint8_t *riff_extradata = temp; uint8_t *riff_extradata_start = temp; if (!par->codec_tag... |
0 | MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp){ MigrationCapabilityStatusList *head = NULL; MigrationCapabilityStatusList *caps; MigrationState *s = migrate_get_current(); int i; caps = NULL; /* silence compiler warning */ for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {#ifndef CONFIG_LIVE... |
0 | static int read_f(BlockBackend *blk, int argc, char **argv){ struct timeval t1, t2; int Cflag = 0, pflag = 0, qflag = 0, vflag = 0; int Pflag = 0, sflag = 0, lflag = 0, bflag = 0; int c, cnt; char *buf; int64_t offset; int count; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int ... |
0 | 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... |
0 | static void monitor_find_completion(const char *cmdline){ const char *cmdname; char *args[MAX_ARGS]; int nb_args, i, len; const char *ptype, *str; const mon_cmd_t *cmd; const KeyDef *key; parse_cmdline(cmdline, &nb_args, args);#ifdef DEBUG_COMPLETION for(i = 0; i < nb_args; i++) { monitor_printf(cur_mon, "arg%d = '%s'\... |
0 | CPUSPARCState *cpu_sparc_init(const char *cpu_model){ SPARCCPU *cpu; CPUSPARCState *env; cpu = SPARC_CPU(object_new(TYPE_SPARC_CPU)); env = &cpu->env; gen_intermediate_code_init(env); if (cpu_sparc_register(env, cpu_model) < 0) { object_delete(OBJECT(cpu)); return NULL; } qemu_init_vcpu(env); return env;} |
0 | static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr, int count, int copy){ struct target_iovec *target_vec; abi_ulong base; int i; target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1); if (!target_vec) return -TARGET_EFAULT; for(i = 0;i < count; i++) { base = tswapl... |
0 | static int v9fs_synth_chmod(FsContext *fs_ctx, V9fsPath *path, FsCred *credp){ errno = EPERM; return -1;} |
0 | static void mem_commit(MemoryListener *listener){ AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener); AddressSpaceDispatch *cur = as->dispatch; AddressSpaceDispatch *next = as->next_dispatch; next->nodes = next_map.nodes; next->sections = next_map.sections; phys_page_compact_all(next, next_map.n... |
0 | static void do_audio_out(AVFormatContext *s, OutputStream *ost, AVFrame *frame){ AVCodecContext *enc = ost->st->codec; AVPacket pkt; int got_packet = 0; av_init_packet(&pkt); pkt.data = NULL; pkt.size = 0;#if 0 if (!check_recording_time(ost)) return;#endif if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0) fram... |
0 | static void qemu_rdma_init_one_block(void *host_addr, ram_addr_t block_offset, ram_addr_t length, void *opaque){ rdma_add_block(opaque, host_addr, block_offset, length);} |
0 | START_TEST(qdict_iterapi_test){ int count; const QDictEntry *ent; fail_unless(qdict_first(tests_dict) == NULL); qdict_put(tests_dict, "key1", qint_from_int(1)); qdict_put(tests_dict, "key2", qint_from_int(2)); qdict_put(tests_dict, "key3", qint_from_int(3)); count = 0; for (ent = qdict_first(tests_dict); ent; ent = qdi... |
0 | static int coroutine_fn bdrv_co_do_zero_pwritev(BlockDriverState *bs, int64_t offset, unsigned int bytes, BdrvRequestFlags flags, BdrvTrackedRequest *req){ uint8_t *buf = NULL; QEMUIOVector local_qiov; struct iovec iov; uint64_t align = bs->bl.request_alignment; unsigned int head_padding_bytes, tail_padding_bytes; int ... |
0 | static void qemu_wait_io_event(CPUState *env){ while (!tcg_has_work()) qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000); qemu_mutex_unlock(&qemu_global_mutex); /* * Users of qemu_global_mutex can be starved, having no chance * to acquire it since this path will get to it first. * So use another lock to pro... |
0 | void qemu_co_queue_init(CoQueue *queue){ QTAILQ_INIT(&queue->entries); /* This will be exposed to callers once there are multiple AioContexts */ queue->ctx = qemu_get_aio_context();} |
0 | int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg){ int64_t deadline = -1; QEMUClockType type; bool play = replay_mode == REPLAY_MODE_PLAY; for (type = 0; type < QEMU_CLOCK_MAX; type++) { if (qemu_clock_use_for_deadline(type)) { if (!play || type == QEMU_CLOCK_REALTIME) { deadline = qemu_soonest_timeout(deadli... |
0 | static void socket_connect_data_free(socket_connect_data *c){ qapi_free_SocketAddressLegacy(c->saddr); g_free(c->model); g_free(c->name); g_free(c);} |
0 | static int blk_connect(struct XenDevice *xendev){ struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); int pers, index, qflags; bool readonly = true; /* read-only ? */ if (blkdev->directiosafe) { qflags = BDRV_O_NOCACHE | BDRV_O_NATIVE_AIO; } else { qflags = BDRV_O_CACHE_WB; } if (strcmp(blkdev->m... |
0 | static uint64_t qemu_rdma_poll(RDMAContext *rdma, uint64_t *wr_id_out){ int ret; struct ibv_wc wc; uint64_t wr_id; ret = ibv_poll_cq(rdma->cq, 1, &wc); if (!ret) { *wr_id_out = RDMA_WRID_NONE; return 0; } if (ret < 0) { fprintf(stderr, "ibv_poll_cq return %d!\n", ret); return ret; } wr_id = wc.wr_id & RDMA_WRID_TYPE_MA... |
0 | build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, const char *oem_id, const char *oem_table_id){ AcpiRsdtDescriptorRev1 *rsdt; size_t rsdt_len; int i; const int table_data_len = (sizeof(uint32_t) * table_offsets->len); rsdt_len = sizeof(*rsdt) + table_data_len; rsdt = acpi_data_push(table_data, ... |
0 | static av_cold int Faac_encode_close(AVCodecContext *avctx){ FaacAudioContext *s = avctx->priv_data; av_freep(&avctx->coded_frame); av_freep(&avctx->extradata); faacEncClose(s->faac_handle); return 0;} |
1 | static int object_create(QemuOpts *opts, void *opaque){ const char *type = qemu_opt_get(opts, "qom-type"); const char *id = qemu_opts_id(opts); Object *obj; g_assert(type != NULL); if (id == NULL) { qerror_report(QERR_MISSING_PARAMETER, "id"); return -1; } obj = object_new(type); if (qemu_opt_foreach(opts, object_set_p... |
1 | void tpm_backend_cancel_cmd(TPMBackend *s){ TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s); assert(k->cancel_cmd); k->cancel_cmd(s);} |
1 | void scsi_bus_legacy_handle_cmdline(SCSIBus *bus){ DriveInfo *dinfo; int unit; for (unit = 0; unit < MAX_SCSI_DEVS; unit++) { dinfo = drive_get(IF_SCSI, bus->busnr, unit); if (dinfo == NULL) { continue; } scsi_bus_legacy_add_drive(bus, dinfo, unit); }} |
1 | AVD3D11VAContext *av_d3d11va_alloc_context(void){ AVD3D11VAContext* res = av_mallocz(sizeof(AVD3D11VAContext)); res->context_mutex = INVALID_HANDLE_VALUE; return res;} |
1 | static TCGv_i32 new_tmp(void){ num_temps++; return tcg_temp_new_i32();} |
1 | static int cudaupload_query_formats(AVFilterContext *ctx){ int ret; static const enum AVPixelFormat input_pix_fmts[] = { AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE, }; static const enum AVPixelFormat output_pix_fmts[] = { AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE, }; AVFilterFormats *in_fmts = ff_m... |
1 | void ioinst_handle_ssch(S390CPU *cpu, uint64_t reg1, uint32_t ipb){ int cssid, ssid, schid, m; SubchDev *sch; ORB orig_orb, orb; uint64_t addr; int ret = -ENODEV; int cc; CPUS390XState *env = &cpu->env; uint8_t ar; addr = decode_basedisp_s(env, ipb, &ar); if (addr & 3) { program_interrupt(env, PGM_SPECIFICATION, 4); re... |
1 | static int virtio_blk_device_init(VirtIODevice *vdev){ DeviceState *qdev = DEVICE(vdev); VirtIOBlock *s = VIRTIO_BLK(vdev); VirtIOBlkConf *blk = &(s->blk); static int virtio_blk_id; if (!blk->conf.bs) { error_report("drive property not set"); return -1; } if (!bdrv_is_inserted(blk->conf.bs)) { error_report("Device need... |
0 | static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno){ int compno, reslevelno, bandno, ret; Jpeg2000T1Context t1; Jpeg2000CodingStyle *codsty = &s->codsty; for (compno = 0; compno < s->ncomponents; compno++){ Jpeg2000Component *comp = s->tile[tileno].comp + compno; av_log(s->avctx, AV_LOG_DE... |
0 | static void check_mct(uint8_t *ref0, uint8_t *ref1, uint8_t *ref2, uint8_t *new0, uint8_t *new1, uint8_t *new2) { declare_func(void, void *src0, void *src1, void *src2, int csize); randomize_buffers(); call_ref(ref0, ref1, ref2, BUF_SIZE / sizeof(int32_t)); call_new(new0, new1, new2, BUF_SIZE / sizeof(int32_t)); if (me... |
1 | int bdrv_flush_all(void){ BlockDriverState *bs; int result = 0; QTAILQ_FOREACH(bs, &bdrv_states, device_list) { int ret = bdrv_flush(bs); if (ret < 0 && !result) { result = ret; } } return result;} |
1 | static void FUNCC(ff_h264_add_pixels4)(uint8_t *_dst, int16_t *_src, int stride){ int i; pixel *dst = (pixel *) _dst; dctcoef *src = (dctcoef *) _src; stride /= sizeof(pixel); for (i = 0; i < 4; i++) { dst[0] += src[0]; dst[1] += src[1]; dst[2] += src[2]; dst[3] += src[3]; dst += stride; src += 4; } memset(_src, 0, siz... |
0 | static inline void downmix_2f_2r_to_mono(float *samples){ int i; for (i = 0; i < 256; i++) { samples[i] += (samples[i + 256] + samples[i + 512] + samples[i + 768]); samples[i + 256] = samples[i + 512] = samples[i + 768] = 0; }} |
0 | static inline void downmix_3f_1r_to_dolby(float *samples){ int i; for (i = 0; i < 256; i++) { samples[i] += (samples[i + 256] - samples[i + 768]); samples[i + 256] += (samples[i + 512] + samples[i + 768]); samples[i + 512] = samples[i + 768] = 0; }} |
1 | static void neon_store_scratch(int scratch, TCGv var){ tcg_gen_st_i32(var, cpu_env, offsetof(CPUARMState, vfp.scratch[scratch])); dead_tmp(var);} |
1 | void compute_images_mse(PSNRContext *s, const uint8_t *main_data[4], const int main_linesizes[4], const uint8_t *ref_data[4], const int ref_linesizes[4], int w, int h, double mse[4]){ int i, c, j; for (c = 0; c < s->nb_components; c++) { const int outw = s->planewidth[c]; const int outh = s->planeheight[c]; const uint8... |
1 | static void sparc_cpu_realizefn(DeviceState *dev, Error **errp){ SPARCCPUClass *scc = SPARC_CPU_GET_CLASS(dev); scc->parent_realize(dev, errp);} |
1 | static void block_migration_cancel(void *opaque){ blk_mig_cleanup();} |
1 | static void tap_cleanup(VLANClientState *nc){ TAPState *s = DO_UPCAST(TAPState, nc, nc); if (s->vhost_net) { vhost_net_cleanup(s->vhost_net); } qemu_purge_queued_packets(nc); if (s->down_script[0]) launch_script(s->down_script, s->down_script_arg, s->fd); tap_read_poll(s, 0); tap_write_poll(s, 0); close(s->fd);} |
0 | static int ape_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AVFrame *frame = data; const uint8_t *buf = avpkt->data; APEContext *s = avctx->priv_data; uint8_t *sample8; int16_t *sample16; int32_t *sample24; int i, ch, ret; int blockstodecode; /* this should never be negative, bu... |
0 | static int decode_plane(UtvideoContext *c, int plane_no, uint8_t *dst, int step, int stride, int width, int height, const uint8_t *src, int src_size, int use_pred){ int i, j, slice, pix; int sstart, send; VLC vlc; GetBitContext gb; int prev; const int cmask = ~(!plane_no && c->avctx->pix_fmt == PIX_FMT_YUV420P); if (bu... |
0 | static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom){ AVStream *st; enum AVAudioServiceType *ast; int ac3info, acmod, lfeon, bsmod; if (c->fc->nb_streams < 1) return 0; st = c->fc->streams[c->fc->nb_streams-1]; ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,... |
0 | static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, int has_alpha_channel){#if VPX_IMAGE_ABI_VERSION >= 3 static const enum AVColorSpace colorspaces[8] = { AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M, AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCO... |
1 | static int blk_mig_save_bulked_block(QEMUFile *f){ int64_t completed_sector_sum = 0; BlkMigDevState *bmds; int progress; int ret = 0; QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) { if (bmds->bulk_completed == 0) { if (mig_save_device_bulk(f, bmds) == 1) { /* completed bulk section for this device */ bmds->... |
1 | static int mpsub_probe(AVProbeData *p){ const char *ptr = p->buf; const char *ptr_end = p->buf + p->buf_size; while (ptr < ptr_end) { if (!memcmp(ptr, "FORMAT=TIME", 11)) return AVPROBE_SCORE_EXTENSION; if (!memcmp(ptr, "FORMAT=", 7)) return AVPROBE_SCORE_EXTENSION / 3; ptr += strcspn(ptr, "\n") + 1; } return 0;} |
1 | void MPV_common_init_altivec(MpegEncContext *s){ if (s->avctx->lowres==0) { if ((s->avctx->idct_algo == FF_IDCT_AUTO) || (s->avctx->idct_algo == FF_IDCT_ALTIVEC)) { s->dsp.idct_put = idct_put_altivec; s->dsp.idct_add = idct_add_altivec; s->dsp.idct_permutation_type = FF_TRANSPOSE_IDCT_PERM; } } // Test to make sure tha... |
1 | static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out){ char *pix_fmts; AVCodecContext *codec = ofilter->ost->st->codec; AVFilterContext *last_filter = out->filter_ctx; int pad_idx = out->pad_idx; int ret; AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();#if F... |
1 | static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ EightSvxContext *esc = avctx->priv_data; int n, out_data_size, ret; uint8_t *src, *dst; /* decode and interleave the first packet */ if (!esc->samples && avpkt) { uint8_t *deinterleaved_samples, *p = NULL; esc->sam... |
0 | static bool cmd_data_set_management(IDEState *s, uint8_t cmd){ switch (s->feature) { case DSM_TRIM: if (s->bs) { ide_sector_start_dma(s, IDE_DMA_TRIM); return false; } break; } ide_abort_command(s); return true;} |
0 | TranslationBlock *tb_gen_code(CPUState *cpu, target_ulong pc, target_ulong cs_base, uint32_t flags, int cflags){ CPUArchState *env = cpu->env_ptr; TranslationBlock *tb; tb_page_addr_t phys_pc, phys_page2; target_ulong virt_page2; tcg_insn_unit *gen_code_buf; int gen_code_size, search_size;#ifdef CONFIG_PROFILER int64_t... |
0 | void scsi_bus_legacy_handle_cmdline(SCSIBus *bus, bool deprecated){ Location loc; DriveInfo *dinfo; int unit; loc_push_none(&loc); for (unit = 0; unit <= bus->info->max_target; unit++) { dinfo = drive_get(IF_SCSI, bus->busnr, unit); if (dinfo == NULL) { continue; } qemu_opts_loc_restore(dinfo->opts); if (deprecated) { ... |
0 | static void axienet_eth_rx_notify(void *opaque){ XilinxAXIEnet *s = XILINX_AXI_ENET(opaque); while (s->rxsize && stream_can_push(s->tx_dev, axienet_eth_rx_notify, s)) { size_t ret = stream_push(s->tx_dev, (void *)s->rxmem + s->rxpos, s->rxsize, s->rxapp); s->rxsize -= ret; s->rxpos += ret; if (!s->rxsize) { s->regs[R_I... |
0 | START_TEST(qint_from_int64_test){ QInt *qi; const int64_t value = 0x1234567890abcdefLL; qi = qint_from_int(value); fail_unless((int64_t) qi->value == value); QDECREF(qi);} |
0 | static int exynos4210_fimd_init(SysBusDevice *dev){ Exynos4210fimdState *s = FROM_SYSBUS(Exynos4210fimdState, dev); s->ifb = NULL; sysbus_init_irq(dev, &s->irq[0]); sysbus_init_irq(dev, &s->irq[1]); sysbus_init_irq(dev, &s->irq[2]); memory_region_init_io(&s->iomem, &exynos4210_fimd_mmio_ops, s, "exynos4210.fimd", FIMD_... |
0 | void helper_fsqrtq(CPUSPARCState *env){ clear_float_exceptions(env); QT0 = float128_sqrt(QT1, &env->fp_status); check_ieee_exceptions(env);} |
0 | static void tpm_tis_abort(TPMState *s, uint8_t locty){ TPMTISEmuState *tis = &s->s.tis; tis->loc[locty].r_offset = 0; tis->loc[locty].w_offset = 0; DPRINTF("tpm_tis: tis_abort: new active locality is %d\n", tis->next_locty); /* * Need to react differently depending on who's aborting now and * which locality will become... |
0 | static TPMInfo *qmp_query_tpm_inst(TPMBackend *drv){ TPMInfo *res = g_new0(TPMInfo, 1); TPMPassthroughOptions *tpo; res->id = g_strdup(drv->id); res->model = drv->fe_model; res->options = g_new0(TpmTypeOptions, 1); switch (drv->ops->type) { case TPM_TYPE_PASSTHROUGH: res->options->type = TPM_TYPE_OPTIONS_KIND_PASSTHROU... |
0 | static void qemu_file_set_if_error(QEMUFile *f, int ret){ if (ret < 0 && !f->last_error) { qemu_file_set_error(f, ret); }} |
0 | static gboolean pty_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque){ CharDriverState *chr = opaque; PtyCharDriver *s = chr->opaque; gsize size, len; uint8_t buf[READ_BUF_LEN]; GIOStatus status; len = sizeof(buf); if (len > s->read_bytes) len = s->read_bytes; if (len == 0) return FALSE; status = g_io_channel... |
0 | void gic_update(GICState *s){ int best_irq; int best_prio; int irq; int level; int cpu; int cm; for (cpu = 0; cpu < NUM_CPU(s); cpu++) { cm = 1 << cpu; s->current_pending[cpu] = 1023; if (!s->enabled || !s->cpu_enabled[cpu]) { qemu_irq_lower(s->parent_irq[cpu]); return; } best_prio = 0x100; best_irq = 1023; for (irq = ... |
0 | static int ftp_auth(FTPContext *s){ const char *user = NULL, *pass = NULL; char *end = NULL, buf[CONTROL_BUFFER_SIZE], credencials[CREDENTIALS_BUFFER_SIZE]; int err; const int user_codes[] = {331, 230, 0}; const int pass_codes[] = {230, 0}; /* Authentication may be repeated, original string has to be saved */ av_strlcp... |
1 | static void put_int64(QEMUFile *f, void *pv, size_t size){ int64_t *v = pv; qemu_put_sbe64s(f, v);} |
0 | int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs, const int16_t *in, int buffer_length, int filter_length, int stop_on_overflow, int shift, int rounder){ int i,n; for (n = 0; n < buffer_length; n++) { int sum = rounder; for (i = 1; i <= filter_length; i++) sum -= filter_coeffs[i-1] * out[n-i];... |
0 | static int push_samples(AVFilterLink *outlink){ ASNSContext *asns = outlink->src->priv; AVFrame *outsamples = NULL; int ret, nb_out_samples, nb_pad_samples; if (asns->pad) { nb_out_samples = av_audio_fifo_size(asns->fifo) ? asns->nb_out_samples : 0; nb_pad_samples = nb_out_samples - FFMIN(nb_out_samples, av_audio_fifo_... |
0 | static void truemotion1_decode_16bit(TrueMotion1Context *s){ int y; int pixels_left; /* remaining pixels on this line */ unsigned int predictor_pair; unsigned int horiz_pred; unsigned int *vert_pred; unsigned int *current_pixel_pair; unsigned char *current_line = s->frame->data[0]; int keyframe = s->flags & FLAG_KEYFRA... |
0 | av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx){ int i; ff_check_alignment();#if CONFIG_ENCODERS if (avctx->bits_per_raw_sample == 10) { c->fdct = ff_jpeg_fdct_islow_10; c->fdct248 = ff_fdct248_islow_10; } else { if(avctx->dct_algo==FF_DCT_FASTINT) { c->fdct = fdct_ifast; c->fdct248 = fdct_ifast248; } e... |
0 | static void decode(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq){ rc->code -= cumFreq * rc->range; rc->range *= freq; while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) { unsigned byte = bytestream2_get_byte(gb); rc->code = (rc->code << 8) | byte; rc->range <<= 8; ... |
0 | int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags){ PerThreadContext *p = avctx->internal->thread_ctx; int err; f->owner = avctx; if (!(avctx->active_thread_type & FF_THREAD_FRAME)) return ff_get_buffer(avctx, f->f, flags); if (atomic_load(&p->state) != STATE_SETTING_UP && (avctx->codec->update_... |
0 | static void nfs_refresh_filename(BlockDriverState *bs, QDict *options){ NFSClient *client = bs->opaque; QDict *opts = qdict_new(); QObject *server_qdict; Visitor *ov; qdict_put(opts, "driver", qstring_from_str("nfs")); if (client->uid && !client->gid) { snprintf(bs->exact_filename, sizeof(bs->exact_filename), "nfs://%s... |
0 | static void pci_basic(gconstpointer data){ QVirtioPCIDevice *dev; QPCIBus *bus; QVirtQueuePCI *tx, *rx; QGuestAllocator *alloc; void (*func) (QVirtioDevice *dev, QGuestAllocator *alloc, QVirtQueue *rvq, QVirtQueue *tvq, int socket) = data; int sv[2], ret; ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sv); g_assert_cmpint(r... |
0 | static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj, Error **errp){ QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true, errp); QBool *qbool; if (!qobj) { return; } qbool = qobject_to_qbool(qobj); if (!qbool) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? n... |
0 | static int spapr_vio_busdev_init(DeviceState *qdev, DeviceInfo *qinfo){ VIOsPAPRDeviceInfo *info = (VIOsPAPRDeviceInfo *)qinfo; VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev; char *id; int ret; ret = spapr_vio_check_reg(dev, info); if (ret) { return ret; } /* Don't overwrite ids assigned on the command line */ if (!dev-... |
0 | static DriveInfo *blockdev_init(QDict *bs_opts, BlockInterfaceType type, DriveMediaType media){ const char *buf; const char *file = NULL; const char *serial; int ro = 0; int bdrv_flags = 0; int on_read_error, on_write_error; DriveInfo *dinfo; ThrottleConfig cfg; int snapshot = 0; bool copy_on_read; int ret; Error *erro... |
0 | static void ioq_init(LaioQueue *io_q){ QSIMPLEQ_INIT(&io_q->pending); io_q->plugged = 0; io_q->n = 0; io_q->blocked = false;} |
0 | static int sys_utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags){ return (utimensat(dirfd, pathname, times, flags));} |
0 | void hmp_delvm(Monitor *mon, const QDict *qdict){ BlockDriverState *bs; Error *err; const char *name = qdict_get_str(qdict, "name"); if (!find_vmstate_bs()) { monitor_printf(mon, "No block device supports snapshots\n"); return; } if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) { monitor_printf(mon, "Error while dele... |
0 | static inline void RENAME(rgb15tobgr24)(const uint8_t *src, uint8_t *dst, long src_size){ const uint16_t *end;#if COMPILE_TEMPLATE_MMX const uint16_t *mm_end;#endif uint8_t *d = dst; const uint16_t *s = (const uint16_t*)src; end = s + src_size/2;#if COMPILE_TEMPLATE_MMX __asm__ volatile(PREFETCH" %0"::"m"(*s):"memory")... |
0 | static void tcg_out_movi(TCGContext *s, TCGType type, TCGReg ret, tcg_target_long sval){ static const S390Opcode lli_insns[4] = { RI_LLILL, RI_LLILH, RI_LLIHL, RI_LLIHH }; tcg_target_ulong uval = sval; int i; if (type == TCG_TYPE_I32) { uval = (uint32_t)sval; sval = (int32_t)sval; } /* Try all 32-bit insns that can loa... |
0 | milkymist_init(MachineState *machine){ const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; LM32CPU *cpu; CPULM32State *env; int kernel_size; DriveInfo *dinfo; Mem... |
0 | static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset, int64_t offset_in_cluster, QEMUIOVector *qiov, uint64_t qiov_offset, uint64_t n_bytes, uint64_t offset){ int ret; VmdkGrainMarker *data = NULL; uLongf buf_len; QEMUIOVector local_qiov; struct iovec iov; int64_t write_offset; int64_t write_end_sect... |
0 | static int vnc_continue_handshake(struct VncState *vs) { int ret; if ((ret = gnutls_handshake(vs->tls_session)) < 0) { if (!gnutls_error_is_fatal(ret)) { VNC_DEBUG("Handshake interrupted (blocking)\n"); if (!gnutls_record_get_direction(vs->tls_session)) qemu_set_fd_handler(vs->csock, vnc_handshake_io, NULL, vs); else q... |
1 | void cpu_reset (CPUMIPSState *env){ memset(env, 0, offsetof(CPUMIPSState, breakpoints)); tlb_flush(env, 1); /* Minimal init */#if defined(CONFIG_USER_ONLY) env->hflags = MIPS_HFLAG_UM;#else if (env->hflags & MIPS_HFLAG_BMASK) { /* If the exception was raised from a delay slot, come back to the jump. */ env->CP0_ErrorEP... |
1 | static int vmdk_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ char *buf; int ret; BDRVVmdkState *s = bs->opaque; uint32_t magic; Error *local_err = NULL; bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false, errp); if (!bs->file) { return -EINVAL; } buf = vmdk_read_desc(bs->fi... |
1 | static inline void gen_neon_widen(TCGv_i64 dest, TCGv src, int size, int u){ if (u) { switch (size) { case 0: gen_helper_neon_widen_u8(dest, src); break; case 1: gen_helper_neon_widen_u16(dest, src); break; case 2: tcg_gen_extu_i32_i64(dest, src); break; default: abort(); } } else { switch (size) { case 0: gen_helper_n... |
1 | static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MpegEncContext *s = avctx->priv_data; int i; AVFrame *pict = data; int slice_count; const uint8_t *slices_hdr = NULL; av_dlog(avctx, "*****frame %d size=%d\n", ... |
1 | static void output_client_manifest(struct VideoFiles *files, const char *basename, int split){ char filename[1000]; FILE *out; int i, j; if (split) snprintf(filename, sizeof(filename), "Manifest"); else snprintf(filename, sizeof(filename), "%s.ismc", basename); out = fopen(filename, "w"); if (!out) { perror(filename); ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.