label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | void ff_mpeg_flush(AVCodecContext *avctx){ int i; MpegEncContext *s = avctx->priv_data; if(s==NULL || s->picture==NULL) return; for(i=0; i<MAX_PICTURE_COUNT; i++){ if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL || s->picture[i].type == FF_BUFFER_TYPE_USER)) avctx->release_buffer(avctx, (AVF... |
1 | void *kvmppc_create_spapr_tce(uint32_t liobn, uint32_t window_size, int *pfd){ struct kvm_create_spapr_tce args = { .liobn = liobn, .window_size = window_size, }; long len; int fd; void *table; /* Must set fd to -1 so we don't try to munmap when called for * destroying the table, which the upper layers -will- do */ *pf... |
1 | long do_rt_sigreturn(CPUM68KState *env){ struct target_rt_sigframe *frame; abi_ulong frame_addr = env->aregs[7] - 4; target_sigset_t target_set; sigset_t set; trace_user_do_rt_sigreturn(env, frame_addr); if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; target_to_host_sigset_internal(&set, &targe... |
1 | static BlockAIOCB *bdrv_co_aio_prw_vector(BdrvChild *child, int64_t offset, QEMUIOVector *qiov, BdrvRequestFlags flags, BlockCompletionFunc *cb, void *opaque, bool is_write){ Coroutine *co; BlockAIOCBCoroutine *acb; /* Matched by bdrv_co_complete's bdrv_dec_in_flight. */ bdrv_inc_in_flight(child->bs); acb = qemu_aio_ge... |
1 | static void ahci_port_write(AHCIState *s, int port, int offset, uint32_t val){ AHCIPortRegs *pr = &s->dev[port].port_regs; DPRINTF(port, "offset: 0x%x val: 0x%x\n", offset, val); switch (offset) { case PORT_LST_ADDR: pr->lst_addr = val; map_page(s->as, &s->dev[port].lst, ((uint64_t)pr->lst_addr_hi << 32) | pr->lst_addr... |
1 | static int jacosub_read_header(AVFormatContext *s){ AVBPrint header; AVIOContext *pb = s->pb; char line[JSS_MAX_LINESIZE]; JACOsubContext *jacosub = s->priv_data; int shift_set = 0; // only the first shift matters int merge_line = 0; int i, ret; AVStream *st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOME... |
0 | static int get_packet_payload_size(AVFormatContext *ctx, int stream_index, int64_t pts, int64_t dts){ MpegMuxContext *s = ctx->priv_data; int buf_index; StreamInfo *stream; stream = ctx->streams[stream_index]->priv_data; buf_index = 0; if (((s->packet_number % s->pack_header_freq) == 0)) { /* pack header size */ if (s-... |
1 | ogm_header(AVFormatContext *s, int idx){ struct ogg *ogg = s->priv_data; struct ogg_stream *os = ogg->streams + idx; AVStream *st = s->streams[idx]; const uint8_t *p = os->buf + os->pstart; uint64_t time_unit; uint64_t spu; uint32_t size; if(!(*p & 1)) return 0; if(*p == 1) { p++; if(*p == 'v'){ int tag; st->codec->cod... |
1 | static int ape_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ AVFrame *frame = data; const uint8_t *buf = avpkt->data; APEContext *s = avctx->priv_data; uint8_t *sample8; int16_t *sample16; int32_t *sample24; int i, ch, ret; int blockstodecode; /* this should never be negative, bu... |
1 | e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt){ E1000State *s = qemu_get_nic_opaque(nc); PCIDevice *d = PCI_DEVICE(s); struct e1000_rx_desc desc; dma_addr_t base; unsigned int n, rdt; uint32_t rdh_start; uint16_t vlan_special = 0; uint8_t vlan_status = 0; uint8_t min_buf[MIN_BUF_SIZE]; struc... |
1 | static void close_peer_eventfds(IVShmemState *s, int posn){ int i, n; if (!ivshmem_has_feature(s, IVSHMEM_IOEVENTFD)) { return; } if (posn < 0 || posn >= s->nb_peers) { error_report("invalid peer %d", posn); return; } n = s->peers[posn].nb_eventfds; memory_region_transaction_begin(); for (i = 0; i < n; i++) { ivshmem_d... |
1 | static void pci_ivshmem_exit(PCIDevice *dev){ IVShmemState *s = IVSHMEM(dev); int i; fifo8_destroy(&s->incoming_fifo); if (s->migration_blocker) { migrate_del_blocker(s->migration_blocker); error_free(s->migration_blocker); } if (s->shm_fd >= 0) { void *addr = memory_region_get_ram_ptr(&s->ivshmem); vmstate_unregister_... |
0 | static inline void RENAME(rgb32tobgr16)(const uint8_t *src, uint8_t *dst, long src_size){ const uint8_t *s = src; const uint8_t *end;#if COMPILE_TEMPLATE_MMX const uint8_t *mm_end;#endif uint16_t *d = (uint16_t *)dst; end = s + src_size;#if COMPILE_TEMPLATE_MMX __asm__ volatile(PREFETCH" %0"::"m"(*src):"memory"); __asm... |
0 | static int truemotion1_decode_header(TrueMotion1Context *s){ int i; int width_shift = 0; int new_pix_fmt; struct frame_header header; uint8_t header_buffer[128]; /* logical maximum size of the header */ const uint8_t *sel_vector_table; header.header_size = ((s->buf[0] >> 5) | (s->buf[0] << 3)) & 0x7f; if (s->buf[0] < 0... |
0 | static int opt_input_ts_scale(const char *opt, const char *arg){ unsigned int stream; double scale; char *p; stream = strtol(arg, &p, 0); if (*p) p++; scale= strtod(p, &p); if(stream >= MAX_STREAMS) ffmpeg_exit(1); ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1); ts_scale[stream] = scale; r... |
0 | static av_always_inline int normal_limit(uint8_t *p, int stride, int E, int I){ LOAD_PIXELS return simple_limit(p, stride, 2*E+I) && FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I && FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;} |
0 | static int mov_open_dref(AVIOContext **pb, const char *src, MOVDref *ref, AVIOInterruptCB *int_cb, int use_absolute_path, AVFormatContext *fc){ /* try relative path, we do not try the absolute because it can leak information about our system to an attacker */ if (ref->nlvl_to > 0 && ref->nlvl_from > 0) { char filename[... |
0 | static int swScale(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t* dst[], int dstStride[]){ /* load a few things into local vars to make the code more readable? and faster */ const int srcW= c->srcW; const int dstW= c->dstW; const int dstH= c->dstH; const int chrDstW= c->chr... |
0 | int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation){ const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat); const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat); memcpy... |
1 | static void alpha_cpu_class_init(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); CPUClass *cc = CPU_CLASS(oc); AlphaCPUClass *acc = ALPHA_CPU_CLASS(oc); acc->parent_realize = dc->realize; dc->realize = alpha_cpu_realizefn; cc->class_by_name = alpha_cpu_class_by_name; cc->has_work = alpha_cpu_has_work;... |
1 | static void rtas_ibm_write_pci_config(sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ uint32_t val, size, addr; uint64_t buid = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 2); PCIDevice *dev = find_dev(spapr, buid, rtas_ld(args, 0)); if (!dev) { rtas... |
1 | static int submit_stats(AVCodecContext *avctx){#ifdef TH_ENCCTL_2PASS_IN TheoraContext *h = avctx->priv_data; int bytes; if (!avctx->stats_in) { av_log(avctx, AV_LOG_ERROR, "No statsfile for second pass\n"); return AVERROR(EINVAL); h->stats_size = strlen(avctx->stats_in) * 3/4; h->stats = av_malloc(h->stats_size); h->s... |
1 | static int encode_plane(AVCodecContext *avctx, uint8_t *src, uint8_t *dst, int stride, int width, int height, PutByteContext *pb){ UtvideoContext *c = avctx->priv_data; uint8_t lengths[256]; uint64_t counts[256] = { 0 }; HuffEntry he[256]; uint32_t offset = 0, slice_len = 0; int i, sstart, send = 0; int symbol; /* Do p... |
0 | static int vhdx_create(const char *filename, QEMUOptionParameter *options, Error **errp){ int ret = 0; uint64_t image_size = (uint64_t) 2 * GiB; uint32_t log_size = 1 * MiB; uint32_t block_size = 0; uint64_t signature; uint64_t metadata_offset; bool use_zero_blocks = false; gunichar2 *creator = NULL; glong creator_item... |
0 | static int zero_single_l2(BlockDriverState *bs, uint64_t offset, uint64_t nb_clusters, int flags){ BDRVQcow2State *s = bs->opaque; uint64_t *l2_table; int l2_index; int ret; int i; ret = get_cluster_table(bs, offset, &l2_table, &l2_index); if (ret < 0) { return ret; } /* Limit nb_clusters to one L2 table */ nb_clusters... |
0 | static int megasas_dcmd_set_properties(MegasasState *s, MegasasCmd *cmd){ struct mfi_ctrl_props info; size_t dcmd_size = sizeof(info); if (cmd->iov_size < dcmd_size) { trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size, dcmd_size); return MFI_STAT_INVALID_PARAMETER; } dma_buf_write((uint8_t *)&info, cmd->iov... |
0 | static int fd_open(BlockDriverState *bs){ BDRVRawState *s = bs->opaque; int last_media_present; if (s->type != FTYPE_FD) return 0; last_media_present = (s->fd >= 0); if (s->fd >= 0 && (qemu_get_clock(rt_clock) - s->fd_open_time) >= FD_OPEN_TIMEOUT) { close(s->fd); s->fd = -1; raw_close_fd_pool(s);#ifdef DEBUG_FLOPPY pr... |
0 | static void qdev_print(Monitor *mon, DeviceState *dev, int indent){ BusState *child; qdev_printf("dev: %s, id \"%s\"\n", dev->info->name, dev->id ? dev->id : ""); indent += 2; if (dev->num_gpio_in) { qdev_printf("gpio-in %d\n", dev->num_gpio_in); } if (dev->num_gpio_out) { qdev_printf("gpio-out %d\n", dev->num_gpio_out... |
0 | static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos){ BDRVQcow2State *s = bs->opaque; bool zero_beyond_eof = bs->zero_beyond_eof; int ret; BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD); bs->zero_beyond_eof = false; ret = bdrv_preadv(bs, qcow2_vm_state_offset(s) + pos, qiov); bs->zero_beyon... |
0 | static av_cold int g726_encode_init(AVCodecContext *avctx){ G726Context* c = avctx->priv_data; if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && avctx->sample_rate != 8000) { av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not " "allowed when the compliance level is higher than unofficial. " ... |
0 | int qemu_acl_insert(qemu_acl *acl, int deny, const char *match, int index){ qemu_acl_entry *entry; qemu_acl_entry *tmp; int i = 0; if (index <= 0) return -1; if (index >= acl->nentries) return qemu_acl_append(acl, deny, match); entry = qemu_malloc(sizeof(*entry)); entry->match = qemu_strdup(match); entry->deny = deny; ... |
0 | int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum, BlockDriverState **file){ return bdrv_get_block_status_above(bs, backing_bs(bs), sector_num, nb_sectors, pnum, file);} |
0 | static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename){ uint32_t magic; if (buf_size < 4) return 0; magic = be32_to_cpu(*(uint32_t *)buf); if (magic == VMDK3_MAGIC || magic == VMDK4_MAGIC) { return 100; } else { const char *p = (const char *)buf; const char *end = p + buf_size; while (p < end) { ... |
0 | static int write_elf64_note(DumpState *s){ Elf64_Phdr phdr; int endian = s->dump_info.d_endian; target_phys_addr_t begin = s->memory_offset - s->note_size; int ret; memset(&phdr, 0, sizeof(Elf64_Phdr)); phdr.p_type = cpu_convert_to_target32(PT_NOTE, endian); phdr.p_offset = cpu_convert_to_target64(begin, endian); phdr.... |
0 | void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top){ assert(!bdrv_requests_pending(bs_top)); assert(!bdrv_requests_pending(bs_new)); bdrv_ref(bs_top); change_parent_backing_link(bs_top, bs_new); bdrv_set_backing_hd(bs_new, bs_top); bdrv_unref(bs_top); /* bs_new is now referenced by its new parents, we ... |
0 | static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc, target_ulong *r0_p){ int i;#define COPY(x) __get_user(regs->x, &sc->sc_##x) COPY(gregs[1]); COPY(gregs[2]); COPY(gregs[3]); COPY(gregs[4]); COPY(gregs[5]); COPY(gregs[6]); COPY(gregs[7]); COPY(gregs[8]); COPY(gregs[9]); COPY(gregs[10]); COP... |
0 | static void vtd_update_iotlb(IntelIOMMUState *s, uint16_t source_id, uint16_t domain_id, hwaddr addr, uint64_t slpte, bool read_flags, bool write_flags){ VTDIOTLBEntry *entry = g_malloc(sizeof(*entry)); uint64_t *key = g_malloc(sizeof(*key)); uint64_t gfn = addr >> VTD_PAGE_SHIFT_4K; VTD_DPRINTF(CACHE, "update iotlb si... |
0 | static void armv7m_nvic_init(SysBusDevice *dev){ nvic_state *s= FROM_SYSBUSGIC(nvic_state, dev); CPUState *env; env = qdev_get_prop_ptr(&dev->qdev, "cpu"); gic_init(&s->gic); cpu_register_physical_memory(0xe000e000, 0x1000, s->gic.iomemtype); s->systick.timer = qemu_new_timer(vm_clock, systick_timer_tick, s); if (env->... |
0 | lookup_scalar(const OptsVisitor *ov, const char *name, Error **errp){ if (ov->repeated_opts == NULL) { GQueue *list; /* the last occurrence of any QemuOpt takes effect when queried by name */ list = lookup_distinct(ov, name, errp); return list ? g_queue_peek_tail(list) : NULL; } return g_queue_peek_head(ov->repeated_op... |
0 | static void hextile_enc_cord(uint8_t *ptr, int x, int y, int w, int h){ ptr[0] = ((x & 0x0F) << 4) | (y & 0x0F); ptr[1] = (((w - 1) & 0x0F) << 4) | ((h - 1) & 0x0F);} |
1 | static void RENAME(hyscale_fast)(SwsContext *c, int16_t *dst, int dstWidth, const uint8_t *src, int srcW, int xInc){ int16_t *filterPos = c->hLumFilterPos; int16_t *filter = c->hLumFilter; void *mmx2FilterCode= c->lumMmx2FilterCode; int i;#if defined(PIC) uint64_t ebxsave;#endif#if ARCH_X86_64 uint64_t retsave;#endif _... |
1 | static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, uint16_t *quant_matrix, int Al){ int val; s->bdsp.clear_block(block); val = mjpeg_decode_dc(s, dc_index); if (val == 0xfffff) { av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); return AVERROR_INVALIDDATA; } val = (val * (q... |
1 | static void vga_screen_dump_common(VGAState *s, const char *filename, int w, int h){ DisplayState *saved_ds, ds1, *ds = &ds1; DisplayChangeListener dcl; /* XXX: this is a little hackish */ vga_invalidate_display(s); saved_ds = s->ds; memset(ds, 0, sizeof(DisplayState)); memset(&dcl, 0, sizeof(DisplayChangeListener)); d... |
1 | static int ehci_state_execute(EHCIQueue *q){ EHCIPacket *p = QTAILQ_FIRST(&q->packets); int again = 0; assert(p != NULL); assert(p->qtdaddr == q->qtdaddr); if (ehci_qh_do_overlay(q) != 0) { return -1; } // TODO verify enough time remains in the uframe as in 4.4.1.1 // TODO write back ptr to async list when done or out ... |
1 | static void update_msix_table_msg_data(S390PCIBusDevice *pbdev, uint64_t offset, uint64_t *data, uint8_t len){ uint32_t val; uint8_t *msg_data; if (offset % PCI_MSIX_ENTRY_SIZE != 8) { return; } if (len != 4) { DPRINTF("access msix table msg data but len is %d\n", len); return; } msg_data = (uint8_t *)data - offset % P... |
1 | static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride){ int i, a1, b1, c1, d1; int16_t tmp[16]; for (i = 0; i < 4; i++) { a1 = (block[i * 4 + 0] + block[i * 4 + 2]) * 23170; b1 = (block[i * 4 + 0] - block[i * 4 + 2]) * 23170; c1 = block[i * 4 + 1] * 12540 - block[i * 4 + 3] * 30274; d1 = block[i ... |
1 | void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status){ const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1); const int end_i = av_clip(endx + endy * s->mb_width, 0, s->mb_num); const int start_xy = s->mb_index2xy[start_i]; const int end_xy = s->mb_index2xy[en... |
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 **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, long dstW, long ch... |
1 | void bitmap_clear(unsigned long *map, long start, long nr){ unsigned long *p = map + BIT_WORD(start); const long size = start + nr; int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG); unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start); while (nr - bits_to_clear >= 0) { *p &= ~mask_to_clear; nr -= bits... |
1 | static inline void tcg_temp_free_internal(int idx){ TCGContext *s = &tcg_ctx; TCGTemp *ts; int k; assert(idx >= s->nb_globals && idx < s->nb_temps); ts = &s->temps[idx]; assert(ts->temp_allocated != 0); ts->temp_allocated = 0; k = ts->base_type; if (ts->temp_local) k += TCG_TYPE_COUNT; ts->next_free_temp = s->first_fre... |
1 | static void mcf_uart_do_tx(mcf_uart_state *s){ if (s->tx_enabled && (s->sr & MCF_UART_TxEMP) == 0) { if (s->chr) qemu_chr_fe_write(s->chr, (unsigned char *)&s->tb, 1); s->sr |= MCF_UART_TxEMP; } if (s->tx_enabled) { s->sr |= MCF_UART_TxRDY; } else { s->sr &= ~MCF_UART_TxRDY; }} |
0 | int av_cold ff_mlp_init_crc2D(AVCodecParserContext *s){ if (!crc_init_2D) { av_crc_init(crc_2D, 0, 16, 0x002D, sizeof(crc_2D)); crc_init_2D = 1; } return 0;} |
1 | static void mainstone_common_init(MemoryRegion *address_space_mem, MachineState *machine, enum mainstone_model_e model, int arm_id){ uint32_t sector_len = 256 * 1024; hwaddr mainstone_flash_base[] = { MST_FLASH_0, MST_FLASH_1 }; PXA2xxState *mpu; DeviceState *mst_irq; DriveInfo *dinfo; int i; int be; MemoryRegion *rom ... |
1 | Visitor *validate_test_init(TestInputVisitorData *data, const char *json_string, ...){ Visitor *v; va_list ap; va_start(ap, json_string); data->obj = qobject_from_jsonv(json_string, &ap); va_end(ap); g_assert(data->obj != NULL); data->qiv = qmp_input_visitor_new_strict(data->obj); g_assert(data->qiv != NULL); v = qmp_i... |
1 | void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, void *opaque, QJSON *vmdesc){ VMStateField *field = vmsd->fields; trace_vmstate_save_state_top(vmsd->name); if (vmsd->pre_save) { vmsd->pre_save(opaque); } if (vmdesc) { json_prop_str(vmdesc, "vmsd_name", vmsd->name); json_prop_int(vmdesc, "version", ... |
1 | static AVStream *add_av_stream1(FFServerStream *stream, AVCodecContext *codec, int copy){ AVStream *fst; if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams)) return NULL; fst = av_mallocz(sizeof(AVStream)); if (!fst) return NULL; if (copy) { fst->codec = avcodec_alloc_context3(codec->codec); if (!fst->codec) { av_... |
1 | static av_cold int vp3_decode_init(AVCodecContext *avctx){ Vp3DecodeContext *s = avctx->priv_data; int i, inter, plane; int c_width; int c_height; int y_fragment_count, c_fragment_count; if (avctx->codec_tag == MKTAG('V','P','3','0')) s->version = 0; else s->version = 1; s->avctx = avctx; s->width = FFALIGN(avctx->widt... |
0 | static inline void RENAME(bgr24ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width){#ifdef HAVE_MMXasm volatile("mov %4, %%"REG_a"\n\t""movq "MANGLE(w1111)", %%mm5\n\t""movq "MANGLE(bgr2UCoeff)", %%mm6\n\t""pxor %%mm7, %%mm7\n\t""lea (%%"REG_a", %%"REG_a", 2), %%"REG_b"\n\t""add %%"REG_b", %%"R... |
0 | static av_cold int fbdev_write_header(AVFormatContext *h){ FBDevContext *fbdev = h->priv_data; enum AVPixelFormat pix_fmt; AVStream *st = NULL; int ret, flags = O_RDWR; int i; for (i = 0; i < h->nb_streams; i++) { if (h->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (!st) { fbdev->index = i; st = h->streams... |
1 | static int qcow2_truncate(BlockDriverState *bs, int64_t offset){ BDRVQcowState *s = bs->opaque; int ret, new_l1_size; if (offset & 511) { return -EINVAL; } /* cannot proceed if image has snapshots */ if (s->nb_snapshots) { return -ENOTSUP; } /* shrinking is currently not supported */ if (offset < bs->total_sectors * 51... |
1 | int qemu_mutex_trylock(QemuMutex *mutex){ int owned; owned = TryEnterCriticalSection(&mutex->lock); if (owned) { assert(mutex->owner == 0); mutex->owner = GetCurrentThreadId(); } return !owned;} |
1 | static void nic_reset(void *opaque){ EEPRO100State *s = opaque; TRACE(OTHER, logout("%p\n", s)); /* TODO: Clearing of multicast table for selective reset, too? */ memset(&s->mult[0], 0, sizeof(s->mult)); nic_selective_reset(s);} |
1 | static void usb_mtp_object_readdir(MTPState *s, MTPObject *o){ struct dirent *entry; DIR *dir; if (o->have_children) { return; } o->have_children = true; dir = opendir(o->path); if (!dir) { return; }#ifdef __linux__ int watchfd = usb_mtp_add_watch(s->inotifyfd, o->path); if (watchfd == -1) { fprintf(stderr, "usb-mtp: f... |
0 | static int swScale(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[]){ /* load a few things into local vars to make the code more readable? * and faster */ const int srcW = c->srcW; const int dstW = c->dstW; const int dstH = c->dstH; const int chrDstW = ... |
1 | static inline int spx_strategy(AC3DecodeContext *s, int blk){ GetBitContext *bc = &s->gbc; int fbw_channels = s->fbw_channels; int dst_start_freq, dst_end_freq, src_start_freq, start_subband, end_subband, ch; /* determine which channels use spx */ if (s->channel_mode == AC3_CHMODE_MONO) { s->channel_uses_spx[1] = 1; } ... |
1 | TPMInfo *tpm_backend_query_tpm(TPMBackend *s){ TPMInfo *info = g_new0(TPMInfo, 1); TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s); TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif); info->id = g_strdup(s->id); info->model = tic->model; if (k->get_tpm_options) { info->options = k->get_tpm_options(s); } return info;} |
1 | static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp){ if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) { int64_t addend; int delta_timestamp; /* compute pts from timestamp with received ntp_time */ delta_timestamp = timestamp - s->last_rtcp_timestamp; /* convert to the PTS timebase */ addend =... |
0 | static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta){ h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);} |
1 | static void v9fs_remove(void *opaque){ int32_t fid; int err = 0; size_t offset = 7; V9fsFidState *fidp; V9fsPDU *pdu = opaque; pdu_unmarshal(pdu, offset, "d", &fid); fidp = get_fid(pdu, fid); if (fidp == NULL) { err = -EINVAL; goto out_nofid; } /* if fs driver is not path based, return EOPNOTSUPP */ if (!pdu->s->ctx.fl... |
1 | static void gen_msgclr(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) GEN_PRIV;#else CHK_SV; gen_helper_msgclr(cpu_env, cpu_gpr[rB(ctx->opcode)]);#endif /* defined(CONFIG_USER_ONLY) */} |
1 | static av_always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin, int src_index, int ref_index, int const penalty_factor, int size, int h, int flags){ MotionEstContext * const c= &s->me; me_cmp_func cmpf, chroma_cmpf; int next_dir=-1; LOAD_COMMON LOAD_COMMON2 unsigned map_generation = c->map_gen... |
1 | void mips_cpu_do_interrupt(CPUState *cs){#if !defined(CONFIG_USER_ONLY) MIPSCPU *cpu = MIPS_CPU(cs); CPUMIPSState *env = &cpu->env; target_ulong offset; int cause = -1; const char *name; if (qemu_log_enabled() && cs->exception_index != EXCP_EXT_INTERRUPT) { if (cs->exception_index < 0 || cs->exception_index > EXCP_LAST... |
1 | void qmp_drive_mirror(const char *device, const char *target, bool has_format, const char *format, enum MirrorSyncMode sync, bool has_mode, enum NewImageMode mode, bool has_speed, int64_t speed, bool has_granularity, uint32_t granularity, bool has_buf_size, int64_t buf_size, bool has_on_source_error, BlockdevOnError on... |
1 | static void opt_frame_aspect_ratio(const char *arg){ int x = 0, y = 0; double ar = 0; const char *p; char *end; p = strchr(arg, ':'); if (p) { x = strtol(arg, &end, 10); if (end == p) y = strtol(end+1, &end, 10); if (x > 0 && y > 0) ar = (double)x / (double)y; } else ar = strtod(arg, NULL); if (!ar) { fprintf(stderr, "... |
0 | static int tcp_write(URLContext *h, uint8_t *buf, int size){ TCPContext *s = h->priv_data; int ret, size1, fd_max; fd_set wfds; struct timeval tv; size1 = size; while (size > 0) { if (url_interrupt_cb()) return -EINTR; fd_max = s->fd; FD_ZERO(&wfds); FD_SET(s->fd, &wfds); tv.tv_sec = 0; tv.tv_usec = 100 * 1000; select(... |
1 | static void glfs_clear_preopened(glfs_t *fs){ ListElement *entry = NULL; if (fs == NULL) { return; } QLIST_FOREACH(entry, &glfs_list, list) { if (entry->saved.fs == fs) { if (--entry->saved.ref) { return; } QLIST_REMOVE(entry, list); glfs_fini(entry->saved.fs); g_free(entry->saved.volume); g_free(entry); } }} |
1 | static av_cold int mm_decode_init(AVCodecContext *avctx){ MmContext *s = avctx->priv_data; s->avctx = avctx; avctx->pix_fmt = AV_PIX_FMT_PAL8; s->frame = av_frame_alloc(); if (!s->frame) return AVERROR(ENOMEM); return 0; |
1 | static void uhci_process_frame(UHCIState *s){ uint32_t frame_addr, link, old_td_ctrl, val, int_mask; uint32_t curr_qh, td_count = 0; int cnt, ret; UHCI_TD td; UHCI_QH qh; QhDb qhdb; frame_addr = s->fl_base_addr + ((s->frnum & 0x3ff) << 2); pci_dma_read(&s->dev, frame_addr, &link, 4); le32_to_cpus(&link); int_mask = 0; ... |
0 | static void test_validate_fail_alternate(TestInputVisitorData *data, const void *unused){ UserDefAlternate *tmp; Visitor *v; Error *err = NULL; v = validate_test_init(data, "3.14"); visit_type_UserDefAlternate(v, NULL, &tmp, &err); error_free_or_abort(&err); g_assert(!tmp);} |
0 | void sclp_print(const char *str){ int len = _strlen(str); WriteEventData *sccb = (void*)_sccb; sccb->h.length = sizeof(WriteEventData) + len; sccb->h.function_code = SCLP_FC_NORMAL_WRITE; sccb->ebh.length = sizeof(EventBufferHeader) + len; sccb->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA; sccb->ebh.flags = 0; _memcpy(scc... |
0 | float64 helper_fstod(CPUSPARCState *env, float32 src){ float64 ret; clear_float_exceptions(env); ret = float32_to_float64(src, &env->fp_status); check_ieee_exceptions(env); return ret;} |
0 | static void do_log(int loglevel, const char *format, ...){ va_list ap; va_start(ap, format); if (is_daemon) { vsyslog(LOG_CRIT, format, ap); } else { vfprintf(stderr, format, ap); } va_end(ap);} |
0 | static void gic_reset(gic_state *s){ int i; memset(s->irq_state, 0, GIC_NIRQ * sizeof(gic_irq_state)); for (i = 0 ; i < NUM_CPU(s); i++) { s->priority_mask[i] = 0xf0; s->current_pending[i] = 1023; s->running_irq[i] = 1023; s->running_priority[i] = 0x100;#ifdef NVIC /* The NVIC doesn't have per-cpu interfaces, so enable... |
0 | static void xhci_er_reset(XHCIState *xhci, int v){ XHCIInterrupter *intr = &xhci->intr[v]; XHCIEvRingSeg seg; if (intr->erstsz == 0) { /* disabled */ intr->er_start = 0; intr->er_size = 0; return; } /* cache the (sole) event ring segment location */ if (intr->erstsz != 1) { DPRINTF("xhci: invalid value for ERSTSZ: %d\n... |
0 | static void pxa2xx_cm_write(void *opaque, hwaddr addr, uint64_t value, unsigned size){ PXA2xxState *s = (PXA2xxState *) opaque; switch (addr) { case CCCR: case CKEN: s->cm_regs[addr >> 2] = value; break; case OSCC: s->cm_regs[addr >> 2] &= ~0x6c; s->cm_regs[addr >> 2] |= value & 0x6e; if ((value >> 1) & 1)/* OON */ s->... |
0 | static void do_mac_write(lan9118_state *s, int reg, uint32_t val){ switch (reg) { case MAC_CR: if ((s->mac_cr & MAC_CR_RXEN) != 0 && (val & MAC_CR_RXEN) == 0) { s->int_sts |= RXSTOP_INT; } s->mac_cr = val & ~MAC_CR_RESERVED; DPRINTF("MAC_CR: %08x\n", val); break; case MAC_ADDRH: s->conf.macaddr.a[4] = val & 0xff; s->co... |
0 | static void decode_rrr_divide(CPUTriCoreState *env, DisasContext *ctx){ uint32_t op2; int r1, r2, r3, r4; op2 = MASK_OP_RRR_OP2(ctx->opcode); r1 = MASK_OP_RRR_S1(ctx->opcode); r2 = MASK_OP_RRR_S2(ctx->opcode); r3 = MASK_OP_RRR_S3(ctx->opcode); r4 = MASK_OP_RRR_D(ctx->opcode); CHECK_REG_PAIR(r3); switch (op2) { case OPC... |
0 | static void qemu_input_transform_abs_rotate(InputEvent *evt){ InputMoveEvent *move = evt->u.abs; switch (graphic_rotate) { case 90: if (move->axis == INPUT_AXIS_X) { move->axis = INPUT_AXIS_Y; } else if (move->axis == INPUT_AXIS_Y) { move->axis = INPUT_AXIS_X; move->value = INPUT_EVENT_ABS_SIZE - 1 - move->value; } bre... |
0 | static int split_init(AVFilterContext *ctx, const char *args, void *opaque){ int i, nb_outputs = 2; if (args) { nb_outputs = strtol(args, NULL, 0); if (nb_outputs <= 0) { av_log(ctx, AV_LOG_ERROR, "Invalid number of outputs specified: %d.\n", nb_outputs); return AVERROR(EINVAL); } } for (i = 0; i < nb_outputs; i++) { c... |
0 | static int mcf_fec_can_receive(void *opaque){ mcf_fec_state *s = (mcf_fec_state *)opaque; return s->rx_enabled;} |
0 | static void qxl_realize_common(PCIQXLDevice *qxl, Error **errp){ uint8_t* config = qxl->pci.config; uint32_t pci_device_rev; uint32_t io_size; qxl->mode = QXL_MODE_UNDEFINED; qxl->generation = 1; qxl->num_memslots = NUM_MEMSLOTS; qemu_mutex_init(&qxl->track_lock); qemu_mutex_init(&qxl->async_lock); qxl->current_async =... |
0 | static int css_interpret_ccw(SubchDev *sch, hwaddr ccw_addr, bool suspend_allowed){ int ret; bool check_len; int len; CCW1 ccw; if (!ccw_addr) { return -EIO; } /* Check doubleword aligned and 31 or 24 (fmt 0) bit addressable. */ if (ccw_addr & (sch->ccw_fmt_1 ? 0x80000007 : 0xff000007)) { return -EINVAL; } /* Translate... |
0 | static void bdrv_detach_child(BdrvChild *child){ if (child->next.le_prev) { QLIST_REMOVE(child, next); child->next.le_prev = NULL; } bdrv_replace_child(child, NULL, false); g_free(child->name); g_free(child);} |
0 | RTCState *rtc_mm_init(target_phys_addr_t base, int it_shift, qemu_irq irq, int base_year){ RTCState *s; int io_memory; s = qemu_mallocz(sizeof(RTCState)); s->irq = irq; s->cmos_data[RTC_REG_A] = 0x26; s->cmos_data[RTC_REG_B] = 0x02; s->cmos_data[RTC_REG_C] = 0x00; s->cmos_data[RTC_REG_D] = 0x80; s->base_year = base_yea... |
0 | INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig ){ return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;} |
0 | static int qcow_create2(const char *filename, int64_t total_size, const char *backing_file, const char *backing_format, int flags, size_t cluster_size, int prealloc){ int fd, header_size, backing_filename_len, l1_size, i, shift, l2_bits; int ref_clusters, backing_format_len = 0; QCowHeader header; uint64_t tmp, offset;... |
0 | static void scsi_cd_change_media_cb(void *opaque, bool load){ SCSIDiskState *s = opaque; /* * When a CD gets changed, we have to report an ejected state and * then a loaded state to guests so that they detect tray * open/close and media change events. Guests that do not use * GET_EVENT_STATUS_NOTIFICATION to detect suc... |
0 | static int check_directory_consistency(BDRVVVFATState *s,int cluster_num, const char* path){ int ret = 0; unsigned char* cluster = g_malloc(s->cluster_size); direntry_t* direntries = (direntry_t*)cluster; mapping_t* mapping = find_mapping_for_cluster(s, cluster_num); long_file_name lfn; int path_len = strlen(path); cha... |
0 | static void scsi_disk_emulate_write_data(SCSIRequest *req){ SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); if (r->iov.iov_len) { int buflen = r->iov.iov_len; DPRINTF("Write buf_len=%zd\n", buflen); r->iov.iov_len = 0; scsi_req_data(&r->req, buflen); return; } switch (req->cmd.buf[0]) { case MODE_SELECT: case MODE_S... |
0 | bool tcg_cpu_exec(void){ int ret = 0; if (next_cpu == NULL) next_cpu = first_cpu; for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) { CPUState *env = cur_cpu = next_cpu; qemu_clock_enable(vm_clock, (cur_cpu->singlestep_enabled & SSTEP_NOTIMER) == 0); if (qemu_alarm_pending()) break; if (cpu_can_run(env)) ret = qe... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.