label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
1 | static int tap_alloc(char *dev, size_t dev_size){ int tap_fd, if_fd, ppa = -1; static int ip_fd = 0; char *ptr; static int arp_fd = 0; int ip_muxid, arp_muxid; struct strioctl strioc_if, strioc_ppa; int link_type = I_PLINK; struct lifreq ifr; char actual_name[32] = ""; memset(&ifr, 0x0, sizeof(ifr)); if( *dev ){ ptr = ... |
0 | static int ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band, IVITile *tile, int32_t mv_scale){ int x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type; int offs, mb_offset, row_offset; IVIMbInfo *mb, *ref_mb; const int16_t *src; int16_t *dst; void (*mc_no_delta_func)(int16_t *buf, const int16_t *ref... |
0 | static void set_palette(AVFrame * frame, const uint8_t * palette_buffer){ uint32_t * palette = (uint32_t *)frame->data[1]; int a; for(a = 0; a < 256; a++){ palette[a] = AV_RB24(&palette_buffer[a * 3]) * 4; } frame->palette_has_changed = 1;} |
0 | static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, unsigned src_size){const uint8_t *s = src;const uint8_t *end;#ifdef HAVE_MMXconst uint8_t *mm_end;#endifuint16_t *d = (uint16_t *)dst;end = s + src_size;#ifdef HAVE_MMXmm_end = end - 15;#if 1 //is faster only if multiplies are reasonable fast (FIXME... |
1 | void helper_do_semihosting(CPUMIPSState *env){ target_ulong *gpr = env->active_tc.gpr; const UHIOp op = gpr[25]; char *p, *p2; switch (op) { case UHI_exit: qemu_log("UHI(%d): exit(%d)\n", op, (int)gpr[4]); exit(gpr[4]); case UHI_open: GET_TARGET_STRING(p, gpr[4]); if (!strcmp("/dev/stdin", p)) { gpr[2] = 0; } else if (... |
1 | static int decode_mb_info(IVI5DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx){ int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, mv_scale, blks_per_mb; IVIMbInfo *mb, *ref_mb; int row_offset = band->mb_size * band->pitch; mb = tile->mbs; ref_mb = tile->ref_mbs; offs = tile->ypos * band->pitch +... |
1 | static int init_input_stream(int ist_index, char *error, int error_len){ int i; InputStream *ist = input_streams[ist_index]; if (ist->decoding_needed) { AVCodec *codec = ist->dec; if (!codec) { snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d", ist->st->codec->codec_id, ist->file_inde... |
1 | static void init_proc_POWER9(CPUPPCState *env){ /* Common Registers */ init_proc_book3s_common(env); gen_spr_book3s_207_dbg(env); /* POWER8 Specific Registers */ gen_spr_book3s_ids(env); gen_spr_amr(env); gen_spr_iamr(env); gen_spr_book3s_purr(env); gen_spr_power5p_common(env); gen_spr_power5p_lpar(env); gen_spr_power5... |
1 | static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){ H264Context *h = avctx->priv_data; MpegEncContext *s = &h->s; AVFrame *pict = data; int buf_index; s->flags= avctx->flags; s->flags2= avctx->flags2; /* end of stream, output what is still in the buffers */ if (... |
1 | target_ulong spapr_rtas_call(PowerPCCPU *cpu, sPAPREnvironment *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets){ if ((token >= TOKEN_BASE) && ((token - TOKEN_BASE) < TOKEN_MAX)) { struct rtas_call *call = rtas_table + (token - TOKEN_BASE); if (call->fn) { call->fn(cpu, spapr,... |
1 | void OPPROTO op_fdivr_ST0_FT0(void){ ST0 = FT0 / ST0;} |
1 | static void spectral_to_sample(AACContext *ac, int samples){ int i, type; void (*imdct_and_window)(AACContext *ac, SingleChannelElement *sce); switch (ac->oc[1].m4ac.object_type) { case AOT_ER_AAC_LD: imdct_and_window = imdct_and_windowing_ld; break; case AOT_ER_AAC_ELD: imdct_and_window = imdct_and_windowing_eld; brea... |
1 | static void serial_ioport_write(void *opaque, uint32_t addr, uint32_t val){ SerialState *s = opaque; unsigned char ch; addr &= 7;#ifdef DEBUG_SERIAL printf("serial: write addr=0x%02x val=0x%02x\n", addr, val);#endif switch(addr) { default: case 0: if (s->lcr & UART_LCR_DLAB) { s->divider = (s->divider & 0xff00) | val; ... |
1 | int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx){ int ret; if ((ret = graph_check_validity(graphctx, log_ctx))) if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0) if ((ret = graph_config_formats(graphctx, log_ctx))) if ((ret = graph_config_links(graphctx, log_ctx))) if ((ret = graph_config_pointers... |
0 | static void process_param(float *bc, EqParameter *param, float fs){ int i; for (i = 0; i <= NBANDS; i++) { param[i].lower = i == 0 ? 0 : bands[i - 1]; param[i].upper = i == NBANDS - 1 ? fs : bands[i]; param[i].gain = bc[i]; }} |
1 | static int apng_read_packet(AVFormatContext *s, AVPacket *pkt){ APNGDemuxContext *ctx = s->priv_data; int64_t ret; int64_t size; AVIOContext *pb = s->pb; uint32_t len, tag; /* * fcTL chunk length, in bytes: * 4 (length) * 4 (tag) * 26 (actual chunk) * 4 (crc) bytes * and needed next: * 4 (length) * 4 (tag (must be fdAT... |
1 | static int set_expr(AVExpr **pexpr, const char *expr, void *log_ctx){ int ret; if (*pexpr) av_expr_free(*pexpr); *pexpr = NULL; ret = av_expr_parse(pexpr, expr, var_names, NULL, NULL, NULL, NULL, 0, log_ctx); if (ret < 0) av_log(log_ctx, AV_LOG_ERROR, "Error when evaluating the expression '%s'\n", expr); return ret;} |
1 | int MPV_encode_init(AVCodecContext *avctx){ MpegEncContext *s = avctx->priv_data; int i, dummy; int chroma_h_shift, chroma_v_shift; avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME s->bit_rate = avctx->bit_rate; s->width = avctx->width; s->height = avctx->height; if(avctx->gop_size > 600){av_log(avctx, AV_LOG_ERROR, "Warning... |
1 | static int32_t ahci_dma_prepare_buf(IDEDMA *dma, int is_write){ AHCIDevice *ad = DO_UPCAST(AHCIDevice, dma, dma); IDEState *s = &ad->port.ifs[0]; if (ahci_populate_sglist(ad, &s->sg, s->io_buffer_offset) == -1) { DPRINTF(ad->port_no, "ahci_dma_prepare_buf failed.\n"); return -1; } s->io_buffer_size = s->sg.size; DPRINT... |
1 | static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs, struct image_info * info){ struct elfhdr elf_ex; struct elfhdr interp_elf_ex; struct exec interp_ex; int interpreter_fd = -1; /* avoid warning */ unsigned long load_addr, load_bias; int load_addr_set = 0; unsigned int interpreter_type ... |
0 | static void vc1_inv_trans_4x4_c(uint8_t *dest, int linesize, DCTELEM *block){ int i; register int t1,t2,t3,t4; DCTELEM *src, *dst; const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; src = block; dst = block; for(i = 0; i < 4; i++){ t1 = 17 * (src[0] + src[2]) + 4; t2 = 17 * (src[0] - src[2]) + 4; t3 = 22 * src[1] + 10 * sr... |
0 | static void fill_buffer(AVIOContext *s){ int max_buffer_size = s->max_packet_size ? s->max_packet_size : IO_BUFFER_SIZE; uint8_t *dst = s->buf_end - s->buffer + max_buffer_size < s->buffer_size ? s->buf_end : s->buffer; int len = s->buffer_size - (dst - s->buffer); /* can't fill the buffer without read_packet, just set... |
0 | AVFilterFormats *avfilter_make_all_channel_layouts(void){ static int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_4POINT0, AV_CH_LAYOUT_QUAD, AV_CH_LAYOUT_5POINT0, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_5POINT1, AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_5POINT1|AV_CH_LAYOUT_STEREO_DOWNMIX, AV... |
1 | static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt){ MatroskaDemuxContext *matroska = s->priv_data; int ret = 0; while (!ret && matroska_deliver_packet(matroska, pkt)) { if (matroska->done) return AVERROR_EOF; ret = matroska_parse_cluster(matroska); } return ret;} |
1 | int av_write_header(AVFormatContext *s){ int ret, i; AVStream *st; // some sanity checks if (s->nb_streams == 0) { av_log(s, AV_LOG_ERROR, "no streams\n"); return AVERROR(EINVAL); } for(i=0;i<s->nb_streams;i++) { st = s->streams[i]; switch (st->codec->codec_type) { case AVMEDIA_TYPE_AUDIO: if(st->codec->sample_rate<=0)... |
1 | static TCGReg tcg_out_tlb_read(TCGContext *s, TCGMemOp s_bits, TCGReg addrlo, TCGReg addrhi, int mem_index, bool is_read){ int cmp_off = (is_read ? offsetof(CPUArchState, tlb_table[mem_index][0].addr_read) : offsetof(CPUArchState, tlb_table[mem_index][0].addr_write)); int add_off = offsetof(CPUArchState, tlb_table[mem_... |
1 | void qemu_tcg_configure(QemuOpts *opts, Error **errp){ const char *t = qemu_opt_get(opts, "thread"); if (t) { if (strcmp(t, "multi") == 0) { if (TCG_OVERSIZED_GUEST) { error_setg(errp, "No MTTCG when guest word size > hosts"); } else if (use_icount) { error_setg(errp, "No MTTCG when icount is enabled"); } else { if (!c... |
1 | static int replaygain_export(AVStream *st, const uint8_t *track_gain, const uint8_t *track_peak, const uint8_t *album_gain, const uint8_t *album_peak){ AVPacketSideData *sd, *tmp; AVReplayGain *replaygain; uint8_t *data; int32_t tg, ag; uint32_t tp, ap; tg = parse_gain(track_gain); ag = parse_gain(album_gain); tp = par... |
0 | static int bytes_left(ByteIOContext *bc){ return bc->buf_end - bc->buf_ptr;} |
0 | int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt){ int i, ret = 0; if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) { av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n"); return AVERROR(EINVAL); } *got_sub_ptr = 0; avcodec_get_subtitle_defaults(sub); i... |
0 | static av_always_inline void thread_park_workers(ThreadContext *c, int thread_count){ while (c->current_job != thread_count + c->job_count) pthread_cond_wait(&c->last_job_cond, &c->current_job_lock); pthread_mutex_unlock(&c->current_job_lock);} |
0 | int ff_h264_check_intra4x4_pred_mode(H264Context *h){ MpegEncContext * const s = &h->s; static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; int i; if(!(h->top_samples_available&0x8000)){ for(i=0; i<4; i++){ int status= t... |
0 | static void sdram_map_bcr (ppc4xx_sdram_t *sdram){ int i; for (i = 0; i < sdram->nbanks; i++) { if (sdram->ram_sizes[i] != 0) { sdram_set_bcr(&sdram->bcr[i], sdram_bcr(sdram->ram_bases[i], sdram->ram_sizes[i]), 1); } else { sdram_set_bcr(&sdram->bcr[i], 0x00000000, 0); } }} |
0 | static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp){ VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); DeviceState *vdev = DEVICE(&dev->vdev); Error *err = NULL; qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); object_property_set_bool(OBJECT(vdev), true, "realized", &err); if (err) { error_... |
0 | static inline void gen_scas(DisasContext *s, int ot){ gen_op_mov_TN_reg(OT_LONG, 0, R_EAX); gen_string_movl_A0_EDI(s); gen_op_ld_T1_A0(ot + s->mem_index); gen_op_cmpl_T0_T1_cc(); gen_op_movl_T0_Dshift[ot]();#ifdef TARGET_X86_64 if (s->aflag == 2) { gen_op_addq_EDI_T0(); } else#endif if (s->aflag) { gen_op_addl_EDI_T0()... |
0 | static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector){ VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); VirtQueue *vq = virtio_vector_first_queue(vdev, vector); int index; while (vq) { index = virtio_get_queue_index(vq); if (!virt... |
0 | static void gen_callwi(DisasContext *dc, int callinc, uint32_t dest, int slot){ TCGv_i32 tmp = tcg_const_i32(dest); if (((dc->pc ^ dest) & TARGET_PAGE_MASK) != 0) { slot = -1; } gen_callw_slot(dc, callinc, tmp, slot); tcg_temp_free(tmp);} |
0 | static inline void gen_neon_narrow_sats(int size, TCGv dest, TCGv src){ switch (size) { case 0: gen_helper_neon_narrow_sat_s8(dest, cpu_env, src); break; case 1: gen_helper_neon_narrow_sat_s16(dest, cpu_env, src); break; case 2: gen_helper_neon_narrow_sat_s32(dest, cpu_env, src); break; default: abort(); }} |
0 | RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *ref, int x0, int y0){ if (x0 < 0 || y0 < 0) { return s->ref->refPicList; } else { int x_cb = x0 >> s->sps->log2_ctb_size; int y_cb = y0 >> s->sps->log2_ctb_size; int pic_width_cb = (s->sps->width + (1 << s->sps->log2_ctb_size) - 1) >> s->sps->log2_ctb_size; in... |
0 | int gtod_load(QEMUFile *f, void *opaque, int version_id){ uint64_t tod_low; uint8_t tod_high; int r; if (qemu_get_byte(f) == S390_TOD_CLOCK_VALUE_MISSING) { fprintf(stderr, "WARNING: Guest clock was not migrated. This could " "cause the guest to hang.\n"); return 0; } tod_high = qemu_get_byte(f); tod_low = qemu_get_be6... |
0 | void stw_be_phys(target_phys_addr_t addr, uint32_t val){ stw_phys_internal(addr, val, DEVICE_BIG_ENDIAN);} |
0 | static TCGv_i32 read_fp_sreg(DisasContext *s, int reg){ TCGv_i32 v = tcg_temp_new_i32(); tcg_gen_ld_i32(v, cpu_env, fp_reg_offset(reg, MO_32)); return v;} |
0 | static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,target_phys_addr_t start_addr,target_phys_addr_t end_addr){return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);} |
0 | static void malta_fpga_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ MaltaFPGAState *s = opaque; uint32_t saddr; saddr = (addr & 0xfffff); switch (saddr) { /* SWITCH Register */ case 0x00200: break; /* JMPRS Register */ case 0x00210: break; /* LEDBAR Register */ case 0x00408: s->leds = val ... |
0 | static inline void reloc_pc26(tcg_insn_unit *code_ptr, tcg_insn_unit *target){ ptrdiff_t offset = target - code_ptr; assert(offset == sextract64(offset, 0, 26)); /* read instruction, mask away previous PC_REL26 parameter contents, set the proper offset, then write back the instruction. */ *code_ptr = deposit32(*code_pt... |
0 | static inline unsigned long align_sigframe(unsigned long sp){ unsigned long i; i = sp & ~3UL; return i;} |
0 | static av_cold void uninit(AVFilterContext *ctx){ EvalContext *eval = ctx->priv; int i; for (i = 0; i < 8; i++) { av_expr_free(eval->expr[i]); eval->expr[i] = NULL; }} |
0 | static inline void gen_405_mulladd_insn(DisasContext *ctx, int opc2, int opc3, int ra, int rb, int rt, int Rc){ TCGv t0, t1; t0 = tcg_temp_local_new(); t1 = tcg_temp_local_new(); switch (opc3 & 0x0D) { case 0x05: /* macchw - macchw. - macchwo - macchwo. */ /* macchws - macchws. - macchwso - macchwso. */ /* nmacchw - nm... |
0 | void ioinst_handle_sal(S390CPU *cpu, uint64_t reg1){ /* We do not provide address limit checking, so let's suppress it. */ if (SAL_REG1_INVALID(reg1) || reg1 & 0x000000000000ffff) { program_interrupt(&cpu->env, PGM_OPERAND, 2); }} |
0 | static void migrate_fd_put_ready(void *opaque){ MigrationState *s = opaque; int ret; if (s->state != MIG_STATE_ACTIVE) { DPRINTF("put_ready returning because of non-active state\n"); return; } DPRINTF("iterate\n"); ret = qemu_savevm_state_iterate(s->mon, s->file); if (ret < 0) { migrate_fd_error(s); } else if (ret == 1... |
0 | void do_info_mice(Monitor *mon, QObject **ret_data){ QEMUPutMouseEntry *cursor; QList *mice_list; int current; mice_list = qlist_new(); if (QTAILQ_EMPTY(&mouse_handlers)) { goto out; } current = QTAILQ_FIRST(&mouse_handlers)->index; QTAILQ_FOREACH(cursor, &mouse_handlers, node) { QObject *obj; obj = qobject_from_jsonf(... |
0 | Visitor *validate_test_init(TestInputVisitorData *data, const char *json_string, ...){ Visitor *v; va_list ap; va_start(ap, json_string); v = validate_test_init_internal(data, json_string, &ap); va_end(ap); return v;} |
0 | static av_cold int vc1_decode_init(AVCodecContext *avctx){ VC1Context *v = avctx->priv_data; MpegEncContext *s = &v->s; GetBitContext gb; /* save the container output size for WMImage */ v->output_width = avctx->width; v->output_height = avctx->height; if (!avctx->extradata_size || !avctx->extradata) return -1; if (!(a... |
0 | static void show_packets(AVFormatContext *fmt_ctx){ AVPacket pkt; av_init_packet(&pkt); while (!av_read_frame(fmt_ctx, &pkt)) show_packet(fmt_ctx, &pkt);} |
0 | static int http_open_cnx_internal(URLContext *h, AVDictionary **options){ const char *path, *proxy_path, *lower_proto = "tcp", *local_path; char hostname[1024], hoststr[1024], proto[10]; char auth[1024], proxyauth[1024] = ""; char path1[MAX_URL_SIZE]; char buf[1024], urlbuf[MAX_URL_SIZE]; int port, use_proxy, err, loca... |
1 | qio_channel_command_new_spawn(const char *const argv[], int flags, Error **errp){ pid_t pid = -1; int stdinfd[2] = { -1, -1 }; int stdoutfd[2] = { -1, -1 }; int devnull = -1; bool stdinnull = false, stdoutnull = false; QIOChannelCommand *ioc; flags = flags & O_ACCMODE; if (flags == O_RDONLY) { stdinnull = true; } if (f... |
1 | static int div_round (int dividend, int divisor){ if (dividend > 0)return (dividend + (divisor>>1)) / divisor; elsereturn -((-dividend + (divisor>>1)) / divisor);} |
1 | long do_sigreturn(CPUX86State *env){ struct sigframe *frame; abi_ulong frame_addr = env->regs[R_ESP] - 8; target_sigset_t target_set; sigset_t set; int eax, i;#if defined(DEBUG_SIGNAL) fprintf(stderr, "do_sigreturn\n");#endif if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) goto badframe; /* set blocked signal... |
1 | void cpu_dump_state(CPUXtensaState *env, FILE *f, fprintf_function cpu_fprintf, int flags){ int i, j; cpu_fprintf(f, "PC=%08x\n\n", env->pc); for (i = j = 0; i < 256; ++i) { if (sregnames[i]) { cpu_fprintf(f, "%s=%08x%c", sregnames[i], env->sregs[i], (j++ % 4) == 3 ? '\n' : ' '); } } cpu_fprintf(f, (j % 4) == 0 ? "\n" ... |
1 | int kvm_arch_init(KVMState *s){ uint64_t identity_base = 0xfffbc000; int ret; struct utsname utsname; ret = kvm_get_supported_msrs(s); if (ret < 0) { return ret; } uname(&utsname); lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0; /* * On older Intel CPUs, KVM uses vm86 mode to emulate 16-bit code directly. *... |
1 | static int matroska_parse_tracks(AVFormatContext *s){ MatroskaDemuxContext *matroska = s->priv_data; MatroskaTrack *tracks = matroska->tracks.elem; AVStream *st; int i, j, ret; int k; for (i = 0; i < matroska->tracks.nb_elem; i++) { MatroskaTrack *track = &tracks[i]; enum AVCodecID codec_id = AV_CODEC_ID_NONE; EbmlList... |
1 | static void vnc_display_close(VncDisplay *vd){ size_t i; if (!vd) { return; } vd->is_unix = false; for (i = 0; i < vd->nlsock; i++) { if (vd->lsock_tag[i]) { g_source_remove(vd->lsock_tag[i]); } object_unref(OBJECT(vd->lsock[i])); } g_free(vd->lsock); g_free(vd->lsock_tag); vd->lsock = NULL; vd->lsock_tag = NULL; vd->n... |
1 | static int scsi_disk_emulate_command(SCSIDiskReq *r, uint8_t *outbuf){ SCSIRequest *req = &r->req; SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); uint64_t nb_sectors; int buflen = 0; int ret; switch (req->cmd.buf[0]) { case TEST_UNIT_READY: if (!bdrv_is_inserted(s->bs)) goto not_ready;break; case REQUEST_... |
1 | static int xen_init(MachineState *ms){ xen_xc = xen_xc_interface_open(0, 0, 0); if (xen_xc == XC_HANDLER_INITIAL_VALUE) { xen_be_printf(NULL, 0, "can't open xen interface\n"); qemu_add_vm_change_state_handler(xen_change_state_handler, NULL); global_state_set_optional(); savevm_skip_configuration(); savevm_skip_section_... |
1 | static void cpu_common_realizefn(DeviceState *dev, Error **errp){ CPUState *cpu = CPU(dev); if (dev->hotplugged) { cpu_synchronize_post_init(cpu); cpu_resume(cpu); }} |
1 | uint8_t sd_read_data(SDState *sd){ /* TODO: Append CRCs */ uint8_t ret; int io_len; if (!sd->blk || !blk_is_inserted(sd->blk) || !sd->enable) return 0x00; if (sd->state != sd_sendingdata_state) { qemu_log_mask(LOG_GUEST_ERROR, "sd_read_data: not in Sending-Data state\n"); return 0x00; } if (sd->card_status & (ADDRESS_E... |
1 | static av_always_inline int sbr_hf_apply_noise(int (*Y)[2], const SoftFloat *s_m, const SoftFloat *q_filt, int noise, int phi_sign0, int phi_sign1, int m_max){ int m; for (m = 0; m < m_max; m++) { int y0 = Y[m][0]; int y1 = Y[m][1]; noise = (noise + 1) & 0x1ff; if (s_m[m].mant) { int shift, round; shift = 22 - s_m[m].e... |
0 | int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, const H2645NAL *nal){ int i, j, ret = 0; int first_slice = sl == h->slice_ctx && !h->current_slice; ret = h264_slice_header_parse(h, sl, nal); if (ret < 0) return ret; if (sl->first_mb_addr == 0) { // FIXME better field boundary detection if (h->curr... |
0 | static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice, const DXVA_PicParams_H264 *pp, unsigned position, unsigned size){ const H264Context *h = avctx->priv_data; H264SliceContext *sl = &h->slice_ctx[0]; AVDXVAContext *ctx = avctx->hwaccel_context; unsigned list; memset(slice, 0, sizeof(*slice))... |
0 | static int dvdsub_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size){ DVDSubParseContext *pc = s->priv_data; if (pc->packet_index == 0) { if (buf_size < 2) return buf_size; pc->packet_len = AV_RB16(buf); if (pc->packet_len == 0) /* HD-DVD ... |
0 | static int kmvc_decode_inter_8x8(KmvcContext * ctx, int w, int h){ BitBuf bb; int res, val; int i, j; int bx, by; int l0x, l1x, l0y, l1y; int mx, my; kmvc_init_getbits(bb, &ctx->g); for (by = 0; by < h; by += 8) for (bx = 0; bx < w; bx += 8) { kmvc_getbit(bb, &ctx->g, res); if (!res) { kmvc_getbit(bb, &ctx->g, res); if... |
0 | static inline int16_t g726_iterate(G726Context* c, int16_t I){ int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0; Float11 f; dq = inverse_quant(c, I); if (I >> (c->tbls->bits - 1)) /* get the sign */ dq = -dq; re_signal = c->se + dq; /* Transition detect */ ylint = (c->yl >> 15); ylfrac = (c->yl >> 10) &... |
0 | static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header){ OMAContext *oc = s->priv_data; ID3v2ExtraMetaGEOB *geob = NULL; uint8_t *gdata; oc->encrypted = 1; av_log(s, AV_LOG_INFO, "File is encrypted\n"); /* find GEOB metadata */ while (em) { if (!strcmp(em->tag, "GEOB") && (geob = em->data) && (... |
0 | uint32_t avpriv_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id){ int i; for (i = 0; avpriv_fmt_conversion_table[i].codec_id != AV_CODEC_ID_NONE; i++) { if ((codec_id == AV_CODEC_ID_NONE || avpriv_fmt_conversion_table[i].codec_id == codec_id) && (pix_fmt == AV_PIX_FMT_NONE || avpriv_fmt_conversion_table[... |
0 | int avfilter_default_config_output_link(AVFilterLink *link){ if (link->src->input_count && link->src->inputs[0]) { if (link->type == AVMEDIA_TYPE_VIDEO) { link->w = link->src->inputs[0]->w; link->h = link->src->inputs[0]->h; link->time_base = link->src->inputs[0]->time_base; } else if (link->type == AVMEDIA_TYPE_AUDIO)... |
0 | static int mov_seek_stream(AVStream *st, int64_t timestamp, int flags){ MOVStreamContext *sc = st->priv_data; int sample, time_sample; int i; sample = av_index_search_timestamp(st, timestamp, flags); dprintf(st->codec, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample); if (sample < 0) /* not ... |
1 | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPADecodeContext *s = avctx->priv_data; uint32_t header; int ret; int skipped = 0; while(buf_size && !*buf){ buf++; buf_size--; skipped++; } if (buf_size < HEAD... |
1 | bool arp_table_search(Slirp *slirp, uint32_t ip_addr, uint8_t out_ethaddr[ETH_ALEN]){ const uint32_t broadcast_addr = ~slirp->vnetwork_mask.s_addr | slirp->vnetwork_addr.s_addr; ArpTable *arptbl = &slirp->arp_table; int i; DEBUG_CALL("arp_table_search"); DEBUG_ARG("ip = 0x%x", ip_addr); /* Check 0.0.0.0/8 invalid sourc... |
1 | void smc91c111_init(NICInfo *nd, uint32_t base, void *pic, int irq){ smc91c111_state *s; int iomemtype; s = (smc91c111_state *)qemu_mallocz(sizeof(smc91c111_state)); iomemtype = cpu_register_io_memory(0, smc91c111_readfn, smc91c111_writefn, s); cpu_register_physical_memory(base, 16, iomemtype); s->base = base; s->pic =... |
1 | void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y){ int cbpc, cbpy, pred_x, pred_y; PutBitContext *const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; PutBitContext *const tex_pb = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B ? &s->tex_pb : &s->pb; PutBitContext *... |
1 | static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1, const uint8_t *buf, int buf_size, int is_start){ MpegTSSectionFilter *tss = &tss1->u.section_filter; int len; if (is_start) { memcpy(tss->section_buf, buf, buf_size); tss->section_index = buf_size; tss->section_h_size = -1; tss->end_of_section_reache... |
1 | av_cold int ff_mpv_encode_init(AVCodecContext *avctx){ MpegEncContext *s = avctx->priv_data; int i, ret, format_supported; mpv_encode_defaults(s); switch (avctx->codec_id) { case AV_CODEC_ID_MPEG2VIDEO: if (avctx->pix_fmt != AV_PIX_FMT_YUV420P && avctx->pix_fmt != AV_PIX_FMT_YUV422P) { av_log(avctx, AV_LOG_ERROR, "only... |
0 | static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr, float X_high[64][40][2], const float X_low[32][40][2], const float (*alpha0)[2], const float (*alpha1)[2], const float bw_array[5], const uint8_t *t_env, int bs_num_env){ int i, j, x; int g = 0; int k = sbr->kx[1]; for (j = 0; j < sbr->num_patches; j++... |
0 | static int find_image_range(int *pfirst_index, int *plast_index, const char *path){ char buf[1024]; int range, last_index, range1, first_index; /* find the first image */ for(first_index = 0; first_index < 5; first_index++) { if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){ *pfirst_index = *plast_in... |
0 | av_cold void ff_MPV_common_init_x86(MpegEncContext *s){#if HAVE_INLINE_ASM int cpu_flags = av_get_cpu_flags(); if (cpu_flags & AV_CPU_FLAG_MMX) { s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_mmx; s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_mmx; s->dct_unquantize_mpeg1_intra = dct_unquantize_mpe... |
0 | static int mjpegb_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ MJpegDecodeContext *s = avctx->priv_data; uint8_t *buf_end, *buf_ptr; AVFrame *picture = data; GetBitContext hgb; /* for the header */ uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs; uint32... |
1 | AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c){ AVStream *st; int i; AVStream **streams; if (s->nb_streams >= INT_MAX/sizeof(*streams)) streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams)); if (!streams) s->streams = streams; st = av_mallocz(sizeof(AVStream)); if (!st) if (!(... |
1 | static void monitor_parse(const char *optarg, const char *mode){ static int monitor_device_index = 0; QemuOpts *opts; const char *p; char label[32]; int def = 0; if (strstart(optarg, "chardev:", &p)) { snprintf(label, sizeof(label), "%s", p); } else { snprintf(label, sizeof(label), "compat_monitor%d", monitor_device_in... |
1 | virtio_gpu_resource_attach_backing(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd){ struct virtio_gpu_simple_resource *res; struct virtio_gpu_resource_attach_backing ab; int ret; VIRTIO_GPU_FILL_CMD(ab); trace_virtio_gpu_cmd_res_back_attach(ab.resource_id); res = virtio_gpu_find_resource(g, ab.resource_id); if (!res... |
1 | static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm, qxl_async_io async){ QXLDevSurfaceCreate surface; QXLSurfaceCreate *sc = &qxl->guest_primary.surface; int size; int requested_height = le32_to_cpu(sc->height); int requested_stride = le32_to_cpu(sc->stride); size = abs(requested_stride) * requested_hei... |
1 | pp_mode *pp_get_mode_by_name_and_quality(const char *name, int quality){ char temp[GET_MODE_BUFFER_SIZE]; char *p= temp; static const char filterDelimiters[] = ",/"; static const char optionDelimiters[] = ":|"; struct PPMode *ppMode; char *filterToken; if (!name) { av_log(NULL, AV_LOG_ERROR, "pp: Missing argument\n"); ... |
1 | static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom){ AVStream *st; uint64_t size; uint8_t *buf; int err; if (c->fc->nb_streams < 1) // will happen with jp2 files return 0; st= c->fc->streams[c->fc->nb_streams-1]; size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING... |
1 | static always_inline void gen_bcond (DisasContext *ctx, int type){ uint32_t bo = BO(ctx->opcode); int l1 = gen_new_label(); TCGv target; ctx->exception = POWERPC_EXCP_BRANCH; if (type == BCOND_LR || type == BCOND_CTR) { target = tcg_temp_local_new(); if (type == BCOND_CTR) tcg_gen_mov_tl(target, cpu_ctr); else tcg_gen_... |
1 | void slavio_serial_ms_kbd_init(target_phys_addr_t base, qemu_irq irq, int disabled, int clock, int it_shift){ DeviceState *dev; SysBusDevice *s; dev = qdev_create(NULL, "escc"); qdev_prop_set_uint32(dev, "disabled", disabled); qdev_prop_set_uint32(dev, "frequency", clock); qdev_prop_set_uint32(dev, "it_shift", it_shift... |
1 | static int v9fs_receive_response(V9fsProxy *proxy, int type, int *status, void *response){ int retval; ProxyHeader header; struct iovec *reply = &proxy->in_iovec; *status = 0; reply->iov_len = 0; retval = socket_read(proxy->sockfd, reply->iov_base, PROXY_HDR_SZ); if (retval < 0) { return retval; } reply->iov_len = PROX... |
1 | static int nbd_opt_go(QIOChannel *ioc, const char *wantname, NBDExportInfo *info, Error **errp){ nbd_opt_reply reply; uint32_t len = strlen(wantname); uint16_t type; int error; char *buf; /* The protocol requires that the server send NBD_INFO_EXPORT with * a non-zero flags (at least NBD_FLAG_HAS_FLAGS must be set); so ... |
1 | AVResampleContext *swr_resample_init(AVResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){ double factor= FFMIN(out_rate * cutoff / in_rate, 1.0); int phase_count= 1<<phase_shift; if (!c || c->phase_shift != phase_shift || c->linear!=linear || c->factor != factor... |
1 | static void add_input_streams(OptionsContext *o, AVFormatContext *ic){ int i; for (i = 0; i < ic->nb_streams; i++) { AVStream *st = ic->streams[i]; AVCodecContext *dec = st->codec; InputStream *ist = av_mallocz(sizeof(*ist)); char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL; if (!ist) exit_program(1); GR... |
1 | static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt, int discard) { AviSynthContext *avs = s->priv_data; AVS_VideoFrame *frame; unsigned char *dst_p; const unsigned char *src_p; int n, i, plane, rowsize, planeheight, pitch, bits; const char *error; if (avs->curr_frame >= avs->vi->num_frames) return ... |
1 | static inline void out_reg(IVState *s, enum Reg reg, unsigned v){ const char *name = reg2str(reg); QTestState *qtest = global_qtest; global_qtest = s->qtest; g_test_message("%x -> *%s\n", v, name); qpci_io_writel(s->dev, s->reg_base + reg, v); global_qtest = qtest;} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.