label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | static int usb_qdev_init(DeviceState *qdev) { USBDevice *dev = USB_DEVICE(qdev); int rc; pstrcpy(dev->product_desc, sizeof(dev->product_desc), usb_device_get_product_desc(dev)); dev->auto_attach = 1; QLIST_INIT(&dev->strings); usb_ep_init(dev); rc = usb_claim_port(dev); if (rc != 0) { return rc; } rc = usb_device_init(... | 12,717 |
0 | static void free_test_data(test_data *data) { AcpiSdtTable *temp; int i; if (data->rsdt_tables_addr) { g_free(data->rsdt_tables_addr); } for (i = 0; i < data->tables->len; ++i) { temp = &g_array_index(data->tables, AcpiSdtTable, i); if (temp->aml) { g_free(temp->aml); } if (temp->aml_file) { if (!temp->tmp_files_retain... | 12,719 |
0 | static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap) { QObject *obj; obj = parse_object(ctxt, tokens, ap); if (obj == NULL) { obj = parse_array(ctxt, tokens, ap); } if (obj == NULL) { obj = parse_escape(ctxt, tokens, ap); } if (obj == NULL) { obj = parse_keyword(ctxt, tokens); } if (obj == ... | 12,720 |
0 | static void ich_ahci_register(void) { type_register_static(&ich_ahci_info); type_register_static_alias(&ich_ahci_info, "ahci"); } | 12,721 |
0 | static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque, int is_write) { QCowAIOCB *acb; acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque); if (!acb) return NULL; acb->hd_aiocb = NULL; acb->sector_num = sector_num; acb->... | 12,722 |
0 | static inline uint64_t vtd_iova_limit(VTDContextEntry *ce) { uint32_t ce_agaw = vtd_ce_get_agaw(ce); return 1ULL << MIN(ce_agaw, VTD_MGAW); } | 12,723 |
0 | MigrationInfo *qmp_query_migrate(Error **errp) { MigrationInfo *info = g_malloc0(sizeof(*info)); MigrationState *s = migrate_get_current(); switch (s->state) { case MIGRATION_STATUS_NONE: /* no migration has happened ever */ break; case MIGRATION_STATUS_SETUP: info->has_status = true; info->status = MIGRATION_STATUS_SE... | 12,725 |
0 | static void do_sendkey(Monitor *mon, const QDict *qdict) { char keyname_buf[16]; char *separator; int keyname_len, keycode, i, idx; const char *keys = qdict_get_str(qdict, "keys"); int has_hold_time = qdict_haskey(qdict, "hold-time"); int hold_time = qdict_get_try_int(qdict, "hold-time", -1); if (nb_pending_keycodes > ... | 12,726 |
0 | static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs) { struct ibv_port_attr port; if (ibv_query_port(verbs, 1, &port)) { error_report("Failed to query port information"); return; } printf("%s RDMA Device opened: kernel name %s " "uverbs device name %s, " "infiniband_verbs class device path %s, " "i... | 12,728 |
0 | void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src, int stride, int height, int log2_denom, int weight_dst, int weight_src, int offset) { avc_biwgt_8width_msa(src, stride, dst, stride, height, log2_denom, weight_src, weight_dst, offset); } | 12,729 |
0 | static av_cold int raw_init_decoder(AVCodecContext *avctx) { RawVideoContext *context = avctx->priv_data; const AVPixFmtDescriptor *desc; ff_bswapdsp_init(&context->bbdsp); if ( avctx->codec_tag == MKTAG('r','a','w',' ') || avctx->codec_tag == MKTAG('N','O','1','6')) avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_... | 12,731 |
0 | static void gen_rfe(DisasContext *s, TCGv_i32 pc, TCGv_i32 cpsr) { gen_set_cpsr(cpsr, CPSR_ERET_MASK); tcg_temp_free_i32(cpsr); store_reg(s, 15, pc); s->is_jmp = DISAS_JUMP; } | 12,732 |
0 | void bdrv_drain_all_end(void) { BlockDriverState *bs; BdrvNextIterator it; BlockJob *job = NULL; for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { AioContext *aio_context = bdrv_get_aio_context(bs); aio_context_acquire(aio_context); aio_enable_external(aio_context); bdrv_io_unplugged_end(bs); bdrv_parent_drained_en... | 12,733 |
0 | int qemu_set_fd_handler(int fd, IOHandler *fd_read, IOHandler *fd_write, void *opaque) { return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque); } | 12,734 |
0 | int float32_lt( float32 a, float32 b STATUS_PARAM ) { flag aSign, bSign; if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { float_raise( float_flag_invalid STATUS_VAR); return 0; } aSign = extractFloat32Sign( a ); bSign = extra... | 12,735 |
0 | build_spcr(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info) { AcpiSerialPortConsoleRedirection *spcr; const MemMapEntry *uart_memmap = &guest_info->memmap[VIRT_UART]; int irq = guest_info->irqmap[VIRT_UART] + ARM_SPI_BASE; spcr = acpi_data_push(table_data, sizeof(*spcr)); spcr->interface_type = 0x3; /* AR... | 12,736 |
0 | static SocketAddressLegacy *sd_server_config(QDict *options, Error **errp) { QDict *server = NULL; QObject *crumpled_server = NULL; Visitor *iv = NULL; SocketAddress *saddr_flat = NULL; SocketAddressLegacy *saddr = NULL; Error *local_err = NULL; qdict_extract_subqdict(options, &server, "server."); crumpled_server = qdi... | 12,737 |
0 | static void tosa_init(ram_addr_t ram_size, int vga_ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model) { struct pxa2xx_state_s *cpu; struct tc6393xb_s *tmio; struct scoop_info_s *scp0, *scp1; if (ram_size < (TOSA_RAM + TOSA_ROM ... | 12,738 |
0 | static inline uint8_t fat_chksum(const direntry_t* entry) { uint8_t chksum=0; int i; for(i=0;i<11;i++) { unsigned char c; c = (i < 8) ? entry->name[i] : entry->extension[i-8]; chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0)) + c; } return chksum; } | 12,739 |
0 | static void event_notifier_ready(EventNotifier *notifier) { ThreadPool *pool = container_of(notifier, ThreadPool, notifier); ThreadPoolElement *elem, *next; event_notifier_test_and_clear(notifier); restart: QLIST_FOREACH_SAFE(elem, &pool->head, all, next) { if (elem->state != THREAD_CANCELED && elem->state != THREAD_DO... | 12,740 |
0 | static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt) { GXFContext *gxf = s->priv_data; AVIOContext *pb = s->pb; AVStream *st = s->streams[pkt->stream_index]; int64_t pos = avio_tell(pb); int padding = 0; int packet_start_offset = avio_tell(pb) / 1024; gxf_write_packet_header(pb, PKT_MEDIA); if (st->codec->cod... | 12,742 |
0 | static CharDriverState *qmp_chardev_open_parallel(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp) { ChardevHostdev *parallel = backend->u.parallel; int fd; fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp); if (fd < 0) { return NULL; } return qemu_chr_open_pp_fd(fd, errp); } | 12,743 |
0 | void qemu_peer_using_vnet_hdr(NetClientState *nc, bool enable) { if (!nc->peer || !nc->peer->info->using_vnet_hdr) { return; } nc->peer->info->using_vnet_hdr(nc->peer, enable); } | 12,744 |
0 | static int scsi_block_initfn(SCSIDevice *dev) { SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); int sg_version; int rc; if (!s->qdev.conf.bs) { error_report("drive property not set"); return -1; } /* check we are using a driver managing SG_IO (version 3 and after) */ rc = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERS... | 12,746 |
0 | static int vga_initfn(ISADevice *dev) { ISACirrusVGAState *d = DO_UPCAST(ISACirrusVGAState, dev, dev); VGACommonState *s = &d->cirrus_vga.vga; vga_common_init(s); cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0, isa_address_space(dev), isa_address_space_io(dev)); s->con = graphic_console_init(s->update, s->inv... | 12,747 |
0 | void memory_region_register_iommu_notifier(MemoryRegion *mr, Notifier *n) { if (mr->iommu_ops->notify_started && QLIST_EMPTY(&mr->iommu_notify.notifiers)) { mr->iommu_ops->notify_started(mr); } notifier_list_add(&mr->iommu_notify, n); } | 12,748 |
0 | static void pc_init1(MachineState *machine) { PCMachineState *pc_machine = PC_MACHINE(machine); MemoryRegion *system_memory = get_system_memory(); MemoryRegion *system_io = get_system_io(); int i; ram_addr_t below_4g_mem_size, above_4g_mem_size; PCIBus *pci_bus; ISABus *isa_bus; PCII440FXState *i440fx_state; int piix3_... | 12,749 |
0 | static int get_int32_le(QEMUFile *f, void *pv, size_t size) { int32_t *old = pv; int32_t new; qemu_get_sbe32s(f, &new); if (*old <= new) { return 0; } return -EINVAL; } | 12,750 |
0 | static void load_asl(GArray *sdts, AcpiSdtTable *sdt) { AcpiSdtTable *temp; GError *error = NULL; GString *command_line = g_string_new("'iasl' "); gint fd; gchar *out, *out_err; gboolean ret; int i; fd = g_file_open_tmp("asl-XXXXXX.dsl", &sdt->asl_file, &error); g_assert_no_error(error); close(fd); /* build command lin... | 12,751 |
0 | static void gen_advance_ccount(DisasContext *dc) { if (dc->ccount_delta > 0) { TCGv_i32 tmp = tcg_const_i32(dc->ccount_delta); dc->ccount_delta = 0; gen_helper_advance_ccount(cpu_env, tmp); tcg_temp_free(tmp); } } | 12,752 |
0 | static av_cold int libgsm_close(AVCodecContext *avctx) { av_freep(&avctx->coded_frame); gsm_destroy(avctx->priv_data); avctx->priv_data = NULL; return 0; } | 12,753 |
0 | static void uhci_ioport_writel(void *opaque, uint32_t addr, uint32_t val) { UHCIState *s = opaque; addr &= 0x1f; #ifdef DEBUG printf("uhci writel port=0x%04x val=0x%08x\n", addr, val); #endif switch(addr) { case 0x08: s->fl_base_addr = val & ~0xfff; break; } } | 12,754 |
0 | hwaddr x86_cpu_get_phys_page_debug(CPUState *cs, vaddr addr) { X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; target_ulong pde_addr, pte_addr; uint64_t pte; hwaddr paddr; uint32_t page_offset; int page_size; if (env->cr[4] & CR4_PAE_MASK) { target_ulong pdpe_addr; uint64_t pde, pdpe; #ifdef TARGET_X86_64 if (... | 12,755 |
0 | static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc) { HDAAudioState *a = HDA_AUDIO(hda); HDAAudioStream *st; const desc_node *node; const desc_param *param; uint32_t i, type; a->desc = desc; a->name = object_get_typename(OBJECT(a)); dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad); AUD_r... | 12,756 |
0 | static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid, unsigned int epid, unsigned int streamid) { XHCIStreamContext *stctx; XHCIEPContext *epctx; XHCIRing *ring; USBEndpoint *ep = NULL; uint64_t mfindex; int length; int i; trace_usb_xhci_ep_kick(slotid, epid, streamid); assert(slotid >= 1 && slotid <= xhci->nu... | 12,757 |
0 | static int pl181_init(SysBusDevice *sbd) { DeviceState *dev = DEVICE(sbd); PL181State *s = PL181(dev); DriveInfo *dinfo; memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, "pl181", 0x1000); sysbus_init_mmio(sbd, &s->iomem); sysbus_init_irq(sbd, &s->irq[0]); sysbus_init_irq(sbd, &s->irq[1]); qdev_init_gpio_out(d... | 12,758 |
0 | static void curl_readv_bh_cb(void *p) { CURLState *state; CURLAIOCB *acb = p; BDRVCURLState *s = acb->common.bs->opaque; qemu_bh_delete(acb->bh); acb->bh = NULL; size_t start = acb->sector_num * SECTOR_SIZE; size_t end; // In case we have the requested data already (e.g. read-ahead), // we can just call the callback an... | 12,759 |
0 | static void kvm_arm_gic_put(GICState *s) { uint32_t reg; int i; int cpu; int num_cpu; int num_irq; if (!kvm_arm_gic_can_save_restore(s)) { DPRINTF("Cannot put kernel gic state, no kernel interface"); return; } /* Note: We do the restore in a slightly different order than the save * (where the order doesn't matter and i... | 12,760 |
0 | void readline_handle_byte(ReadLineState *rs, int ch) { switch(rs->esc_state) { case IS_NORM: switch(ch) { case 1: readline_bol(rs); break; case 4: readline_delete_char(rs); break; case 5: readline_eol(rs); break; case 9: readline_completion(rs); break; case 10: case 13: rs->cmd_buf[rs->cmd_buf_size] = '\0'; if (!rs->re... | 12,761 |
0 | static void ats_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) { hwaddr phys_addr; target_ulong page_size; int prot; int ret, is_user = ri->opc2 & 2; int access_type = ri->opc2 & 1; ret = get_phys_addr(env, value, access_type, is_user, &phys_addr, &prot, &page_size); if (extended_addresses_enabled(env)... | 12,763 |
0 | static void test_hybrid_analysis(void) { LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]); LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]); LOCAL_ALIGNED_16(INTFLOAT, in, [12], [2]); LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]); declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2], const INTFLOAT (*filter)[8]... | 12,764 |
0 | static void test_qemu_strtoul_full_max(void) { char *str = g_strdup_printf("%lu", ULONG_MAX); unsigned long res = 999; int err; err = qemu_strtoul(str, NULL, 0, &res); g_assert_cmpint(err, ==, 0); g_assert_cmpint(res, ==, ULONG_MAX); g_free(str); } | 12,766 |
0 | static uint64_t assigned_dev_ioport_read(void *opaque, target_phys_addr_t addr, unsigned size) { return assigned_dev_ioport_rw(opaque, addr, size, NULL); } | 12,767 |
0 | int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr) { RAMBlock *block; uint8_t *host = ptr; if (xen_enabled()) { *ram_addr = xen_ram_addr_from_mapcache(ptr); return 0; } QTAILQ_FOREACH(block, &ram_list.blocks, next) { /* This case append when the block is not mapped. */ if (block->host == NULL) { continue; } i... | 12,768 |
0 | static void address_space_update_topology_pass(AddressSpace *as, const FlatView *old_view, const FlatView *new_view, bool adding) { unsigned iold, inew; FlatRange *frold, *frnew; /* Generate a symmetric difference of the old and new memory maps. * Kill ranges in the old map, and instantiate ranges in the new map. */ io... | 12,769 |
0 | static void pxb_dev_exitfn(PCIDevice *pci_dev) { PXBDev *pxb = PXB_DEV(pci_dev); pxb_dev_list = g_list_remove(pxb_dev_list, pxb); } | 12,770 |
0 | static void ne2000_write(void *opaque, target_phys_addr_t addr, uint64_t data, unsigned size) { NE2000State *s = opaque; if (addr < 0x10 && size == 1) { ne2000_ioport_write(s, addr, data); } else if (addr == 0x10) { if (size <= 2) { ne2000_asic_ioport_write(s, addr, data); } else { ne2000_asic_ioport_writel(s, addr, da... | 12,771 |
0 | static void cuda_writew (void *opaque, target_phys_addr_t addr, uint32_t value) { } | 12,772 |
0 | void smbios_set_defaults(const char *manufacturer, const char *product, const char *version) { SMBIOS_SET_DEFAULT(type1.manufacturer, manufacturer); SMBIOS_SET_DEFAULT(type1.product, product); SMBIOS_SET_DEFAULT(type1.version, version); } | 12,773 |
0 | void qio_channel_socket_dgram_async(QIOChannelSocket *ioc, SocketAddressLegacy *localAddr, SocketAddressLegacy *remoteAddr, QIOTaskFunc callback, gpointer opaque, GDestroyNotify destroy) { QIOTask *task = qio_task_new( OBJECT(ioc), callback, opaque, destroy); struct QIOChannelSocketDGramWorkerData *data = g_new0( struc... | 12,774 |
0 | static void spawn_thread_bh_fn(void *opaque) { ThreadPool *pool = opaque; qemu_mutex_lock(&pool->lock); do_spawn_thread(pool); qemu_mutex_unlock(&pool->lock); } | 12,776 |
1 | static void ppc_prep_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; const char *boot_device = machine->boot_order; MemoryRegion *s... | 12,779 |
1 | gen_set_condexec (DisasContext *s) { if (s->condexec_mask) { uint32_t val = (s->condexec_cond << 4) | (s->condexec_mask >> 1); TCGv tmp = new_tmp(); tcg_gen_movi_i32(tmp, val); store_cpu_field(tmp, condexec_bits); } } | 12,781 |
1 | void *mcf_uart_init(qemu_irq irq, CharDriverState *chr) { mcf_uart_state *s; s = g_malloc0(sizeof(mcf_uart_state)); s->chr = chr; s->irq = irq; if (chr) { qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive, mcf_uart_event, s); } mcf_uart_reset(s); return s; } | 12,782 |
1 | static void parse_waveformatex(AVIOContext *pb, AVCodecParameters *par) { ff_asf_guid subformat; par->bits_per_coded_sample = avio_rl16(pb); par->channel_layout = avio_rl32(pb); /* dwChannelMask */ ff_get_guid(pb, &subformat); if (!memcmp(subformat + 4, (const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) { par->codec_... | 12,783 |
1 | static void ict_int(void *_src0, void *_src1, void *_src2, int csize) { int32_t *src0 = _src0, *src1 = _src1, *src2 = _src2; int32_t i0, i1, i2; int i; for (i = 0; i < csize; i++) { i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16); i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16) - (((i_ict_para... | 12,784 |
1 | static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name, int flags) { int ret = -1; if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { int map_dirfd; if (flags == AT_REMOVEDIR) { int fd; fd = openat(dirfd, name, O_RDONLY | O_DIRECTORY | O_PATH); if (fd == -1) { goto err_out; } /* * If directory remove ... | 12,788 |
1 | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir) { MpegEncContext *s = &v->s; DSPContext *dsp = &v->s.dsp; uint8_t *srcY; int dxy, mx, my, src_x, src_y; int off; int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0; int v_edge_pos = s->v_edge_pos >> v->field_mode; if ((!v->field_mode ... | 12,790 |
1 | int main(int argc, char **argv) { int ret = EXIT_SUCCESS; GAState *s = g_new0(GAState, 1); GAConfig *config = g_new0(GAConfig, 1); config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL; module_call_init(MODULE_INIT_QAPI); init_dfl_pathnames(); config_load(config); config_parse(config, argc, argv); if (config->pi... | 12,791 |
1 | static int gen_rp_interrupts_init(PCIDevice *d, Error **errp) { int rc; rc = msix_init_exclusive_bar(d, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0); if (rc < 0) { assert(rc == -ENOTSUP); error_setg(errp, "Unable to init msix vectors"); } else { msix_vector_use(d, 0); } return rc; } | 12,792 |
0 | static int vaapi_decode_make_config(AVCodecContext *avctx) { VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data; AVVAAPIHWConfig *hwconfig = NULL; AVHWFramesConstraints *constraints = NULL; VAStatus vas; int err, i, j; const AVCodecDescriptor *codec_desc; VAProfile profile, *profile_list = NULL; int profile_c... | 12,793 |
1 | static int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp) { if (qemu_opt_get_bool(opts, "enable", false)) { #ifdef CONFIG_SECCOMP uint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT | QEMU_SECCOMP_SET_OBSOLETE; const char *value = NULL; value = qemu_opt_get(opts, "obsolete"); if (g_str_equal(value, "allow")) { ... | 12,794 |
1 | static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id) { return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name; } | 12,795 |
1 | static int wm8750_tx(I2CSlave *i2c, uint8_t data) { WM8750State *s = (WM8750State *) i2c; uint8_t cmd; uint16_t value; if (s->i2c_len >= 2) { printf("%s: long message (%i bytes)\n", __FUNCTION__, s->i2c_len); #ifdef VERBOSE return 1; #endif } s->i2c_data[s->i2c_len ++] = data; if (s->i2c_len != 2) return 0; cmd = s->i2... | 12,797 |
1 | static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp) { const QDictEntry *ent; const char *arg_name; const QObject *arg_obj; bool has_exec_key = false; QDict *dict = NULL; dict = qobject_to_qdict(request); if (!dict) { error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "request is not a dictionary"); retu... | 12,798 |
1 | static void j2k_flush(J2kDecoderContext *s) { if (*s->buf == 0xff) s->buf++; s->bit_index = 8; s->buf++; } | 12,800 |
1 | av_cold int ff_ac3_encode_close(AVCodecContext *avctx) { int blk, ch; AC3EncodeContext *s = avctx->priv_data; av_freep(&s->windowed_samples); for (ch = 0; ch < s->channels; ch++) av_freep(&s->planar_samples[ch]); av_freep(&s->planar_samples); av_freep(&s->bap_buffer); av_freep(&s->bap1_buffer); av_freep(&s->mdct_coef_b... | 12,802 |
1 | static uint64_t pit_ioport_read(void *opaque, hwaddr addr, unsigned size) { PITCommonState *pit = opaque; int ret, count; PITChannelState *s; addr &= 3; s = &pit->channels[addr]; if (s->status_latched) { s->status_latched = 0; ret = s->status; } else if (s->count_latched) { switch(s->count_latched) { default: case RW_S... | 12,803 |
1 | static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt) { ASFContext *asf = s->priv_data; ASFStream *asf_st = 0; for (;;) { int ret; if(pb->eof_reached) return AVERROR_EOF; if (asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1) { //asf->packet_size_left <= asf->packet_pads... | 12,804 |
1 | static int h264_slice_header_init(H264Context *h, int reinit) { MpegEncContext *const s = &h->s; int i, ret; if( FFALIGN(s->avctx->width , 16 ) == s->width && FFALIGN(s->avctx->height, 16*(2 - h->sps.frame_mbs_only_flag)) == s->height && !h->sps.crop_right && !h->sps.crop_bottom && (s->avctx->width != s->width || s->av... | 12,806 |
1 | void qpci_io_writeb(QPCIDevice *dev, void *data, uint8_t value) { uintptr_t addr = (uintptr_t)data; if (addr < QPCI_PIO_LIMIT) { dev->bus->pio_writeb(dev->bus, addr, value); } else { dev->bus->memwrite(dev->bus, addr, &value, sizeof(value)); } } | 12,807 |
1 | static inline void RENAME(hyscale)(uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hLumFilter, int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode, int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter, int32_t *mmx2FilterPos, uint8_t *pal) { if(sr... | 12,808 |
1 | static void ich9_smb_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->vendor_id = PCI_VENDOR_ID_INTEL; k->device_id = PCI_DEVICE_ID_INTEL_ICH9_6; k->revision = ICH9_A2_SMB_REVISION; k->class_id = PCI_CLASS_SERIAL_SMBUS; dc->no_user = 1; ... | 12,811 |
1 | bool qemu_file_mode_is_not_valid(const char *mode) { if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 'b' || mode[2] != 0) { fprintf(stderr, "qemu_fopen: Argument validity check failed\n"); return true; } return false; } | 12,812 |
1 | void qemu_mutex_unlock(QemuMutex *mutex) { assert(mutex->owner == GetCurrentThreadId()); mutex->owner = 0; LeaveCriticalSection(&mutex->lock); } | 12,813 |
1 | void register_watchdogs(void) { wdt_ib700_init(); wdt_i6300esb_init(); } | 12,815 |
1 | static int rtmp_write(URLContext *s, const uint8_t *buf, int size) { RTMPContext *rt = s->priv_data; int size_temp = size; int pktsize, pkttype; uint32_t ts; const uint8_t *buf_temp = buf; uint8_t c; int ret; do { if (rt->skip_bytes) { int skip = FFMIN(rt->skip_bytes, size_temp); buf_temp += skip; size_temp -= skip; rt... | 12,816 |
1 | void ff_thread_flush(AVCodecContext *avctx) { FrameThreadContext *fctx = avctx->thread_opaque; if (!avctx->thread_opaque) return; park_frame_worker_threads(fctx, avctx->thread_count); if (fctx->prev_thread) update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0); fctx->next_decoding = fctx->next_f... | 12,818 |
1 | static int check_strtox_error(const char **next, char *endptr, int err) { if (!next && *endptr) { return -EINVAL; } if (next) { *next = endptr; } return -err; } | 12,819 |
1 | static void pc_init1(MachineState *machine, const char *host_type, const char *pci_type) { PCMachineState *pcms = PC_MACHINE(machine); PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms); MemoryRegion *system_memory = get_system_memory(); MemoryRegion *system_io = get_system_io(); int i; PCIBus *pci_bus; ISABus *isa_bus;... | 12,820 |
1 | static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data) { struct bdrv_iterate_context context = { mon, 0 }; bdrv_iterate(encrypted_bdrv_it, &context); /* only resume the vm if all keys are set and valid */ if (!context.err) { vm_start(); return 0; } else { | 12,821 |
1 | static void colo_old_packet_check(void *opaque) { CompareState *s = opaque; g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL); } | 12,822 |
1 | int pci_add_capability(PCIDevice *pdev, uint8_t cap_id, uint8_t offset, uint8_t size) { int ret; Error *local_err = NULL; ret = pci_add_capability2(pdev, cap_id, offset, size, &local_err); if (local_err) { assert(ret < 0); error_report_err(local_err); } else { /* success implies a positive offset in config space */ ass... | 12,824 |
1 | static void write_bootloader(uint8_t *base, int64_t run_addr, int64_t kernel_entry) { uint32_t *p; /* Small bootloader */ p = (uint32_t *)base; stl_p(p++, 0x08000000 | /* j 0x1fc00580 */ ((run_addr + 0x580) & 0x0fffffff) >> 2); stl_p(p++, 0x00000000); /* nop */ /* YAMON service vector */ stl_p(base + 0x500, run_addr + ... | 12,825 |
1 | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num) { TCPCharDriver *s = chr->opaque; /* clear old pending fd array */ g_free(s->write_msgfds); if (num) { s->write_msgfds = g_malloc(num * sizeof(int)); memcpy(s->write_msgfds, fds, num * sizeof(int)); } s->write_msgfds_num = num; return 0; } | 12,826 |
1 | void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty) { int reslevelno, bandno, precno; for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) { Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno; for (bandno = 0; bandno < reslevel->nbands; bandno++) { Jpeg2000Band *band = resleve... | 12,827 |
0 | static int get_physical_address(CPUState *env, target_phys_addr_t *physical, int *prot, int *access_index, target_ulong address, int rw, int mmu_idx) { int is_user = mmu_idx == MMU_USER_IDX; if (rw == 2) return get_physical_address_code(env, physical, prot, address, is_user); else return get_physical_address_data(env, ... | 12,831 |
0 | void op_flush_icache_all(void) { CALL_FROM_TB1(tb_flush, env); RETURN(); } | 12,832 |
0 | static void test_visitor_in_struct_nested(TestInputVisitorData *data, const void *unused) { UserDefTwo *udp = NULL; Visitor *v; v = visitor_input_test_init(data, "{ 'string0': 'string0', " "'dict1': { 'string1': 'string1', " "'dict2': { 'userdef': { 'integer': 42, " "'string': 'string' }, 'string': 'string2'}}}"); visi... | 12,833 |
0 | static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw, int group_id) { fprintf(stderr, ": type %s effect %s", qxl_name(qxl_draw_type, draw->type), qxl_name(qxl_draw_effect, draw->effect)); if (draw->bitmap_offset) { fprintf(stderr, ": bitmap %d", draw->bitmap_offset); qxl_log_rect(&draw->bitmap... | 12,834 |
0 | int apic_init(CPUState *env) { APICState *s; if (last_apic_idx >= MAX_APICS) return -1; s = qemu_mallocz(sizeof(APICState)); env->apic_state = s; s->idx = last_apic_idx++; s->id = env->cpuid_apic_id; s->cpu_env = env; apic_reset(s); msix_supported = 1; /* XXX: mapping more APICs at the same memory location */ if (apic_... | 12,835 |
0 | static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data, const char *json_string, va_list *ap) { visitor_input_teardown(data, NULL); data->obj = qobject_from_jsonv(json_string, ap); g_assert(data->obj); data->qiv = qmp_input_visitor_new(data->obj, false); g_assert(data->qiv); return data->qiv; } | 12,836 |
0 | target_ulong helper_rdhwr_cc(CPUMIPSState *env) { if ((env->hflags & MIPS_HFLAG_CP0) || (env->CP0_HWREna & (1 << 2))) { #ifdef CONFIG_USER_ONLY return env->CP0_Count; #else return (int32_t)cpu_mips_get_count(env); #endif } else { do_raise_exception(env, EXCP_RI, GETPC()); } return 0; } | 12,837 |
0 | static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs) { memset(stfs, 0, sizeof(*stfs)); stfs->f_type = prstfs->f_type; stfs->f_bsize = prstfs->f_bsize; stfs->f_blocks = prstfs->f_blocks; stfs->f_bfree = prstfs->f_bfree; stfs->f_bavail = prstfs->f_bavail; stfs->f_files = prstfs->f_files; stfs->f_ffree... | 12,838 |
0 | static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size) { ProresContext *ctx = avctx->priv_data; int i, hdr_size, slice_count; unsigned pic_data_size; int log2_slice_mb_width, log2_slice_mb_height; int slice_mb_count, mb_x, mb_y; const uint8_t *data_ptr, *index_ptr; hdr_size = bu... | 12,839 |
0 | static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun, uint8_t *buf, void *hba_private) { SCSIRequest *req; req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private); return req; } | 12,840 |
0 | static int kvm_get_xcrs(CPUState *env) { #ifdef KVM_CAP_XCRS int i, ret; struct kvm_xcrs xcrs; if (!kvm_has_xcrs()) return 0; ret = kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs); if (ret < 0) return ret; for (i = 0; i < xcrs.nr_xcrs; i++) /* Only support xcr0 now */ if (xcrs.xcrs[0].xcr == 0) { env->xcr0 = xcrs.xcrs[0].valu... | 12,841 |
0 | static int is_dup_page(uint8_t *page) { VECTYPE *p = (VECTYPE *)page; VECTYPE val = SPLAT(page); int i; for (i = 0; i < TARGET_PAGE_SIZE / sizeof(VECTYPE); i++) { if (!ALL_EQ(val, p[i])) { return 0; } } return 1; } | 12,842 |
0 | static void spapr_phb_realize(DeviceState *dev, Error **errp) { sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); SysBusDevice *s = SYS_BUS_DEVICE(dev); sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s); PCIHostState *phb = PCI_HOST_BRIDGE(s); char *namebuf; int i; PCIBus *bus; uint64_t msi_window_size = 4096;... | 12,843 |
0 | static inline int is_sector_in_chunk(BDRVDMGState* s, uint32_t chunk_num,int sector_num) { if(chunk_num>=s->n_chunks || s->sectors[chunk_num]>sector_num || s->sectors[chunk_num]+s->sectorcounts[chunk_num]<=sector_num) return 0; else return -1; } | 12,844 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.