label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | static inline uint64_t vtd_get_slpte_addr(uint64_t slpte) { return slpte & VTD_SL_PT_BASE_ADDR_MASK(VTD_HOST_ADDRESS_WIDTH); } | 18,237 |
0 | static void open_eth_cleanup(NetClientState *nc) { } | 18,239 |
0 | void HELPER(wsr_lbeg)(uint32_t v) { if (env->sregs[LBEG] != v) { tb_invalidate_phys_page_range( env->sregs[LEND] - 1, env->sregs[LEND], 0); env->sregs[LBEG] = v; } } | 18,240 |
0 | void mips_cpu_do_interrupt(CPUState *cs) { #if !defined(CONFIG_USER_ONLY) MIPSCPU *cpu = MIPS_CPU(cs); CPUMIPSState *env = &cpu->env; bool update_badinstr = 0; target_ulong offset; int cause = -1; const char *name; if (qemu_loglevel_mask(CPU_LOG_INT) && cs->exception_index != EXCP_EXT_INTERRUPT) { if (cs->exception_ind... | 18,241 |
0 | uri_resolve_relative (const char *uri, const char * base) { char *val = NULL; int ret; int ix; int pos = 0; int nbslash = 0; int len; URI *ref = NULL; URI *bas = NULL; char *bptr, *uptr, *vptr; int remove_path = 0; if ((uri == NULL) || (*uri == 0)) return NULL; /* * First parse URI into a standard form */ ref = uri_new... | 18,242 |
0 | static uint64_t omap_sti_fifo_read(void *opaque, target_phys_addr_t addr, unsigned size) { OMAP_BAD_REG(addr); return 0; } | 18,243 |
0 | static inline uint64_t hpet_calculate_diff(HPETTimer *t, uint64_t current) { if (t->config & HPET_TN_32BIT) { uint32_t diff, cmp; cmp = (uint32_t)t->cmp; diff = cmp - (uint32_t)current; diff = (int32_t)diff > 0 ? diff : (uint32_t)0; return (uint64_t)diff; } else { uint64_t diff, cmp; cmp = t->cmp; diff = cmp - current;... | 18,244 |
0 | static int mpc8_decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPCContext *c = avctx->priv_data; GetBitContext gb2, *gb = &gb2; int i, j, k, ch, cnt, res, t; Band *bands = c->bands; int off; int maxband, keyframe; int... | 18,245 |
0 | int configure_accelerator(MachineState *ms) { const char *p; char buf[10]; int ret; bool accel_initialised = false; bool init_failed = false; AccelClass *acc = NULL; p = qemu_opt_get(qemu_get_machine_opts(), "accel"); if (p == NULL) { /* Use the default "accelerator", tcg */ p = "tcg"; } while (!accel_initialised && *p... | 18,246 |
0 | int bdrv_snapshot_goto(BlockDriverState *bs, const char *snapshot_id, Error **errp) { BlockDriver *drv = bs->drv; int ret, open_ret; int64_t len; if (!drv) { error_setg(errp, "Block driver is closed"); return -ENOMEDIUM; } len = bdrv_getlength(bs); if (len < 0) { error_setg_errno(errp, -len, "Cannot get block device si... | 18,247 |
0 | static void test_qemu_strtoull_negative(void) { const char *str = " \t -321"; char f = 'X'; const char *endptr = &f; uint64_t res = 999; int err; err = qemu_strtoull(str, &endptr, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, -321); g_assert(endptr == str + strlen(str)); } | 18,248 |
0 | static void omap_clkdsp_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; uint16_t diff; if (size != 2) { return omap_badwidth_write16(opaque, addr, value); } switch (addr) { case 0x04: /* DSP_IDLECT1 */ diff = s->clkm.dsp_idle... | 18,249 |
0 | uint64_t helper_frsqrte (uint64_t arg) { CPU_DoubleU fone, farg; fone.ll = 0x3FF0000000000000ULL; /* 1.0 */ farg.ll = arg; if (unlikely(float64_is_signaling_nan(farg.d))) { /* sNaN reciprocal square root */ farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN); } else if (unlikely(float64_is_neg(farg.d) && !float64_i... | 18,250 |
0 | static void gen_compute_compact_branch(DisasContext *ctx, uint32_t opc, int rs, int rt, int32_t offset) { int bcond_compute = 0; TCGv t0 = tcg_temp_new(); TCGv t1 = tcg_temp_new(); if (ctx->hflags & MIPS_HFLAG_BMASK) { #ifdef MIPS_DEBUG_DISAS LOG_DISAS("Branch in delay / forbidden slot at PC 0x" TARGET_FMT_lx "\n", ctx... | 18,251 |
0 | int qemu_chr_fe_get_msgfd(CharDriverState *s) { int fd; return (qemu_chr_fe_get_msgfds(s, &fd, 1) == 1) ? fd : -1; } | 18,252 |
0 | static void vnc_client_write_locked(void *opaque) { VncState *vs = opaque; #ifdef CONFIG_VNC_SASL if (vs->sasl.conn && vs->sasl.runSSF && !vs->sasl.waitWriteSSF) { vnc_client_write_sasl(vs); } else #endif /* CONFIG_VNC_SASL */ { #ifdef CONFIG_VNC_WS if (vs->encode_ws) { vnc_client_write_ws(vs); } else #endif /* CONFIG_... | 18,253 |
0 | iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque) { IscsiAIOCB *acb = opaque; trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled); g_free(acb->buf); acb->buf = NULL; if (acb->canceled != 0) { return; } acb->status = 0; if (status < 0) { error_report("Failed to wri... | 18,255 |
0 | static void spr_write_40x_sler (void *opaque, int sprn) { DisasContext *ctx = opaque; gen_op_store_40x_sler(); /* We must stop the translation as we may have changed * some regions endianness */ RET_STOP(ctx); } | 18,256 |
0 | static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code) { SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp); SCLPEventFacility *ef = sclp->event_facility; SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef); switch (code & SCLP_CMD_CODE_MASK) { case SCLP_CMDW_READ_SCP_INFO: case SCLP_CMDW_READ_SCP_INF... | 18,258 |
0 | static void smbios_build_type_0_fields(const char *t) { char buf[1024]; unsigned char major, minor; if (get_param_value(buf, sizeof(buf), "vendor", t)) smbios_add_field(0, offsetof(struct smbios_type_0, vendor_str), buf, strlen(buf) + 1); if (get_param_value(buf, sizeof(buf), "version", t)) smbios_add_field(0, offsetof... | 18,259 |
0 | truncate_f(int argc, char **argv) { int64_t offset; int ret; offset = cvtnum(argv[1]); if (offset < 0) { printf("non-numeric truncate argument -- %s\n", argv[1]); return 0; } ret = bdrv_truncate(bs, offset); if (ret < 0) { printf("truncate: %s", strerror(ret)); return 0; } return 0; } | 18,260 |
0 | static inline void *host_from_stream_offset(QEMUFile *f, ram_addr_t offset, int flags) { static RAMBlock *block = NULL; char id[256]; uint8_t len; if (flags & RAM_SAVE_FLAG_CONTINUE) { if (!block || block->max_length <= offset) { error_report("Ack, bad migration stream!"); return NULL; } return block->host + offset; } ... | 18,261 |
0 | int mpcifc_service_call(S390CPU *cpu, uint8_t r1, uint64_t fiba, uint8_t ar) { CPUS390XState *env = &cpu->env; uint8_t oc, dmaas; uint32_t fh; ZpciFib fib; S390PCIBusDevice *pbdev; uint64_t cc = ZPCI_PCI_LS_OK; if (env->psw.mask & PSW_MASK_PSTATE) { program_interrupt(env, PGM_PRIVILEGED, 6); return 0; } oc = env->regs[... | 18,262 |
0 | static void s390_cpu_plug(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp) { gchar *name; S390CPU *cpu = S390_CPU(dev); CPUState *cs = CPU(dev); name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num); object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name, errp); g_free(name); } | 18,263 |
0 | static void gen_maskg(DisasContext *ctx) { int l1 = gen_new_label(); TCGv t0 = tcg_temp_new(); TCGv t1 = tcg_temp_new(); TCGv t2 = tcg_temp_new(); TCGv t3 = tcg_temp_new(); tcg_gen_movi_tl(t3, 0xFFFFFFFF); tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F); tcg_gen_andi_tl(t1, cpu_gpr[rS(ctx->opcode)], 0x1F); tcg_gen_... | 18,264 |
0 | uint64_t qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, int *num) { BDRVQcowState *s = bs->opaque; unsigned int l1_index, l2_index; uint64_t l2_offset, *l2_table, cluster_offset; int l1_bits, c; unsigned int index_in_cluster, nb_clusters; uint64_t nb_available, nb_needed; index_in_cluster = (offset >> ... | 18,265 |
0 | static bool lowprot_enabled(const CPUS390XState *env) { if (!(env->cregs[0] & CR0_LOWPROT)) { return false; } if (!(env->psw.mask & PSW_MASK_DAT)) { return true; } /* Check the private-space control bit */ switch (env->psw.mask & PSW_MASK_ASC) { case PSW_ASC_PRIMARY: return !(env->cregs[1] & _ASCE_PRIVATE_SPACE); case ... | 18,266 |
0 | static int net_slirp_init(VLANState *vlan, const char *model, const char *name, int restricted, const char *ip) { if (slirp_in_use) { /* slirp only supports a single instance so far */ return -1; } if (!slirp_inited) { slirp_inited = 1; slirp_init(restricted, ip); while (slirp_redirs) { struct slirp_config_str *config ... | 18,269 |
0 | static uint64_t hpdmc_read(void *opaque, target_phys_addr_t addr, unsigned size) { MilkymistHpdmcState *s = opaque; uint32_t r = 0; addr >>= 2; switch (addr) { case R_SYSTEM: case R_BYPASS: case R_TIMING: case R_IODELAY: r = s->regs[addr]; break; default: error_report("milkymist_hpdmc: read access to unknown register 0... | 18,270 |
0 | int qemu_init_main_loop(Error **errp) { int ret; GSource *src; Error *local_error = NULL; init_clocks(); ret = qemu_signal_init(); if (ret) { return ret; } qemu_aio_context = aio_context_new(&local_error); if (!qemu_aio_context) { error_propagate(errp, local_error); return -EMFILE; } qemu_notify_bh = qemu_bh_new(notify... | 18,271 |
0 | static int os_host_main_loop_wait(uint32_t timeout) { int ret; glib_select_fill(&nfds, &rfds, &wfds, &xfds, &timeout); if (timeout > 0) { qemu_mutex_unlock_iothread(); } /* We'll eventually drop fd_set completely. But for now we still have * *_fill() and *_poll() functions that use rfds/wfds/xfds. */ gpollfds_from_sele... | 18,273 |
0 | static int cris_mmu_segmented_addr(int seg, uint32_t rw_mm_cfg) { return (1 << seg) & rw_mm_cfg; } | 18,274 |
0 | static uint64_t pfpu_read(void *opaque, target_phys_addr_t addr, unsigned size) { MilkymistPFPUState *s = opaque; uint32_t r = 0; addr >>= 2; switch (addr) { case R_CTL: case R_MESHBASE: case R_HMESHLAST: case R_VMESHLAST: case R_CODEPAGE: case R_VERTICES: case R_COLLISIONS: case R_STRAYWRITES: case R_LASTDMA: case R_P... | 18,275 |
0 | static void qdev_reset(void *opaque) { DeviceState *dev = opaque; if (dev->info->reset) dev->info->reset(dev); } | 18,276 |
0 | static void disas_cond_b_imm(DisasContext *s, uint32_t insn) { unsigned int cond; uint64_t addr; if ((insn & (1 << 4)) || (insn & (1 << 24))) { unallocated_encoding(s); return; } addr = s->pc + sextract32(insn, 5, 19) * 4 - 4; cond = extract32(insn, 0, 4); if (cond < 0x0e) { /* genuinely conditional branches */ int lab... | 18,277 |
0 | void tcg_gen_atomic_cmpxchg_i64(TCGv_i64 retv, TCGv addr, TCGv_i64 cmpv, TCGv_i64 newv, TCGArg idx, TCGMemOp memop) { memop = tcg_canonicalize_memop(memop, 1, 0); if (!parallel_cpus) { TCGv_i64 t1 = tcg_temp_new_i64(); TCGv_i64 t2 = tcg_temp_new_i64(); tcg_gen_ext_i64(t2, cmpv, memop & MO_SIZE); tcg_gen_qemu_ld_i64(t1,... | 18,280 |
0 | static void scsi_disk_unit_attention_reported(SCSIDevice *dev) { SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); if (s->media_changed) { s->media_changed = false; s->qdev.unit_attention = SENSE_CODE(MEDIUM_CHANGED); } } | 18,281 |
1 | static void lsi_command_complete(SCSIBus *bus, int reason, uint32_t tag, uint32_t arg) { LSIState *s = DO_UPCAST(LSIState, dev.qdev, bus->qbus.parent); int out; out = (s->sstat1 & PHASE_MASK) == PHASE_DO; if (reason == SCSI_REASON_DONE) { DPRINTF("Command complete status=%d\n", (int)arg); s->status = arg; s->command_co... | 18,284 |
1 | static void xenstore_record_dm_state(struct xs_handle *xs, const char *state) { char path[50]; if (xs == NULL) { fprintf(stderr, "xenstore connection not initialized\n"); exit(1); } snprintf(path, sizeof (path), "/local/domain/0/device-model/%u/state", xen_domid); if (!xs_write(xs, XBT_NULL, path, state, strlen(state))... | 18,286 |
1 | static void *ff_realloc_static(void *ptr, unsigned int size) { int i; if(!ptr) return av_mallocz_static(size); /* Look for the old ptr */ for(i = 0; i < last_static; i++) { if(array_static[i] == ptr) { array_static[i] = av_realloc(array_static[i], size); return array_static[i]; } } return NULL; } | 18,287 |
1 | static int vhdx_log_read_desc(BlockDriverState *bs, BDRVVHDXState *s, VHDXLogEntries *log, VHDXLogDescEntries **buffer, bool convert_endian) { int ret = 0; uint32_t desc_sectors; uint32_t sectors_read; VHDXLogEntryHeader hdr; VHDXLogDescEntries *desc_entries = NULL; VHDXLogDescriptor desc; int i; assert(*buffer == NULL... | 18,288 |
1 | static int irq_cpu_hotplug_init(SCLPEvent *event) { irq_cpu_hotplug = *qemu_allocate_irqs(trigger_signal, event, 1); return 0; } | 18,289 |
0 | static int escape124_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { int buf_size = avpkt->size; Escape124Context *s = avctx->priv_data; AVFrame *frame = data; GetBitContext gb; unsigned frame_flags, frame_size; unsigned i; unsigned superblock_index, cb_index = 1, superblock_col_index... | 18,291 |
0 | static int adx_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) { const uint8_t *buf0 = avpkt->data; int buf_size = avpkt->size; ADXContext *c = avctx->priv_data; int16_t *samples = data; const uint8_t *buf = buf0; int rest = buf_size; if (!c->header_parsed) { int hdrsize = adx_decode_he... | 18,292 |
1 | static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant) { GetBitContext *gb = &v->s.gb; MpegEncContext *s = &v->s; int dc_pred_dir = 0; /* Direction of the DC prediction used */ int run_diff, i; int16_t *dc_val; int16_t *ac_val, *ac_val2; int dcdiff; int a_avail ... | 18,293 |
1 | int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset, int nb_clusters) { BDRVQcowState *s = bs->opaque; uint64_t cluster_index; uint64_t old_free_cluster_index; int i, refcount, ret; /* Check how many clusters there are free */ cluster_index = offset >> s->cluster_bits; for(i = 0; i < nb_clusters; i++) { r... | 18,294 |
1 | static void oledate_to_iso8601(char *buf, int buf_size, int64_t value) { time_t t = 631112400LL + 86400*av_int2dbl(value); strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", gmtime(&t)); } | 18,295 |
1 | const char *get_register_name_32(unsigned int reg) { if (reg > CPU_NB_REGS32) { return NULL; } return x86_reg_info_32[reg].name; } | 18,296 |
1 | struct pxa2xx_state_s *pxa255_init(unsigned int sdram_size, DisplayState *ds) { struct pxa2xx_state_s *s; struct pxa2xx_ssp_s *ssp; int iomemtype, i; s = (struct pxa2xx_state_s *) qemu_mallocz(sizeof(struct pxa2xx_state_s)); s->env = cpu_init(); cpu_arm_set_model(s->env, "pxa255"); register_savevm("cpu", 0, 0, cpu_save... | 18,297 |
0 | int av_read_packet(AVFormatContext *s, AVPacket *pkt) { int ret, i; AVStream *st; for(;;){ AVPacketList *pktl = s->raw_packet_buffer; if (pktl) { *pkt = pktl->pkt; if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE || !s->streams[pkt->stream_index]->probe_packets){ s->raw_packet_buffer = pktl->next; av... | 18,299 |
1 | void nbd_export_close(NBDExport *exp) { NBDClient *client, *next; nbd_export_get(exp); QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) { client_close(client); } nbd_export_set_name(exp, NULL); nbd_export_put(exp); if (exp->blk) { blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach, exp); b... | 18,301 |
1 | void iothread_stop(IOThread *iothread) { if (!iothread->ctx || iothread->stopping) { return; } iothread->stopping = true; aio_notify(iothread->ctx); if (atomic_read(&iothread->main_loop)) { g_main_loop_quit(iothread->main_loop); } qemu_thread_join(&iothread->thread); } | 18,302 |
1 | void qmp_stop(Error **errp) { vm_stop(RUN_STATE_PAUSED); } | 18,303 |
0 | const char *postproc_configuration(void) { return FFMPEG_CONFIGURATION; } | 18,305 |
0 | static void qdm2_decode_fft_packets(QDM2Context *q) { int i, j, min, max, value, type, unknown_flag; GetBitContext gb; if (q->sub_packet_list_B[0].packet == NULL) return; /* reset minimum indexes for FFT coefficients */ q->fft_coefs_index = 0; for (i = 0; i < 5; i++) q->fft_coefs_min_index[i] = -1; /* process subpacket... | 18,306 |
0 | void ff_avg_h264_qpel16_mc22_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride) { avc_luma_mid_and_aver_dst_16x16_msa(src - (2 * stride) - 2, stride, dst, stride); } | 18,307 |
0 | int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name) { AVFilterContext *ret; *filter_ctx = NULL; if (!filter) return AVERROR(EINVAL); ret = av_mallocz(sizeof(AVFilterContext)); ret->av_class = &avfilter_class; ret->filter = filter; ret->name = inst_name ? av_strdup(inst_name) : NULL;... | 18,308 |
1 | static void test_panic(void) { uint8_t val; QDict *response, *data; val = inb(0x505); g_assert_cmpuint(val, ==, 1); outb(0x505, 0x1); response = qmp_receive(); g_assert(qdict_haskey(response, "event")); g_assert_cmpstr(qdict_get_str(response, "event"), ==, "GUEST_PANICKED"); g_assert(qdict_haskey(response, "data")); da... | 18,309 |
1 | static void spr_write_decr(DisasContext *ctx, int sprn, int gprn) { if (ctx->tb->cflags & CF_USE_ICOUNT) { gen_io_start(); } gen_helper_store_decr(cpu_env, cpu_gpr[gprn]); if (ctx->tb->cflags & CF_USE_ICOUNT) { gen_io_end(); gen_stop_exception(ctx); } } | 18,310 |
1 | PPC_OP(b_T1) { regs->nip = T1 & ~3; RETURN(); } | 18,312 |
1 | static int make_cdt15_entry(int p1, int p2, int16_t *cdt) { int r, b, lo; b = cdt[p2]; r = cdt[p1] * 1024; lo = b + r; return (lo + (lo * (1 << 16))) * 2; } | 18,313 |
1 | static int ogg_build_flac_headers(AVCodecContext *avctx, OGGStreamContext *oggstream, int bitexact) { const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT; enum FLACExtradataFormat format; uint8_t *streaminfo; uint8_t *p; if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo)) return -1; oggstream->header... | 18,314 |
1 | void qmp_netdev_del(const char *id, Error **errp) { NetClientState *nc; nc = qemu_find_netdev(id); if (!nc) { error_set(errp, QERR_DEVICE_NOT_FOUND, id); return; } qemu_del_net_client(nc); qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id)); } | 18,315 |
1 | int qemu_savevm_state_iterate(QEMUFile *f) { SaveStateEntry *se; int ret = 1; trace_savevm_state_iterate(); QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { if (!se->ops || !se->ops->save_live_iterate) { continue; } if (se->ops && se->ops->is_active) { if (!se->ops->is_active(se->opaque)) { continue; } } if (qemu_fi... | 18,316 |
1 | yuv2rgba64_2_c_template(SwsContext *c, const int32_t *buf[2], const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf[2], uint16_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha) { const int32_t *buf0 = buf[0], *buf1 = buf[1], *ubuf0 = ubuf[0], *ubuf1 = ubuf[1], *vb... | 18,317 |
1 | static int ogg_restore(AVFormatContext *s) { struct ogg *ogg = s->priv_data; AVIOContext *bc = s->pb; struct ogg_state *ost = ogg->state; int i, err; if (!ost) return 0; ogg->state = ost->next; for (i = 0; i < ogg->nstreams; i++) av_freep(&ogg->streams[i].buf); avio_seek(bc, ost->pos, SEEK_SET); ogg->page_pos = -1; ogg... | 18,318 |
1 | static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *sc) { const H264Context *h = avctx->priv_data; const unsigned mb_count = h->mb_width * h->mb_height; AVDXVAContext *ctx = avctx->hwaccel_context; const H264Picture *current_picture = h->cur_pic_ptr; struct ... | 18,319 |
0 | static int qtrle_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { QtrleContext *s = avctx->priv_data; int header, start_line; int height, row_ptr; int has_palette = 0; int ret; bytestream2_init(&s->g, avpkt->data, avpkt->size); if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) return r... | 18,321 |
0 | int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options) { return avio_open2(pb, url, flags, int_cb, options); } | 18,322 |
1 | static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb) { int ret; rcb->ret = rbd_aio_get_return_value(c); rbd_aio_release(c); ret = qemu_rbd_send_pipe(rcb->s, rcb); if (ret < 0) { error_report("failed writing to acb->s->fds"); g_free(rcb); } } | 18,325 |
1 | static void pcihotplug_write(void *opaque, uint32_t addr, uint32_t val) { struct pci_status *g = opaque; switch (addr) { case PCI_BASE: g->up = val; break; case PCI_BASE + 4: g->down = val; break; } PIIX4_DPRINTF("pcihotplug write %x <== %d\n", addr, val); } | 18,327 |
1 | static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels, int line_size) { int i; uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; /* read the pixels */ for(i=0;i<2;i++) { pixels[0] = cm[block[0]]; pixels[1] = cm[block[1]]; pixels += line_size; block += 8; } } | 18,330 |
1 | bool qemu_file_is_writable(QEMUFile *f) { return f->ops->writev_buffer || f->ops->put_buffer; } | 18,331 |
1 | static int encode_thread(AVCodecContext *c, void *arg){ MpegEncContext *s= *(void**)arg; int mb_x, mb_y, pdif = 0; int chr_h= 16>>s->chroma_y_shift; int i, j; MpegEncContext best_s, backup_s; uint8_t bit_buf[2][MAX_MB_BYTES]; uint8_t bit_buf2[2][MAX_MB_BYTES]; uint8_t bit_buf_tex[2][MAX_MB_BYTES]; PutBitContext pb[2], ... | 18,332 |
1 | static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, int nb_sectors) { return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, nb_sectors * BDRV_SECTOR_SIZE); | 18,333 |
1 | int oggvorbis_init_encoder(vorbis_info *vi, AVCodecContext *avccontext) { if(avccontext->coded_frame->quality) /* VBR requested */ return vorbis_encode_init_vbr(vi, avccontext->channels, avccontext->sample_rate, (float)avccontext->coded_frame->quality / 1000) ; return vorbis_encode_init(vi, avccontext->channels, avccon... | 18,334 |
1 | static void gt_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) { ARMCPU *cpu = arm_env_get_cpu(env); int timeridx = ri->crm & 1; uint32_t oldval = env->cp15.c14_timer[timeridx].ctl; env->cp15.c14_timer[timeridx].ctl = value & 3; if ((oldval ^ value) & 1) { /* Enable toggled */ gt_recalc_timer(cpu, t... | 18,335 |
1 | static av_cold int vp8_decode_free(AVCodecContext *avctx) { vp8_decode_flush_impl(avctx, 0, 1); release_queued_segmaps(avctx->priv_data, 1); return 0; } | 18,336 |
0 | static int a64_write_header(AVFormatContext *s) { AVCodecContext *avctx = s->streams[0]->codec; uint8_t header[5] = { 0x00, //load 0x40, //address 0x00, //mode 0x00, //charset_lifetime (multi only) 0x00 //fps in 50/fps; }; if (avctx->extradata_size < 4) { av_log(s, AV_LOG_ERROR, "Missing extradata\n"); return AVERROR(E... | 18,337 |
0 | static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num) { BDRVBochsState *s = bs->opaque; uint64_t offset = sector_num * 512; uint64_t extent_index, extent_offset, bitmap_offset; char bitmap_entry; // seek to sector extent_index = offset / s->extent_size; extent_offset = (offset % s->extent_size) / 512;... | 18,338 |
0 | static void slirp_bootp_save(QEMUFile *f, Slirp *slirp) { int i; for (i = 0; i < NB_BOOTP_CLIENTS; i++) { qemu_put_be16(f, slirp->bootp_clients[i].allocated); qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6); } } | 18,339 |
0 | int qemu_opts_id_wellformed(const char *id) { int i; if (!qemu_isalpha(id[0])) { return 0; } for (i = 1; id[i]; i++) { if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) { return 0; } } return 1; } | 18,340 |
0 | ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags) { if (so->s == -1 && so->extra) { qemu_chr_fe_write(so->extra, buf, len); return len; } return send(so->s, buf, len, flags); } | 18,341 |
0 | int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize) { TRACE("Setting NBD socket"); if (ioctl(fd, NBD_SET_SOCK, csock) < 0) { int serrno = errno; LOG("Failed to set NBD socket"); errno = serrno; return -1; } TRACE("Setting block size to %lu", (unsigned long)blocksize); if (ioctl(fd, NBD_SET_BLK... | 18,343 |
0 | static void rgb24_to_yuvj420p(AVPicture *dst, AVPicture *src, int width, int height) { int wrap, wrap3, width2; int r, g, b, r1, g1, b1, w; uint8_t *lum, *cb, *cr; const uint8_t *p; lum = dst->data[0]; cb = dst->data[1]; cr = dst->data[2]; width2 = (width + 1) >> 1; wrap = dst->linesize[0]; wrap3 = src->linesize[0]; p ... | 18,346 |
0 | static void do_multiwrite(BlockDriverState *bs, BlockRequest *blkreq, int num_writes) { int i, ret; ret = bdrv_aio_multiwrite(bs, blkreq, num_writes); if (ret != 0) { for (i = 0; i < num_writes; i++) { if (blkreq[i].error) { virtio_blk_rw_complete(blkreq[i].opaque, -EIO); } } } } | 18,348 |
0 | static void qjson_register_types(void) { type_register_static(&qjson_type_info); } | 18,350 |
0 | void css_generate_sch_crws(uint8_t cssid, uint8_t ssid, uint16_t schid, int hotplugged, int add) { uint8_t guest_cssid; bool chain_crw; if (add && !hotplugged) { return; } if (channel_subsys.max_cssid == 0) { /* Default cssid shows up as 0. */ guest_cssid = (cssid == channel_subsys.default_cssid) ? 0 : cssid; } else { ... | 18,352 |
0 | static void term_insert_char(int ch) { if (term_cmd_buf_index < TERM_CMD_BUF_SIZE) { memmove(term_cmd_buf + term_cmd_buf_index + 1, term_cmd_buf + term_cmd_buf_index, term_cmd_buf_size - term_cmd_buf_index); term_cmd_buf[term_cmd_buf_index] = ch; term_cmd_buf_size++; term_cmd_buf_index++; } } | 18,354 |
0 | static void spapr_phb_add_pci_device(sPAPRDRConnector *drc, sPAPRPHBState *phb, PCIDevice *pdev, Error **errp) { sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); DeviceState *dev = DEVICE(pdev); int drc_index = drck->get_index(drc); void *fdt = NULL; int fdt_start_offset = 0, fdt_size; if (dev->hotplugg... | 18,355 |
0 | static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, uint8_t(*scaling_matrix4)[16], uint8_t(*scaling_matrix8)[64]) { int fallback_sps = !is_sps && sps->scaling_matrix_present; const uint8_t *fallback[4] = { fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], fallback_sps ? sps->... | 18,357 |
0 | static void macio_nvram_writeb(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { MacIONVRAMState *s = opaque; addr = (addr >> s->it_shift) & (s->size - 1); s->data[addr] = value; NVR_DPRINTF("writeb addr %04x val %x\n", (int)addr, value); } | 18,358 |
0 | static void fill_prstatus(struct target_elf_prstatus *prstatus, const TaskState *ts, int signr) { (void) memset(prstatus, 0, sizeof (*prstatus)); prstatus->pr_info.si_signo = prstatus->pr_cursig = signr; prstatus->pr_pid = ts->ts_tid; prstatus->pr_ppid = getppid(); prstatus->pr_pgrp = getpgrp(); prstatus->pr_sid = gets... | 18,359 |
0 | static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name) { FILE *f; int ret = 0; char filename[PATH_MAX]; snprintf(filename, PATH_MAX, device_file, device_name); f = fopen(filename, "r"); if (f) { fgets(line, line_size, f); fclose(f); ret = 1; } else { term_printf("h... | 18,360 |
0 | static uint32_t sdhci_read_dataport(SDHCIState *s, unsigned size) { uint32_t value = 0; int i; /* first check that a valid data exists in host controller input buffer */ if ((s->prnsts & SDHC_DATA_AVAILABLE) == 0) { ERRPRINT("Trying to read from empty buffer\n"); return 0; } for (i = 0; i < size; i++) { value |= s->fif... | 18,362 |
0 | static void pc_fw_add_pflash_drv(void) { QemuOpts *opts; QEMUMachine *machine; char *filename; if (bios_name == NULL) { bios_name = BIOS_FILENAME; } filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); opts = drive_add(IF_PFLASH, -1, filename, "readonly=on"); g_free(filename); if (opts == NULL) { return; } machin... | 18,363 |
0 | static void escc_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size) { SerialState *serial = opaque; ChannelState *s; uint32_t saddr; int newreg, channel; val &= 0xff; saddr = (addr >> serial->it_shift) & 1; channel = (addr >> (serial->it_shift + 1)) & 1; s = &serial->chn[channel]; switch (sad... | 18,364 |
0 | int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag) { int err; err = ff_cbs_write_fragment_data(ctx, frag); if (err < 0) return err; av_new_packet(pkt, frag->data_size); if (err < 0) return err; memcpy(pkt->data, frag->data, frag->data_size); pkt->size = frag->data_size; ret... | 18,365 |
0 | static av_cold int sunrast_encode_close(AVCodecContext *avctx) { av_frame_free(&avctx->coded_frame); return 0; } | 18,367 |
0 | static void RENAME(yadif_filter_line)(uint8_t *dst, uint8_t *prev, uint8_t *cur, uint8_t *next, int w, int prefs, int mrefs, int parity, int mode) { DECLARE_ALIGNED(16, uint8_t, tmp0)[16]; DECLARE_ALIGNED(16, uint8_t, tmp1)[16]; DECLARE_ALIGNED(16, uint8_t, tmp2)[16]; DECLARE_ALIGNED(16, uint8_t, tmp3)[16]; int x; #def... | 18,368 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.