label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | static const TCGTargetOpDef *tcg_target_op_def(TCGOpcode op){ static const TCGTargetOpDef r = { .args_ct_str = { "r" } }; static const TCGTargetOpDef r_r = { .args_ct_str = { "r", "r" } }; static const TCGTargetOpDef r_L = { .args_ct_str = { "r", "L" } }; static const TCGTargetOpDef L_L = { .args_ct_str = { "L", "L" } ... |
0 | void portio_list_del(PortioList *piolist){ MemoryRegion *mr, *alias; unsigned i; for (i = 0; i < piolist->nr; ++i) { mr = piolist->regions[i]; alias = piolist->aliases[i]; memory_region_del_subregion(piolist->address_space, alias); memory_region_destroy(alias); memory_region_destroy(mr); g_free((MemoryRegionOps *)mr->o... |
0 | static void set_gsi(KVMState *s, unsigned int gsi){ assert(gsi < s->max_gsi); s->used_gsi_bitmap[gsi / 32] |= 1U << (gsi % 32);} |
0 | void arm_cpu_do_interrupt(CPUState *cs){ ARMCPU *cpu = ARM_CPU(cs); CPUARMState *env = &cpu->env; uint32_t addr; uint32_t mask; int new_mode; uint32_t offset; uint32_t moe; assert(!IS_M(env)); arm_log_exception(cs->exception_index); if (arm_is_psci_call(cpu, cs->exception_index)) { arm_handle_psci_call(cpu); qemu_log_m... |
0 | static void fdt_add_gic_node(VirtBoardInfo *vbi){ vbi->gic_phandle = qemu_fdt_alloc_phandle(vbi->fdt); qemu_fdt_setprop_cell(vbi->fdt, "/", "interrupt-parent", vbi->gic_phandle); qemu_fdt_add_subnode(vbi->fdt, "/intc"); /* 'cortex-a15-gic' means 'GIC v2' */ qemu_fdt_setprop_string(vbi->fdt, "/intc", "compatible", "arm,... |
0 | static int sad_hpel_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h){ MotionEstContext * const c= &s->me; const int penalty_factor= c->sub_penalty_factor; int mx, my, dminh; uint8_t *pix, *ptr; int stride= c->stride; LOAD_COMMON av_assert2(c->sub_flags... |
0 | int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr){#ifdef KVM_CAP_MCE void *vaddr; ram_addr_t ram_addr; target_phys_addr_t paddr; if ((env->mcg_cap & MCG_SER_P) && addr && (code == BUS_MCEERR_AR || code == BUS_MCEERR_AO)) { vaddr = (void *)addr; if (qemu_ram_addr_from_host(vaddr, &ram_addr) || !kvm_physic... |
0 | void ff_flac_compute_autocorr(const int32_t *data, int len, int lag, double *autoc){ int i, j; double tmp[len + lag + 1]; double *data1= tmp + lag; apply_welch_window(data, len, data1); for(j=0; j<lag; j++) data1[j-lag]= 0.0; data1[len] = 0.0; for(j=0; j<lag; j+=2){ double sum0 = 1.0, sum1 = 1.0; for(i=0; i<len; i++){ ... |
0 | static unsigned int rms(const int *data){ int x; unsigned int res = 0x10000; int b = 0; for (x=0; x<10; x++) { res = (((0x1000000 - (*data) * (*data)) >> 12) * res) >> 12; if (res == 0) return 0; while (res <= 0x3fff) { b++; res <<= 2; } data++; } if (res > 0) res = t_sqrt(res); res >>= (b + 10); return res;} |
1 | void remove_migration_state_change_notifier(Notifier *notify){ notifier_remove(notify);} |
1 | static void mm_decode_inter(MmContext * s, int half_horiz, int half_vert, const uint8_t *buf, int buf_size){ const int data_ptr = 2 + AV_RL16(&buf[0]); int d, r, y; d = data_ptr; r = 2; y = 0; while(r < data_ptr) { int i, j; int length = buf[r] & 0x7f; int x = buf[r+1] + ((buf[r] & 0x80) << 1); r += 2; if (length==0) {... |
1 | static void test_tco_ticks_counter(void){ TestData d; uint16_t ticks = TCO_SECS_TO_TICKS(8); uint16_t rld; d.args = NULL; d.noreboot = true; test_init(&d); stop_tco(&d); clear_tco_status(&d); reset_on_second_timeout(false); set_tco_timeout(&d, ticks); load_tco(&d); start_tco(&d); do { rld = qpci_io_readw(d.dev, d.tco_i... |
1 | static void decode_mb(MpegEncContext *s, int ref){ s->dest[0] = s->current_picture.f.data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16; s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift); s->dest[2] = s->current_picture.f.data[2] +... |
1 | static int alloc_cluster_link_l2(BlockDriverState *bs, uint64_t cluster_offset, QCowL2Meta *m){ BDRVQcowState *s = bs->opaque; int i, j = 0, l2_index, ret; uint64_t *old_cluster, start_sect, l2_offset, *l2_table; if (m->nb_clusters == 0) return 0; old_cluster = qemu_malloc(m->nb_clusters * sizeof(uint64_t)); /* copy co... |
1 | int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep){ int ret, count = 0; while (*opts) { if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0) return ret; count++; if (*opts) opts++; } return count;} |
1 | static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp){ char *buffer; int ret = -1; char *path = fs_path->data; if (fs_ctx->export_flags & V9FS_SM_MAPPED) { buffer = rpath(fs_ctx, path); ret = local_set_xattr(buffer, credp); g_free(buffer); } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { r... |
1 | static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ DPCMContext *s = avctx->priv_data; int in, out = 0; int predictor[2]; int channel_number = 0; short *output_samples = data; int shift[2]; unsigned char byte; short diff; if (!buf_size) return 0; // almost every ... |
1 | static void kvm_reset_vcpu(void *opaque){ CPUState *env = opaque; kvm_arch_reset_vcpu(env); if (kvm_arch_put_registers(env)) { fprintf(stderr, "Fatal: kvm vcpu reset failed\n"); abort(); }} |
1 | static int parse_cube(AVFilterContext *ctx, FILE *f){ LUT3DContext *lut3d = ctx->priv; char line[MAX_LINE_SIZE]; float min[3] = {0.0, 0.0, 0.0}; float max[3] = {1.0, 1.0, 1.0}; while (fgets(line, sizeof(line), f)) { if (!strncmp(line, "LUT_3D_SIZE ", 12)) { int i, j, k; const int size = strtol(line + 12, NULL, 0); if (... |
0 | static void csrhci_in_packet(struct csrhci_s *s, uint8_t *pkt){ uint8_t *rpkt; int opc; switch (*pkt ++) { case H4_CMD_PKT: opc = le16_to_cpu(((struct hci_command_hdr *) pkt)->opcode); if (cmd_opcode_ogf(opc) == OGF_VENDOR_CMD) { csrhci_in_packet_vendor(s, cmd_opcode_ocf(opc), pkt + sizeof(struct hci_command_hdr), s->i... |
0 | static int client_migrate_info(Monitor *mon, const QDict *qdict, QObject **ret_data){ const char *protocol = qdict_get_str(qdict, "protocol"); const char *hostname = qdict_get_str(qdict, "hostname"); const char *subject = qdict_get_try_str(qdict, "cert-subject"); int port = qdict_get_try_int(qdict, "port", -1); int tls... |
0 | void backup_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, BlockdevOnError on_source_error, BlockdevOnError on_target_error, BlockDriverCompletionFunc *cb, void *opaque, Error **errp){ int64_t len; assert(bs); assert(target); assert(cb); if ((on_source_error == BLOCKDEV_ON_ERROR_STOP || on_source_... |
0 | void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics const int uvlinesize = s->current_picture.f->linesize[1]; const int mb_size= 4; s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2; ... |
0 | int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len){ int offset = 0; int res = 0; qemu_mutex_lock(&s->chr_write_lock); while (offset < len) { do { res = s->chr_write(s, buf + offset, len - offset); if (res == -1 && errno == EAGAIN) { g_usleep(100); } } while (res == -1 && errno == EAGAIN); if (re... |
0 | static GenericList *qmp_output_next_list(Visitor *v, GenericList *tail, size_t size){ return tail->next;} |
0 | int get_physical_address (CPUState *env, mmu_ctx_t *ctx, target_ulong eaddr, int rw, int access_type){ int ret;#if 0 qemu_log("%s\n", __func__);#endif if ((access_type == ACCESS_CODE && msr_ir == 0) || (access_type != ACCESS_CODE && msr_dr == 0)) { /* No address translation */ ret = check_physical(env, ctx, eaddr, rw);... |
0 | static unsigned int dec_btstq(DisasContext *dc){TCGv l0;dc->op1 = EXTRACT_FIELD(dc->ir, 0, 4);DIS(fprintf (logfile, "btstq %u, $r%d\n", dc->op1, dc->op2));cris_cc_mask(dc, CC_MASK_NZ);l0 = tcg_temp_local_new(TCG_TYPE_TL);cris_alu(dc, CC_OP_BTST, l0, cpu_R[dc->op2], tcg_const_tl(dc->op1), 4);cris_update_cc_op(dc, CC_OP_... |
0 | static void tcg_out_brcond2(TCGContext *s, const TCGArg *args, const int *const_args, int small){ int label_next; label_next = gen_new_label(); switch(args[4]) { case TCG_COND_EQ: tcg_out_brcond32(s, TCG_COND_NE, args[0], args[2], const_args[2], label_next, 1); tcg_out_brcond32(s, TCG_COND_EQ, args[1], args[3], const_a... |
0 | int qemu_savevm_state_begin(QEMUFile *f){ SaveStateEntry *se; qemu_put_be32(f, QEMU_VM_FILE_MAGIC); qemu_put_be32(f, QEMU_VM_FILE_VERSION); TAILQ_FOREACH(se, &savevm_handlers, entry) { int len; if (se->save_live_state == NULL) continue; /* Section type */ qemu_put_byte(f, QEMU_VM_SECTION_START); qemu_put_be32(f, se->se... |
0 | static void gen_jumpi(DisasContext *dc, uint32_t dest, int slot){ TCGv_i32 tmp = tcg_const_i32(dest); if (((dc->pc ^ dest) & TARGET_PAGE_MASK) != 0) { slot = -1; } gen_jump_slot(dc, tmp, slot); tcg_temp_free(tmp);} |
0 | int qed_read_l1_table_sync(BDRVQEDState *s){ int ret = -EINPROGRESS; async_context_push(); qed_read_table(s, s->header.l1_table_offset, s->l1_table, qed_sync_cb, &ret); while (ret == -EINPROGRESS) { qemu_aio_wait(); } async_context_pop(); return ret;} |
0 | static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof){ int ret = 0, i; int repeating = 0; int eof_reached = 0; AVPacket avpkt; if (!ist->saw_first_ts) { ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0; ist->pts = 0; ... |
0 | BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp){ BlockDeviceInfoList *list, *entry; BlockDriverState *bs; list = NULL; QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { BlockDeviceInfo *info = bdrv_block_device_info(bs, errp); if (!info) { qapi_free_BlockDeviceInfoList(list); return NULL; } entry = g_malloc0... |
0 | static uint32_t dp8393x_readw(void *opaque, target_phys_addr_t addr){ dp8393xState *s = opaque; int reg; if ((addr & ((1 << s->it_shift) - 1)) != 0) { return 0; } reg = addr >> s->it_shift; return read_register(s, reg);} |
0 | void cpu_outw(pio_addr_t addr, uint16_t val){ LOG_IOPORT("outw: %04"FMT_pioaddr" %04"PRIx16"\n", addr, val); trace_cpu_out(addr, val); ioport_write(1, addr, val);} |
0 | void HELPER(wfe)(CPUARMState *env){ CPUState *cs = CPU(arm_env_get_cpu(env)); /* Don't actually halt the CPU, just yield back to top * level loop. This is not going into a "low power state" * (ie halting until some event occurs), so we never take * a configurable trap to a different exception level. */ cs->exception_in... |
0 | static int xenfb_send_position(struct XenInput *xenfb, int abs_x, int abs_y, int z){ union xenkbd_in_event event; memset(&event, 0, XENKBD_IN_EVENT_SIZE); event.type = XENKBD_TYPE_POS; event.pos.abs_x = abs_x; event.pos.abs_y = abs_y;#if __XEN_LATEST_INTERFACE_VERSION__ == 0x00030207 event.pos.abs_z = z;#endif#if __XEN... |
0 | static int latm_decode_frame(AVCodecContext *avctx, void *out, int *got_frame_ptr, AVPacket *avpkt){ struct LATMContext *latmctx = avctx->priv_data; int muxlength, err; GetBitContext gb; init_get_bits(&gb, avpkt->data, avpkt->size * 8); // check for LOAS sync word if (get_bits(&gb, 11) != LOAS_SYNC_WORD) return AVERROR... |
0 | static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y){ MotionEstContext * const c= &s->me; int P[10][2]; const int mot_stride = s->mb_stride; const int mot_xy = mb_y*mot_stride + mb_x; const int shift= 1+s->quarter_sample; int dmin, i; const int time_pp= s->pp_time; const int time_pb= s->pb_time; int ... |
0 | static av_cold void iv_alloc_frames(Indeo3DecodeContext *s){ int luma_width, luma_height, luma_pixels, chroma_width, chroma_height, chroma_pixels, i; unsigned int bufsize; luma_width = (s->width + 3) & (~3); luma_height = (s->height + 3) & (~3); s->iv_frame[0].y_w = s->iv_frame[0].y_h = s->iv_frame[0].the_buf_size = 0;... |
0 | int avpriv_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr){ int frame_size_code; memset(hdr, 0, sizeof(*hdr)); hdr->sync_word = get_bits(gbc, 16); if(hdr->sync_word != 0x0B77) return AAC_AC3_PARSE_ERROR_SYNC; /* read ahead to bsid to distinguish between AC-3 and E-AC-3 */ hdr->bitstream_id = show_bits_long(gbc... |
0 | av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v){ MpegEncContext *s = &v->s; int i; int mb_height = FFALIGN(s->mb_height, 2); /* Allocate mb bitplanes */ v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height); v->direct_mb_plane = av_malloc (s->mb_stride * mb_height); v->forward_mb_plane = av_malloc (s->m... |
0 | static void iv_Decode_Chunk(Indeo3DecodeContext *s, uint8_t *cur, uint8_t *ref, int width, int height, const uint8_t *buf1, long cb_offset, const uint8_t *hdr, const uint8_t *buf2, int min_width_160){ uint8_t bit_buf; unsigned long bit_pos, lv, lv1, lv2; long *width_tbl, width_tbl_arr[10]; const signed char *ref_vector... |
0 | void ff_avg_h264_qpel4_mc33_msa(uint8_t *dst, const uint8_t *src, ptrdiff_t stride){ avc_luma_hv_qrt_and_aver_dst_4x4_msa(src + stride - 2, src - (stride * 2) + sizeof(uint8_t), stride, dst, stride);} |
1 | static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size){ Mpeg1Context *s1 = avctx->priv_data; MpegEncContext *s = &s1->mpeg_enc_ctx; int ref, f_code, vbv_delay; if(mpeg_decode_postinit(s->avctx) < 0) return -2; init_get_bits(&s->gb, buf, buf_size*8); ref = get_bits(&s->gb, 10); /* tempo... |
1 | static void disas_arm_insn(DisasContext *s, unsigned int insn){ unsigned int cond, val, op1, i, shift, rm, rs, rn, rd, sh; TCGv_i32 tmp; TCGv_i32 tmp2; TCGv_i32 tmp3; TCGv_i32 addr; TCGv_i64 tmp64; /* M variants do not implement ARM mode. */ if (arm_dc_feature(s, ARM_FEATURE_M)) { goto illegal_op; } cond = insn >> 28; ... |
1 | static void pcie_pci_bridge_reset(DeviceState *qdev){ PCIDevice *d = PCI_DEVICE(qdev); pci_bridge_reset(qdev); msi_reset(d); shpc_reset(d);} |
1 | static int protocol_client_auth_sasl_step_len(VncState *vs, uint8_t *data, size_t len){ uint32_t steplen = read_u32(data, 0); VNC_DEBUG("Got client step len %d\n", steplen); if (steplen > SASL_DATA_MAX_LEN) { VNC_DEBUG("Too much SASL data %d\n", steplen); vnc_client_error(vs); return -1; } if (steplen == 0) return prot... |
1 | int qemu_devtree_nop_node(void *fdt, const char *node_path){ int offset; offset = fdt_path_offset(fdt, node_path); if (offset < 0) return offset; return fdt_nop_node(fdt, offset);} |
1 | static int ogg_read_header(AVFormatContext *s){ struct ogg *ogg = s->priv_data; int ret, i; ogg->curidx = -1; //linear headers seek from start do { ret = ogg_packet(s, NULL, NULL, NULL, NULL); if (ret < 0) { ogg_read_close(s); return ret; } } while (!ogg->headers); av_log(s, AV_LOG_TRACE, "found headers\n"); for (i = 0... |
1 | void qmp_drive_backup(DriveBackup *arg, Error **errp){ return do_drive_backup(arg, NULL, errp);} |
0 | static void vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha){ AVFrame *frame_current, *frame_ref; VP56mb mb_type; VP56Frame ref_frame; int b, ab, b_max, plane, off; if (s->framep[VP56_FRAME_CURRENT]->key_frame) mb_type = VP56_MB_INTRA; else mb_type = vp56_decode_mv(s, row, col); ref_frame = vp56_reference... |
1 | AVRational av_get_q(void *obj, const char *name, const AVOption **o_out){ int64_t intnum=1; double num=1; int den=1; av_get_number(obj, name, o_out, &num, &den, &intnum); if (num == 1.0 && (int)intnum == intnum) return (AVRational){intnum, den}; else return av_d2q(num*intnum/den, 1<<24);} |
0 | static uint64_t megasas_queue_read(void *opaque, target_phys_addr_t addr, unsigned size){ return 0;} |
0 | int float32_is_nan( float32 a1 ){ float32u u; uint64_t a; u.f = a1; a = u.i; return ( 0xFF800000 < ( a<<1 ) );} |
0 | static void bitband_writel(void *opaque, target_phys_addr_t offset, uint32_t value){ uint32_t addr; uint32_t mask; uint32_t v; addr = bitband_addr(opaque, offset) & ~3; mask = (1 << ((offset >> 2) & 31)); mask = tswap32(mask); cpu_physical_memory_read(addr, (uint8_t *)&v, 4); if (value & 1) v |= mask; else v &= ~mask; ... |
0 | static void vvfat_refresh_limits(BlockDriverState *bs, Error **errp){ bs->request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O supported */} |
0 | void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env){ SLAVIO_INTCTLState *s = opaque; s->cpu_envs[cpu] = env;} |
0 | static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[7], int bsi, int qp ) { int index_a = qp + h->slice_alpha_c0_offset; int alpha = alpha_table[index_a]; int beta = beta_table[qp + h->slice_beta_offset]; if (alpha ==0 || beta == 0) return; if( bS[0] < 4 ) { int8_t tc[4]; tc[0] = tc0... |
0 | static void kbd_write_command(void *opaque, hwaddr addr, uint64_t val, unsigned size){ KBDState *s = opaque; DPRINTF("kbd: write cmd=0x%02" PRIx64 "\n", val); /* Bits 3-0 of the output port P2 of the keyboard controller may be pulsed * low for approximately 6 micro seconds. Bits 3-0 of the KBD_CCMD_PULSE * command spec... |
0 | static int kvm_s390_supports_mem_limit(KVMState *s){ struct kvm_device_attr attr = { .group = KVM_S390_VM_MEM_CTRL, .attr = KVM_S390_VM_MEM_LIMIT_SIZE, }; return (kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attr) == 0);} |
0 | static inline uint64_t fload_invalid_op_excp(CPUPPCState *env, int op){ uint64_t ret = 0; int ve; ve = fpscr_ve; switch (op) { case POWERPC_EXCP_FP_VXSNAN: env->fpscr |= 1 << FPSCR_VXSNAN; break; case POWERPC_EXCP_FP_VXSOFT: env->fpscr |= 1 << FPSCR_VXSOFT; break; case POWERPC_EXCP_FP_VXISI: /* Magnitude subtraction of... |
0 | VirtIODevice *virtio_blk_init(DeviceState *dev, DriveInfo *dinfo){ VirtIOBlock *s; int cylinders, heads, secs; static int virtio_blk_id; char *ps; s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK, sizeof(struct virtio_blk_config), sizeof(VirtIOBlock)); s->vdev.get_config = virtio_blk_update_config; s... |
0 | static BlockAIOCB *raw_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockCompletionFunc *cb, void *opaque){ return raw_aio_submit(bs, sector_num, qiov, nb_sectors, cb, opaque, QEMU_AIO_WRITE);} |
0 | static void text_console_update(void *opaque, console_ch_t *chardata){ QemuConsole *s = (QemuConsole *) opaque; int i, j, src; if (s->text_x[0] <= s->text_x[1]) { src = (s->y_base + s->text_y[0]) * s->width; chardata += s->text_y[0] * s->width; for (i = s->text_y[0]; i <= s->text_y[1]; i ++) for (j = 0; j < s->width; j... |
0 | bool qemu_peer_has_ufo(NetClientState *nc){ if (!nc->peer || !nc->peer->info->has_ufo) { return false; } return nc->peer->info->has_ufo(nc->peer);} |
0 | void kbd_put_keycode(int keycode){ if (!runstate_is_running()) { return; } if (qemu_put_kbd_event) { qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode); }} |
0 | ssize_t nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp){ uint8_t buf[NBD_REPLY_SIZE]; uint32_t magic; ssize_t ret; ret = read_sync_eof(ioc, buf, sizeof(buf), errp); if (ret <= 0) { return ret; } if (ret != sizeof(buf)) { error_setg(errp, "read failed"); return -EINVAL; } /* Reply [ 0 .. 3] magic (NBD_... |
0 | static int file_open(URLContext *h, const char *filename, int flags){ int access; int fd; av_strstart(filename, "file:", &filename); if (flags & URL_RDWR) { access = O_CREAT | O_TRUNC | O_RDWR; } else if (flags & URL_WRONLY) { access = O_CREAT | O_TRUNC | O_WRONLY; } else { access = O_RDONLY; }#if defined(__MINGW32__) ... |
0 | void *qemu_get_ram_ptr(ram_addr_t addr){ RAMBlock *prev; RAMBlock **prevp; RAMBlock *block;#ifdef CONFIG_KQEMU if (kqemu_phys_ram_base) { return kqemu_phys_ram_base + addr; }#endif prev = NULL; prevp = &ram_blocks; block = ram_blocks; while (block && (block->offset > addr || block->offset + block->length <= addr)) { if... |
0 | static inline void tcg_reg_sync(TCGContext *s, int reg){ TCGTemp *ts; int temp; temp = s->reg_to_temp[reg]; ts = &s->temps[temp]; assert(ts->val_type == TEMP_VAL_REG); if (!ts->mem_coherent && !ts->fixed_reg) { if (!ts->mem_allocated) { temp_allocate_frame(s, temp); } tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_o... |
0 | int qio_channel_socket_connect_sync(QIOChannelSocket *ioc, SocketAddressLegacy *addr, Error **errp){ int fd; trace_qio_channel_socket_connect_sync(ioc, addr); fd = socket_connect(addr, NULL, NULL, errp); if (fd < 0) { trace_qio_channel_socket_connect_fail(ioc); return -1; } trace_qio_channel_socket_connect_complete(ioc... |
1 | static int transcode(OutputFile *output_files, int nb_output_files, InputFile *input_files, int nb_input_files){ int ret, i; AVFormatContext *is, *os; OutputStream *ost; InputStream *ist; uint8_t *no_packet; int no_packet_count=0; int64_t timer_start; int key; if (!(no_packet = av_mallocz(nb_input_files))) exit_program... |
1 | static void mirror_start_job(const char *job_id, BlockDriverState *bs, int creation_flags, BlockDriverState *target, const char *replaces, int64_t speed, uint32_t granularity, int64_t buf_size, BlockMirrorBackingMode backing_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, bool unmap, BlockComple... |
1 | static void perf_cost(void){ const unsigned long maxcycles = 40000000; unsigned long i = 0; double duration; unsigned long ops; Coroutine *co; g_test_timer_start(); while (i++ < maxcycles) { co = qemu_coroutine_create(perf_cost_func); qemu_coroutine_enter(co, &i); qemu_coroutine_enter(co, NULL); } duration = g_test_tim... |
1 | int ff_ass_add_rect(AVSubtitle *sub, const char *dialog, int ts_start, int duration, int raw){ AVBPrint buf; int ret, dlen; AVSubtitleRect **rects; av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED); if ((ret = ff_ass_bprint_dialog(&buf, dialog, ts_start, duration, raw)) < 0) goto err; dlen = ret; if (!av_bprint_is_comp... |
1 | static int compute_bit_allocation(AC3EncodeContext *s, uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2], uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS], int frame_bits){ int i, ch; int csnroffst, fsnroffst; uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2]; static int... |
1 | static void decode_plane_bitstream(HYuvContext *s, int count, int plane){ int i; count /= 2; if (s->bps <= 8) { OPEN_READER(re, &s->gb); if (count >= (get_bits_left(&s->gb)) / (32 * 2)) { for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) { READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits)... |
1 | static void qxl_hard_reset(PCIQXLDevice *d, int loadvm){ dprint(d, 1, "%s: start%s\n", __FUNCTION__, loadvm ? " (loadvm)" : ""); qemu_mutex_unlock_iothread(); d->ssd.worker->reset_cursor(d->ssd.worker); d->ssd.worker->reset_image_cache(d->ssd.worker); qemu_mutex_lock_iothread(); qxl_reset_surfaces(d); qxl_reset_memslot... |
0 | int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; RV34DecContext *r = avctx->priv_data; MpegEncContext *s = &r->s; AVFrame *pict = data; SliceInfo si; int i; int slice_count; const uint8_t *slices_hdr = NULL; int l... |
1 | static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num, int remaining_sectors, QEMUIOVector *qiov){ BDRVQcowState *s = bs->opaque; int index_in_cluster, n1; int ret; int cur_nr_sectors; /* number of sectors in current iteration */ uint64_t cluster_offset = 0; uint64_t bytes_done = 0; QEMUIOVect... |
1 | static int mov_write_udta_tag(ByteIOContext *pb, MOVMuxContext *mov, AVFormatContext *s){ ByteIOContext *pb_buf; int i, ret, size; uint8_t *buf; for (i = 0; i < s->nb_streams; i++) if (mov->tracks[i].enc->flags & CODEC_FLAG_BITEXACT) { return 0; } ret = url_open_dyn_buf(&pb_buf); if(ret < 0) return ret; if (mov->mode &... |
1 | static void gen_tlbwe_booke206(DisasContext *ctx){#if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);#else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } gen_update_nip(ctx, ctx->nip - 4); gen_helper_booke206_tlbwe(cpu_env);#endif} |
1 | static void serial_xmit(SerialState *s){ do { assert(!(s->lsr & UART_LSR_TEMT)); if (s->tsr_retry == 0) { assert(!(s->lsr & UART_LSR_THRE)); if (s->fcr & UART_FCR_FE) { assert(!fifo8_is_empty(&s->xmit_fifo)); s->tsr = fifo8_pop(&s->xmit_fifo); if (!s->xmit_fifo.num) { s->lsr |= UART_LSR_THRE; } } else { s->tsr = s->thr... |
1 | void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict){ struct in_addr host_addr = { .s_addr = INADDR_ANY }; int host_port; char buf[256] = ""; const char *src_str, *p; SlirpState *s; int is_udp = 0; int err; const char *arg1 = qdict_get_str(qdict, "arg1"); const char *arg2 = qdict_get_try_str(qdict, "arg2"); ... |
1 | static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom){ AVStream *st; MOVStreamContext *sc; unsigned int i, entries; int64_t duration=0; int64_t total_sample_count=0; if (c->fc->nb_streams < 1) return 0; st = c->fc->streams[c->fc->nb_streams-1]; sc = st->priv_data; avio_r8(pb); /* version */ avio_rb24(p... |
0 | static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit){ AVPacket pkt1, *pkt = &pkt1; ASFStream *asf_st; int64_t pts; int64_t pos= *ppos; int i; int64_t start_pos[ASF_MAX_STREAMS]; for(i=0; i<s->nb_streams; i++){ start_pos[i]= pos; } if (s->packet_size > 0) pos= (pos+s->packe... |
0 | static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk, Jpeg2000Component *comp, Jpeg2000T1Context *t1, Jpeg2000Band *band){ int i, j; int w = cblk->coord[0][1] - cblk->coord[0][0]; for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) { int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coor... |
1 | static void vmxnet3_update_features(VMXNET3State *s){ uint32_t guest_features; int rxcso_supported; guest_features = VMXNET3_READ_DRV_SHARED32(s->drv_shmem, devRead.misc.uptFeatures); rxcso_supported = VMXNET_FLAG_IS_SET(guest_features, UPT1_F_RXCSUM); s->rx_vlan_stripping = VMXNET_FLAG_IS_SET(guest_features, UPT1_F_RX... |
1 | int object_property_get_enum(Object *obj, const char *name, const char *typename, Error **errp){ StringOutputVisitor *sov; StringInputVisitor *siv; char *str; int ret; ObjectProperty *prop = object_property_find(obj, name, errp); EnumProperty *enumprop; if (prop == NULL) { return 0; } if (!g_str_equal(prop->type, typen... |
1 | void ahci_init(AHCIState *s, DeviceState *qdev, AddressSpace *as, int ports){ qemu_irq *irqs; int i; s->as = as; s->ports = ports; s->dev = g_malloc0(sizeof(AHCIDevice) * ports); ahci_reg_init(s); /* XXX BAR size should be 1k, but that breaks, so bump it to 4k for now */ memory_region_init_io(&s->mem, OBJECT(qdev), &ah... |
1 | static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, int (*read_child)(), int ctx_size, enum MXFMetadataSetType type){ ByteIOContext *pb = mxf->fc->pb; MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf; uint64_t klv_end = url_ftell(pb) + klv->length; if (!ctx) return -1; while (url_ftell(pb) + 4 < ... |
1 | void do_ddiv (void){ if (T1 != 0) { lldiv_t res = lldiv((int64_t)T0, (int64_t)T1); env->LO[0][env->current_tc] = res.quot; env->HI[0][env->current_tc] = res.rem; }} |
1 | static inline void idct(int16_t *block){ int64_t __attribute__((aligned(8))) align_tmp[16]; int16_t * const temp= (int16_t*)align_tmp; asm volatile(#if 0 //Alternative, simpler variant#define ROW_IDCT(src0, src4, src1, src5, dst, rounder, shift) \ "movq " #src0 ", %%mm0 \n\t" /* R4 R0 r4 r0 */\ "movq " #src4 ", %%mm1 \... |
1 | static int flush_packet(AVFormatContext *ctx, int stream_index, int64_t pts, int64_t dts, int64_t scr, int trailer_size){ MpegMuxContext *s = ctx->priv_data; StreamInfo *stream = ctx->streams[stream_index]->priv_data; uint8_t *buf_ptr; int size, payload_size, startcode, id, stuffing_size, i, header_len; int packet_size... |
1 | static void mux_chr_update_read_handler(CharDriverState *chr, GMainContext *context){ MuxDriver *d = chr->opaque; int idx; if (d->mux_cnt >= MAX_MUX) { fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n"); return; } if (chr->mux_idx == -1) { chr->mux_idx = d->mux_cnt++; } idx = chr->mux_idx; d->ext_opaque[id... |
1 | static inline void RENAME(yuv2packed2)(SwsContext *c, uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1, uint8_t *dest, int dstW, int yalpha, int uvalpha, int y){ int yalpha1=yalpha^4095; int uvalpha1=uvalpha^4095; int i;#if 0 //isn't used if (flags&SWS_FULL_CHR_H_INT) { switch(dstFormat) {#ifdef HAVE_... |
1 | static void apply_delogo(uint8_t *dst, int dst_linesize, uint8_t *src, int src_linesize, int w, int h, AVRational sar, int logo_x, int logo_y, int logo_w, int logo_h, unsigned int band, int show, int direct){ int x, y; uint64_t interp, weightl, weightr, weightt, weightb; uint8_t *xdst, *xsrc; uint8_t *topleft, *botleft... |
1 | static long getrampagesize(void){ long hpsize = LONG_MAX; Object *memdev_root; if (mem_path) { return gethugepagesize(mem_path); } /* it's possible we have memory-backend objects with * hugepage-backed RAM. these may get mapped into system * address space via -numa parameters or memory hotplug * hooks. we want to take ... |
1 | static int kvm_put_xsave(CPUState *env){#ifdef KVM_CAP_XSAVE int i; struct kvm_xsave* xsave; uint16_t cwd, swd, twd, fop; if (!kvm_has_xsave()) return kvm_put_fpu(env); xsave = qemu_memalign(4096, sizeof(struct kvm_xsave)); memset(xsave, 0, sizeof(struct kvm_xsave)); cwd = swd = twd = fop = 0; swd = env->fpus & ~(7 << ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.