label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | void bdrv_init(void){ module_call_init(MODULE_INIT_BLOCK);} |
0 | void hmp_change(Monitor *mon, const QDict *qdict){ const char *device = qdict_get_str(qdict, "device"); const char *target = qdict_get_str(qdict, "target"); const char *arg = qdict_get_try_str(qdict, "arg"); Error *err = NULL; if (strcmp(device, "vnc") == 0 && (strcmp(target, "passwd") == 0 || strcmp(target, "password"... |
0 | static void gen_loop(DisasContext *ctx, int r1, int32_t offset){ int l1; l1 = gen_new_label(); tcg_gen_subi_tl(cpu_gpr_a[r1], cpu_gpr_a[r1], 1); tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr_a[r1], -1, l1); gen_goto_tb(ctx, 1, ctx->pc + offset); gen_set_label(l1); gen_goto_tb(ctx, 0, ctx->next_pc);} |
0 | static void tight_send_compact_size(VncState *vs, size_t len){ int lpc = 0; int bytes = 0; char buf[3] = {0, 0, 0}; buf[bytes++] = len & 0x7F; if (len > 0x7F) { buf[bytes-1] |= 0x80; buf[bytes++] = (len >> 7) & 0x7F; if (len > 0x3FFF) { buf[bytes-1] |= 0x80; buf[bytes++] = (len >> 14) & 0xFF; } } for (lpc = 0; lpc < by... |
0 | static inline void gen_evmwsmi(DisasContext *ctx){ TCGv_i64 t0, t1; if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; } t0 = tcg_temp_new_i64(); t1 = tcg_temp_new_i64(); /* t0 := rA; t1 := rB */#if defined(TARGET_PPC64) tcg_gen_ext32s_tl(t0, cpu_gpr[rA(ctx->opcode)]); tcg_gen_ext32s_tl(t1... |
0 | static uint64_t subpage_ram_read(void *opaque, target_phys_addr_t addr, unsigned size){ ram_addr_t raddr = addr; void *ptr = qemu_get_ram_ptr(raddr); switch (size) { case 1: return ldub_p(ptr); case 2: return lduw_p(ptr); case 4: return ldl_p(ptr); default: abort(); }} |
0 | static int xan_decode_init(AVCodecContext *avctx){ XanContext *s = avctx->priv_data; int i; s->avctx = avctx; if ((avctx->codec->id == CODEC_ID_XAN_WC3) && (s->avctx->palctrl == NULL)) { av_log(avctx, AV_LOG_ERROR, " WC3 Xan video: palette expected.\n"); return -1; } avctx->pix_fmt = PIX_FMT_PAL8; avctx->has_b_frames =... |
0 | void gen_intermediate_code_internal(XtensaCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUXtensaState *env = &cpu->env; DisasContext dc; int insn_count = 0; int j, lj = -1; int max_insns = tb->cflags & CF_COUNT_MASK; uint32_t pc_start = tb->pc; uint32_t next_page_start = (pc_start & TARGET_... |
1 | static void restore_median_il(uint8_t *src, int step, int stride, int width, int height, int slices, int rmode){ int i, j, slice; int A, B, C; uint8_t *bsrc; int slice_start, slice_height; const int cmask = ~(rmode ? 3 : 1); const int stride2 = stride << 1; for (slice = 0; slice < slices; slice++) { slice_start = ((sli... |
1 | static target_ulong h_put_tce_indirect(PowerPCCPU *cpu, sPAPRMachineState *spapr, target_ulong opcode, target_ulong *args){ int i; target_ulong liobn = args[0]; target_ulong ioba = args[1]; target_ulong ioba1 = ioba; target_ulong tce_list = args[2]; target_ulong npages = args[3]; target_ulong ret = H_PARAMETER, tce = 0... |
1 | ivshmem_server_parse_args(IvshmemServerArgs *args, int argc, char *argv[]){ int c; unsigned long long v; Error *errp = NULL; while ((c = getopt(argc, argv, "h" /* help */ "v" /* verbose */ "F" /* foreground */ "p:" /* pid_file */ "S:" /* unix_socket_path */ "m:" /* shm_path */ "l:" /* shm_size */ "n:" /* n_vectors */ )... |
1 | static int nbd_negotiate_options(NBDClient *client, uint16_t myflags, Error **errp){ uint32_t flags; bool fixedNewstyle = false; bool no_zeroes = false; /* Client sends: [ 0 .. 3] client flags Then we loop until NBD_OPT_EXPORT_NAME or NBD_OPT_GO: [ 0 .. 7] NBD_OPTS_MAGIC [ 8 .. 11] NBD option [12 .. 15] Data length ...... |
0 | static int svq1_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; uint8_t *current, *previous; int result, i, x, y, width, height; AVFrame *pict = data; svq1_pmv *pmv; /* initialize bit bu... |
1 | static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id){ BDRVSheepdogState *s = bs->opaque; BDRVSheepdogState *old_s; char tag[SD_MAX_VDI_TAG_LEN]; uint32_t snapid = 0; int ret = 0; old_s = g_malloc(sizeof(BDRVSheepdogState)); memcpy(old_s, s, sizeof(BDRVSheepdogState)); snapid = strtoul(snapshot_id,... |
1 | static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap){ RMContext *rm = s->priv_data; AVStream *st; ByteIOContext *pb = &s->pb; unsigned int tag, v; int tag_size, size, codec_data_size, i; int64_t codec_pos; unsigned int h263_hack_version, start_time, duration; char buf[128]; int flags = 0; tag = get_le3... |
1 | static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum){ BDRVParallelsState *s = bs->opaque; uint32_t idx, to_allocate, i; int64_t pos, space; pos = block_status(s, sector_num, nb_sectors, pnum); if (pos > 0) { return pos; } idx = sector_num / s->tracks; if (idx >= s->bat_s... |
1 | static void send_scsi_cdb_read10(QPCIDevice *dev, void *ide_base, uint64_t lba, int nblocks){ Read10CDB pkt = { .padding = 0 }; int i; g_assert_cmpint(lba, <=, UINT32_MAX); g_assert_cmpint(nblocks, <=, UINT16_MAX); g_assert_cmpint(nblocks, >=, 0); /* Construct SCSI CDB packet */ pkt.opcode = 0x28; pkt.lba = cpu_to_be32... |
1 | static int vobsub_read_header(AVFormatContext *s){ int i, ret = 0, header_parsed = 0, langidx = 0; MpegDemuxContext *vobsub = s->priv_data; char *sub_name = NULL; size_t fname_len; char *ext, *header_str; AVBPrint header; int64_t delay = 0; AVStream *st = NULL; sub_name = av_strdup(s->filename); fname_len = strlen(sub_... |
1 | QBool *qobject_to_qbool(const QObject *obj){ if (qobject_type(obj) != QTYPE_QBOOL) return NULL; return container_of(obj, QBool, base);} |
1 | static av_always_inline int mvd_decode(HEVCContext *s){ int ret = 2; int k = 1; while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) { ret += 1 << k; k++; } if (k == CABAC_MAX_BIN) av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); while (k--) ret += get_cabac_bypass(&s->HEVClc->cc) << k; return get_ca... |
1 | static int handle_hypercall(S390CPU *cpu, struct kvm_run *run){ CPUS390XState *env = &cpu->env; cpu_synchronize_state(CPU(cpu)); env->regs[2] = s390_virtio_hypercall(env); return 0;} |
1 | av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v){ MpegEncContext *s = &v->s; int i; int mb_height = FFALIGN(s->mb_height, 2); /* Allocate mb bitplanes */ v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height); v->direct_mb_plane = av_malloc (s->mb_stride * mb_height); v->forward_mb_plane = av_malloc (s->m... |
1 | static int vapic_prepare(VAPICROMState *s){ vapic_map_rom_writable(s); if (patch_hypercalls(s) < 0) { return -1; } vapic_enable_tpr_reporting(true); return 0;} |
1 | void ahci_uninit(AHCIState *s){ int i, j; for (i = 0; i < s->ports; i++) { AHCIDevice *ad = &s->dev[i]; for (j = 0; j < 2; j++) { IDEState *s = &ad->port.ifs[j]; ide_exit(s); } } g_free(s->dev);} |
1 | int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt){ int ret, size; size = RAW_PACKET_SIZE; if (av_new_packet(pkt, size) < 0) return AVERROR(ENOMEM); pkt->pos= avio_tell(s->pb); pkt->stream_index = 0; ret = ffio_read_partial(s->pb, pkt->data, size); if (ret < 0) { av_free_packet(pkt); return ret; } pkt->s... |
1 | static inline struct rgbvec interp_tetrahedral(const LUT3DContext *lut3d, const struct rgbvec *s){ const struct rgbvec d = {s->r - PREV(s->r), s->g - PREV(s->g), s->b - PREV(s->b)}; const struct rgbvec c000 = lut3d->lut[PREV(s->r)][PREV(s->g)][PREV(s->b)]; const struct rgbvec c001 = lut3d->lut[PREV(s->r)][PREV(s->g)][N... |
0 | static av_cold int nvenc_setup_device(AVCodecContext *avctx){ NvencContext *ctx = avctx->priv_data; NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs; CUresult cu_res; CUcontext cu_context_curr; switch (avctx->codec->id) { case AV_CODEC_ID_H264: ctx->init_encode_params.encodeGUID = NV_ENC_CODEC_H264_GUID; break; c... |
1 | static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c){ GetBitContext *gb = &ctx->gb; ALSChannelData *current = cd; unsigned int channels = ctx->avctx->channels; int entries = 0; while (entries < channels && !(current->stop_flag = get_bits1(gb))) { current->master_channel = get_bits_long(gb, av_cei... |
1 | static void cpu_unregister_map_client(void *_client){ MapClient *client = (MapClient *)_client; QLIST_REMOVE(client, link); g_free(client);} |
1 | static int rv34_decoder_alloc(RV34DecContext *r){ r->intra_types_stride = r->s.mb_width * 4 + 4; r->cbp_chroma = av_malloc(r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_chroma)); r->cbp_luma = av_malloc(r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_luma)); r->deblock_coefs = av_malloc(r->s.mb_stride * r->s.mb_hei... |
1 | static int dvbsub_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size){ DVBSubParseContext *pc = s->priv_data; uint8_t *p, *p_end; int i, len, buf_pos = 0; av_dlog(avctx, "DVB parse packet pts=%"PRIx64", lpts=%"PRIx64", cpts=%"PRIx64":\n", s... |
1 | static void id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags, ID3v2ExtraMeta **extra_meta){ int isv34, unsync; unsigned tlen; char tag[5]; int64_t next, end = avio_tell(s->pb) + len; int taghdrlen; const char *reason = NULL; AVIOContext pb; AVIOContext *pbx; unsigned char *buffer = NULL; int buff... |
1 | static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, int ecpl, int start_subband, int end_subband, const uint8_t *default_band_struct, uint8_t *band_struct, int *num_subbands, int *num_bands, uint8_t *band_sizes){ int subbnd, bnd, n_subbands, n_bands; uint8_t bnd_sz[22]; n_subbands = end_subband - s... |
1 | static void dump_iterate(DumpState *s, Error **errp){ GuestPhysBlock *block; int64_t size; int ret; Error *local_err = NULL; while (1) { block = s->next_block; size = block->target_end - block->target_start; if (s->has_filter) { size -= s->start; if (s->begin + s->length < block->target_end) { size -= block->target_end... |
1 | fdctrl_t *fdctrl_init_sysbus(qemu_irq irq, int dma_chann, target_phys_addr_t mmio_base, DriveInfo **fds){ fdctrl_t *fdctrl; DeviceState *dev; fdctrl_sysbus_t *sys; dev = qdev_create(NULL, "sysbus-fdc"); sys = DO_UPCAST(fdctrl_sysbus_t, busdev.qdev, dev); fdctrl = &sys->state; fdctrl->dma_chann = dma_chann; /* FIXME */ ... |
0 | static void uhci_async_complete(USBPort *port, USBPacket *packet){ UHCIAsync *async = container_of(packet, UHCIAsync, packet); UHCIState *s = async->queue->uhci; if (async->isoc) { UHCI_TD td; uint32_t link = async->td; uint32_t int_mask = 0, val; pci_dma_read(&s->dev, link & ~0xf, &td, sizeof(td)); le32_to_cpus(&td.li... |
0 | int coroutine_fn thread_pool_submit_co(ThreadPoolFunc *func, void *arg){ ThreadPoolCo tpc = { .co = qemu_coroutine_self(), .ret = -EINPROGRESS }; assert(qemu_in_coroutine()); thread_pool_submit_aio(func, arg, thread_pool_co_cb, &tpc); qemu_coroutine_yield(); return tpc.ret;} |
0 | static void uhci_process_frame(UHCIState *s){ uint32_t frame_addr, link, old_td_ctrl, val, int_mask; uint32_t curr_qh; int cnt, ret; UHCI_TD td; UHCI_QH qh; QhDb qhdb; frame_addr = s->fl_base_addr + ((s->frnum & 0x3ff) << 2); DPRINTF("uhci: processing frame %d addr 0x%x\n" , s->frnum, frame_addr); cpu_physical_memory_r... |
0 | int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr){ AVFrame tmp; AVFrame *padded_frame = NULL; int ret; AVPacket user_pkt = *avpkt; int needs_realloc = !user_pkt.data; *got_packet_ptr = 0; if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) &... |
0 | static void virtio_input_handle_sts(VirtIODevice *vdev, VirtQueue *vq){ VirtIOInputClass *vic = VIRTIO_INPUT_GET_CLASS(vdev); VirtIOInput *vinput = VIRTIO_INPUT(vdev); virtio_input_event event; VirtQueueElement elem; int len; while (virtqueue_pop(vinput->sts, &elem)) { memset(&event, 0, sizeof(event)); len = iov_to_buf... |
0 | void qmp_guest_file_close(int64_t handle, Error **err){ GuestFileHandle *gfh = guest_file_handle_find(handle, err); int ret; slog("guest-file-close called, handle: %ld", handle); if (!gfh) { return; } ret = fclose(gfh->fh); if (ret == -1) { error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed"); return; } QTAILQ_RE... |
0 | static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sectors, uint8_t *buf){ int n; int ret; if (s->status == BLK_ZERO || s->status == BLK_BACKING_FILE) { return 0; } assert(nb_sectors <= s->buf_sectors); while (nb_sectors > 0) { BlockBackend *blk; int64_t bs_sectors; /* In the case of compression wit... |
0 | static void qemu_announce_self_once(void *opaque){ static int count = SELF_ANNOUNCE_ROUNDS; QEMUTimer *timer = *(QEMUTimer **)opaque; qemu_foreach_nic(qemu_announce_self_iter, NULL); if (--count) { /* delay 50ms, 150ms, 250ms, ... */ qemu_mod_timer(timer, qemu_get_clock(rt_clock) + 50 + (SELF_ANNOUNCE_ROUNDS - count - ... |
0 | static int nvme_init(PCIDevice *pci_dev){ NvmeCtrl *n = NVME(pci_dev); NvmeIdCtrl *id = &n->id_ctrl; int i; int64_t bs_size; uint8_t *pci_conf; if (!(n->conf.bs)) { return -1; } bs_size = bdrv_getlength(n->conf.bs); if (bs_size < 0) { return -1; } blkconf_serial(&n->conf, &n->serial); if (!n->serial) { return -1; } pci... |
0 | int blk_get_max_transfer_length(BlockBackend *blk){ BlockDriverState *bs = blk_bs(blk); if (bs) { return bs->bl.max_transfer_length; } else { return 0; }} |
0 | START_TEST(qstring_append_chr_test){ int i; QString *qstring; const char *str = "qstring append char unit-test"; qstring = qstring_new(); for (i = 0; str[i]; i++) qstring_append_chr(qstring, str[i]); fail_unless(strcmp(str, qstring_get_str(qstring)) == 0); QDECREF(qstring);} |
0 | static int ftp_get_line(FTPContext *s, char *line, int line_size){ int ch; char *q = line; int ori_block_flag = s->conn_control_block_flag; for (;;) { ch = ftp_getc(s); if (ch < 0) { s->conn_control_block_flag = ori_block_flag; return ch; } if (ch == '\n') { /* process line */ if (q > line && q[-1] == '\r') q--; *q = '... |
0 | static int raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf){ BDRVRawState *s = bs->opaque; if (s->offset || s->has_size) { return -ENOTSUP; } return bdrv_co_ioctl(bs->file->bs, req, buf);} |
0 | static void lsi_io_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ LSIState *s = opaque; lsi_reg_writeb(s, addr & 0xff, val);} |
0 | void input_type_enum(Visitor *v, int *obj, const char *strings[], const char *kind, const char *name, Error **errp){ int64_t value = 0; char *enum_str; assert(strings); visit_type_str(v, &enum_str, name, errp); if (error_is_set(errp)) { return; } while (strings[value] != NULL) { if (strcmp(strings[value], enum_str) == ... |
0 | int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info){ CPUState *cpu = ENV_GET_CPU(env); TaskState *ts = cpu->opaque; struct emulated_sigtable *k; struct sigqueue *q, **pq; abi_ulong handler; int queue; trace_user_queue_signal(env, sig); k = &ts->sigtab[sig - 1]; queue = gdb_queuesig (); handler = sigact... |
1 | int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){ int i; int w= s->width; int h= s->height; InternalBuffer *buf; int *picture_number; if(pic->data[0]!=NULL) { av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n"); return -1; } if(s->internal_buffer_count >= INTERNAL_BUFFER_SIZE) {... |
1 | static int tm2_build_huff_table(TM2Context *ctx, TM2Codes *code){ TM2Huff huff; int res = 0; huff.val_bits = get_bits(&ctx->gb, 5); huff.max_bits = get_bits(&ctx->gb, 5); huff.min_bits = get_bits(&ctx->gb, 5); huff.nodes = get_bits_long(&ctx->gb, 17); huff.num = 0; /* check for correct codes parameters */ if((huff.val_... |
1 | void gen_intermediate_code_internal(XtensaCPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUXtensaState *env = &cpu->env; DisasContext dc; int insn_count = 0; int j, lj = -1; uint16_t *gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE; int max_insns = tb->cflags & CF_COUNT_MASK; uint32_t pc_st... |
1 | static void dump_map_entry(OutputFormat output_format, MapEntry *e, MapEntry *next){ switch (output_format) { case OFORMAT_HUMAN: if ((e->flags & BDRV_BLOCK_DATA) && !(e->flags & BDRV_BLOCK_OFFSET_VALID)) { error_report("File contains external, encrypted or compressed clusters."); exit(1); } if ((e->flags & (BDRV_BLOCK... |
1 | int escc_init(target_phys_addr_t base, qemu_irq irqA, qemu_irq irqB, CharDriverState *chrA, CharDriverState *chrB, int clock, int it_shift){ DeviceState *dev; SysBusDevice *s; SerialState *d; dev = qdev_create(NULL, "escc"); qdev_prop_set_uint32(dev, "disabled", 0); qdev_prop_set_uint32(dev, "frequency", clock); qdev_p... |
1 | static void wmv2_idct_row(short * b){ int s1, s2; int a0, a1, a2, a3, a4, a5, a6, a7; /* step 1 */ a1 = W1 * b[1] + W7 * b[7]; a7 = W7 * b[1] - W1 * b[7]; a5 = W5 * b[5] + W3 * b[3]; a3 = W3 * b[5] - W5 * b[3]; a2 = W2 * b[2] + W6 * b[6]; a6 = W6 * b[2] - W2 * b[6]; a0 = W0 * b[0] + W0 * b[4]; a4 = W0 * b[0] - W0 * b[4... |
1 | static void init_dev(tc58128_dev * dev, const char *filename){ int ret, blocks; dev->state = WAIT; dev->flash_contents = g_malloc0(FLASH_SIZE); memset(dev->flash_contents, 0xff, FLASH_SIZE); if (!dev->flash_contents) {fprintf(stderr, "could not alloc memory for flash\n");exit(1); } if (filename) {/* Load flash image sk... |
1 | int ff_h264_decode_mb_cavlc(H264Context *h){ MpegEncContext * const s = &h->s; int mb_xy; int partition_count; unsigned int mb_type, cbp; int dct8x8_allowed= h->pps.transform_8x8_mode; int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2; const int pixel_shift = h->pixel_shift; mb_xy = h->... |
1 | static void d3d11va_frames_uninit(AVHWFramesContext *ctx){ AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx; D3D11VAFramesContext *s = ctx->internal->priv; if (frames_hwctx->texture) ID3D11Texture2D_Release(frames_hwctx->texture); if (s->staging_texture) ID3D11Texture2D_Release(s->staging_texture);} |
0 | static void mov_read_chapters(AVFormatContext *s){ MOVContext *mov = s->priv_data; AVStream *st = NULL; MOVStreamContext *sc; int64_t cur_pos; int i; for (i = 0; i < s->nb_streams; i++) if (s->streams[i]->id == mov->chapter_track) { st = s->streams[i]; break; } if (!st) { av_log(s, AV_LOG_ERROR, "Referenced QT chapter ... |
0 | static int msrle_decode_pal4(AVCodecContext *avctx, AVFrame *pic, GetByteContext *gb){ unsigned char rle_code; unsigned char extra_byte, odd_pixel; unsigned char stream_byte; int pixel_ptr = 0; int line = avctx->height - 1; int i; while (line >= 0 && pixel_ptr <= avctx->width) { if (bytestream2_get_bytes_left(gb) <= 0)... |
0 | static void update_initial_durations(AVFormatContext *s, AVStream *st, int stream_index, int duration){ AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue; int64_t cur_dts = RELATIVE_TS_BASE; if (st->first_dts != AV_NOPTS_VALUE) { if (st->update_initial_durations_don... |
0 | int poll(struct pollfd *fds, nfds_t numfds, int timeout){ fd_set read_set; fd_set write_set; fd_set exception_set; nfds_t i; int n; int rc;#ifdef __MINGW32__ if (numfds >= FD_SETSIZE) { errno = EINVAL; return -1; }#endif FD_ZERO(&read_set); FD_ZERO(&write_set); FD_ZERO(&exception_set); n = -1; for(i = 0; i < numfds; i+... |
0 | int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags){ int i, nb_streams = ic->nb_streams; int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe; unsigned *program... |
1 | static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len){ MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int program_info_length, pcr_pid, pid, stream_type; int desc_list_len, d... |
1 | static inline void RENAME(yuv2yuvX)(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, int dstW, int chrDstW){#if COMPILE_TEMPLATE_... |
1 | static int qcow_make_empty(BlockDriverState *bs){ BDRVQcowState *s = bs->opaque; uint32_t l1_length = s->l1_size * sizeof(uint64_t); int ret; memset(s->l1_table, 0, l1_length); if (bdrv_pwrite(bs->file, s->l1_table_offset, s->l1_table, l1_length) < 0)return -1; ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_leng... |
1 | static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, int mvn, int r_x, int r_y, uint8_t* is_intra, int dir){ MpegEncContext *s = &v->s; int xy, wrap, off = 0; int A[2], B[2], C[2]; int px, py; int a_valid = 0, b_valid = 0, c_valid = 0; int field_a, field_b, field_c; // 0: same, 1: opposit in... |
1 | void bdrv_append_temp_snapshot(BlockDriverState *bs, Error **errp){ /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ char tmp_filename[PATH_MAX + 1]; int64_t total_size; BlockDriver *bdrv_qcow2; QEMUOptionParameter *create_options; QDict *snapshot_options; BlockDriverState *bs_snapshot; Error *loca... |
1 | int nbd_client_co_flush(BlockDriverState *bs){ NBDClientSession *client = nbd_get_client_session(bs); NBDRequest request = { .type = NBD_CMD_FLUSH }; NBDReply reply; ssize_t ret; if (!(client->nbdflags & NBD_FLAG_SEND_FLUSH)) { return 0; } request.from = 0; request.len = 0; nbd_coroutine_start(client, &request); ret = ... |
1 | int do_sigaction(int sig, const struct target_sigaction *act, struct target_sigaction *oact){ struct emulated_sigaction *k; if (sig < 1 || sig > TARGET_NSIG) return -EINVAL; k = &sigact_table[sig - 1];#if defined(DEBUG_SIGNAL) && 0 fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n", sig, (int)act, (int)oact);... |
1 | DeviceState *qdev_try_create(BusState *bus, const char *name){ DeviceState *dev; dev = DEVICE(object_new(name)); if (!dev) { if (!bus) { bus = sysbus_get_default(); qdev_set_parent_bus(dev, bus); qdev_prop_set_globals(dev); return dev; |
1 | const AVOption *av_set_string(void *obj, const char *name, const char *val){ const AVOption *o= av_find_opt(obj, name, NULL, 0, 0); if(o && o->offset==0 && o->type == FF_OPT_TYPE_CONST && o->unit){ return set_all_opt(obj, o->unit, o->default_val); } if(!o || !val || o->offset<=0) return NULL; if(o->type != FF_OPT_TYPE_... |
1 | int ff_h2645_extract_rbsp(const uint8_t *src, int length, H2645NAL *nal, int small_padding){ int i, si, di; uint8_t *dst; int64_t padding = small_padding ? AV_INPUT_BUFFER_PADDING_SIZE : MAX_MBPAIR_SIZE; nal->skipped_bytes = 0;#define STARTCODE_TEST \ if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \ if (sr... |
1 | static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix, bool *rebuild, uint16_t **refcount_table, int64_t *nb_clusters){ BDRVQcowState *s = bs->opaque; int64_t i, size; int ret; for(i = 0; i < s->refcount_table_size; i++) { uint64_t offset, cluster; offset = s->refcount_table[i]; clust... |
1 | static void choose_pixel_fmt(AVStream *st, AVCodec *codec){ if(codec && codec->pix_fmts){ const enum PixelFormat *p= codec->pix_fmts; if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){ if(st->codec->codec_id==CODEC_ID_MJPEG){ p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV42... |
1 | static void virtio_gpu_reset(VirtIODevice *vdev){ VirtIOGPU *g = VIRTIO_GPU(vdev); struct virtio_gpu_simple_resource *res, *tmp; int i; g->enable = 0; QTAILQ_FOREACH_SAFE(res, &g->reslist, next, tmp) { virtio_gpu_resource_destroy(g, res); } for (i = 0; i < g->conf.max_outputs; i++) {#if 0 g->req_state[i].x = 0; g->req_... |
1 | static void gen_divu(DisasContext *dc, TCGv dest, TCGv srca, TCGv srcb){ TCGv sr_cy = tcg_temp_new(); TCGv t0 = tcg_temp_new(); tcg_gen_setcondi_tl(TCG_COND_EQ, sr_cy, srcb, 0); /* The result of divide-by-zero is undefined. Supress the host-side exception by dividing by 1. */ tcg_gen_or_tl(t0, srcb, sr_cy); tcg_gen_div... |
1 | av_cold int vp56_free(AVCodecContext *avctx){ VP56Context *s = avctx->priv_data; int pt; av_freep(&s->qscale_table); av_freep(&s->above_blocks); av_freep(&s->macroblocks); av_freep(&s->edge_emu_buffer_alloc); if (s->framep[VP56_FRAME_GOLDEN]->data[0]) avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]); if (s->f... |
1 | static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block, int stride, int x, int y){ int i; block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1); block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1); if (s->num_refs == 2) { block->ref |= pred_block_mode(block, stride... |
1 | static void adb_mouse_class_init(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); ADBDeviceClass *adc = ADB_DEVICE_CLASS(oc); ADBMouseClass *amc = ADB_MOUSE_CLASS(oc); amc->parent_realize = dc->realize; dc->realize = adb_mouse_realizefn; set_bit(DEVICE_CATEGORY_INPUT, dc->categories); adc->devreq = adb... |
1 | static int do_sd_create(char *filename, int64_t vdi_size, uint32_t base_vid, uint32_t *vdi_id, int snapshot, const char *addr, const char *port){ SheepdogVdiReq hdr; SheepdogVdiRsp *rsp = (SheepdogVdiRsp *)&hdr; int fd, ret; unsigned int wlen, rlen = 0; char buf[SD_MAX_VDI_LEN]; fd = connect_to_sdog(addr, port); if (fd... |
1 | int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; RV34DecContext *r = avctx->priv_data; MpegEncContext *s = &r->s; AVFrame *pict = data; SliceInfo si; int i; int slice_count; const uint8_t *slices_hdr = NULL;... |
1 | static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, void *data, int *got_frame, const uint8_t *buf, int buf_size){ /* Note, the only difference between the 15Bpp and 16Bpp */ /* Format is the pixel format, the packets are processed the same. */ FlicDecodeContext *s = avctx->priv_data; GetByteContext g2; int pi... |
1 | void gen_intermediate_code(CPUState *cs, TranslationBlock * tb){ CPUSPARCState *env = cs->env_ptr; target_ulong pc_start, last_pc; DisasContext dc1, *dc = &dc1; int num_insns; int max_insns; unsigned int insn; memset(dc, 0, sizeof(DisasContext)); dc->tb = tb; pc_start = tb->pc; dc->pc = pc_start; last_pc = dc->pc; dc->... |
1 | static void cortex_a15_initfn(Object *obj){ ARMCPU *cpu = ARM_CPU(obj); set_feature(&cpu->env, ARM_FEATURE_V7); set_feature(&cpu->env, ARM_FEATURE_VFP4); set_feature(&cpu->env, ARM_FEATURE_VFP_FP16); set_feature(&cpu->env, ARM_FEATURE_NEON); set_feature(&cpu->env, ARM_FEATURE_THUMB2EE); set_feature(&cpu->env, ARM_FEATU... |
1 | void OPPROTO op_check_reservation_64 (void){ if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003)) env->reserve = -1; RETURN();} |
1 | static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ VP8Context *s = avctx->priv_data; int ret, mb_x, mb_y, i, y, referenced; enum AVDiscard skip_thresh; AVFrame *av_uninit(curframe), *prev_frame; release_queued_segmaps(s, 0); if ((ret = decode_frame_header(s, avpkt->data, av... |
1 | static void serial_update_parameters(SerialState *s){ int speed, parity, data_bits, stop_bits, frame_size; QEMUSerialSetParams ssp; if (s->divider == 0) return; /* Start bit. */ frame_size = 1; if (s->lcr & 0x08) { /* Parity bit. */ frame_size++; if (s->lcr & 0x10) parity = 'E'; else parity = 'O'; } else { parity = 'N'... |
1 | static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16]){ int i, a1, b1, c1, d1; int16_t tmp[16]; for (i = 0; i < 4; i++) { a1 = (dc[i * 4 + 0] + dc[i * 4 + 2]) * 23170; b1 = (dc[i * 4 + 0] - dc[i * 4 + 2]) * 23170; c1 = dc[i * 4 + 1] * 12540 - dc[i * 4 + 3] * 30274; d1 = dc[i * 4 + 1] * 30274 + dc[i * 4 ... |
1 | static void generate_noise(G723_1_Context *p){ int i, j, idx, t; int off[SUBFRAMES]; int signs[SUBFRAMES / 2 * 11], pos[SUBFRAMES / 2 * 11]; int tmp[SUBFRAME_LEN * 2]; int16_t *vector_ptr; int64_t sum; int b0, c, delta, x, shift; p->pitch_lag[0] = cng_rand(&p->cng_random_seed, 21) + 123; p->pitch_lag[1] = cng_rand(&p->... |
1 | struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, int64_t count, Error **errp){ GuestFileHandle *gfh = guest_file_handle_find(handle, errp); GuestFileRead *read_data = NULL; guchar *buf; FILE *fh; size_t read_count; if (!gfh) { return NULL; } if (!has_count) { count = QGA_READ_COUNT_DEFAULT; } e... |
1 | static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, int is_read){ BlockInterfaceErrorAction action = drive_get_on_error(req->dev->bs, is_read); VirtIOBlock *s = req->dev; if (action == BLOCK_ERR_IGNORE) { bdrv_mon_event(req->dev->bs, BDRV_ACTION_IGNORE, is_read); return 0; } if ((error == ENOSPC && ac... |
0 | int av_read_pause(AVFormatContext *s){ if (s->iformat->read_pause) return s->iformat->read_pause(s); if (s->pb && s->pb->read_pause) return av_url_read_fpause(s->pb, 1); return AVERROR(ENOSYS);} |
1 | static BlockAIOCB *iscsi_aio_ioctl(BlockDriverState *bs, unsigned long int req, void *buf, BlockCompletionFunc *cb, void *opaque){ IscsiLun *iscsilun = bs->opaque; struct iscsi_context *iscsi = iscsilun->iscsi; struct iscsi_data data; IscsiAIOCB *acb; acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque); acb->iscsilun... |
1 | static void *thread_function(void *data){ GMainLoop *loop; loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(loop); return NULL;} |
1 | static DisplaySurface* sdl_create_displaysurface(int width, int height){ DisplaySurface *surface = (DisplaySurface*) g_malloc0(sizeof(DisplaySurface)); if (surface == NULL) { fprintf(stderr, "sdl_create_displaysurface: malloc failed\n"); exit(1); } surface->width = width; surface->height = height; if (scaling_active) {... |
0 | static int _get_transform_coeffs(uint8_t *exps, uint8_t *bap, float chcoeff, float *samples, int start, int end, int dith_flag, GetBitContext *gb, dither_state *state){ int16_t mantissa; int i; int gcode; mant_group l3_grp, l5_grp, l11_grp; for (i = 0; i < 3; i++) l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i]... |
0 | static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){ MOVQ_BFE(mm6); __asm__ volatile( "lea (%3, %3), %%"REG_a" \n\t" "movq (%1), %%mm0 \n\t" ".p2align 3 \n\t" "1: \n\t" "movq (%1, %3), %%mm1 \n\t" "movq (%1, %%"REG_a"), %%mm2 \n\t" PAVGBP(%%mm1, %%mm0, %%mm4, %%mm2, %%mm1... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.