label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc, int step){ int i, j; int offset = avctx->width * step; uint8_t *outdata = p->data[0]; for (i = 0; i < avctx->height; i++) { int size, left, code, pix; uint8_t *out = outdata; int pos = 0; /* size of packed line */ size = left = bytestream2_ge... |
1 | uint64_t helper_msub64_q_ssov(CPUTriCoreState *env, uint64_t r1, uint32_t r2, uint32_t r3, uint32_t n){ int64_t t1 = (int64_t)r1; int64_t t2 = sextract64(r2, 0, 32); int64_t t3 = sextract64(r3, 0, 32); int64_t result, mul; int64_t ovf; mul = (t2 * t3) << n; result = t1 - mul; env->PSW_USB_AV = (result ^ result * 2u) >>... |
1 | static void mtree_print_mr(fprintf_function mon_printf, void *f, const MemoryRegion *mr, unsigned int level, hwaddr base, MemoryRegionListHead *alias_print_queue){ MemoryRegionList *new_ml, *ml, *next_ml; MemoryRegionListHead submr_print_queue; const MemoryRegion *submr; unsigned int i; if (!mr) { return; } for (i = 0;... |
1 | static uint64_t bonito_cop_readl(void *opaque, hwaddr addr, unsigned size){ uint32_t val; PCIBonitoState *s = opaque; val = ((uint32_t *)(&s->boncop))[addr/sizeof(uint32_t)]; return val; |
1 | static int vmdk_snapshot_create(const char *filename, const char *backing_file){ int snp_fd, p_fd; int ret; uint32_t p_cid; char *p_name, *gd_buf, *rgd_buf; const char *real_filename, *temp_str; VMDK4Header header; uint32_t gde_entries, gd_size; int64_t gd_offset, rgd_offset, capacity, gt_size; char p_desc[DESC_SIZE], ... |
1 | static void piix3_ide_xen_class_init(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); k->init = pci_piix_ide_initfn; k->vendor_id = PCI_VENDOR_ID_INTEL; k->device_id = PCI_DEVICE_ID_INTEL_82371SB_1; k->class_id = PCI_CLASS_STORAGE_IDE; set_bit(DEVICE_C... |
1 | static int sami_paragraph_to_ass(AVCodecContext *avctx, const char *src){ SAMIContext *sami = avctx->priv_data; int ret = 0; char *tag = NULL; char *dupsrc = av_strdup(src); char *p = dupsrc; AVBPrint *dst_content = &sami->encoded_content; AVBPrint *dst_source = &sami->encoded_source; av_bprint_clear(&sami->encoded_con... |
1 | static void reset_codec(WmallDecodeCtx *s){ int ich, ilms; s->mclms_recent = s->mclms_order * s->num_channels; for (ich = 0; ich < s->num_channels; ich++) { for (ilms = 0; ilms < s->cdlms_ttl[ich]; ilms++) s->cdlms[ich][ilms].recent = s->cdlms[ich][ilms].order; /* first sample of a seekable subframe is considered as th... |
1 | static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid, int read) { AVCodecContext *vcodec = vstream->codec; switch(flv_codecid) { case FLV_CODECID_H263 : vcodec->codec_id = AV_CODEC_ID_FLV1 ; break; case FLV_CODECID_SCREEN: vcodec->codec_id = AV_CODEC_ID_FLASHSV; break; case FLV_CODECID_... |
1 | float64 float64_scalbn( float64 a, int n STATUS_PARAM ){ flag aSign; int16 aExp; uint64_t aSig; a = float64_squash_input_denormal(a STATUS_VAR); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { return a; } if ( aExp != 0 ) aSig |= LIT64( 0x0010000000... |
1 | static int postcopy_start(MigrationState *ms, bool *old_vm_running){ int ret; QIOChannelBuffer *bioc; QEMUFile *fb; int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); bool restart_block = false; int cur_state = MIGRATION_STATUS_ACTIVE; if (!migrate_pause_before_switchover()) { migrate_set_state(&ms->state, ... |
1 | static BusState *qbus_find(const char *path){ DeviceState *dev; BusState *bus; char elem[128]; int pos, len; /* find start element */ if (path[0] == '/') { bus = sysbus_get_default(); pos = 0; } else { if (sscanf(path, "%127[^/]%n", elem, &len) != 1) { assert(!path[0]); elem[0] = len = 0; } bus = qbus_find_recursive(sy... |
1 | void bdrv_init(void){ bdrv_register(&bdrv_raw); bdrv_register(&bdrv_host_device); bdrv_register(&bdrv_cow); bdrv_register(&bdrv_qcow); bdrv_register(&bdrv_vmdk); bdrv_register(&bdrv_cloop); bdrv_register(&bdrv_dmg); bdrv_register(&bdrv_bochs); bdrv_register(&bdrv_vpc); bdrv_register(&bdrv_vvfat); bdrv_register(&bdrv_qc... |
1 | void ff_h264_direct_dist_scale_factor(H264Context * const h){ const int poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; const int poc1 = h->ref_list[1][0].poc; int i, field; if (FRAME_MBAFF(h)) for (field = 0; field < 2; field++){ const int poc = h->cur_pic_ptr->field_poc[field]; const int p... |
1 | static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq){ VirtIONet *n = to_virtio_net(vdev); if (unlikely(n->tx_waiting)) { return; } virtio_queue_set_notification(vq, 0); qemu_bh_schedule(n->tx_bh); n->tx_waiting = 1;} |
1 | static int net_dump_init(NetClientState *peer, const char *device, const char *name, const char *filename, int len){ struct pcap_file_hdr hdr; NetClientState *nc; DumpState *s; struct tm tm; int fd; fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644); if (fd < 0) { error_report("-net dump: can't open %s"... |
1 | AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms, enum AVSampleFormat sample_fmt, int size, int64_t channel_layout, int planar){ AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer)); AVFilterBufferRef *ref = NULL; int i, sample_size, chans_nb, bufsize, per_channel_size, step_si... |
1 | static void test_keyval_visit_any(void){ Visitor *v; QDict *qdict; QObject *any; QList *qlist; QString *qstr; qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort); v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); QDECREF(qdict); visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_type_any(v, "a", &any,... |
1 | static int vc1_decode_i_block_adv(VC1Context *v, int16_t 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 i; int16_t *dc_val; int16_t *ac_val, *ac_val2; int dcdiff; int a_avail = v->a_avai... |
0 | static int crc_write_packet(struct AVFormatContext *s, int stream_index, const uint8_t *buf, int size, int64_t pts){ CRCState *crc = s->priv_data; crc->crcval = adler32(crc->crcval, buf, size); return 0;} |
1 | void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg){} |
1 | static void do_subtitle_out(AVFormatContext *s, OutputStream *ost, InputStream *ist, AVSubtitle *sub){ int subtitle_out_max_size = 1024 * 1024; int subtitle_out_size, nb, i; AVCodecContext *enc; AVPacket pkt; int64_t pts; if (sub->pts == AV_NOPTS_VALUE) { av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n")... |
0 | static uint32_t uhci_ioport_readw(void *opaque, uint32_t addr){ UHCIState *s = opaque; uint32_t val; addr &= 0x1f; switch(addr) { case 0x00: val = s->cmd; break; case 0x02: val = s->status; break; case 0x04: val = s->intr; break; case 0x06: val = s->frnum; break; case 0x10 ... 0x1f: { UHCIPort *port; int n; n = (addr >... |
0 | cac_delete_pki_applet_private(VCardAppletPrivate *applet_private){ CACPKIAppletData *pki_applet_data = NULL; if (applet_private == NULL) { return; } pki_applet_data = &(applet_private->u.pki_data); if (pki_applet_data->cert != NULL) { g_free(pki_applet_data->cert); } if (pki_applet_data->sign_buffer != NULL) { g_free(p... |
0 | static void cpu_handle_debug_exception(CPUState *env){ CPUWatchpoint *wp; if (!env->watchpoint_hit) TAILQ_FOREACH(wp, &env->watchpoints, entry) wp->flags &= ~BP_WATCHPOINT_HIT; if (debug_excp_handler) debug_excp_handler(env);} |
0 | static int do_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, int64_t count, int flags, int64_t *total){ Coroutine *co; CoWriteZeroes data = { .blk = blk, .offset = offset, .count = count, .total = total, .flags = flags, .done = false, }; if (count >> BDRV_SECTOR_BITS > INT_MAX) { return -ERANGE; } co = qemu_corout... |
0 | static inline void cow_set_bits(uint8_t *bitmap, int start, int64_t nb_sectors){ int64_t bitnum = start, last = start + nb_sectors; while (bitnum < last) { if ((bitnum & 7) == 0 && bitnum + 8 <= last) { bitmap[bitnum / 8] = 0xFF; bitnum += 8; continue; } bitmap[bitnum/8] |= (1 << (bitnum % 8)); bitnum++; }} |
0 | int bdrv_open2(BlockDriverState *bs, const char *filename, int flags, BlockDriver *drv){ int ret, open_flags; char tmp_filename[PATH_MAX]; char backing_filename[PATH_MAX]; bs->is_temporary = 0; bs->encrypted = 0; bs->valid_key = 0; /* buffer_alignment defaulted to 512, drivers can change this value */ bs->buffer_alignm... |
0 | milkymist_init(QEMUMachineInitArgs *args){ const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; LM32CPU *cpu; CPULM32State *env; int kernel_size; DriveInfo *dinfo; MemoryRegio... |
0 | static int aac_decode_frame_int(AVCodecContext *avctx, void *data, int *got_frame_ptr, GetBitContext *gb, AVPacket *avpkt){ AACContext *ac = avctx->priv_data; ChannelElement *che = NULL, *che_prev = NULL; enum RawDataBlockType elem_type, elem_type_prev = TYPE_END; int err, elem_id; int samples = 0, multiplier, audio_fo... |
0 | void pc_cmos_init(ram_addr_t ram_size, ram_addr_t above_4g_mem_size, const char *boot_device, BusState *idebus0, BusState *idebus1, FDCtrl *floppy_controller, ISADevice *s){ int val, nb; FDriveType fd0, fd1; static pc_cmos_init_late_arg arg; /* various important CMOS locations needed by PC/Bochs bios */ /* memory size ... |
0 | START_TEST(unterminated_dict_comma){ QObject *obj = qobject_from_json("{'abc':32,"); fail_unless(obj == NULL);} |
0 | void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t soffset, size_t sbytes){ int i; size_t done; struct iovec *siov = src->iov; assert(dst->nalloc != -1); assert(src->size >= soffset); for (i = 0, done = 0; done < sbytes && i < src->niov; i++) { if (soffset < siov[i].iov_len) { size_t len = MIN(siov[i].... |
0 | void net_host_device_add(Monitor *mon, const char *device, const char *opts){ if (!net_host_check_device(device)) { monitor_printf(mon, "invalid host network device %s\n", device); return; } if (net_client_init(device, opts ? : "") < 0) { monitor_printf(mon, "adding host network device %s failed\n", device); }} |
0 | static void musicpal_register_devices(void){ sysbus_register_dev("mv88w8618_pic", sizeof(mv88w8618_pic_state), mv88w8618_pic_init); sysbus_register_dev("mv88w8618_pit", sizeof(mv88w8618_pit_state), mv88w8618_pit_init); sysbus_register_dev("mv88w8618_flashcfg", sizeof(mv88w8618_flashcfg_state), mv88w8618_flashcfg_init);... |
0 | static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVQcowState *s = bs->opaque; int len, i, ret = 0; QCowHeader header; QemuOpts *opts; Error *local_err = NULL; uint64_t ext_end; uint64_t l1_vm_state_index; const char *opt_overlap_check; int overlap_check_template = 0; ret = bdrv_pr... |
0 | static void vexpress_a9_init(ram_addr_t ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ CPUState *env = NULL; MemoryRegion *sysmem = get_system_memory(); MemoryRegion *ram = g_new(MemoryRegion, 1); MemoryRegion *lowram = g_... |
0 | static void gpollfds_to_select(int ret){ int i; FD_ZERO(&rfds); FD_ZERO(&wfds); FD_ZERO(&xfds); if (ret <= 0) { return; } for (i = 0; i < gpollfds->len; i++) { int fd = g_array_index(gpollfds, GPollFD, i).fd; int revents = g_array_index(gpollfds, GPollFD, i).revents; if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) { FD_... |
0 | static void cpu_4xx_pit_cb (void *opaque){ CPUState *env; ppc_tb_t *tb_env; ppcemb_timer_t *ppcemb_timer; env = opaque; tb_env = env->tb_env; ppcemb_timer = tb_env->opaque; env->spr[SPR_40x_TSR] |= 1 << 27; if ((env->spr[SPR_40x_TCR] >> 26) & 0x1) ppc_set_irq(env, PPC_INTERRUPT_PIT, 1); start_stop_pit(env, tb_env, 1); ... |
0 | CPUArchState *cpu_copy(CPUArchState *env){ CPUState *cpu = ENV_GET_CPU(env); CPUArchState *new_env = cpu_init(cpu_model); CPUState *new_cpu = ENV_GET_CPU(new_env);#if defined(TARGET_HAS_ICE) CPUBreakpoint *bp; CPUWatchpoint *wp;#endif /* Reset non arch specific state */ cpu_reset(new_cpu); memcpy(new_env, env, sizeof(C... |
0 | static void mdct512(AC3MDCTContext *mdct, float *out, float *in){ mdct->fft.mdct_calc(&mdct->fft, out, in);} |
0 | static void av_noinline qpeg_decode_inter(QpegContext *qctx, uint8_t *dst, int stride, int width, int height, int delta, const uint8_t *ctable, uint8_t *refdata){ int i, j; int code; int filled = 0; int orig_height; if(!refdata) refdata= dst; /* copy prev frame */ for(i = 0; i < height; i++) memcpy(dst + (i * stride), ... |
0 | static void block_job_detach_aio_context(void *opaque){ BlockJob *job = opaque; /* In case the job terminates during aio_poll()... */ block_job_ref(job); block_job_pause(job); if (!job->paused) { /* If job is !job->busy this kicks it into the next pause point. */ block_job_enter(job); } while (!job->paused && !job->com... |
0 | void numa_cpu_pre_plug(const CPUArchId *slot, DeviceState *dev, Error **errp){ int mapped_node_id; /* set by -numa option */ int node_id = object_property_get_int(OBJECT(dev), "node-id", &error_abort); /* by default CPUState::numa_node was 0 if it wasn't set explicitly * TODO: make it error when incomplete numa mapping... |
0 | static void multiwrite_cb(void *opaque, int ret){ MultiwriteCB *mcb = opaque; trace_multiwrite_cb(mcb, ret); if (ret < 0 && !mcb->error) { mcb->error = ret; } mcb->num_requests--; if (mcb->num_requests == 0) { multiwrite_user_cb(mcb); g_free(mcb); }} |
0 | static void qdict_setup(void){ tests_dict = qdict_new(); fail_unless(tests_dict != NULL);} |
0 | static int parallels_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVParallelsState *s = bs->opaque; int i; ParallelsHeader ph; int ret; ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph)); if (ret < 0) { goto fail; } bs->total_sectors = le64_to_cpu(ph.nb_sectors); if (le32_to_cpu(ph.version) != HEA... |
0 | void imx_timerp_create(const target_phys_addr_t addr, qemu_irq irq, DeviceState *ccm){ IMXTimerPState *pp; DeviceState *dev; dev = sysbus_create_simple("imx_timerp", addr, irq); pp = container_of(dev, IMXTimerPState, busdev.qdev); pp->ccm = ccm;} |
0 | if_start(Slirp *slirp){ uint64_t now = qemu_get_clock_ns(rt_clock); int requeued = 0; bool from_batchq = false;struct mbuf *ifm, *ifqt;DEBUG_CALL("if_start");if (slirp->if_queued == 0) return; /* Nothing to do */ again: /* check if we can really output */ if (!slirp_can_output(slirp->opaque)) return;/* * See which queu... |
0 | e1000_cleanup(NetClientState *nc){ E1000State *s = qemu_get_nic_opaque(nc); s->nic = NULL;} |
0 | void ff_vp3_h_loop_filter_mmx(uint8_t *src, int stride, int *bounding_values){ x86_reg tmp; __asm__ volatile( "movd -2(%1), %%mm6 \n\t" "movd -2(%1,%3), %%mm0 \n\t" "movd -2(%1,%3,2), %%mm1 \n\t" "movd -2(%1,%4), %%mm4 \n\t" TRANSPOSE8x4(%%mm6, %%mm0, %%mm1, %%mm4, -2(%2), -2(%2,%3), -2(%2,%3,2), -2(%2,%4), %%mm2) VP3_... |
0 | static void sdram_set_bcr (uint32_t *bcrp, uint32_t bcr, int enabled){ if (*bcrp & 0x00000001) { /* Unmap RAM */#ifdef DEBUG_SDRAM printf("%s: unmap RAM area " TARGET_FMT_plx " " TARGET_FMT_lx "\n", __func__, sdram_base(*bcrp), sdram_size(*bcrp));#endif cpu_register_physical_memory(sdram_base(*bcrp), sdram_size(*bcrp),... |
0 | static Suite *qfloat_suite(void){ Suite *s; TCase *qfloat_public_tcase; s = suite_create("QFloat test-suite"); qfloat_public_tcase = tcase_create("Public Interface"); suite_add_tcase(s, qfloat_public_tcase); tcase_add_test(qfloat_public_tcase, qfloat_from_double_test); tcase_add_test(qfloat_public_tcase, qfloat_destroy... |
0 | void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier){ qemu_clock_unregister_reset_notifier(clock->type, notifier);} |
0 | target_ulong cpu_get_phys_page_debug(CPUState *env, target_ulong addr){ uint8_t *pde_ptr, *pte_ptr; uint32_t pde, pte, paddr, page_offset, page_size; if (!(env->cr[0] & CR0_PG_MASK)) { pte = addr; page_size = 4096; } else { /* page directory entry */ pde_ptr = phys_ram_base + (((env->cr[3] & ~0xfff) + ((addr >> 20) & ~... |
0 | static uint64_t imx_serial_read(void *opaque, target_phys_addr_t offset, unsigned size){ IMXSerialState *s = (IMXSerialState *)opaque; uint32_t c; DPRINTF("read(offset=%x)\n", offset >> 2); switch (offset >> 2) { case 0x0: /* URXD */ c = s->readbuff; if (!(s->uts1 & UTS1_RXEMPTY)) { /* Character is valid */ c |= URXD_C... |
0 | void qemu_del_net_client(NetClientState *nc){ NetClientState *ncs[MAX_QUEUE_NUM]; int queues, i; /* If the NetClientState belongs to a multiqueue backend, we will change all * other NetClientStates also. */ queues = qemu_find_net_clients_except(nc->name, ncs, NET_CLIENT_OPTIONS_KIND_NIC, MAX_QUEUE_NUM); assert(queues !... |
0 | static inline void omap_gp_timer_trigger(struct omap_gp_timer_s *timer){ if (timer->pt) /* TODO in overflow-and-match mode if the first event to * occurs is the match, don't toggle. */ omap_gp_timer_out(timer, !timer->out_val); else /* TODO inverted pulse on timer->out_val == 1? */ qemu_irq_pulse(timer->out);} |
0 | timer_write(void *opaque, target_phys_addr_t addr, uint64_t val64, unsigned int size){ struct etrax_timer *t = opaque; uint32_t value = val64; switch (addr) { case RW_TMR0_DIV: t->rw_tmr0_div = value; break; case RW_TMR0_CTRL: D(printf ("RW_TMR0_CTRL=%x\n", value)); t->rw_tmr0_ctrl = value; update_ctrl(t, 0); break; ca... |
0 | void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number){ mpeg1_encode_sequence_header(s); /* mpeg1 picture header */ put_header(s, PICTURE_START_CODE); /* temporal reference */ // RAL: s->picture_number instead of s->fake_picture_number put_bits(&s->pb, 10, (s->picture_number - s->gop_picture_number) & ... |
0 | static inline void gen_op_fcmpd(int fccno, TCGv_i64 r_rs1, TCGv_i64 r_rs2){ gen_helper_fcmpd(cpu_env, r_rs1, r_rs2);} |
0 | int pcistb_service_call(S390CPU *cpu, uint8_t r1, uint8_t r3, uint64_t gaddr, uint8_t ar, uintptr_t ra){ CPUS390XState *env = &cpu->env; S390PCIBusDevice *pbdev; MemoryRegion *mr; MemTxResult result; int i; uint32_t fh; uint8_t pcias; uint8_t len; uint8_t buffer[128]; if (env->psw.mask & PSW_MASK_PSTATE) { s390_program... |
0 | static void *spapr_create_fdt_skel(const char *cpu_model, target_phys_addr_t rma_size, target_phys_addr_t initrd_base, target_phys_addr_t initrd_size, const char *boot_device, const char *kernel_cmdline, long hash_shift){ void *fdt; CPUState *env; uint64_t mem_reg_property_rma[] = { 0, cpu_to_be64(rma_size) }; uint64_t... |
0 | static target_phys_addr_t get_offset(target_phys_addr_t phys_addr, DumpState *s){ RAMBlock *block; target_phys_addr_t offset = s->memory_offset; int64_t size_in_block, start; if (s->has_filter) { if (phys_addr < s->begin || phys_addr >= s->begin + s->length) { return -1; } } QLIST_FOREACH(block, &ram_list.blocks, next)... |
0 | static MegasasCmd *megasas_enqueue_frame(MegasasState *s, target_phys_addr_t frame, uint64_t context, int count){ MegasasCmd *cmd = NULL; int frame_size = MFI_FRAME_SIZE * 16; target_phys_addr_t frame_size_p = frame_size; cmd = megasas_next_frame(s, frame); /* All frames busy */ if (!cmd) { return NULL; } if (!cmd->pa)... |
0 | void helper_stl_raw(uint64_t t0, uint64_t t1){ stl_raw(t1, t0);} |
0 | static void string_deserialize(void **native_out, void *datap, VisitorFunc visit, Error **errp){ StringSerializeData *d = datap; d->string = string_output_get_string(d->sov); d->siv = string_input_visitor_new(d->string); visit(d->siv, native_out, errp);} |
0 | static uint16_t mlp_checksum16(const uint8_t *buf, unsigned int buf_size){ uint16_t crc; if (!crc_init) { av_crc_init(crc_2D, 0, 16, 0x002D, sizeof(crc_2D)); crc_init = 1; } crc = av_crc(crc_2D, 0, buf, buf_size - 2); crc ^= AV_RL16(buf + buf_size - 2); return crc;} |
0 | static void blkdebug_debug_event(BlockDriverState *bs, BlkDebugEvent event){ BDRVBlkdebugState *s = bs->opaque; struct BlkdebugRule *rule; bool injected; assert((int)event >= 0 && event < BLKDBG_EVENT_MAX); injected = false; s->new_state = s->state; QLIST_FOREACH(rule, &s->rules[event], next) { injected = process_rule(... |
0 | static int protocol_client_init(VncState *vs, uint8_t *data, size_t len){ char buf[1024]; VncShareMode mode; int size; mode = data[0] ? VNC_SHARE_MODE_SHARED : VNC_SHARE_MODE_EXCLUSIVE; switch (vs->vd->share_policy) { case VNC_SHARE_POLICY_IGNORE: /* * Ignore the shared flag. Nothing to do here. * * Doesn't conform to ... |
0 | static void migration_completion(MigrationState *s, int current_active_state, bool *old_vm_running, int64_t *start_time){ int ret; if (s->state == MIGRATION_STATUS_ACTIVE) { qemu_mutex_lock_iothread(); *start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); *old_vm_ru... |
0 | void replay_read_next_clock(ReplayClockKind kind){ unsigned int read_kind = replay_data_kind - EVENT_CLOCK; assert(read_kind == kind); int64_t clock = replay_get_qword(); replay_check_error(); replay_finish_event(); replay_state.cached_clock[read_kind] = clock;} |
0 | static void exynos4210_gfrc_event(void *opaque){ Exynos4210MCTState *s = (Exynos4210MCTState *)opaque; int i; uint64_t distance; DPRINTF("\n"); s->g_timer.reg.cnt += s->g_timer.count; /* Process all comparators */ for (i = 0; i < MCT_GT_CMP_NUM; i++) { if (s->g_timer.reg.cnt == s->g_timer.reg.comp[i]) { /* reached near... |
1 | static void lance_init(NICInfo *nd, target_phys_addr_t leaddr, void *dma_opaque, qemu_irq irq){ DeviceState *dev; SysBusDevice *s; qemu_irq reset; qemu_check_nic_model(&nd_table[0], "lance"); dev = qdev_create(NULL, "lance"); dev->nd = nd; qdev_prop_set_ptr(dev, "dma", dma_opaque); qdev_init(dev); s = sysbus_from_qdev(... |
1 | int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src){ int ret; av_assert0(!dst->f.buf[0]); av_assert0(src->f.buf[0]); src->tf.f = &src->f; dst->tf.f = &dst->f; ret = ff_thread_ref_frame(&dst->tf, &src->tf); if (ret < 0) goto fail; ret = update_picture_tables(dst, src); if (ret < 0) goto fail; if (src-... |
1 | static int encode_slices(VC2EncContext *s){ uint8_t *buf; int i, slice_x, slice_y, skip = 0; int bytes_left = 0; SliceArgs *enc_args = s->slice_args; int bytes_top[SLICE_REDIST_TOTAL] = {0}; SliceArgs *top_loc[SLICE_REDIST_TOTAL] = {NULL}; avpriv_align_put_bits(&s->pb); flush_put_bits(&s->pb); buf = put_bits_ptr(&s->pb... |
1 | int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration){ int64_t us; if (av_parse_time(&us, timestr, is_duration) < 0) { av_log(NULL, AV_LOG_FATAL, "Invalid %s specification for %s: %s\n", is_duration ? "duration" : "date", context, timestr); exit(1); } return us;} |
1 | PPC_OP(mulhw){ T0 = ((int64_t)Ts0 * (int64_t)Ts1) >> 32; RETURN();} |
1 | static void rtas_stop_self(PowerPCCPU *cpu, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ CPUState *cs = CPU(cpu); CPUPPCState *env = &cpu->env; cs->halted = 1; qemu_cpu_kick(cs); /* * While stopping a CPU, the guest calls H_CPPR which * effectively disa... |
1 | static int get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate, int compressed_size, int n_start, int n_end, uint64_t *result){ BDRVQcowState *s = bs->opaque; int min_index, i, j, l1_index, l2_index, ret; uint64_t l2_offset, *l2_table, cluster_offset, tmp; uint32_t min_count; int new_l2_table; *resul... |
1 | int av_get_packet(AVIOContext *s, AVPacket *pkt, int size){ int ret; size= ffio_limit(s, size); ret= av_new_packet(pkt, size); if(ret<0) return ret; pkt->pos= avio_tell(s); ret= avio_read(s, pkt->data, size); if(ret<=0) av_free_packet(pkt); else av_shrink_packet(pkt, ret); if (pkt->size < orig_size) pkt->flags |= AV_PK... |
1 | void xtensa_translate_init(void){ static const char * const regnames[] = { "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7", "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15", }; static const char * const fregnames[] = { "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "... |
1 | float64 HELPER(recpe_f64)(float64 input, void *fpstp){ float_status *fpst = fpstp; float64 f64 = float64_squash_input_denormal(input, fpst); uint64_t f64_val = float64_val(f64); uint64_t f64_sbit = 0x8000000000000000ULL & f64_val; int64_t f64_exp = extract64(f64_val, 52, 11); float64 r64; uint64_t r64_val; int64_t r64_... |
1 | static void stm32f2xx_usart_write(void *opaque, hwaddr addr, uint64_t val64, unsigned int size){ STM32F2XXUsartState *s = opaque; uint32_t value = val64; unsigned char ch; DB_PRINT("Write 0x%" PRIx32 ", 0x%"HWADDR_PRIx"\n", value, addr); switch (addr) { case USART_SR: if (value <= 0x3FF) { s->usart_sr = value; } else {... |
1 | static void simpleCopy(SwsContext *c, uint8_t* srcParam[], int srcStrideParam[], int srcSliceY, int srcSliceH, uint8_t* dstParam[], int dstStride[]){int srcStride[3];uint8_t *src[3];uint8_t *dst[3];if(c->srcFormat == IMGFMT_I420){src[0]= srcParam[0];src[1]= srcParam[2];src[2]= srcParam[1];srcStride[0]= srcStrideParam[0... |
1 | static void free_ahci_device(QPCIDevice *dev){ QPCIBus *pcibus = dev ? dev->bus : NULL; /* libqos doesn't have a function for this, so free it manually */ g_free(dev); qpci_free_pc(pcibus);} |
1 | int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){ AVRational a0={0,1}, a1={1,0}; int sign= (nom<0) ^ (den<0); int64_t gcd= ff_gcd(FFABS(nom), FFABS(den)); nom = FFABS(nom)/gcd; den = FFABS(den)/gcd; if(nom<=max && den<=max){ a1= (AVRational){nom, den}; den=0; } while(den){ int64_t x = no... |
1 | PPC_OP(cmpi){ if (Ts0 < SPARAM(1)) { T0 = 0x08; } else if (Ts0 > SPARAM(1)) { T0 = 0x04; } else { T0 = 0x02; } RETURN();} |
1 | static int bdrv_rd_badreq_bytes(BlockDriverState *bs, int64_t offset, int count){ int64_t size = bs->total_sectors << SECTOR_BITS; return count < 0 || size < 0 || count > size || offset > size - count;} |
1 | static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, ff_asf_guid mediatype, ff_asf_guid subtype, ff_asf_guid formattype, int size){ WtvContext *wtv = s->priv_data; AVIOContext *pb = wtv->pb; if (!ff_guidcmp(subtype, mediasubtype_cpfilters_processed) && !ff_guidcmp(formattype, format_cpfilters_p... |
0 | 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){ if(srcFormat==IMGFMT... |
0 | static void filter(AVFilterContext *ctx, AVFilterBufferRef *dstpic, int parity, int tff){ YADIFContext *yadif = ctx->priv; int y, i; for (i = 0; i < yadif->csp->nb_components; i++) { int w = dstpic->video->w; int h = dstpic->video->h; int refs = yadif->cur->linesize[i]; int df = (yadif->csp->comp[i].depth_minus1 + 8) /... |
0 | static void vorbis_free_extradata(PayloadContext * data){ av_free(data);} |
0 | static int dxva2_alloc(AVCodecContext *s){ InputStream *ist = s->opaque; int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR; DXVA2Context *ctx; HANDLE device_handle; HRESULT hr; AVHWDeviceContext *device_ctx; AVDXVA2DeviceContext *device_hwctx; int ret; ctx = av_mallocz(sizeof(*ctx)); if (... |
0 | static av_cold int amr_nb_encode_init(AVCodecContext *avctx){ AMRContext *s = avctx->priv_data; if (avctx->sample_rate != 8000) { av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n"); return AVERROR(ENOSYS); } if (avctx->channels != 1) { av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); return AVERROR... |
0 | static void avc_luma_mid_4w_msa(const uint8_t *src, int32_t src_stride, uint8_t *dst, int32_t dst_stride, int32_t height){ uint32_t loop_cnt; v16i8 src0, src1, src2, src3, src4; v16i8 mask0, mask1, mask2; v8i16 hz_out0, hz_out1, hz_out2, hz_out3; v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8; v8i16 dst0, dst1, dst2... |
0 | static int svq1_motion_inter_4v_block(MpegEncContext *s, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y){ uint8_t *src; uint8_t *dst; svq1_pmv mv; svq1_pmv *pmv[4]; int i, result; /* predict and decode motion vector (0) */ pmv[0] = &motion[0]; if (y == 0) { pmv[1] ... |
0 | int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size){ const uint8_t *p = buf_in; const uint8_t *end = p + size; const uint8_t *nal_start, *nal_end; size = 0; nal_start = ff_avc_find_startcode(p, end); while (nal_start < end) { while(!*(nal_start++)); nal_end = ff_avc_find_startcode(nal_start, en... |
0 | static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size){ FLACParseContext *fpc = s->priv_data; FLACHeaderMarker *curr; int nb_headers; int read_size = 0; if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { FLACFrameInfo fi; if (frame_... |
0 | void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len){ if (s->chr_read) { s->chr_read(s->handler_opaque, buf, len); }} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.