label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp){ BDRVQcowState *s = bs->opaque; int flags = s->flags; AES_KEY aes_encrypt_key; AES_KEY aes_decrypt_key; uint32_t crypt_method = 0; QDict *options; Error *local_err = NULL; int ret; /* * Backing files are read-only which makes all of their metadata i... |
1 | static void ppc_prep_init (ram_addr_t ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUState *env = NULL, *envs[MAX_CPUS]; char *filename; nvram_t nvram; m48t59_t *m48t59; int PPC_io_memory; int linux_boot, i, nb_nics1, b... |
1 | static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ MpegEncContext * const s = &h->s; int i, j; int current_ref_assigned=0; Picture *pic; if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0) av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); for(i=0; i<mmco_count; i++){ int structure, frame... |
0 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref){ AVFilterContext *ctx = inlink->dst; ShowInfoContext *showinfo = ctx->priv; uint32_t plane_checksum[8] = {0}, checksum = 0; char chlayout_str[128]; int plane; for (plane = 0; samplesref->data[plane] && plane < 8; plane++) { uint8_t *data = ... |
0 | static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx){ VAAPIEncodeContext *ctx = avctx->priv_data; int hrd_buffer_size; int hrd_initial_buffer_fullness; if (avctx->rc_buffer_size) hrd_buffer_size = avctx->rc_buffer_size; else hrd_buffer_size = avctx->bit_rate; if (avctx->rc_initial_buffer_occupancy) ... |
0 | static void glib_pollfds_poll(void){ GMainContext *context = g_main_context_default(); GPollFD *pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx); if (g_main_context_check(context, max_priority, pfds, glib_n_poll_fds)) { g_main_context_dispatch(context); }} |
0 | static int parse_drive(DeviceState *dev, const char *str, void **ptr){ BlockDriverState *bs; bs = bdrv_find(str); if (bs == NULL) { return -ENOENT; } if (bdrv_attach_dev(bs, dev) < 0) { return -EEXIST; } *ptr = bs; return 0;} |
0 | static void hda_audio_exit(HDACodecDevice *hda){ HDAAudioState *a = HDA_AUDIO(hda); HDAAudioStream *st; int i; dprint(a, 1, "%s\n", __FUNCTION__); for (i = 0; i < ARRAY_SIZE(a->st); i++) { st = a->st + i; if (st->node == NULL) { continue; } if (st->output) { AUD_close_out(&a->card, st->voice.out); } else { AUD_close_in... |
0 | static void curl_block_init(void){ bdrv_register(&bdrv_http); bdrv_register(&bdrv_https); bdrv_register(&bdrv_ftp); bdrv_register(&bdrv_ftps); bdrv_register(&bdrv_tftp);} |
0 | static always_inline void gen_fcmov (void *func, int ra, int rb, int rc){ int l1; TCGv tmp; if (unlikely(rc == 31)) return; l1 = gen_new_label(); tmp = tcg_temp_new(TCG_TYPE_I64); if (ra != 31) { tmp = tcg_temp_new(TCG_TYPE_I64); tcg_gen_helper_1_1(func, tmp, cpu_fir[ra]); } else { tmp = tcg_const_i64(0); tcg_gen_helpe... |
0 | static inline void gen_outs(DisasContext *s, int ot){ gen_string_movl_A0_ESI(s); gen_op_ld_T0_A0(ot + s->mem_index); gen_op_mov_TN_reg(OT_WORD, 1, R_EDX); tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[1]); tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff); tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[0]); tcg_gen_helper_0_2(... |
0 | static void vscsi_command_complete(SCSIRequest *sreq, uint32_t status){ VSCSIState *s = DO_UPCAST(VSCSIState, vdev.qdev, sreq->bus->qbus.parent); vscsi_req *req = sreq->hba_private; int32_t res_in = 0, res_out = 0; dprintf("VSCSI: SCSI cmd complete, r=0x%x tag=0x%x status=0x%x, req=%p\n", reason, sreq->tag, status, req... |
0 | static void virtio_blk_flush_complete(void *opaque, int ret){ VirtIOBlockReq *req = opaque; if (ret) { if (virtio_blk_handle_rw_error(req, -ret, 0)) { return; } } virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); block_acct_done(bdrv_get_stats(req->dev->bs), &req->acct); virtio_blk_free_request(req);} |
0 | void ppc_hw_interrupt (CPUState *env){ env->exception_index = -1;} |
0 | void qmp_ringbuf_write(const char *device, const char *data, bool has_format, enum DataFormat format, Error **errp){ CharDriverState *chr; const uint8_t *write_data; int ret; gsize write_count; chr = qemu_chr_find(device); if (!chr) { error_setg(errp, "Device '%s' not found", device); return; } if (!chr_is_ringbuf(chr)... |
0 | int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data){ MigrationState *s = migrate_get_current(); const char *p; int detach = qdict_get_try_bool(qdict, "detach", 0); int blk = qdict_get_try_bool(qdict, "blk", 0); int inc = qdict_get_try_bool(qdict, "inc", 0); const char *uri = qdict_get_str(qdict, "uri")... |
0 | void *laio_init(void){ struct qemu_laio_state *s; s = qemu_mallocz(sizeof(*s)); QLIST_INIT(&s->completed_reqs); s->efd = eventfd(0, 0); if (s->efd == -1) goto out_free_state; fcntl(s->efd, F_SETFL, O_NONBLOCK); if (io_setup(MAX_EVENTS, &s->ctx) != 0) goto out_close_efd; qemu_aio_set_fd_handler(s->efd, qemu_laio_complet... |
0 | static TileExcp decode_x1(DisasContext *dc, tilegx_bundle_bits bundle){ unsigned opc = get_Opcode_X1(bundle); unsigned dest = get_Dest_X1(bundle); unsigned srca = get_SrcA_X1(bundle); unsigned ext, srcb; int imm; switch (opc) { case RRR_0_OPCODE_X1: ext = get_RRROpcodeExtension_X1(bundle); srcb = get_SrcB_X1(bundle); s... |
0 | static void compute_pkt_fields(AVFormatContext *s, AVStream *st, AVCodecParserContext *pc, AVPacket *pkt){ int num, den, presentation_delayed; /* handle wrapping */ if(st->cur_dts != AV_NOPTS_VALUE){ if(pkt->pts != AV_NOPTS_VALUE) pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits); if(pkt->dts != AV_NOPTS_VAL... |
0 | static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt){ int size; FFMContext *ffm = s->priv_data; int duration, ret; switch(ffm->read_state) { case READ_HEADER: if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0) return ret; av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\... |
0 | static int vda_h264_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size){ VDAContext *vda = avctx->internal->hwaccel_priv_data; struct vda_context *vda_ctx = avctx->hwaccel_context; if (!vda_ctx->decoder) return -1; vda->bitstream_size = 0; return 0;} |
0 | static void colored_fputs(int level, int tint, const char *str){ if (!*str) return; if (use_color < 0) check_color_terminal();#if defined(_WIN32) && !defined(__MINGW32CE__) && HAVE_SETCONSOLETEXTATTRIBUTE if (use_color && level != AV_LOG_INFO/8) SetConsoleTextAttribute(con, background | color[level]); fputs(str, stderr... |
0 | static int aasc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AascContext *s = avctx->priv_data; int compr, i, stride, ret; s->frame.reference = 1; s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |... |
1 | static int rv10_decode_packet(AVCodecContext *avctx, uint8_t *buf, int buf_size){ MpegEncContext *s = avctx->priv_data; int i, mb_count, mb_pos, left; init_get_bits(&s->gb, buf, buf_size*8);#if 0 for(i=0; i<buf_size*8 && i<200; i++) printf("%d", get_bits1(&s->gb)); printf("\n"); return 0;#endif if(s->codec_id ==CODEC_I... |
1 | static bool memory_region_dispatch_write(MemoryRegion *mr, hwaddr addr, uint64_t data, unsigned size){ if (!memory_region_access_valid(mr, addr, size, true)) { unassigned_mem_write(mr, addr, data, size); return true; } adjust_endianness(mr, &data, size); if (mr->ops->write) { access_with_adjusted_size(addr, &data, size... |
1 | static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len){ int8_t id = pdu->id + 1; /* Response */ if (len < 0) { int err = -len; len = 7; if (s->proto_version != V9FS_PROTO_2000L) { V9fsString str; str.data = strerror(err); str.size = strlen(str.data); len += pdu_marshal(pdu, len, "s", &str); id = P9_RERROR; }... |
1 | static void gen_rsr(DisasContext *dc, TCGv_i32 d, uint32_t sr){ static void (* const rsr_handler[256])(DisasContext *dc, TCGv_i32 d, uint32_t sr) = { [CCOUNT] = gen_rsr_ccount, [PTEVADDR] = gen_rsr_ptevaddr, }; if (sregnames[sr]) { if (rsr_handler[sr]) { rsr_handler[sr](dc, d, sr); } else { tcg_gen_mov_i32(d, cpu_SR[sr... |
1 | static inline uint64_t cksm_overflow(uint64_t cksm){ if (cksm > 0xffffffffULL) { cksm &= 0xffffffffULL; cksm++; } return cksm;} |
1 | int tcp_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp){ s->get_error = socket_errno; s->write = socket_write; s->close = tcp_close; s->fd = inet_connect(host_port, false, NULL, errp); if (!error_is_set(errp)) { migrate_fd_connect(s); } else if (error_is_type(*errp, QERR_SOCKET_CONNECT_... |
1 | static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g){ ASFContext *asf = s->priv_data; AVIOContext *pb = s->pb; AVStream *st = NULL; uint64_t interval; // index entry time interval in 100 ns units, usually it's 1s uint32_t pkt_num, nb_entries; int32_t prev_pkt_num = -1; int i, ret; uint64_t size... |
1 | static void ehci_advance_async_state(EHCIState *ehci){ const int async = 1; switch(ehci_get_state(ehci, async)) { case EST_INACTIVE: if (!(ehci->usbcmd & USBCMD_ASE)) { break; } ehci_set_usbsts(ehci, USBSTS_ASS); ehci_set_state(ehci, async, EST_ACTIVE); // No break, fall through to ACTIVE case EST_ACTIVE: if ( !(ehci->... |
1 | static uint32_t read_long(const unsigned char *p){return (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3];} |
1 | PPC_OP(subfeo){ do_subfeo(); RETURN();} |
1 | static void pci_bus_init(PCIBus *bus, DeviceState *parent, const char *name, MemoryRegion *address_space_mem, MemoryRegion *address_space_io, uint8_t devfn_min){ assert(PCI_FUNC(devfn_min) == 0); bus->devfn_min = devfn_min; bus->address_space_mem = address_space_mem; bus->address_space_io = address_space_io; memory_reg... |
1 | void qmp_change_blockdev(const char *device, const char *filename, const char *format, Error **errp){ BlockBackend *blk; BlockDriverState *bs; BlockDriver *drv = NULL; int bdrv_flags; Error *err = NULL; blk = blk_by_name(device); if (!blk) { error_set(errp, QERR_DEVICE_NOT_FOUND, device); return; } bs = blk_bs(blk); if... |
1 | static void do_video_out(AVFormatContext *s, OutputStream *ost, AVFrame *next_picture, double sync_ipts){ int ret, format_video_sync; AVPacket pkt; AVCodecContext *enc = ost->enc_ctx; AVCodecContext *mux_enc = ost->st->codec; int nb_frames, nb0_frames, i; double delta, delta0; double duration = 0; int frame_size = 0; I... |
1 | static int read_header(AVFormatContext *s){ BRSTMDemuxContext *b = s->priv_data; int bom, major, minor, codec, chunk; int64_t h1offset, pos, toffset; uint32_t size, asize, start = 0; AVStream *st; int ret = AVERROR_EOF; int loop = 0; int bfstm = !strcmp("bfstm", s->iformat->name); st = avformat_new_stream(s, NULL); if ... |
1 | static inline void RENAME(rgb15to16)(const uint8_t *src,uint8_t *dst,unsigned src_size){ register const uint8_t* s=src; register uint8_t* d=dst; register const uint8_t *end; const uint8_t *mm_end; end = s + src_size;#ifdef HAVE_MMX __asm __volatile(PREFETCH"%0"::"m"(*s)); __asm __volatile("movq%0, %%mm4"::"m"(mask15s))... |
1 | static void dec_sexth(DisasContext *dc){ LOG_DIS("sexth r%d, r%d\n", dc->r2, dc->r0); if (!(dc->env->features & LM32_FEATURE_SIGN_EXTEND)) { cpu_abort(dc->env, "hardware sign extender is not available\n"); } tcg_gen_ext16s_tl(cpu_R[dc->r2], cpu_R[dc->r0]);} |
1 | static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet){ X264Context *x4 = ctx->priv_data; x264_nal_t *nal; int nnal, i, ret; x264_picture_t pic_out; x264_picture_init( &x4->pic ); x4->pic.img.i_csp = x4->params.i_csp; if (x264_bit_depth > 8) x4->pic.img.i_csp |= X264_CSP_HIGH_D... |
1 | QCryptoHmac *qcrypto_hmac_new(QCryptoHashAlgorithm alg, const uint8_t *key, size_t nkey, Error **errp){ QCryptoHmac *hmac; void *ctx = NULL; Error *err2 = NULL; QCryptoHmacDriver *drv = NULL;#ifdef CONFIG_AF_ALG ctx = qcrypto_afalg_hmac_ctx_new(alg, key, nkey, &err2); if (ctx) { drv = &qcrypto_hmac_afalg_driver; }#endi... |
1 | target_ulong do_load_msr (CPUPPCState *env){ return#if defined (TARGET_PPC64) ((target_ulong)msr_sf << MSR_SF) | ((target_ulong)msr_isf << MSR_ISF) | ((target_ulong)msr_hv << MSR_HV) |#endif ((target_ulong)msr_ucle << MSR_UCLE) | ((target_ulong)msr_vr << MSR_VR) | /* VR / SPE */ ((target_ulong)msr_ap << MSR_AP) | ((tar... |
1 | static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits){ const int mask = (1 << num_bits) - 1; int i, idx, val, alpha_val; idx = 0; alpha_val = mask; do { do { if (get_bits1(gb)) val = get_bits(gb, num_bits); else { int sign; val = get_bits(gb, num_bits == 16 ? 7 : 4); sign = val ... |
1 | bool desc_ring_set_size(DescRing *ring, uint32_t size){ int i; if (size < 2 || size > 0x10000 || (size & (size - 1))) { DPRINTF("ERROR: ring[%d] size (%d) not a power of 2 " "or in range [2, 64K]\n", ring->index, size); return false; } for (i = 0; i < ring->size; i++) { g_free(ring->info[i].buf); } ring->size = size; r... |
1 | static void gen_wsr_windowstart(DisasContext *dc, uint32_t sr, TCGv_i32 v){ tcg_gen_andi_i32(cpu_SR[sr], v, (1 << dc->config->nareg / 4) - 1); reset_used_window(dc);} |
1 | static void qemu_laio_process_completion(struct qemu_laiocb *laiocb){ int ret; ret = laiocb->ret; if (ret != -ECANCELED) { if (ret == laiocb->nbytes) { ret = 0; } else if (ret >= 0) { /* Short reads mean EOF, pad with zeros. */ if (laiocb->is_read) { qemu_iovec_memset(laiocb->qiov, ret, 0, laiocb->qiov->size - ret); } ... |
1 | static uint32_t msix_mmio_readl(void *opaque, target_phys_addr_t addr){ PCIDevice *dev = opaque; unsigned int offset = addr & (MSIX_PAGE_SIZE - 1); void *page = dev->msix_table_page; uint32_t val = 0; memcpy(&val, (void *)((char *)page + offset), 4); return val;} |
1 | int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt){ int ret; if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec)) return AVERROR(EINVAL); if (avctx->internal->draining) return AVERROR_EOF; if (!avpkt || !avpkt->size) { avctx->internal->draining = 1; avpkt = NULL; if ... |
1 | static int asf_read_stream_properties(AVFormatContext *s, const GUIDParseTable *g){ ASFContext *asf = s->priv_data; AVIOContext *pb = s->pb; uint64_t size; uint32_t err_data_len, ts_data_len; // type specific data length uint16_t flags; ff_asf_guid stream_type; enum AVMediaType type; int i, ret; uint8_t stream_index; A... |
1 | static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, size_t srclen){ z_stream s; ssize_t dstbytes; int r, i, flags; /* skip header */ i = 10; flags = src[3]; if (src[2] != DEFLATED || (flags & RESERVED) != 0) { puts ("Error: Bad gzipped data\n"); return -1; } if ((flags & EXTRA_FIELD) != 0) i = 12 + src[10] + ... |
1 | int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y){ if (!mb_x) return mb_y ? VERT_PRED8x8 : DC_129_PRED8x8; else return mb_y ? mode : HOR_PRED8x8;} |
1 | static void omap_i2c_recv(I2CAdapter *i2c, uint8_t addr, uint8_t *buf, uint16_t len){ OMAPI2C *s = (OMAPI2C *)i2c; uint16_t data, stat; omap_i2c_set_slave_addr(s, addr); data = len; memwrite(s->addr + OMAP_I2C_CNT, &data, 2); data = OMAP_I2C_CON_I2C_EN | OMAP_I2C_CON_MST | OMAP_I2C_CON_STT | OMAP_I2C_CON_STP; memwrite(... |
1 | double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max){ char *tail; const char *error; double d = av_strtod(numstr, &tail); if (*tail) error= "Expected number for %s but found: %s\n"; else if (d < min || d > max) error= "The value for %s was %s which is not within %f - %f\... |
1 | static void do_video_out(AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, AVFrame *in_picture, int *frame_size){ int nb_frames, i, ret; int64_t topBand, bottomBand, leftBand, rightBand; AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src; AVFrame picture_crop_temp, picture_pad_temp; AV... |
1 | static void gen_ld(DisasContext *ctx, uint32_t opc, int rt, int base, int16_t offset){ TCGv t0, t1, t2; int mem_idx = ctx->mem_idx; if (rt == 0 && ctx->insn_flags & (INSN_LOONGSON2E | INSN_LOONGSON2F)) { /* Loongson CPU uses a load to zero register for prefetch. We emulate it as a NOP. On other CPU we must perform the ... |
1 | static void libschroedinger_decode_frame_free(void *frame){ schro_frame_unref(frame);} |
1 | static void network_to_caps(RDMACapabilities *cap){ cap->version = ntohl(cap->version); cap->flags = ntohl(cap->flags);} |
1 | static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index){ OutputStream *ost; AVStream *st = avformat_new_stream(oc, NULL); int idx = oc->nb_streams - 1, ret = 0; char *bsf = NULL, *next, *codec_tag = NULL; AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL; ... |
1 | static void pcnet_common_init(PCNetState *d, NICInfo *nd){ d->poll_timer = qemu_new_timer(vm_clock, pcnet_poll_timer, d); d->nd = nd; if (nd && nd->vlan) { d->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name, pcnet_receive, pcnet_can_receive, d); qemu_format_nic_info_str(d->vc, d->nd->macaddr); } else { d->vc = ... |
0 | static int get_transform_coeffs(AC3DecodeContext * ctx){ int i; ac3_audio_block *ab = &ctx->audio_block; float *samples = ctx->samples; int got_cplchan = 0; int dithflag = 0; samples += (ctx->bsi.flags & AC3_BSI_LFEON) ? 256 : 0; for (i = 0; i < ctx->bsi.nfchans; i++) { if ((ab->flags & AC3_AB_CPLINU) && (ab->chincpl &... |
0 | static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set){ int err; if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets)) return AVERROR(ENOMEM); if ((err = av_reallocp_array(&mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets))) < 0) { mxf->metadata_sets_count =... |
0 | static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, const AVFrame *frame, int *got_packet){ DVVideoContext *s = c->priv_data; int ret; s->sys = avpriv_dv_codec_profile(c); if (!s->sys || ff_dv_init_dynamic_tables(s->sys)) return -1; if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) { av_log(c, AV_... |
0 | static void mxf_write_partition(AVFormatContext *s, int bodysid, int indexsid, const uint8_t *key, int write_metadata){ MXFContext *mxf = s->priv_data; ByteIOContext *pb = s->pb; int64_t header_byte_count_offset; unsigned index_byte_count = 0; uint64_t partition_offset = url_ftell(pb); if (mxf->edit_units_count) { inde... |
1 | static void *spapr_create_fdt_skel(const char *cpu_model, target_phys_addr_t rma_size, target_phys_addr_t initrd_base, target_phys_addr_t initrd_size, target_phys_addr_t kernel_size, const char *boot_device, const char *kernel_cmdline, long hash_shift){ void *fdt; CPUPPCState *env; uint64_t mem_reg_property[2]; uint32_... |
1 | void arm_sysctl_init(uint32_t base, uint32_t sys_id){ arm_sysctl_state *s; int iomemtype; s = (arm_sysctl_state *)qemu_mallocz(sizeof(arm_sysctl_state)); if (!s) return; s->base = base; s->sys_id = sys_id; iomemtype = cpu_register_io_memory(0, arm_sysctl_readfn, arm_sysctl_writefn, s); cpu_register_physical_memory(base... |
1 | static void qobject_input_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp){ /* FIXME: qobject_to_qint mishandles values over INT64_MAX */ QObjectInputVisitor *qiv = to_qiv(v); QObject *qobj = qobject_input_get_object(qiv, name, true, errp); QInt *qint; if (!qobj) { return; } qint = qobject_to_qint... |
1 | void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b){#if defined(__x86_64__) __asm__ ("mul %0\n\t" : "=d" (*phigh), "=a" (*plow) : "a" (a), "0" (b) );#else uint64_t ph, pm1, pm2, pl; pl = (uint64_t)((uint32_t)a) * (uint64_t)((uint32_t)b); pm1 = (a >> 32) * (uint32_t)b; pm2 = (uint32_t)a * (b >> 32); ph ... |
1 | static void av_update_stream_timings(AVFormatContext *ic){ int64_t start_time, start_time1, end_time, end_time1; int64_t duration, duration1; int i; AVStream *st; start_time = INT64_MAX; end_time = INT64_MIN; duration = INT64_MIN; for(i = 0;i < ic->nb_streams; i++) { st = ic->streams[i]; if (st->start_time != AV_NOPTS_... |
1 | static inline int get_a32_user_mem_index(DisasContext *s){ /* Return the core mmu_idx to use for A32/T32 "unprivileged load/store" * insns: * if PL2, UNPREDICTABLE (we choose to implement as if PL0) * otherwise, access as if at PL0. */ switch (s->mmu_idx) { case ARMMMUIdx_S1E2: /* this one is UNPREDICTABLE */ case ARMM... |
1 | static uint32_t virtio_net_bad_features(VirtIODevice *vdev){ uint32_t features = 0; /* Linux kernel 2.6.25. It understood MAC (as everyone must), * but also these: */ features |= (1 << VIRTIO_NET_F_MAC); features |= (1 << VIRTIO_NET_F_GUEST_CSUM); features |= (1 << VIRTIO_NET_F_GUEST_TSO4); features |= (1 << VIRTIO_NET... |
0 | void qemu_get_timer(QEMUFile *f, QEMUTimer *ts){ uint64_t expire_time; expire_time = qemu_get_be64(f); if (expire_time != -1) { qemu_mod_timer(ts, expire_time); } else { qemu_del_timer(ts); }} |
0 | static void qemu_co_queue_next_bh(void *opaque){ Coroutine *next; trace_qemu_co_queue_next_bh(); while ((next = QTAILQ_FIRST(&unlock_bh_queue))) { QTAILQ_REMOVE(&unlock_bh_queue, next, co_queue_next); qemu_coroutine_enter(next, NULL); }} |
0 | static void test_to_from_buf_1(void){ unsigned niov; struct iovec *iov; size_t sz; unsigned char *ibuf, *obuf; unsigned i, j, n; iov_random(&iov, &niov); sz = iov_size(iov, niov); ibuf = g_malloc(sz + 8) + 4; memcpy(ibuf-4, "aaaa", 4); memcpy(ibuf + sz, "bbbb", 4); obuf = g_malloc(sz + 8) + 4; memcpy(obuf-4, "xxxx", 4)... |
0 | static uint64_t exynos4210_i2c_read(void *opaque, target_phys_addr_t offset, unsigned size){ Exynos4210I2CState *s = (Exynos4210I2CState *)opaque; uint8_t value; switch (offset) { case I2CCON_ADDR: value = s->i2ccon; break; case I2CSTAT_ADDR: value = s->i2cstat; break; case I2CADD_ADDR: value = s->i2cadd; break; case I... |
0 | int unix_socket_incoming(const char *path){ Error *local_err = NULL; int fd = unix_listen(path, NULL, 0, &local_err); if (local_err != NULL) { qerror_report_err(local_err); error_free(local_err); } return fd;} |
0 | static int iscsi_reopen_prepare(BDRVReopenState *state, BlockReopenQueue *queue, Error **errp){ /* NOP */ return 0;} |
0 | static void raw_probe_alignment(BlockDriverState *bs, Error **errp){ BDRVRawState *s = bs->opaque; DWORD sectorsPerCluster, freeClusters, totalClusters, count; DISK_GEOMETRY_EX dg; BOOL status; if (s->type == FTYPE_CD) { bs->request_alignment = 2048; return; } if (s->type == FTYPE_HARDDISK) { status = DeviceIoControl(s... |
0 | static int local_name_to_path(FsContext *ctx, V9fsPath *dir_path, const char *name, V9fsPath *target){ if (ctx->export_flags & V9FS_SM_MAPPED_FILE && local_is_mapped_file_metadata(ctx, name)) { errno = EINVAL; return -1; } if (dir_path) { v9fs_path_sprintf(target, "%s/%s", dir_path->data, name); } else if (strcmp(name,... |
0 | static inline void gen_op_fcmpes(int fccno, TCGv r_rs1, TCGv r_rs2){ gen_helper_fcmpes(cpu_env, r_rs1, r_rs2);} |
0 | long do_sigreturn(CPUMIPSState *regs){ struct sigframe *frame; abi_ulong frame_addr; sigset_t blocked; target_sigset_t target_set; int i;#if defined(DEBUG_SIGNAL) fprintf(stderr, "do_sigreturn\n");#endif frame_addr = regs->active_tc.gpr[29]; if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; for(i... |
0 | static int con_init(struct XenDevice *xendev){ struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); char *type, *dom; int ret = 0; /* setup */ dom = xs_get_domain_path(xenstore, con->xendev.dom); snprintf(con->console, sizeof(con->console), "%s/console", dom); free(dom); type = xenstore_read_str(co... |
0 | av_cold int ff_intrax8_common_init(AVCodecContext *avctx, IntraX8Context *w, IDCTDSPContext *idsp, int16_t (*block)[64], int block_last_index[12], int mb_width, int mb_height){ int ret = x8_vlc_init(); if (ret < 0) return ret; w->avctx = avctx; w->idsp = *idsp; w->mb_width = mb_width; w->mb_height = mb_height; w->block... |
0 | static void string_output_free(Visitor *v){ StringOutputVisitor *sov = to_sov(v); string_output_visitor_cleanup(sov);} |
0 | static void external_snapshot_abort(BlkActionState *common){ ExternalSnapshotState *state = DO_UPCAST(ExternalSnapshotState, common, common); if (state->new_bs) { if (state->new_bs->backing) { bdrv_replace_in_backing_chain(state->new_bs, state->old_bs); } }} |
0 | static void virtio_ccw_device_plugged(DeviceState *d, Error **errp){ VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); CcwDevice *ccw_dev = CCW_DEVICE(d); SubchDev *sch = ccw_dev->sch; int n = virtio_get_num_queues(vdev); S390FLICState *flic = s390_get_flic(); if (!virt... |
0 | HELPER_LD(lbu, ldub, uint8_t)HELPER_LD(lhu, lduw, uint16_t)HELPER_LD(lw, ldl, int32_t)HELPER_LD(ld, ldq, int64_t)#undef HELPER_LD#if defined(CONFIG_USER_ONLY)#define HELPER_ST(name, insn, type) \static inline void do_##name(CPUMIPSState *env, target_ulong addr, \ type val, int mem_idx) \{ \ cpu_##insn##_data(env, addr,... |
0 | static void do_video_out(AVFormatContext *s, OutputStream *ost, InputStream *ist, AVFrame *in_picture, int *frame_size, float quality){ int nb_frames, i, ret, format_video_sync; AVFrame *final_picture; AVCodecContext *enc; double sync_ipts; enc = ost->st->codec; sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base); ... |
0 | static void vc1_decode_i_blocks_adv(VC1Context *v){ int k, j; MpegEncContext *s = &v->s; int cbp, val; uint8_t *coded_val; int mb_pos; int mquant = v->pq; int mqdiff; int overlap; GetBitContext *gb = &s->gb; /* select codingmode used for VLC tables selection */ switch(v->y_ac_table_index){ case 0: v->codingset = (v->pq... |
1 | static int parse_channel_name(char **arg, int *rchannel, int *rnamed){ char buf[8]; int len, i, channel_id = 0; int64_t layout, layout0; /* try to parse a channel name, e.g. "FL" */ if (sscanf(*arg, " %7[A-Z] %n", buf, &len)) { layout0 = layout = av_get_channel_layout(buf); /* channel_id <- first set bit in layout */ f... |
1 | int qcow2_grow_l1_table(BlockDriverState *bs, int min_size){ BDRVQcowState *s = bs->opaque; int new_l1_size, new_l1_size2, ret, i; uint64_t *new_l1_table; int64_t new_l1_table_offset; uint8_t data[12]; new_l1_size = s->l1_size; if (min_size <= new_l1_size) return 0; if (new_l1_size == 0) { new_l1_size = 1; } while (min... |
1 | static void clr_msg_flags(IPMIBmcSim *ibs, uint8_t *cmd, unsigned int cmd_len, uint8_t *rsp, unsigned int *rsp_len, unsigned int max_rsp_len){ IPMIInterface *s = ibs->parent.intf; IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); IPMI_CHECK_CMD_LEN(3); ibs->msg_flags &= ~cmd[2]; k->set_atn(s, attn_set(ibs), attn_irq... |
1 | static int pci_ich9_ahci_init(PCIDevice *dev){ struct AHCIPCIState *d; d = DO_UPCAST(struct AHCIPCIState, card, dev); pci_config_set_vendor_id(d->card.config, PCI_VENDOR_ID_INTEL); pci_config_set_device_id(d->card.config, PCI_DEVICE_ID_INTEL_82801IR); pci_config_set_class(d->card.config, PCI_CLASS_STORAGE_SATA); pci_co... |
1 | static void get_attachment(AVFormatContext *s, AVIOContext *pb, int length){ char mime[1024]; char description[1024]; unsigned int filesize; AVStream *st; int64_t pos = avio_tell(pb); avio_get_str16le(pb, INT_MAX, mime, sizeof(mime)); if (strcmp(mime, "image/jpeg")) goto done; avio_r8(pb); avio_get_str16le(pb, INT_MAX,... |
1 | static int parse_filename(char *filename, char **representation_id, char **initialization_pattern, char **media_pattern) { char *underscore_pos = NULL; char *period_pos = NULL; char *temp_pos = NULL; char *filename_str = av_strdup(filename); if (!filename_str) return AVERROR(ENOMEM); temp_pos = av_stristr(filename_str,... |
1 | struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, int64_t whence, Error **errp){ GuestFileHandle *gfh = guest_file_handle_find(handle, errp); GuestFileSeek *seek_data = NULL; FILE *fh; int ret; if (!gfh) { return NULL; fh = gfh->fh; ret = fseek(fh, offset, whence); if (ret == -1) { error_setg_er... |
1 | static void tpm_passthrough_cancel_cmd(TPMBackend *tb){ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); int n; /* * As of Linux 3.7 the tpm_tis driver does not properly cancel * commands on all TPM manufacturers' TPMs. * Only cancel if we're busy so we don't cancel someone else's * command, e.g., a command executed on ... |
1 | static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data){ int i, j; for (i = f->start_band; i < f->end_band; i++) { float *dst = data + (ff_celt_freq_bands[i] << f->size); float norm = exp2f(block->energy[i] + ff_celt_mean_energy[i]); for (j = 0; j < ff_celt_freq_range[i] << f->size; j++) dst[j] *= nor... |
1 | static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ FlacEncodeContext *s; const int16_t *samples; int frame_bytes, out_bytes, ret; s = avctx->priv_data; /* when the last block is reached, update the header in extradata */ if (!frame) { s->max_framesize = s->m... |
1 | TC6393xbState *tc6393xb_init(MemoryRegion *sysmem, uint32_t base, qemu_irq irq){ TC6393xbState *s; DriveInfo *nand; static const MemoryRegionOps tc6393xb_ops = { .read = tc6393xb_readb, .write = tc6393xb_writeb, .endianness = DEVICE_NATIVE_ENDIAN, .impl = { .min_access_size = 1, .max_access_size = 1, }, }; s = (TC6393x... |
0 | static int cdg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ GetByteContext gb; int buf_size = avpkt->size; int ret; uint8_t command, inst; uint8_t cdg_data[CDG_DATA_SIZE]; AVFrame *frame = data; CDGraphicsContext *cc = avctx->priv_data; bytestream2_init(&gb, avpkt->data, avpkt->size... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.