label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type){ if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) { fmt = av_guess_format(NULL, filename, NULL); } if (type == AVMEDIA_TYPE_VIDEO) { enum AVCodec... |
1 | static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st){ AVIOContext *pb = s->pb; int ret; /* parse fmt header */ *st = av_new_stream(s, 0); if (!*st) return AVERROR(ENOMEM); ff_get_wav_header(pb, (*st)->codec, size); if (ret < 0) return ret; (*st)->need_parsing = AVSTREAM_PARSE_FULL; av_set_pts_i... |
1 | static int get_float64(QEMUFile *f, void *pv, size_t size){ float64 *v = pv; *v = make_float64(qemu_get_be64(f)); return 0;} |
1 | static int chunk_mux_init(AVFormatContext *s){ WebMChunkContext *wc = s->priv_data; AVFormatContext *oc; int ret; ret = avformat_alloc_output_context2(&wc->avf, wc->oformat, NULL, NULL); if (ret < 0) return ret; oc = wc->avf; oc->interrupt_callback = s->interrupt_callback; oc->max_delay = s->max_delay; av_dict_copy(&oc... |
0 | void commit_active_start(const char *job_id, BlockDriverState *bs, BlockDriverState *base, int64_t speed, BlockdevOnError on_error, BlockCompletionFunc *cb, void *opaque, Error **errp){ int64_t length, base_length; int orig_base_flags; int ret; Error *local_err = NULL; orig_base_flags = bdrv_get_flags(base); if (bdrv_r... |
0 | static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb){ block_acct_start(bdrv_get_stats(req->dev->bs), &req->acct, 0, BLOCK_ACCT_FLUSH); /* * Make sure all outstanding writes are posted to the backing device. */ virtio_submit_multiwrite(req->dev->bs, mrb); bdrv_aio_flush(req->dev->bs, virtio_blk_... |
0 | static void gen_store_exclusive(DisasContext *s, int rd, int rt, int rt2, TCGv_i64 addr, int size, int is_pair){ /* if (env->exclusive_addr == addr && env->exclusive_val == [addr] * && (!is_pair || env->exclusive_high == [addr + datasize])) { * [addr] = {Rt}; * if (is_pair) { * [addr + datasize] = {Rt2}; * } * {Rd} = 0... |
0 | void virt_acpi_build(VirtMachineState *vms, AcpiBuildTables *tables){ VirtMachineClass *vmc = VIRT_MACHINE_GET_CLASS(vms); GArray *table_offsets; unsigned dsdt, rsdt; GArray *tables_blob = tables->table_data; table_offsets = g_array_new(false, true /* clear */, sizeof(uint32_t)); bios_linker_loader_alloc(tables->linker... |
0 | static void versatile_init(QEMUMachineInitArgs *args, int board_id){ ARMCPU *cpu; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); qemu_irq *cpu_pic; qemu_irq pic[32]; qemu_irq sic[32]; DeviceState *dev, *sysctl; SysBusDevice *busdev; DeviceState *pl041; PCIBus *pci_bus; NICInfo *... |
0 | static int interp(RA144Context *ractx, int16_t *out, int block_num, int copyold, int energy){ int work[10]; int a = block_num + 1; int b = NBLOCKS - a; int x; // Interpolate block coefficients from the this frame forth block and // last frame forth block for (x=0; x<30; x++) out[x] = (a * ractx->lpc_coef[0][x] + b * ra... |
0 | sorecvfrom(so)struct socket *so;{struct sockaddr_in addr;int addrlen = sizeof(struct sockaddr_in);DEBUG_CALL("sorecvfrom");DEBUG_ARG("so = %lx", (long)so);if (so->so_type == IPPROTO_ICMP) { /* This is a "ping" reply */ char buff[256]; int len; len = recvfrom(so->s, buff, 256, 0, (struct sockaddr *)&addr, &addrlen); /* ... |
0 | char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index, int64_t cpu_index, Error **errp){ char *output = NULL; Monitor *old_mon, hmp; memset(&hmp, 0, sizeof(hmp)); hmp.outbuf = qstring_new(); hmp.skip_flush = true; old_mon = cur_mon; cur_mon = &hmp; if (has_cpu_index) { int ret = monitor_set_cpu(c... |
0 | static void do_screen_dump(int argc, const char **argv){ if (argc != 2) { help_cmd(argv[0]); return; } vga_screen_dump(argv[1]);} |
0 | static int rndis_get_response(USBNetState *s, uint8_t *buf){ int ret = 0; struct rndis_response *r = s->rndis_resp.tqh_first; if (!r) return ret; TAILQ_REMOVE(&s->rndis_resp, r, entries); ret = r->length; memcpy(buf, r->buf, r->length); qemu_free(r); return ret;} |
0 | START_TEST(single_quote_string){ int i; struct { const char *encoded; const char *decoded; } test_cases[] = { { "'hello world'", "hello world" }, { "'the quick brown fox \\' jumped over the fence'", "the quick brown fox ' jumped over the fence" }, {} }; for (i = 0; test_cases[i].encoded; i++) { QObject *obj; QString *s... |
0 | static inline void compute_hflags(CPUMIPSState *env){ env->hflags &= ~(MIPS_HFLAG_COP1X | MIPS_HFLAG_64 | MIPS_HFLAG_CP0 | MIPS_HFLAG_F64 | MIPS_HFLAG_FPU | MIPS_HFLAG_KSU | MIPS_HFLAG_UX); if (!(env->CP0_Status & (1 << CP0St_EXL)) && !(env->CP0_Status & (1 << CP0St_ERL)) && !(env->hflags & MIPS_HFLAG_DM)) { env->hflag... |
0 | static void handle_9p_output(VirtIODevice *vdev, VirtQueue *vq){ V9fsVirtioState *v = (V9fsVirtioState *)vdev; V9fsState *s = &v->state; V9fsPDU *pdu; ssize_t len; while ((pdu = pdu_alloc(s))) { struct { uint32_t size_le; uint8_t id; uint16_t tag_le; } QEMU_PACKED out; VirtQueueElement *elem = &v->elems[pdu->idx]; len ... |
0 | hwaddr ppc_hash64_get_phys_page_debug(CPUPPCState *env, target_ulong addr){ struct mmu_ctx_hash64 ctx; if (unlikely(ppc_hash64_get_physical_address(env, &ctx, addr, 0, ACCESS_INT) != 0)) { return -1; } return ctx.raddr & TARGET_PAGE_MASK;} |
0 | int ff_framesync_request_frame(FFFrameSync *fs, AVFilterLink *outlink){ AVFilterContext *ctx = outlink->src; int input, ret; if ((ret = ff_framesync_process_frame(fs, 0)) < 0) return ret; if (ret > 0) return 0; if (fs->eof) return AVERROR_EOF; input = fs->in_request; ret = ff_request_frame(ctx->inputs[input]); if (ret ... |
0 | int pcilg_service_call(S390CPU *cpu, uint8_t r1, uint8_t r2){ CPUS390XState *env = &cpu->env; S390PCIBusDevice *pbdev; uint64_t offset; uint64_t data; uint8_t len; uint32_t fh; uint8_t pcias; cpu_synchronize_state(CPU(cpu)); if (env->psw.mask & PSW_MASK_PSTATE) { program_interrupt(env, PGM_PRIVILEGED, 4); return 0; } i... |
0 | static Jpeg2000TgtNode *ff_jpeg2000_tag_tree_init(int w, int h){ int pw = w, ph = h; Jpeg2000TgtNode *res, *t, *t2; int32_t tt_size; tt_size = tag_tree_size(w, h); if (tt_size == -1) return NULL; t = res = av_mallocz_array(tt_size, sizeof(*t)); if (!res) return NULL; while (w > 1 || h > 1) { int i, j; pw = w; ph = h; w... |
1 | int kvm_arch_put_registers(CPUState *cs, int level){ struct kvm_one_reg reg; uint32_t fpr; uint64_t val; int i; int ret; ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; /* If we are in AArch32 mode then we need to copy the AArch32 regs to the * AArch64 registers before pushing them out to 64-bit KVM. */ if (!i... |
0 | static void sdl_refresh(DisplayState *ds){ SDL_Event ev1, *ev = &ev1; int mod_state; int buttonstate = SDL_GetMouseState(NULL, NULL); if (last_vm_running != vm_running) { last_vm_running = vm_running; sdl_update_caption(); } vga_hw_update(); SDL_EnableUNICODE(!is_graphic_console()); while (SDL_PollEvent(ev)) { switch (... |
0 | static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, size_t size){ int64_t len; if (size > INT_MAX) { return -EIO; } if (!bdrv_is_inserted(bs)) return -ENOMEDIUM; if (bs->growable) return 0; len = bdrv_getlength(bs); if (offset < 0) return -EIO; if ((offset > len) || (len - offset < size)) return -E... |
0 | static int planarRgb16ToRgb16Wrapper(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[]){ const uint16_t *src102[] = { (uint16_t *)src[1], (uint16_t *)src[0], (uint16_t *)src[2] }; const uint16_t *src201[] = { (uint16_t *)src[2], (uint16_t *)src[0], (uint... |
0 | void put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h){POWERPC_TBL_DECLARE(altivec_put_pixels16_num, 1);#ifdef ALTIVEC_USE_REFERENCE_C_CODE int i;POWERPC_TBL_START_COUNT(altivec_put_pixels16_num, 1); for(i=0; i<h; i++) { *((uint32_t*)(block )) = (((const struct unaligned_32 *) (pixels))-... |
0 | static ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport, void *data, size_t len) { struct VncState *vs = (struct VncState *)transport; int ret; retry: ret = recv(vs->csock, data, len, 0); if (ret < 0) {if (errno == EINTR) goto retry;return -1; } return ret;} |
0 | static bool pcie_aer_msg_root_port(PCIDevice *dev, const PCIEAERMsg *msg){ bool msg_sent; uint16_t cmd; uint8_t *aer_cap; uint32_t root_cmd; uint32_t root_status; bool msi_trigger; msg_sent = false; cmd = pci_get_word(dev->config + PCI_COMMAND); aer_cap = dev->config + dev->exp.aer_cap; root_cmd = pci_get_long(aer_cap ... |
0 | static void put_pci_irq_state(QEMUFile *f, void *pv, size_t size){ int i; PCIDevice *s = container_of(pv, PCIDevice, config); for (i = 0; i < PCI_NUM_PINS; ++i) { qemu_put_be32(f, pci_irq_state(s, i)); }} |
0 | static void data_plane_blk_remove_notifier(Notifier *n, void *data){ VirtIOBlockDataPlane *s = container_of(n, VirtIOBlockDataPlane, remove_notifier); assert(s->conf->conf.blk == data); data_plane_remove_op_blockers(s);} |
0 | static int nbd_co_send_request(NbdClientSession *s, struct nbd_request *request, QEMUIOVector *qiov, int offset){ AioContext *aio_context; int rc, ret; qemu_co_mutex_lock(&s->send_mutex); s->send_coroutine = qemu_coroutine_self(); aio_context = bdrv_get_aio_context(s->bs); aio_set_fd_handler(aio_context, s->sock, nbd_r... |
0 | static uint64_t ac97_read(void *opaque, target_phys_addr_t addr, unsigned size){ MilkymistAC97State *s = opaque; uint32_t r = 0; addr >>= 2; switch (addr) { case R_AC97_CTRL: case R_AC97_ADDR: case R_AC97_DATAOUT: case R_AC97_DATAIN: case R_D_CTRL: case R_D_ADDR: case R_D_REMAINING: case R_U_CTRL: case R_U_ADDR: case R... |
0 | static void spr_write_ibatu_h (void *opaque, int sprn){ DisasContext *ctx = opaque; gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2); RET_STOP(ctx);} |
0 | static int find_partition(BlockBackend *blk, int partition, off_t *offset, off_t *size){ struct partition_record mbr[4]; uint8_t data[512]; int i; int ext_partnum = 4; int ret; if ((ret = blk_read(blk, 0, data, 1)) < 0) { error_report("error while reading: %s", strerror(-ret)); exit(EXIT_FAILURE); } if (data[510] != 0x... |
0 | static void sun4m_common_init(int ram_size, int boot_device, DisplayState *ds, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model, unsigned int machine, int max_ram){ if ((unsigned int)ram_size > (unsigned int)max_ram) { fprintf(stderr, "qemu: Too much memory for... |
0 | static always_inline void _cpu_ppc_store_hdecr (CPUState *env, uint32_t hdecr, uint32_t value, int is_excp){ ppc_tb_t *tb_env = env->tb_env; __cpu_ppc_store_decr(env, &tb_env->hdecr_next, tb_env->hdecr_timer, &cpu_ppc_hdecr_excp, hdecr, value, is_excp);} |
0 | static int nvdec_vp9_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size){ VP9SharedContext *h = avctx->priv_data; const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt); NVDECContext *ctx = avctx->internal->hwaccel_priv_data; CUVIDPICPARAMS *pp = &ctx->pic_params; CUVIDVP9PICPAR... |
0 | void qmp_disable_command(const char *name){ QmpCommand *cmd; QTAILQ_FOREACH(cmd, &qmp_commands, node) { if (strcmp(cmd->name, name) == 0) { cmd->enabled = false; return; } }} |
0 | static void ref405ep_init(MachineState *machine){ ram_addr_t ram_size = machine->ram_size; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; char *filename; ppc4xx_bd_info_t bd; CPUPPCState *env; qemu_irq... |
0 | static int v9fs_synth_opendir(FsContext *ctx, V9fsPath *fs_path, V9fsFidOpenState *fs){ V9fsSynthOpenState *synth_open; V9fsSynthNode *node = *(V9fsSynthNode **)fs_path->data; synth_open = g_malloc(sizeof(*synth_open)); synth_open->node = node; node->open_count++; fs->private = synth_open; return 0;} |
0 | static void raw_reopen_commit(BDRVReopenState *state){ BDRVRawState *new_s = state->opaque; BDRVRawState *s = state->bs->opaque; memcpy(s, new_s, sizeof(BDRVRawState)); g_free(state->opaque); state->opaque = NULL;} |
1 | static int draw_text(AVFilterContext *ctx, AVFilterBufferRef *picref, int width, int height){ DrawTextContext *dtext = ctx->priv; uint32_t code = 0, prev_code = 0; int x = 0, y = 0, i = 0, ret; int max_text_line_w = 0, len; int box_w, box_h; char *text = dtext->text; uint8_t *p; int y_min = 32000, y_max = -32000; int x... |
1 | static int av_thread_message_queue_recv_locked(AVThreadMessageQueue *mq, void *msg, unsigned flags){ while (!mq->err_recv && av_fifo_size(mq->fifo) < mq->elsize) { if ((flags & AV_THREAD_MESSAGE_NONBLOCK)) return AVERROR(EAGAIN); pthread_cond_wait(&mq->cond, &mq->lock); } if (av_fifo_size(mq->fifo) < mq->elsize) return... |
1 | static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag){ BDRVBlkdebugState *s = bs->opaque; BlkdebugSuspendedReq *r; QLIST_FOREACH(r, &s->suspended_reqs, next) { if (!strcmp(r->tag, tag)) { qemu_coroutine_enter(r->co, NULL); return 0; } } return -ENOENT;} |
1 | static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb){ BlockRequest *blkreq; 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_WRITE); trace_virtio_blk_handle_write(req, sector, req->qiov.size / ... |
1 | static int ppce500_load_device_tree(MachineState *machine, PPCE500Params *params, hwaddr addr, hwaddr initrd_base, hwaddr initrd_size, hwaddr kernel_base, hwaddr kernel_size, bool dry_run){ CPUPPCState *env = first_cpu->env_ptr; int ret = -1; uint64_t mem_reg_property[] = { 0, cpu_to_be64(machine->ram_size) }; int fdt_... |
1 | pvscsi_on_cmd_setup_rings(PVSCSIState *s){ PVSCSICmdDescSetupRings *rc = (PVSCSICmdDescSetupRings *) s->curr_cmd_data; trace_pvscsi_on_cmd_arrived("PVSCSI_CMD_SETUP_RINGS"); pvscsi_dbg_dump_tx_rings_config(rc); pvscsi_ring_init_data(&s->rings, rc); s->rings_info_valid = TRUE; return PVSCSI_COMMAND_PROCESSING_SUCCEEDED;... |
1 | void ff_snow_vertical_compose97i_mmx(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){ long i = width; while(i & 15) { i--; b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS; b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS; b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS; b1[i] += (... |
1 | static int parse_add_fd(QemuOpts *opts, void *opaque){ int fd, dupfd, flags; int64_t fdset_id; const char *fd_opaque = NULL; fd = qemu_opt_get_number(opts, "fd", -1); fdset_id = qemu_opt_get_number(opts, "set", -1); fd_opaque = qemu_opt_get(opts, "opaque"); if (fd < 0) { qerror_report(ERROR_CLASS_GENERIC_ERROR, "fd opt... |
1 | void av_thread_message_flush(AVThreadMessageQueue *mq){#if HAVE_THREADS int used, off; void *free_func = mq->free_func; pthread_mutex_lock(&mq->lock); used = av_fifo_size(mq->fifo); if (free_func) for (off = 0; off < used; off += mq->elsize) av_fifo_generic_peek_at(mq->fifo, mq, off, mq->elsize, free_func_wrap); av_fif... |
1 | int av_open_input_stream(AVFormatContext **ic_ptr, AVIOContext *pb, const char *filename, AVInputFormat *fmt, AVFormatParameters *ap){ int err; AVDictionary *opts; AVFormatContext *ic; AVFormatParameters default_ap; if(!ap){ ap=&default_ap; memset(ap, 0, sizeof(default_ap)); } opts = convert_format_parameters(ap); if(!... |
1 | void hmp_info_local_apic(Monitor *mon, const QDict *qdict){ x86_cpu_dump_local_apic_state(mon_get_cpu(), (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);} |
0 | void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap){ if (!mon) return; if (mon->mc && !mon->mc->print_enabled) { qemu_error_new(QERR_UNDEFINED_ERROR); } else { char buf[4096]; vsnprintf(buf, sizeof(buf), fmt, ap); monitor_puts(mon, buf); }} |
0 | static void piix4_acpi_system_hot_add_init(MemoryRegion *parent, PCIBus *bus, PIIX4PMState *s){ memory_region_init_io(&s->io_gpe, OBJECT(s), &piix4_gpe_ops, s, "acpi-gpe0", GPE_LEN); memory_region_add_subregion(parent, GPE_BASE, &s->io_gpe); acpi_pcihp_init(OBJECT(s), &s->acpi_pci_hotplug, bus, parent, s->use_acpi_pci_... |
0 | long do_sigreturn(CPUX86State *env){ struct sigframe *frame; abi_ulong frame_addr = env->regs[R_ESP] - 8; target_sigset_t target_set; sigset_t set; int eax, i;#if defined(DEBUG_SIGNAL) fprintf(stderr, "do_sigreturn\n");#endif if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; /* set blocked signal... |
0 | static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov, int iovcnt){ uint8_t buffer[4096]; size_t offset = 0; int i; for (i = 0; i < iovcnt; i++) { size_t len; len = MIN(sizeof(buffer) - offset, iov[i].iov_len); memcpy(buffer + offset, iov[i].iov_base, len); offset += len; } vc->receive(vc->opaque,... |
0 | void do_blockdev_backup(BlockdevBackup *backup, BlockJobTxn *txn, Error **errp){ BlockDriverState *bs; BlockDriverState *target_bs; Error *local_err = NULL; AioContext *aio_context; if (!backup->has_speed) { backup->speed = 0; } if (!backup->has_on_source_error) { backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT; } i... |
0 | static void input_visitor_test_add(const char *testpath, TestInputVisitorData *data, void (*test_func)(TestInputVisitorData *data, const void *user_data)){ g_test_add(testpath, TestInputVisitorData, data, NULL, test_func, visitor_input_teardown);} |
0 | static void spapr_populate_pa_features(PowerPCCPU *cpu, void *fdt, int offset, bool legacy_guest){ CPUPPCState *env = &cpu->env; uint8_t pa_features_206[] = { 6, 0, 0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 }; uint8_t pa_features_207[] = { 24, 0, 0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x... |
0 | void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, BlockDriverCompletionFunc *cb, void *opaque, Error **errp){ BlockJob *job; if (bs->job || bdrv_in_use(bs)) { error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); return NULL; } bdrv_set_in_use(bs, 1); job = g_malloc0(job_type->instance... |
0 | int bdrv_is_snapshot(BlockDriverState *bs){ return !!(bs->open_flags & BDRV_O_SNAPSHOT);} |
0 | static void nvdimm_init_fit_buffer(NvdimmFitBuffer *fit_buf){ qemu_mutex_init(&fit_buf->lock); fit_buf->fit = g_array_new(false, true /* clear */, 1);} |
1 | static void test_cipher(const void *opaque){ const QCryptoCipherTestData *data = opaque; QCryptoCipher *cipher; Error *err = NULL; uint8_t *key, *iv, *ciphertext, *plaintext, *outtext; size_t nkey, niv, nciphertext, nplaintext; char *outtexthex; g_test_message("foo"); nkey = unhex_string(data->key, &key); niv = unhex_s... |
1 | static uint64_t pmsav5_insn_ap_read(CPUARMState *env, const ARMCPRegInfo *ri){ return simple_mpu_ap_bits(env->cp15.c5_insn);} |
1 | static av_cold int libgsm_encode_init(AVCodecContext *avctx) { if (avctx->channels > 1) { av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n", avctx->channels); return -1; if (avctx->sample_rate != 8000) { av_log(avctx, AV_LOG_ERROR, "Sample rate 8000Hz required for GSM, got %dHz\n", avctx->sample_ra... |
0 | static void avc_wgt_4x2_msa(uint8_t *data, int32_t stride, int32_t log2_denom, int32_t src_weight, int32_t offset_in){ uint32_t data0, data1; v16u8 zero = { 0 }; v16u8 src0, src1; v4i32 res0, res1; v8i16 temp0, temp1; v16u8 vec0, vec1; v8i16 wgt, denom, offset; offset_in <<= (log2_denom); if (log2_denom) { offset_in +=... |
1 | static int quorum_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVQuorumState *s = bs->opaque; Error *local_err = NULL; QemuOpts *opts; bool *opened; QDict *sub = NULL; QList *list = NULL; const QListEntry *lentry; int i; int ret = 0; qdict_flatten(options); qdict_extract_subqdict(options, &sub... |
1 | void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input, FFTSample *tmp){ long n8, n4, n2, n; x86_reg k; const uint16_t *revtab = s->fft.revtab; const FFTSample *tcos = s->tcos; const FFTSample *tsin = s->tsin; const FFTSample *in1, *in2; FFTComplex *z = (FFTComplex *)tmp; n = 1 << s->nbits; n... |
0 | void ff_put_h264_qpel8_mc01_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride){ avc_luma_vt_qrt_8w_msa(src - (stride * 2), stride, dst, stride, 8, 0);} |
0 | int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec){ int ret = 0; /* If there is a user-supplied mutex locking routine, call it. */ if (ff_lockmgr_cb) { if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN)) return -1; } entangled_thread_counter++; if(entangled_thread_counter != 1){ av_log(avctx, A... |
0 | static int synth_superframe(AVCodecContext *ctx, AVFrame *frame, int *got_frame_ptr){ WMAVoiceContext *s = ctx->priv_data; GetBitContext *gb = &s->gb, s_gb; int n, res, n_samples = 480; double lsps[MAX_FRAMES][MAX_LSPS]; const double *mean_lsf = s->lsps == 16 ? wmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10... |
1 | static void virtual_css_bridge_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); k->init = virtual_css_bridge_init; dc->no_user = 1;} |
1 | static void free_picture(MpegEncContext *s, Picture *pic){ int i; if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ free_frame_buffer(s, pic); } av_freep(&pic->mb_var); av_freep(&pic->mc_mb_var); av_freep(&pic->mb_mean); av_freep(&pic->mbskip_table); av_freep(&pic->qscale_table); av_freep(&pic->mb_type_base); av_fr... |
1 | static void tracked_request_begin(BdrvTrackedRequest *req, BlockDriverState *bs, int64_t sector_num, int nb_sectors, bool is_write){ *req = (BdrvTrackedRequest){ .bs = bs, .sector_num = sector_num, .nb_sectors = nb_sectors, .is_write = is_write, }; qemu_co_queue_init(&req->wait_queue); QLIST_INSERT_HEAD(&bs->tracked_re... |
1 | static int mov_read_close(AVFormatContext *s){ int i; MOVContext *mov = s->priv_data; for(i=0; i<mov->total_streams; i++) mov_free_stream_context(mov->streams[i]); for(i=0; i<s->nb_streams; i++) av_free(s->streams[i]); return 0;} |
1 | static int aac_decode_frame(AVCodecContext *avccontext, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; AACContext *ac = avccontext->priv_data; ChannelElement *che = NULL, *che_prev = NULL; GetBitContext gb; enum RawDataBlockType elem_type, elem_type_prev = TY... |
1 | static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos){ int size[5]; int i, j, k, a, prev, a2; EncBlockInfo* b; size[4]= 1<<24; do { b = blks; for (i=0; i<5; i++) { if (!qnos[i]) continue; qnos[i]--; size[i] = 0; for (j=0; j<6; j++, b++) { for (a=0; a<4; a++) { if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_... |
0 | static av_cold int hnm_decode_init(AVCodecContext *avctx){ Hnm4VideoContext *hnm = avctx->priv_data; if (avctx->extradata_size < 1) { av_log(avctx, AV_LOG_ERROR, "Extradata missing, decoder requires version number\n"); return AVERROR_INVALIDDATA; } hnm->version = avctx->extradata[0]; avctx->pix_fmt = AV_PIX_FMT_PAL8; h... |
1 | static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, int64_t align, QEMUIOVector *qiov, int flags){ BlockDriver *drv = bs->drv; int ret; int64_t sector_num = offset >> BDRV_SECTOR_BITS; unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; assert(... |
1 | static uint16_t nvme_identify_ns(NvmeCtrl *n, NvmeIdentify *c){ NvmeNamespace *ns; uint32_t nsid = le32_to_cpu(c->nsid); uint64_t prp1 = le64_to_cpu(c->prp1); uint64_t prp2 = le64_to_cpu(c->prp2); if (nsid == 0 || nsid > n->num_namespaces) { return NVME_INVALID_NSID | NVME_DNR; } ns = &n->namespaces[nsid - 1]; return n... |
1 | void dpy_gfx_replace_surface(QemuConsole *con, DisplaySurface *surface){ DisplayState *s = con->ds; DisplaySurface *old_surface = con->surface; DisplayChangeListener *dcl; con->surface = surface; QLIST_FOREACH(dcl, &s->listeners, next) { if (con != (dcl->con ? dcl->con : active_console)) { continue; } if (dcl->ops->dpy... |
1 | static int tqi_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; const uint8_t *buf_end = buf+buf_size; TqiContext *t = avctx->priv_data; MpegEncContext *s = &t->s; s->width = AV_RL16(&buf[0]); s->height = AV_RL16(&buf[2]); tq... |
1 | static void patch_call(VAPICROMState *s, X86CPU *cpu, target_ulong ip, uint32_t target){ uint32_t offset; offset = cpu_to_le32(target - ip - 5); patch_byte(cpu, ip, 0xe8); /* call near */ cpu_memory_rw_debug(CPU(cpu), ip + 1, (void *)&offset, sizeof(offset), 1);} |
1 | static void sbr_dequant(SpectralBandReplication *sbr, int id_aac){ int k, e; int ch; if (id_aac == TYPE_CPE && sbr->bs_coupling) { float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f; float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f; for (e = 1; e <= sbr->data[0].bs_num_env; e++) { for (k = 0; k < sbr->n[sbr-... |
0 | static inline int16_t logadd(int16_t a, int16_t b){ int16_t c = a - b; uint8_t address = FFMIN((ABS(c) >> 1), 255); return ((c >= 0) ? (a + latab[address]) : (b + latab[address]));} |
1 | static void range_merge(Range *range1, Range *range2){ if (range1->end < range2->end) { range1->end = range2->end; } if (range1->begin > range2->begin) { range1->begin = range2->begin; }} |
1 | static int write_manifest(AVFormatContext *s, int final){ DASHContext *c = s->priv_data; AVIOContext *out; char temp_filename[1024]; int ret, i; AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0); snprintf(temp_filename, sizeof(temp_filename), "%s.tmp", s->filename); ret = avio_open2(&out, temp_filen... |
1 | static int get_scale_factor(H264SliceContext *sl, int poc, int poc1, int i){ int poc0 = sl->ref_list[0][i].poc; int td = av_clip_int8(poc1 - poc0); if (td == 0 || sl->ref_list[0][i].parent->long_ref) { return 256; } else { int tb = av_clip_int8(poc - poc0); int tx = (16384 + (FFABS(td) >> 1)) / td; return av_clip_intp2... |
0 | static int ppc_hash64_pte_prot(CPUPPCState *env, ppc_slb_t *slb, ppc_hash_pte64_t pte){ unsigned pp, key; /* Some pp bit combinations have undefined behaviour, so default * to no access in those cases */ int prot = 0; key = !!(msr_pr ? (slb->vsid & SLB_VSID_KP) : (slb->vsid & SLB_VSID_KS)); pp = (pte.pte1 & HPTE64_R_PP... |
0 | static int get_video_frame(VideoState *is, AVFrame *frame, int64_t *pts, AVPacket *pkt){ int got_picture, i; if (packet_queue_get(&is->videoq, pkt, 1) < 0) return -1; if (pkt->data == flush_pkt.data) { avcodec_flush_buffers(is->video_st->codec); SDL_LockMutex(is->pictq_mutex); // Make sure there are no long delay timer... |
0 | static void omap_sysctl_write8(void *opaque, target_phys_addr_t addr, uint32_t value){ struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; int pad_offset, byte_offset; int prev_value; switch (addr) { case 0x030 ... 0x140:/* CONTROL_PADCONF - only used in the POP */ pad_offset = (addr - 0x30) >> 2; byte_offset = ... |
0 | static void l2tpv3_update_fd_handler(NetL2TPV3State *s){ qemu_set_fd_handler2(s->fd, s->read_poll ? l2tpv3_can_send : NULL, s->read_poll ? net_l2tpv3_send : NULL, s->write_poll ? l2tpv3_writable : NULL, s);} |
0 | void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size){ bs->boot_sector_enabled = 1; if (size > 512) size = 512; memcpy(bs->boot_sector_data, data, size); memset(bs->boot_sector_data + size, 0, 512 - size);} |
0 | void helper_sysexit(CPUX86State *env, int dflag){ int cpl; cpl = env->hflags & HF_CPL_MASK; if (env->sysenter_cs == 0 || cpl != 0) { raise_exception_err(env, EXCP0D_GPF, 0); } cpu_x86_set_cpl(env, 3);#ifdef TARGET_X86_64 if (dflag == 2) { cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 32) & 0xfffc) | 3, 0, 0xff... |
0 | static int slirp_guestfwd(SlirpState *s, const char *config_str, int legacy_format){ struct in_addr server = { .s_addr = 0 }; struct GuestFwd *fwd; const char *p; char buf[128]; char *end; int port; p = config_str; if (legacy_format) { if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) { goto fail_syntax; } } else { if (g... |
0 | BlockAIOCB *laio_submit(BlockDriverState *bs, LinuxAioState *s, int fd, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockCompletionFunc *cb, void *opaque, int type){ struct qemu_laiocb *laiocb; struct iocb *iocbs; off_t offset = sector_num * 512; laiocb = qemu_aio_get(&laio_aiocb_info, bs, cb, opaque); laio... |
0 | static int X264_frame(AVCodecContext *ctx, uint8_t *buf, int bufsize, void *data){ X264Context *x4 = ctx->priv_data; AVFrame *frame = data; x264_nal_t *nal; int nnal, i; x264_picture_t pic_out; x4->pic.img.i_csp = X264_CSP_I420; x4->pic.img.i_plane = 3; if (frame) { for (i = 0; i < 3; i++) { x4->pic.img.plane[i] = fram... |
0 | static void v9fs_rename(void *opaque){ int32_t fid; ssize_t err = 0; size_t offset = 7; V9fsString name; int32_t newdirfid; V9fsFidState *fidp; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "dds", &fid, &newdirfid, &name); fidp = get_fid(pdu, fid); if (fidp == NULL) { err = -ENOENT; goto out_... |
0 | static int coroutine_fn cow_co_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *num_same){ int64_t bitnum = sector_num + sizeof(struct cow_header_v2) * 8; uint64_t offset = (bitnum / 8) & -BDRV_SECTOR_SIZE; bool first = true; int changed = 0, same = 0; do { int ret; uint8_t bitmap[BDRV_SECTOR... |
0 | void os_setup_post(void){ int fd = 0; if (daemonize) { uint8_t status = 0; ssize_t len; again1: len = write(daemon_pipe, &status, 1); if (len == -1 && (errno == EINTR)) { goto again1; } if (len != 1) { exit(1); } if (chdir("/")) { perror("not able to chdir to /"); exit(1); } TFR(fd = qemu_open("/dev/null", O_RDWR)); if... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.