static av_cold int init(AVFilterContext *ctx) { MPTestContext *test = ctx->priv; #ifdef IDE_COMPILE AVRational tmp; #endif #ifdef IDE_COMPILE tmp.num = 1; tmp.den = AV_TIME_BASE; test->max_pts = test->duration >= 0 ? av_rescale_q(test->duration, tmp, av_inv_q(test->frame_rate)) : -1; #else test->max_pts = test->duration >= 0 ? av_rescale_q(test->duration, AV_TIME_BASE_Q, av_inv_q(test->frame_rate)) : -1; #endif test->pts = 0; av_log(ctx, AV_LOG_VERBOSE, "rate:%d/%d duration:%f\n", test->frame_rate.num, test->frame_rate.den, test->duration < 0 ? -1 : test->max_pts * av_q2d(av_inv_q(test->frame_rate))); init_idct(); return 0; }
static av_cold int init(AVFilterContext *ctx) { MPTestContext *test = ctx->priv; test->max_pts = test->duration >= 0 ? av_rescale_q(test->duration, AV_TIME_BASE_Q, av_inv_q(test->frame_rate)) : -1; test->pts = 0; av_log(ctx, AV_LOG_VERBOSE, "rate:%d/%d duration:%f\n", test->frame_rate.num, test->frame_rate.den, test->duration < 0 ? -1 : test->max_pts * av_q2d(av_inv_q(test->frame_rate))); init_idct(); return 0; }
static av_cold void vp9dsp_itxfm_init_arm(VP9DSPContext *dsp) { int cpu_flags = av_get_cpu_flags(); if (have_neon(cpu_flags)) { #define init_itxfm(tx, sz) \ dsp->itxfm_add[tx][DCT_DCT] = ff_vp9_idct_idct_##sz##_add_neon; \ dsp->itxfm_add[tx][DCT_ADST] = ff_vp9_iadst_idct_##sz##_add_neon; \ dsp->itxfm_add[tx][ADST_DCT] = ff_vp9_idct_iadst_##sz##_add_neon; \ dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_neon #define init_idct(tx, nm) \ dsp->itxfm_add[tx][DCT_DCT] = \ dsp->itxfm_add[tx][ADST_DCT] = \ dsp->itxfm_add[tx][DCT_ADST] = \ dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_neon init_itxfm(TX_4X4, 4x4); init_itxfm(TX_8X8, 8x8); init_itxfm(TX_16X16, 16x16); init_idct(TX_32X32, idct_idct_32x32); init_idct(4, iwht_iwht_4x4); } }
int decode_scan(void) { #ifdef _JPEG_DEBUG printf("%d MCUs in total.\n", iceenv.num_mcu_x * iceenv.num_mcu_y); printf("MCU dimension: %dx%d\n", iceenv.max_samp_x << 3, iceenv.max_samp_y << 3); #endif // if (iceenv.scan_buffer[iceenv.buf_pos] == 0xFF && iceenv.scan_buffer[iceenv.buf_pos + 1] == 0x00) // skip_stuff_byte = 1; init_idct(); for (iceenv.cur_mcu_x = iceenv.cur_mcu_y = 0;;) { //printf("Decoding MCU [%d,%d]\n", iceenv.cur_mcu_x, iceenv.cur_mcu_y); decode_mcu(); iceenv.cur_mcu_x++; if (iceenv.cur_mcu_x == iceenv.num_mcu_x) { iceenv.cur_mcu_x = 0; iceenv.cur_mcu_y++; if (iceenv.cur_mcu_y == iceenv.num_mcu_y) break; } if (!iceenv.restart_interval) continue; iceenv.rstcount--; if (!iceenv.rstcount) { int err = process_rst(); if (err != ERR_OK) return err; } } //if (iceenv.cur_byte_remaining > 0) iceenv.buf_pos++; return ERR_OK; }
static av_cold void vp9dsp_itxfm_init_msa(VP9DSPContext *dsp, int bpp) { if (bpp == 8) { #define init_itxfm(tx, sz) \ dsp->itxfm_add[tx][DCT_DCT] = ff_idct_idct_##sz##_add_msa; \ dsp->itxfm_add[tx][DCT_ADST] = ff_iadst_idct_##sz##_add_msa; \ dsp->itxfm_add[tx][ADST_DCT] = ff_idct_iadst_##sz##_add_msa; \ dsp->itxfm_add[tx][ADST_ADST] = ff_iadst_iadst_##sz##_add_msa \ #define init_idct(tx, nm) \ dsp->itxfm_add[tx][DCT_DCT] = \ dsp->itxfm_add[tx][ADST_DCT] = \ dsp->itxfm_add[tx][DCT_ADST] = \ dsp->itxfm_add[tx][ADST_ADST] = nm##_add_msa init_itxfm(TX_4X4, 4x4); init_itxfm(TX_8X8, 8x8); init_itxfm(TX_16X16, 16x16); init_idct(TX_32X32, ff_idct_idct_32x32); #undef init_itxfm #undef init_idct } }
*/ void initdecoder() { int i, cc, size; /* clip table */ if (!(clp=(unsigned char *)malloc(1024))) error((char*)"malloc failed\n"); clp += 384; for (i=-384; i<640; i++) clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i); /* MPEG-1 = TMN parameters */ matrix_coefficients = 5; switch (source_format) { case (SF_SQCIF): horizontal_size = 128; vertical_size = 96; break; case (SF_QCIF): horizontal_size = 176; vertical_size = 144; break; case (SF_CIF): horizontal_size = 352; vertical_size = 288; break; case (SF_4CIF): horizontal_size = 704; vertical_size = 576; break; case (SF_16CIF): horizontal_size = 1408; vertical_size = 1152; break; default: myLog.WriteLog((char*)"initdecoder",(char*)"ERROR: Illegal input format"); return; break; } char slog[128]; sprintf(slog, "H.Size:%d V.Size:%d", horizontal_size, vertical_size); myLog.WriteLog((char*)"initdecoder",slog); mb_width = horizontal_size/16; mb_height = vertical_size/16; coded_picture_width = horizontal_size; coded_picture_height = vertical_size; chrom_width = coded_picture_width>>1; chrom_height = coded_picture_height>>1; blk_cnt = 6; int iSize1, iSize2; size = coded_picture_width*coded_picture_height; iSize1 = size; iSize2 = chrom_width*chrom_height; size += (iSize2*2); if (!(refframe[0] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); else{ unsigned char *p = refframe[0]; refframe[1] = p+iSize1; refframe[2] = p+iSize1+iSize2; } if (!(oldrefframe[0] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); else{ unsigned char *p = oldrefframe[0]; oldrefframe[1] = p+iSize1; oldrefframe[2] = p+iSize1+iSize2; } if (!(bframe[0] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); else{ unsigned char *p = bframe[0]; bframe[1] = p+iSize1; bframe[2] = p+iSize1+iSize2; } /* for (cc=0; cc<3; cc++) { // Find out size... if (cc==0) size = coded_picture_width*coded_picture_height; else size = chrom_width*chrom_height; // Allocate memory if (!(refframe[cc] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); if (!(oldrefframe[cc] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); if (!(bframe[cc] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); } */ for (cc=0; cc<3; cc++) { if (cc==0) { size = (coded_picture_width+64)*(coded_picture_height+64); if (!(edgeframeorig[cc] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); edgeframe[cc] = edgeframeorig[cc] + (coded_picture_width+64) * 32 + 32; } else { size = (chrom_width+32)*(chrom_height+32); if (!(edgeframeorig[cc] = (unsigned char *)malloc(size))) error((char*)"malloc failed\n"); edgeframe[cc] = edgeframeorig[cc] + (chrom_width+32) * 16 + 16; } } /* IDCT */ if (refidct) init_idctref(); else init_idct();
/** * Initialize decoder * * */ void initdecoder() { int i, cc, size; /* clip table */ if (!(clp=(unsigned char *)malloc(1024))) error("malloc failed\n"); clp += 384; for (i=-384; i<640; i++) clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i); /* MPEG-1 = TMN parameters */ matrix_coefficients = 5; switch (source_format) { case (SF_SQCIF): horizontal_size = 128; vertical_size = 96; break; case (SF_QCIF): horizontal_size = 176; vertical_size = 144; break; case (SF_CIF): horizontal_size = 352; vertical_size = 288; break; case (SF_4CIF): horizontal_size = 704; vertical_size = 576; break; case (SF_16CIF): horizontal_size = 1408; vertical_size = 1152; break; default: if(trace) fputs("ERROR: Illegal input format\n",dlog); return; break; } mb_width = horizontal_size/16; mb_height = vertical_size/16; coded_picture_width = horizontal_size; coded_picture_height = vertical_size; chrom_width = coded_picture_width>>1; chrom_height = coded_picture_height>>1; blk_cnt = 6; for (cc=0; cc<3; cc++) { // Find out size... if (cc==0) size = coded_picture_width*coded_picture_height; else size = chrom_width*chrom_height; // Allocate memory if (!(refframe[cc] = (unsigned char *)malloc(size))) error("malloc failed\n"); if (!(oldrefframe[cc] = (unsigned char *)malloc(size))) error("malloc failed\n"); if (!(bframe[cc] = (unsigned char *)malloc(size))) error("malloc failed\n"); } for (cc=0; cc<3; cc++) { if (cc==0) { size = (coded_picture_width+64)*(coded_picture_height+64); if (!(edgeframeorig[cc] = (unsigned char *)malloc(size))) error("malloc failed\n"); edgeframe[cc] = edgeframeorig[cc] + (coded_picture_width+64) * 32 + 32; } else { size = (chrom_width+32)*(chrom_height+32); if (!(edgeframeorig[cc] = (unsigned char *)malloc(size))) error("malloc failed\n"); edgeframe[cc] = edgeframeorig[cc] + (chrom_width+32) * 16 + 16; } } /* IDCT */ if (refidct) init_idctref(); else init_idct(); }
struct pipe_video_decoder * vl_create_mpeg12_decoder(struct pipe_context *context, enum pipe_video_profile profile, enum pipe_video_entrypoint entrypoint, enum pipe_video_chroma_format chroma_format, unsigned width, unsigned height, unsigned max_references, bool expect_chunked_decode) { const unsigned block_size_pixels = VL_BLOCK_WIDTH * VL_BLOCK_HEIGHT; const struct format_config *format_config; struct vl_mpeg12_decoder *dec; assert(u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12); dec = CALLOC_STRUCT(vl_mpeg12_decoder); if (!dec) return NULL; dec->base.context = context; dec->base.profile = profile; dec->base.entrypoint = entrypoint; dec->base.chroma_format = chroma_format; dec->base.width = width; dec->base.height = height; dec->base.max_references = max_references; dec->base.destroy = vl_mpeg12_destroy; dec->base.begin_frame = vl_mpeg12_begin_frame; dec->base.decode_macroblock = vl_mpeg12_decode_macroblock; dec->base.decode_bitstream = vl_mpeg12_decode_bitstream; dec->base.end_frame = vl_mpeg12_end_frame; dec->base.flush = vl_mpeg12_flush; dec->blocks_per_line = MAX2(util_next_power_of_two(dec->base.width) / block_size_pixels, 4); dec->num_blocks = (dec->base.width * dec->base.height) / block_size_pixels; dec->width_in_macroblocks = align(dec->base.width, VL_MACROBLOCK_WIDTH) / VL_MACROBLOCK_WIDTH; dec->expect_chunked_decode = expect_chunked_decode; /* TODO: Implement 422, 444 */ assert(dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420); if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) { dec->chroma_width = dec->base.width / 2; dec->chroma_height = dec->base.height / 2; dec->num_blocks = dec->num_blocks * 2; } else if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422) { dec->chroma_width = dec->base.width; dec->chroma_height = dec->base.height / 2; dec->num_blocks = dec->num_blocks * 2 + dec->num_blocks; } else { dec->chroma_width = dec->base.width; dec->chroma_height = dec->base.height; dec->num_blocks = dec->num_blocks * 3; } dec->quads = vl_vb_upload_quads(dec->base.context); dec->pos = vl_vb_upload_pos( dec->base.context, dec->base.width / VL_MACROBLOCK_WIDTH, dec->base.height / VL_MACROBLOCK_HEIGHT ); dec->ves_ycbcr = vl_vb_get_ves_ycbcr(dec->base.context); dec->ves_mv = vl_vb_get_ves_mv(dec->base.context); switch (entrypoint) { case PIPE_VIDEO_ENTRYPOINT_BITSTREAM: format_config = find_format_config(dec, bitstream_format_config, num_bitstream_format_configs); break; case PIPE_VIDEO_ENTRYPOINT_IDCT: format_config = find_format_config(dec, idct_format_config, num_idct_format_configs); break; case PIPE_VIDEO_ENTRYPOINT_MC: format_config = find_format_config(dec, mc_format_config, num_mc_format_configs); break; default: assert(0); FREE(dec); return NULL; } if (!format_config) { FREE(dec); return NULL; } if (!init_zscan(dec, format_config)) goto error_zscan; if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { if (!init_idct(dec, format_config)) goto error_sources; } else { if (!init_mc_source_widthout_idct(dec, format_config)) goto error_sources; } if (!vl_mc_init(&dec->mc_y, dec->base.context, dec->base.width, dec->base.height, VL_MACROBLOCK_HEIGHT, format_config->mc_scale, mc_vert_shader_callback, mc_frag_shader_callback, dec)) goto error_mc_y; // TODO if (!vl_mc_init(&dec->mc_c, dec->base.context, dec->base.width, dec->base.height, VL_BLOCK_HEIGHT, format_config->mc_scale, mc_vert_shader_callback, mc_frag_shader_callback, dec)) goto error_mc_c; if (!init_pipe_state(dec)) goto error_pipe_state; return &dec->base; error_pipe_state: vl_mc_cleanup(&dec->mc_c); error_mc_c: vl_mc_cleanup(&dec->mc_y); error_mc_y: if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { vl_idct_cleanup(&dec->idct_y); vl_idct_cleanup(&dec->idct_c); dec->idct_source->destroy(dec->idct_source); } dec->mc_source->destroy(dec->mc_source); error_sources: vl_zscan_cleanup(&dec->zscan_y); vl_zscan_cleanup(&dec->zscan_c); error_zscan: FREE(dec); return NULL; }
int InitH263Encoder(CParam *params) { Global.pic = (Pict *)malloc(sizeof(Pict)); if(!Global.pic) { return -1; } Global.pic->unrestricted_mv_mode = DEF_UMV_MODE; Global.pic->use_gobsync = DEF_INSERT_SYNC; Global.pic->PB = 0; Global.pic->TR = 0; Global.pic->QP_mean = 0.0; if(params->format == CPARAM_QCIF) { Global.pels = QCIF_YWIDTH; Global.lines = QCIF_YHEIGHT; Global.cpels = QCIF_YWIDTH/2; Global.pic->source_format = SF_QCIF; } else if (params->format == CPARAM_CIF) { Global.pels = CIF_YWIDTH; Global.lines = CIF_YHEIGHT; Global.cpels = CIF_YWIDTH/2; Global.pic->source_format = SF_CIF; } else if (params->format == CPARAM_SQCIF) { Global.pels = SQCIF_YWIDTH; Global.lines = SQCIF_YHEIGHT; Global.cpels = SQCIF_YWIDTH/2; Global.pic->source_format = SF_SQCIF; } else if (params->format == CPARAM_4CIF) { Global.pels = CIF4_YWIDTH; Global.lines = CIF4_YHEIGHT; Global.cpels = CIF4_YWIDTH/2; Global.pic->source_format = SF_4CIF; } else if (params->format == CPARAM_16CIF) { Global.pels = CIF16_YWIDTH; Global.lines = CIF16_YHEIGHT; Global.cpels = CIF16_YWIDTH/2; Global.pic->source_format = SF_16CIF; } else { Global.pels = params->pels; Global.lines = params->lines; Global.cpels = params->pels / 2; Global.pic->source_format = 0; /* ILLEGAL H.263! Use it only for testing */ } Global.mbr = Global.lines / MB_SIZE; Global.mbc = Global.pels / MB_SIZE; Global.uskip = Global.lines*Global.pels; Global.vskip = Global.uskip + Global.lines*Global.pels/4; Global.sizeof_frame = (Global.vskip + Global.lines*Global.pels/4)*sizeof(int); Global.headerlength = DEF_HEADERLENGTH; /* Initalize VLC_tables */ InitHuff(); mwinit(); /* Init motion detection */ init_motion_detection(); #ifdef VERYFASTIDCT init_idct(); /* Do this in case of VERYFASTIDCT */ #elif STANDARDIDCT init_idctref(); /* Do this in case of standard IDCT */ #endif /* Do nothing for FASTIDCT */ /* Set internal variables */ Global.advanced = DEF_ADV_MODE; Global.mv_outside_frame = DEF_UMV_MODE || DEF_ADV_MODE; Global.long_vectors = DEF_UMV_MODE; Global.pb_frames = DEF_PBF_MODE; Global.search_p_frames = DEF_SPIRAL_SEARCH; Global.trace = DEF_WRITE_TRACE; params->half_pixel_searchwindow = CPARAM_DEFAULT_SEARCHWINDOW; params->inter = CPARAM_DEFAULT_INTER; params->search_method = CPARAM_DEFAULT_SEARCH_METHOD; params->advanced_method = CPARAM_DEFAULT_ADVANCED_METHOD; params->Q_inter = CPARAM_DEFAULT_INTER_Q; params->Q_intra = CPARAM_DEFAULT_INTRA_Q; params->interpolated_lum = (unsigned int*)malloc(Global.pels*Global.lines*4*sizeof(int)); if(!params->interpolated_lum) return -1; params->recon =(unsigned int*) malloc(Global.sizeof_frame); if(!params->recon) { free(params->interpolated_lum); free(Global.pic); return -1; } return 0; }
static void init() { int i, n, size; static int block_count_tab[3] = {6,8,12}; int lum_buffer_size, chrom_buffer_size; pthread_mutexattr_t mutex_attr; pthread_mutexattr_init(&mutex_attr); pthread_mutex_init(&test_lock, &mutex_attr); bzero(&cur_picture, sizeof(pict_data_s)); mpeg2_initbits(); init_fdct(); init_idct(); init_motion(); init_predict_hv(); init_quantizer_hv(); init_transform_hv(); /* round picture dimensions to nZearest multiple of 16 or 32 */ mb_width = (horizontal_size+15)/16; mb_height = prog_seq ? (vertical_size + 15) / 16 : 2 * ((vertical_size + 31) / 32); mb_height2 = fieldpic ? mb_height >> 1 : mb_height; /* for field pictures */ width = 16 * mb_width; height = 16 * mb_height; chrom_width = (chroma_format==CHROMA444) ? width : width>>1; chrom_height = (chroma_format!=CHROMA420) ? height : height>>1; height2 = fieldpic ? height>>1 : height; width2 = fieldpic ? width<<1 : width; chrom_width2 = fieldpic ? chrom_width<<1 : chrom_width; block_count = block_count_tab[chroma_format-1]; lum_buffer_size = (width*height) + sizeof(uint8_t) *(width/2)*(height/2) + sizeof(uint8_t) *(width/4)*(height/4+1); chrom_buffer_size = chrom_width*chrom_height; fsubsample_offset = (width)*(height) * sizeof(uint8_t); qsubsample_offset = fsubsample_offset + (width/2)*(height/2)*sizeof(uint8_t); rowsums_offset = 0; colsums_offset = 0; mb_per_pict = mb_width*mb_height2; /* clip table */ if (!(clp = (unsigned char *)malloc(1024))) error("malloc failed\n"); clp+= 384; for (i=-384; i<640; i++) clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i); /* Allocate the frame buffer */ frame_buffers = (uint8_t ***) bufalloc(2*READ_LOOK_AHEAD*sizeof(uint8_t**)); for(n=0;n<2*READ_LOOK_AHEAD;n++) { frame_buffers[n] = (uint8_t **) bufalloc(3*sizeof(uint8_t*)); for (i=0; i<3; i++) { frame_buffers[n][i] = bufalloc( (i==0) ? lum_buffer_size : chrom_buffer_size ); } } /* TODO: The ref and aux frame buffers are no redundant! */ for( i = 0 ; i<3; i++) { int size = (i==0) ? lum_buffer_size : chrom_buffer_size; newrefframe[i] = bufalloc(size); oldrefframe[i] = bufalloc(size); auxframe[i] = bufalloc(size); predframe[i] = bufalloc(size); } cur_picture.qblocks = (int16_t (*)[64])bufalloc(mb_per_pict*block_count*sizeof(int16_t [64])); /* Initialise current transformed picture data tables These will soon become a buffer for transformed picture data to allow look-ahead for bit allocation etc. */ cur_picture.mbinfo = ( struct mbinfo *)bufalloc(mb_per_pict*sizeof(struct mbinfo)); cur_picture.blocks = (int16_t (*)[64])bufalloc(mb_per_pict * block_count * sizeof(int16_t [64])); /* open statistics output file */ if(statname[0]=='-') statfile = stdout; else if(!(statfile = fopen(statname,"w"))) { sprintf(errortext,"Couldn't create statistics output file %s",statname); error(errortext); } ratectl = malloc(processors * sizeof(ratectl_t*)); for(i = 0; i < processors; i++) ratectl[i] = calloc(1, sizeof(ratectl_t)); /* Start parallel threads */ //printf("init 1\n"); start_motion_engines(); //printf("init 2\n"); start_transform_engines(); //printf("init 3\n"); start_itransform_engines(); //printf("init 4\n"); start_slice_engines(); //printf("init 5\n"); }