开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
lencod.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：53k
源码类别：

Audio

开发平台：

Visual C++

lencod.c：源码内容
  1. /*!
  2.  ***********************************************************************
  3.  *  mainpage
  4.  *     This is the H.264/AVC encoder reference software. For detailed documentation
  5.  *     see the comments in each file.
  6.  *
  7.  *     The JM software web site is located at:
  8.  *     http://iphome.hhi.de/suehring/tml
  9.  *
  10.  *     For bug reporting and known issues see:
  11.  *     https://ipbt.hhi.de
  12.  *
  13.  *  author
  14.  *     The main contributors are listed in contributors.h
  15.  *
  16.  *  version
  17.  *     JM 14.2 (FRExt)
  18.  *
  19.  *  note
  20.  *     tags are used for document system "doxygen"
  21.  *     available at http://www.doxygen.org
  22.  */
  23. /*!
  24.  *  file
  25.  *     lencod.c
  26.  *  brief
  27.  *     H.264/AVC reference encoder project main()
  28.  *  author
  29.  *   Main contributors (see contributors.h for copyright, address and affiliation details)
  30.  *   - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
  31.  *   - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  32.  *   - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  33.  *   - Jani Lainema                    <jani.lainema@nokia.com>
  34.  *   - Byeong-Moon Jeon                <jeonbm@lge.com>
  35.  *   - Yoon-Seong Soh                  <yunsung@lge.com>
  36.  *   - Thomas Stockhammer              <stockhammer@ei.tum.de>
  37.  *   - Detlev Marpe                    <marpe@hhi.de>
  38.  *   - Guido Heising
  39.  *   - Valeri George                   <george@hhi.de>
  40.  *   - Karsten Suehring                <suehring@hhi.de>
  41.  *   - Alexis Michael Tourapis         <alexismt@ieee.org>
  42.  ***********************************************************************
  43.  */
  45. #include "contributors.h"
  47. #include <time.h>
  48. #include <math.h>
  49. #include <sys/timeb.h>
  50. #include "global.h"
  52. #include "cconv_yuv2rgb.h"
  53. #include "configfile.h"
  54. #include "context_ini.h"
  55. #include "explicit_gop.h"
  56. #include "filehandle.h"
  57. #include "image.h"
  58. #include "input.h"
  59. #include "slice.h"
  60. #include "intrarefresh.h"
  61. #include "leaky_bucket.h"
  62. #include "memalloc.h"
  63. #include "me_epzs.h"
  64. #include "me_umhex.h"
  65. #include "me_umhexsmp.h"
  66. #include "output.h"
  67. #include "parset.h"
  68. #include "q_matrix.h"
  69. #include "q_offsets.h"
  70. #include "ratectl.h"
  71. #include "report.h"
  72. #include "rdoq.h"
  73. #include "errdo.h"
  74. #include "rdopt.h"
  75. #include "wp_mcprec.h"
  77. InputParameters  inputs, *params = &inputs;
  78. ImageParameters  images, *img    = &images;
  79. Decoders       decoders, *decs   = &decoders;
  81. #ifdef _ADAPT_LAST_GROUP_
  82. int initial_Bframes = 0;
  83. #endif
  85. Boolean In2ndIGOP = FALSE;
  86. int    start_frame_no_in_this_IGOP = 0;
  87. int    start_tr_in_this_IGOP = 0;
  88. int    FirstFrameIn2ndIGOP=0;
  89. int    cabac_encoding = 0;
  90. int    frame_statistic_start;
  91. extern ColocatedParams *Co_located;
  92. extern ColocatedParams *Co_located_JV[MAX_PLANE];  //!< Co_located to be used during 4:4:4 independent mode encoding
  93. extern double *mb16x16_cost_frame;
  94. extern int FrameNumberInFile;
  96. extern void Init_Motion_Search_Module (void);
  97. extern void Clear_Motion_Search_Module (void);
  99. static void SetImgType(void);
  100. void SetLevelIndices(void);
  101. void chroma_mc_setup(void);
  102. int  get_mem_mv  (short*******);
  103. int  get_mem_bipred_mv (short********);
  104. void free_mem_bipred_mv (short*******);
  105. void free_mem_mv (short******);
  106. static void init_img( ImageParameters *img, InputParameters *params);
  107. static void init_poc(void);
  109. void init_stats (StatParameters *stats)
  110. {
  111.   memset(stats, 0, sizeof(StatParameters));
  112.   stats->successive_Bframe = params->successive_Bframe;
  113. }
  115. void init_dstats (DistortionParams *dist)
  116. {
  117.   dist->frame_ctr = 0;
  118.   memset(dist->metric, 0, TOTAL_DIST_TYPES * sizeof(DistMetric));
  119. }
  121. /*!
  122.  ***********************************************************************
  123.  * brief
  124.  *    Initialize encoding parameters.
  125.  ***********************************************************************
  126.  */
  127. void init_frame_params()
  128. {
  129.   int base_mul = 0;
  131.   if (params->idr_period)
  132.   {
  133.     if (!params->adaptive_idr_period && ( img->frm_number - img->lastIDRnumber ) % params->idr_period == 0 )
  134.       img->nal_reference_idc = NALU_PRIORITY_HIGHEST;
  136.     if (params->adaptive_idr_period == 1 && ( img->frm_number - imax(img->lastIntraNumber, img->lastIDRnumber) ) % params->idr_period == 0 )
  137.       img->nal_reference_idc = NALU_PRIORITY_HIGHEST;
  138.     else
  139.       img->nal_reference_idc = (params->DisposableP) ? (img->frm_number + 1)% 2 : NALU_PRIORITY_LOW;
  140.   }
  141.   else
  142.     img->nal_reference_idc = (img->frm_number && params->DisposableP) ? (img->frm_number + 1)% 2 : NALU_PRIORITY_LOW;
  144.   //much of this can go in init_frame() or init_field()?
  145.   //poc for this frame or field
  146.   if (params->idr_period)
  147.   {
  148.     if (!params->adaptive_idr_period)
  149.       base_mul = ( img->frm_number - img->lastIDRnumber ) % params->idr_period;
  150.     else if (params->adaptive_idr_period == 1)
  151.       base_mul = (( img->frm_number - imax(img->lastIntraNumber, img->lastIDRnumber) ) % params->idr_period == 0) ? 0 : ( img->frm_number - img->lastIDRnumber );
  152.   }
  153.   else 
  154.     base_mul = ( img->frm_number - img->lastIDRnumber );
  156.   if ((img->frm_number - img->lastIDRnumber) <= params->intra_delay)
  157.   {    
  158.     base_mul = -base_mul;
  159.   }
  160.   else
  161.   {
  162.     base_mul -= ( base_mul ? params->intra_delay :  0);    
  163.   }
  165.   img->toppoc = base_mul * (2 * (params->jumpd + 1));
  167.   if ((params->PicInterlace==FRAME_CODING) && (params->MbInterlace==FRAME_CODING))
  168.     img->bottompoc = img->toppoc;     //progressive
  169.   else
  170.     img->bottompoc = img->toppoc + 1;   //hard coded
  172.   img->framepoc = imin (img->toppoc, img->bottompoc);
  174.   //the following is sent in the slice header
  175.   img->delta_pic_order_cnt[0] = 0;
  177.   if ((params->BRefPictures == 1) && (img->frm_number))
  178.   {
  179.     img->delta_pic_order_cnt[0] = +2 * params->successive_Bframe;
  180.   }  
  181. }
  183. /*!
  184.  ***********************************************************************
  185.  * brief
  186.  *    Main function for encoder.
  187.  * param argc
  188.  *    number of command line arguments
  189.  * param argv
  190.  *    command line arguments
  191.  * return
  192.  *    exit code
  193.  ***********************************************************************
  194.  */
  195. int main(int argc,char **argv)
  196. {
  197.   int primary_disp = 0;
  198.   giRDOpt_B8OnlyFlag = 0;
  200.   p_dec = p_in = -1;
  202.   p_log = p_trace = NULL;
  204.   frame_statistic_start = 1;
  206.   Configure (argc, argv);
  208.   Init_QMatrix();
  209.   Init_QOffsetMatrix();
  211.   init_poc();
  212.   GenerateParameterSets();
  213.   SetLevelIndices();
  215.   init_img(img, params);
  217.   init_rdopt(params);
  219.   if (params->rdopt == 3)
  220.   {
  221.     init_error_conceal(params->ErrorConcealment); 
  222.   }
  224. #ifdef _LEAKYBUCKET_
  225.   Bit_Buffer = malloc((params->no_frames * (params->successive_Bframe + 1) + 1) * sizeof(long));
  226. #endif
  228.   // Prepare hierarchical coding structures. 
  229.   // Code could be extended in the future to allow structure adaptation.
  230.   if (params->HierarchicalCoding)
  231.   {
  232.     init_gop_structure();
  233.     if (params->successive_Bframe && params->HierarchicalCoding == 3)
  234.       interpret_gop_structure();
  235.     else
  236.       create_hierarchy();
  237.   }
  239.   dpb.init_done = 0;
  240.   init_dpb();
  241.   init_out_buffer();
  242.   init_stats (stats);
  243.   init_dstats(dist);
  245.   enc_picture = NULL;
  247.   init_global_buffers();
  249.   if ( params->WPMCPrecision )
  250.   {
  251.     wpxInitWPXPasses(params);
  252.   }
  254.   create_context_memory ();
  255.   Init_Motion_Search_Module ();
  256.   information_init(img, params, stats);
  258.   if(params->DistortionYUVtoRGB)
  259.     init_YUVtoRGB();
  261.   //Rate control
  262.   if (params->RCEnable)
  263.     rc_init_sequence();
  265.   img->last_valid_reference = 0;
  266.   tot_time = 0;                 // time for total encoding session
  268. #ifdef _ADAPT_LAST_GROUP_
  269.   if (params->last_frame > 0)
  270.     params->no_frames = 1 + (params->last_frame + params->jumpd) / (params->jumpd + 1);
  271.   initial_Bframes = params->successive_Bframe;
  272. #endif
  274.   PatchInputNoFrames();
  276.   // Write sequence header (with parameter sets)
  277.   stats->bit_ctr_parametersets = 0;
  278.   stats->bit_slice = start_sequence();
  279.   stats->bit_ctr_parametersets += stats->bit_ctr_parametersets_n;
  280.   start_frame_no_in_this_IGOP = 0;
  282.   if (params->UseRDOQuant)
  283.     precalculate_unary_exp_golomb_level();
  285.   for (img->number=0; img->number < params->no_frames; img->number++)
  286.   {
  287.     img->frm_number = img->number;    
  288.     FrameNumberInFile = CalculateFrameNumber();
  289.     SetImgType();
  290.     init_frame_params();
  292.     if (img->last_ref_idc)
  293.     {
  294.       img->frame_num++;                 //increment frame_num once for B-frames
  295.       img->frame_num %= max_frame_num;
  296.     }
  298.     //frame_num for this frame
  299.     if (params->idr_period && ((!params->adaptive_idr_period && ( img->frm_number - img->lastIDRnumber ) % params->idr_period == 0)
  300.       || (params->adaptive_idr_period == 1 && ( img->frm_number - imax(img->lastIntraNumber, img->lastIDRnumber) ) % params->idr_period == 0)) )
  301.     {
  302.       img->frame_num = 0;
  303.       primary_disp   = 0;   
  304.     }
  306.     if (params->ResendSPS == 1 && img->type == I_SLICE && img->frm_number != 0)
  307.     {
  308.       stats->bit_slice = rewrite_paramsets();
  309.       stats->bit_ctr_parametersets += stats->bit_ctr_parametersets_n;
  310.     }
  312. #ifdef _ADAPT_LAST_GROUP_
  313.     if (params->successive_Bframe && params->last_frame && (IMG_NUMBER + 1) == params->no_frames)
  314.     {
  315.       int bi = (int)((float)(params->jumpd + 1)/(params->successive_Bframe + 1.0) + 0.499999);
  317.       params->successive_Bframe = ((params->last_frame - (img->frm_number - 1)*(params->jumpd + 1)) / bi) - 1;
  319.       //about to code the last ref frame, adjust delta poc
  320.       img->delta_pic_order_cnt[0]= -2*(initial_Bframes - params->successive_Bframe);
  321.       img->toppoc    += img->delta_pic_order_cnt[0];
  322.       img->bottompoc += img->delta_pic_order_cnt[0];
  323.       img->framepoc   = imin (img->toppoc, img->bottompoc);
  324.     }
  325. #endif
  327.     //Rate control
  328.     if (params->RCEnable && img->type == I_SLICE)
  329.       rc_init_gop_params();
  331.     // which layer does the image belong to?
  332.     img->layer = (IMG_NUMBER % (params->NumFramesInELSubSeq + 1)) ? 0 : 1;
  334.     // redundant frame initialization and allocation
  335.     if (params->redundant_pic_flag)
  336.     {
  337.       Init_redundant_frame();
  338.       Set_redundant_frame();
  339.     }
  341.     encode_one_frame(); // encode one I- or P-frame
  343.     img->last_ref_idc = img->nal_reference_idc ? 1 : 0;
  345.     // if key frame is encoded, encode one redundant frame
  346.     if (params->redundant_pic_flag && key_frame)
  347.     {
  348.       encode_one_redundant_frame();
  349.     }
  351.     if (img->type == I_SLICE && params->EnableOpenGOP)
  352.       img->last_valid_reference = img->ThisPOC;
  354.     if (params->ReportFrameStats)
  355.       report_frame_statistic();
  357.     if (img->nal_reference_idc == 0)
  358.     {
  359.       primary_disp ++;
  360.     }
  362.     if (img->currentPicture->idr_flag)
  363.     {
  364.       img->idr_gop_number = 0;
  365.     }
  366.     else
  367.       img->idr_gop_number ++;
  369.     encode_enhancement_layer();    
  370.   }
  371.   // terminate sequence
  372.   free_encoder_memory(img);
  374.   return 0;
  375. }
  378. void free_encoder_memory(ImageParameters *img)
  379. {
  380.   int nplane;
  381.   terminate_sequence();
  383.   flush_dpb();
  385.   close(p_in);
  386.   if (-1 != p_dec)
  387.     close(p_dec);
  388.   if (p_trace)
  389.     fclose(p_trace);
  391.   Clear_Motion_Search_Module ();
  393.   RandomIntraUninit();
  394.   FmoUninit();
  396.   if (params->HierarchicalCoding)
  397.     clear_gop_structure ();
  399.   // free structure for rd-opt. mode decision
  400.   clear_rdopt (params);
  402. #ifdef _LEAKYBUCKET_
  403.   calc_buffer();
  404. #endif
  406.   // report everything
  407.   report(img, params, stats);
  409. #ifdef _LEAKYBUCKET_
  410.   if (Bit_Buffer)
  411.     free(Bit_Buffer);
  412. #endif
  414.   free_dpb();
  416.   if( IS_INDEPENDENT(params) )
  417.   {
  418.     for( nplane=0; nplane<MAX_PLANE; nplane++ )
  419.     {
  420.       free_colocated(Co_located_JV[nplane]);
  421.     }
  422.   }
  423.   else
  424.   {
  425.     free_colocated(Co_located);
  426.   }
  428.   uninit_out_buffer();
  430.   free_global_buffers();
  432.   // free image mem
  433.   free_img ();
  434.   free_context_memory ();
  435.   FreeParameterSets();
  436. }
  438. /*!
  439.  ***********************************************************************
  440.  * brief
  441.  *    Initializes the POC structure with appropriate parameters.
  442.  *
  443.  ***********************************************************************
  444.  */
  445. void init_poc()
  446. {
  447.   //the following should probably go in sequence parameters
  448.   // frame poc's increase by 2, field poc's by 1
  450.   img->pic_order_cnt_type=params->pic_order_cnt_type;
  452.   img->delta_pic_order_always_zero_flag = FALSE;
  453.   img->num_ref_frames_in_pic_order_cnt_cycle= 1;
  455.   if (params->BRefPictures == 1)
  456.   {
  457.     img->offset_for_non_ref_pic  =  0;
  458.     img->offset_for_ref_frame[0] =  2;
  459.   }
  460.   else
  461.   {
  462.     img->offset_for_non_ref_pic  = -2*(params->successive_Bframe);
  463.     img->offset_for_ref_frame[0] =  2*(params->successive_Bframe + 1);
  464.   }
  466.   if ((params->PicInterlace==FRAME_CODING) && (params->MbInterlace==FRAME_CODING))
  467.   {
  468.     img->offset_for_top_to_bottom_field = 0;
  469.     img->pic_order_present_flag = FALSE;
  470.     img->delta_pic_order_cnt_bottom = 0;
  471.   }
  472.   else
  473.   {
  474.     img->offset_for_top_to_bottom_field = 1;
  475.     img->pic_order_present_flag = TRUE;
  476.     img->delta_pic_order_cnt_bottom = 1;
  477.   }
  478. }
  481. /*!
  482.  ***********************************************************************
  483.  * brief
  484.  *    Initializes the img->nz_coeff
  485.  * par Input:
  486.  *    none
  487.  * par  Output:
  488.  *    none
  489.  *  side effects
  490.  *    sets omg->nz_coef[][][][] to -1
  491.  ***********************************************************************
  492.  */
  493. void CAVLC_init(void)
  494. {
  495.   unsigned int i, k, l;
  497.   for (i = 0; i < img->PicSizeInMbs; i++)
  498.     for (k = 0; k < 4; k++)
  499.       for (l = 0; l < (4 + (unsigned int)img->num_blk8x8_uv); l++)
  500.         img->nz_coeff[i][k][l] = 0;
  501. }
  504. /*!
  505.  ***********************************************************************
  506.  * brief
  507.  *    Initializes the Image structure with appropriate parameters.
  508.  * par Input:
  509.  *    Input Parameters struct inp_par *inp
  510.  * par  Output:
  511.  *    Image Parameters ImageParameters *img
  512.  ***********************************************************************
  513.  */
  514. static void init_img( ImageParameters *img, InputParameters *params)
  515. {
  516.   int i, j;
  517.   int byte_abs_range;
  519.   static int mb_width_cr[4] = {0,8, 8,16};
  520.   static int mb_height_cr[4]= {0,8,16,16};
  522.   // Color format
  523.   img->yuv_format = params->yuv_format;
  524.   img->P444_joined = (img->yuv_format == YUV444 && !IS_INDEPENDENT(params));  
  526.   //pel bitdepth init
  527.   img->bitdepth_luma            = params->output.bit_depth[0];
  528.   img->bitdepth_scale[0]        = 1 << (img->bitdepth_luma - 8);
  529.   img->bitdepth_lambda_scale    = 2 * (img->bitdepth_luma - 8);
  530.   img->bitdepth_luma_qp_scale   = 3 *  img->bitdepth_lambda_scale;
  531.   img->dc_pred_value_comp[0]    =  1<<(img->bitdepth_luma - 1);
  532.   img->max_imgpel_value_comp[0] = (1<<img->bitdepth_luma) - 1;
  533.   img->max_imgpel_value_comp_sq[0] = img->max_imgpel_value_comp[0] * img->max_imgpel_value_comp[0];
  535.   img->dc_pred_value            = img->dc_pred_value_comp[0]; // set defaults
  536.   img->max_imgpel_value         = img->max_imgpel_value_comp[0];
  537.   img->mb_size[0][0]            = img->mb_size[0][1] = MB_BLOCK_SIZE;
  539.   // Initialization for RC QP parameters (could be placed in ratectl.c)
  540.   img->RCMinQP                = params->RCMinQP[P_SLICE];
  541.   img->RCMaxQP                = params->RCMaxQP[P_SLICE];
  543.   // Set current residue & prediction array pointers
  544.   img->curr_res = img->mb_rres[0];
  545.   img->curr_prd = img->mb_pred[0];
  547.   if (img->yuv_format != YUV400)
  548.   {
  549.     img->bitdepth_chroma          = params->output.bit_depth[1];
  550.     img->bitdepth_scale[1]        = 1 << (img->bitdepth_chroma - 8);
  551.     img->dc_pred_value_comp[1]    = 1<<(img->bitdepth_chroma - 1);
  552.     img->dc_pred_value_comp[2]    = img->dc_pred_value_comp[1];
  553.     img->max_imgpel_value_comp[1] = (1<<img->bitdepth_chroma) - 1;
  554.     img->max_imgpel_value_comp[2] = img->max_imgpel_value_comp[1];
  555.     img->max_imgpel_value_comp_sq[1] = img->max_imgpel_value_comp[1] * img->max_imgpel_value_comp[1];
  556.     img->max_imgpel_value_comp_sq[2] = img->max_imgpel_value_comp[2] * img->max_imgpel_value_comp[2];
  557.     img->num_blk8x8_uv            = (1<<img->yuv_format)&(~(0x1));
  558.     img->num_cdc_coeff            = img->num_blk8x8_uv << 1;
  560.     img->mb_size[1][0] = img->mb_size[2][0] = img->mb_cr_size_x = (img->yuv_format == YUV420 || img->yuv_format == YUV422) ? 8 : 16;
  561.     img->mb_size[1][1] = img->mb_size[2][1] = img->mb_cr_size_y = (img->yuv_format == YUV444 || img->yuv_format == YUV422) ? 16 : 8;
  563.     img->bitdepth_chroma_qp_scale = 6*(img->bitdepth_chroma - 8);
  565.     img->chroma_qp_offset[0] = active_pps->cb_qp_index_offset;
  566.     img->chroma_qp_offset[1] = active_pps->cr_qp_index_offset;
  567.   }
  568.   else
  569.   {
  570.     img->bitdepth_chroma     = 0;
  571.     img->bitdepth_scale[1]   = 0;
  572.     img->max_imgpel_value_comp[1] = 0;
  573.     img->max_imgpel_value_comp[2] = img->max_imgpel_value_comp[1];
  574.     img->max_imgpel_value_comp_sq[1] = img->max_imgpel_value_comp[1] * img->max_imgpel_value_comp[1];
  575.     img->max_imgpel_value_comp_sq[2] = img->max_imgpel_value_comp[2] * img->max_imgpel_value_comp[2];
  576.     img->num_blk8x8_uv       = 0;
  577.     img->num_cdc_coeff       = 0;
  578.     img->mb_size[1][0] = img->mb_size[2][0] = img->mb_cr_size_x = 0;
  579.     img->mb_size[1][1] = img->mb_size[2][1] = img->mb_cr_size_y = 0;
  581.     img->bitdepth_chroma_qp_scale = 0;
  582.     img->bitdepth_chroma_qp_scale = 0;
  584.     img->chroma_qp_offset[0] = 0;
  585.     img->chroma_qp_offset[1] = 0;
  586.   }  
  588.   //img->pic_unit_size_on_disk = (imax(img->bitdepth_luma , img->bitdepth_chroma) > 8) ? 16 : 8;
  589.   img->pic_unit_size_on_disk = (imax(params->source.bit_depth[0], params->source.bit_depth[1]) > 8) ? 16 : 8;
  590.   img->out_unit_size_on_disk = (imax(params->output.bit_depth[0], params->output.bit_depth[1]) > 8) ? 16 : 8;
  592.   img->max_bitCount =  128 + 256 * img->bitdepth_luma + 2 * img->mb_cr_size_y * img->mb_cr_size_x * img->bitdepth_chroma;
  593.   //img->max_bitCount =  (128 + 256 * img->bitdepth_luma + 2 *img->mb_cr_size_y * img->mb_cr_size_x * img->bitdepth_chroma)*2;
  595.   img->max_qp_delta = (25 + (img->bitdepth_luma_qp_scale>>1));
  596.   img->min_qp_delta = img->max_qp_delta + 1;
  598.   img->num_ref_frames = active_sps->num_ref_frames;
  599.   img->max_num_references   = active_sps->frame_mbs_only_flag ? active_sps->num_ref_frames : 2 * active_sps->num_ref_frames;
  601.   img->buf_cycle = params->num_ref_frames;
  602.   img->base_dist = params->jumpd;  
  604.   // Intra/IDR related parameters
  605.   img->lastIntraNumber = 0;
  606.   img->lastINTRA       = 0;
  607.   img->lastIDRnumber   = 0;
  608.   img->last_ref_idc    = 0;
  609.   img->idr_refresh     = 0;
  610.   img->idr_gop_number  = 0;
  611.   img->rewind_frame    = 0;
  613.   img->DeblockCall     = 0;
  614.   img->framerate       = (float) params->FrameRate;   // The basic frame rate (of the original sequence)
  616.   // Allocate proper memory space for different parameters (i.e. MVs, coefficients, etc)
  617.   if (!params->IntraProfile)
  618.   {
  619.     get_mem_mv (&(img->pred_mv));
  620.     get_mem_mv (&(img->all_mv));
  622.     if (params->BiPredMotionEstimation)
  623.     {
  624.       get_mem_bipred_mv(&(img->bipred_mv)); 
  625.     }
  626.   }
  628.   get_mem_ACcoeff (&(img->cofAC));
  629.   get_mem_DCcoeff (&(img->cofDC));
  631.   if (params->AdaptiveRounding)
  632.   {
  633.     get_mem3Dint(&(img->fadjust4x4), 4, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  634.     get_mem3Dint(&(img->fadjust8x8), 3, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  636.     if (img->yuv_format != 0)
  637.     {
  638.       get_mem4Dint(&(img->fadjust4x4Cr), 2, 4, img->mb_cr_size_y, img->mb_cr_size_x);
  639.       get_mem4Dint(&(img->fadjust8x8Cr), 2, 3, img->mb_cr_size_y, img->mb_cr_size_x);
  640.     }
  641.   }
  643.   if(params->MbInterlace)
  644.   {
  645.     if (!params->IntraProfile)
  646.     {
  647.       get_mem_mv (&(rddata_top_frame_mb.pred_mv));
  648.       get_mem_mv (&(rddata_top_frame_mb.all_mv));
  650.       get_mem_mv (&(rddata_bot_frame_mb.pred_mv));
  651.       get_mem_mv (&(rddata_bot_frame_mb.all_mv));
  652.     }
  654.     get_mem_ACcoeff (&(rddata_top_frame_mb.cofAC));
  655.     get_mem_DCcoeff (&(rddata_top_frame_mb.cofDC));
  657.     get_mem_ACcoeff (&(rddata_bot_frame_mb.cofAC));
  658.     get_mem_DCcoeff (&(rddata_bot_frame_mb.cofDC));
  660.     if ( params->MbInterlace != FRAME_MB_PAIR_CODING )
  661.     {
  662.       if (!params->IntraProfile)
  663.       {      
  664.         get_mem_mv (&(rddata_top_field_mb.pred_mv));
  665.         get_mem_mv (&(rddata_top_field_mb.all_mv));
  667.         get_mem_mv (&(rddata_bot_field_mb.pred_mv));
  668.         get_mem_mv (&(rddata_bot_field_mb.all_mv));
  669.       }
  671.       get_mem_ACcoeff (&(rddata_top_field_mb.cofAC));
  672.       get_mem_DCcoeff (&(rddata_top_field_mb.cofDC));
  674.       get_mem_ACcoeff (&(rddata_bot_field_mb.cofAC));
  675.       get_mem_DCcoeff (&(rddata_bot_field_mb.cofDC));
  676.     }
  677.   }
  679.   if (params->UseRDOQuant && params->RDOQ_QP_Num > 1)
  680.   {
  681.     get_mem_ACcoeff (&(rddata_trellis_curr.cofAC));
  682.     get_mem_DCcoeff (&(rddata_trellis_curr.cofDC));
  684.     get_mem_ACcoeff (&(rddata_trellis_best.cofAC));
  685.     get_mem_DCcoeff (&(rddata_trellis_best.cofDC));
  687.     if (!params->IntraProfile)
  688.     {          
  689.       get_mem_mv (&(rddata_trellis_curr.pred_mv));
  690.       get_mem_mv (&(rddata_trellis_curr.all_mv));
  691.       get_mem_mv (&(rddata_trellis_best.pred_mv));
  692.       get_mem_mv (&(rddata_trellis_best.all_mv));
  694.       if (params->Transform8x8Mode && params->RDOQ_CP_MV)
  695.       {
  696.         get_mem5Dshort(&tmp_mv8, 2, img->max_num_references, 4, 4, 2);
  697.         get_mem5Dshort(&tmp_pmv8, 2, img->max_num_references, 4, 4, 2);
  698.         get_mem3Dint  (&motion_cost8, 2, img->max_num_references, 4);
  699.       }
  700.     }
  701.   }
  703.   byte_abs_range = (imax(img->max_imgpel_value_comp[0], img->max_imgpel_value_comp[1]) + 1) * 2;
  705.   if ((img->quad = (int*)calloc (byte_abs_range, sizeof(int))) == NULL)
  706.     no_mem_exit ("init_img: img->quad");
  708.   img->quad += byte_abs_range/2;
  709.   for (i=0; i < byte_abs_range/2; ++i)
  710.   {
  711.     img->quad[i] = img->quad[-i] = i * i;
  712.   }
  714.   img->width         = (params->output.width  + img->auto_crop_right);
  715.   img->height        = (params->output.height + img->auto_crop_bottom);
  716.   img->width_blk     = img->width  / BLOCK_SIZE;
  717.   img->height_blk    = img->height / BLOCK_SIZE;
  718.   img->width_padded  = img->width  + 2 * IMG_PAD_SIZE;
  719.   img->height_padded = img->height + 2 * IMG_PAD_SIZE;
  721.   if (img->yuv_format != YUV400)
  722.   {
  723.     img->width_cr = img->width  * mb_width_cr [img->yuv_format] / 16;
  724.     img->height_cr= img->height * mb_height_cr[img->yuv_format] / 16;
  725.   }
  726.   else
  727.   {
  728.     img->width_cr = 0;
  729.     img->height_cr= 0;
  730.   }
  732.   img->height_cr_frame = img->height_cr;
  734.   img->size = img->width * img->height;
  735.   img->size_cr = img->width_cr * img->height_cr;
  737.   img->PicWidthInMbs    = img->width  / MB_BLOCK_SIZE;
  738.   img->FrameHeightInMbs = img->height / MB_BLOCK_SIZE;
  739.   img->FrameSizeInMbs   = img->PicWidthInMbs * img->FrameHeightInMbs;
  741.   img->PicHeightInMapUnits = ( active_sps->frame_mbs_only_flag ? img->FrameHeightInMbs : img->FrameHeightInMbs/2 );
  742.   
  743.   if ((img->b8x8info = (Block8x8Info *) calloc(1, sizeof(Block8x8Info))) == NULL)
  744.      no_mem_exit("init_img: img->block8x8info");
  746.   if( IS_INDEPENDENT(params) )
  747.   {
  748.     for( i = 0; i < MAX_PLANE; i++ ){
  749.       if ((img->mb_data_JV[i] = (Macroblock *) calloc(img->FrameSizeInMbs,sizeof(Macroblock))) == NULL)
  750.         no_mem_exit("init_img: img->mb_data_JV");
  751.     }
  752.     img->mb_data = NULL;
  753.   }
  754.   else
  755.   {
  756.     if ((img->mb_data = (Macroblock *) calloc(img->FrameSizeInMbs, sizeof(Macroblock))) == NULL)
  757.       no_mem_exit("init_img: img->mb_data");
  758.   }
  760.   if (params->UseConstrainedIntraPred)
  761.   {
  762.     if ((img->intra_block = (int*)calloc(img->FrameSizeInMbs, sizeof(int))) == NULL)
  763.       no_mem_exit("init_img: img->intra_block");
  764.   }
  766.   if (params->CtxAdptLagrangeMult == 1)
  767.   {
  768.     if ((mb16x16_cost_frame = (double*)calloc(img->FrameSizeInMbs, sizeof(double))) == NULL)
  769.     {
  770.       no_mem_exit("init mb16x16_cost_frame");
  771.     }
  772.   }
  773.   get_mem2D((byte***)&(img->ipredmode), img->height_blk, img->width_blk);        //need two extra rows at right and bottom
  774.   get_mem2D((byte***)&(img->ipredmode8x8), img->height_blk, img->width_blk);     // help storage for ipredmode 8x8, inserted by YV
  775.   memset(&(img->ipredmode[0][0])   , -1, img->height_blk * img->width_blk *sizeof(char));
  776.   memset(&(img->ipredmode8x8[0][0]), -1, img->height_blk * img->width_blk *sizeof(char));
  778.   get_mem2D((byte***)&(rddata_top_frame_mb.ipredmode), img->height_blk, img->width_blk);
  779.   get_mem2D((byte***)&(rddata_trellis_curr.ipredmode), img->height_blk, img->width_blk);
  780.   get_mem2D((byte***)&(rddata_trellis_best.ipredmode), img->height_blk, img->width_blk);
  782.   if (params->MbInterlace)
  783.   {
  784.     get_mem2D((byte***)&(rddata_bot_frame_mb.ipredmode), img->height_blk, img->width_blk);
  785.     get_mem2D((byte***)&(rddata_top_field_mb.ipredmode), img->height_blk, img->width_blk);
  786.     get_mem2D((byte***)&(rddata_bot_field_mb.ipredmode), img->height_blk, img->width_blk);
  787.   }
  789.   // CAVLC mem
  790.   get_mem3Dint(&(img->nz_coeff), img->FrameSizeInMbs, 4, 4+img->num_blk8x8_uv);
  791.   CAVLC_init();
  792.   
  793.   get_mem2Dolm     (&(img->lambda), 10, 52 + img->bitdepth_luma_qp_scale, img->bitdepth_luma_qp_scale);
  794.   get_mem2Dodouble (&(img->lambda_md), 10, 52 + img->bitdepth_luma_qp_scale, img->bitdepth_luma_qp_scale);
  795.   get_mem3Dodouble (&(img->lambda_me), 10, 52 + img->bitdepth_luma_qp_scale, 3, img->bitdepth_luma_qp_scale);
  796.   get_mem3Doint    (&(img->lambda_mf), 10, 52 + img->bitdepth_luma_qp_scale, 3, img->bitdepth_luma_qp_scale);
  798.   if (params->CtxAdptLagrangeMult == 1)
  799.   {
  800.     get_mem2Dodouble(&(img->lambda_mf_factor), 10, 52 + img->bitdepth_luma_qp_scale, img->bitdepth_luma_qp_scale);
  801.   }
  803.   img->b_frame_to_code = 0;
  804.   img->GopLevels = (params->successive_Bframe) ? 1 : 0;
  805.   img->mb_y_upd=0;
  807.   RandomIntraInit (img->PicWidthInMbs, img->FrameHeightInMbs, params->RandomIntraMBRefresh);
  809.   InitSEIMessages(); 
  811.   initInput(&params->source, &params->output);
  813.   // Allocate I/O Frame memory
  814.   if (AllocateFrameMemory(img, params->source.size))
  815.     no_mem_exit("AllocateFrameMemory: buf");
  817.   // Initialize filtering parameters. If sending parameters, the offsets are
  818.   // multiplied by 2 since inputs are taken in "div 2" format.
  819.   // If not sending parameters, all fields are cleared
  820.   if (params->DFSendParameters)
  821.   {
  822.     for (j = 0; j < 2; j++)
  823.     {
  824.       for (i = 0; i < NUM_SLICE_TYPES; i++)
  825.       {
  826.         params->DFAlpha[j][i] <<= 1;
  827.         params->DFBeta [j][i] <<= 1;
  828.       }
  829.     }
  830.   }
  831.   else
  832.   {
  833.     for (j = 0; j < 2; j++)
  834.     {
  835.       for (i = 0; i < NUM_SLICE_TYPES; i++)
  836.       {
  837.         params->DFDisableIdc[j][i] = 0;
  838.         params->DFAlpha     [j][i] = 0;
  839.         params->DFBeta      [j][i] = 0;
  840.       }
  841.     }
  842.   }
  844.   img->ChromaArrayType = params->separate_colour_plane_flag ? 0 : params->yuv_format;
  846.   if (params->RDPictureDecision)
  847.     img->frm_iter = 3;
  848.   else
  849.     img->frm_iter = 1;
  850. }
  853. /*!
  854.  ***********************************************************************
  855.  * brief
  856.  *    Free the Image structures
  857.  * par Input:
  858.  *    Image Parameters ImageParameters *img
  859.  ***********************************************************************
  860.  */
  861. void free_img ()
  862. {
  863.   // Delete Frame memory 
  864.   DeleteFrameMemory();
  866.   CloseSEIMessages(); 
  867.   if (!params->IntraProfile)
  868.   {
  869.     free_mem_mv (img->pred_mv);
  870.     free_mem_mv (img->all_mv);
  872.     if (params->BiPredMotionEstimation)
  873.     {
  874.       free_mem_bipred_mv (img->bipred_mv);
  875.     }
  876.   }
  878.   free_mem_ACcoeff (img->cofAC);
  879.   free_mem_DCcoeff (img->cofDC);
  881.   if (params->AdaptiveRounding)
  882.   {
  883.     free_mem3Dint(img->fadjust4x4);
  884.     free_mem3Dint(img->fadjust8x8);
  885.     if (img->yuv_format != 0)
  886.     {
  887.       free_mem4Dint(img->fadjust4x4Cr);
  888.       free_mem4Dint(img->fadjust8x8Cr);
  889.     }
  890.   }
  893.   if (params->MbInterlace)
  894.   {
  895.     if (!params->IntraProfile)
  896.     {    
  897.       free_mem_mv (rddata_top_frame_mb.pred_mv);
  898.       free_mem_mv (rddata_top_frame_mb.all_mv);
  900.       free_mem_mv (rddata_bot_frame_mb.pred_mv);
  901.       free_mem_mv (rddata_bot_frame_mb.all_mv);
  902.     }
  904.     free_mem_ACcoeff (rddata_top_frame_mb.cofAC);
  905.     free_mem_DCcoeff (rddata_top_frame_mb.cofDC);
  907.     free_mem_ACcoeff (rddata_bot_frame_mb.cofAC);
  908.     free_mem_DCcoeff (rddata_bot_frame_mb.cofDC);
  910.     if ( params->MbInterlace != FRAME_MB_PAIR_CODING )
  911.     {
  912.       if (!params->IntraProfile)
  913.       {
  914.         free_mem_mv (rddata_top_field_mb.pred_mv);
  915.         free_mem_mv (rddata_top_field_mb.all_mv);
  917.         free_mem_mv (rddata_bot_field_mb.pred_mv);
  918.         free_mem_mv (rddata_bot_field_mb.all_mv);
  919.       }
  921.       free_mem_ACcoeff (rddata_top_field_mb.cofAC);
  922.       free_mem_DCcoeff (rddata_top_field_mb.cofDC);
  924.       free_mem_ACcoeff (rddata_bot_field_mb.cofAC);
  925.       free_mem_DCcoeff (rddata_bot_field_mb.cofDC);
  926.     }
  927.   }
  929.   if (params->UseRDOQuant && params->RDOQ_QP_Num > 1)
  930.   {
  931.     free_mem_ACcoeff (rddata_trellis_curr.cofAC);
  932.     free_mem_DCcoeff (rddata_trellis_curr.cofDC);
  933.     free_mem_ACcoeff (rddata_trellis_best.cofAC);
  934.     free_mem_DCcoeff (rddata_trellis_best.cofDC);
  936.     if (!params->IntraProfile)
  937.     {    
  938.       free_mem_mv (rddata_trellis_curr.pred_mv);
  939.       free_mem_mv (rddata_trellis_curr.all_mv);
  941.       free_mem_mv (rddata_trellis_best.pred_mv);
  942.       free_mem_mv (rddata_trellis_best.all_mv);
  944.       if (params->Transform8x8Mode && params->RDOQ_CP_MV)
  945.       {
  946.         free_mem5Dshort(tmp_mv8);
  947.         free_mem5Dshort(tmp_pmv8);
  948.         free_mem3Dint(motion_cost8);
  949.       }
  950.     }
  951.   }
  953.   free (img->quad - (imax(img->max_imgpel_value_comp[0],img->max_imgpel_value_comp[1]) + 1));
  955.   if (params->MbInterlace)
  956.   {
  957.     free_mem2D((byte**) rddata_bot_frame_mb.ipredmode);
  958.     free_mem2D((byte**) rddata_top_field_mb.ipredmode);
  959.     free_mem2D((byte**) rddata_bot_field_mb.ipredmode);
  960.   }
  961. }
  964. /*!
  965.  ************************************************************************
  966.  * brief
  967.  *    Allocates the picture structure along with its dependent
  968.  *    data structures
  969.  * return
  970.  *    Pointer to a Picture
  971.  ************************************************************************
  972.  */
  974. Picture *malloc_picture()
  975. {
  976.   Picture *pic;
  977.   if ((pic = calloc (1, sizeof (Picture))) == NULL) no_mem_exit ("malloc_picture: Picture structure");
  978.   //! Note: slice structures are allocated as needed in code_a_picture
  979.   return pic;
  980. }
  982. /*!
  983.  ************************************************************************
  984.  * brief
  985.  *    Frees a picture
  986.  * param
  987.  *    pic: POinter to a Picture to be freed
  988.  ************************************************************************
  989.  */
  992. void free_picture(Picture *pic)
  993. {
  994.   if (pic != NULL)
  995.   {
  996.     free_slice_list(pic);
  997.     free (pic);
  998.   }
  999. }
  1003. /*!
  1004.  ************************************************************************
  1005.  * brief
  1006.  *    memory allocation for original picture buffers
  1007.  ************************************************************************
  1008.  */
  1009. int init_orig_buffers(void)
  1010. {
  1011.   int memory_size = 0;
  1012.   int nplane;
  1014.   // allocate memory for reference frame buffers: img_org_frm
  1015.   if( IS_INDEPENDENT(params) )
  1016.   {
  1017.     for( nplane=0; nplane<MAX_PLANE; nplane++ )
  1018.     {
  1019.       memory_size += get_mem2Dpel(&img_org_frm[nplane], img->height, img->width);
  1020.     }
  1021.   }
  1022.   else
  1023.   {
  1024.     memory_size += get_mem2Dpel(&img_org_frm[0], img->height, img->width);
  1025.     if (img->yuv_format != YUV400)
  1026.     {
  1027.       int i, j, k;
  1028.       memory_size += get_mem2Dpel(&img_org_frm[1], img->height_cr, img->width_cr);
  1029.       memory_size += get_mem2Dpel(&img_org_frm[2], img->height_cr, img->width_cr);
  1030.       for (k = 1; k < 3; k++)
  1031.         for (j = 0; j < img->height_cr; j++)
  1032.           for (i = 0; i < img->width_cr; i++)
  1033.             img_org_frm[k][j][i] = 128;
  1034.     }
  1035.   }
  1037.   if (!active_sps->frame_mbs_only_flag)
  1038.   {
  1039.     // allocate memory for field reference frame buffers
  1040.     memory_size += init_top_bot_planes(img_org_frm[0], img->height, img->width, &img_org_top[0], &img_org_bot[0]);
  1042.     if (img->yuv_format != YUV400)
  1043.     {
  1045.       memory_size += 4*(sizeof(imgpel**));
  1047.       memory_size += init_top_bot_planes(img_org_frm[1], img->height_cr, img->width_cr, &(img_org_top[1]), &(img_org_bot[1]));
  1048.       memory_size += init_top_bot_planes(img_org_frm[2], img->height_cr, img->width_cr, &(img_org_top[2]), &(img_org_bot[2]));
  1049.     }
  1050.   }
  1051.   return memory_size;
  1052. }
  1054. /*!
  1055.  ************************************************************************
  1056.  * brief
  1057.  *    Dynamic memory allocation of frame size related global buffers
  1058.  *    buffers are defined in global.h, allocated memory must be freed in
  1059.  *    void free_global_buffers()
  1060.  * par Input:
  1061.  *    Input Parameters struct inp_par *inp,                            n
  1062.  *    Image Parameters ImageParameters *img
  1063.  * return Number of allocated bytes
  1064.  ************************************************************************
  1065.  */
  1066. int init_global_buffers(void)
  1067. {
  1068.   int j, memory_size=0;
  1069. #ifdef _ADAPT_LAST_GROUP_
  1070.   extern int *last_P_no_frm;
  1071.   extern int *last_P_no_fld;
  1073. //  if ((last_P_no_frm = (int*)malloc(2*img->max_num_references*sizeof(int))) == NULL)
  1074.   if ((last_P_no_frm = (int*)malloc(32*sizeof(int))) == NULL)
  1075.     no_mem_exit("init_global_buffers: last_P_no");
  1076.   if (!active_sps->frame_mbs_only_flag)
  1077. //    if ((last_P_no_fld = (int*)malloc(4*img->max_num_references*sizeof(int))) == NULL)
  1078.     if ((last_P_no_fld = (int*)malloc(64*sizeof(int))) == NULL)
  1079.       no_mem_exit("init_global_buffers: last_P_no");
  1080. #endif
  1082.   if ((enc_frame_picture = (StorablePicture**)malloc(6 * sizeof(StorablePicture*))) == NULL)
  1083.     no_mem_exit("init_global_buffers: *enc_frame_picture");
  1085.   for (j = 0; j < 6; j++)
  1086.     enc_frame_picture[j] = NULL;
  1088.   if ((enc_field_picture = (StorablePicture**)malloc(2 * sizeof(StorablePicture*))) == NULL)
  1089.     no_mem_exit("init_global_buffers: *enc_field_picture");
  1091.   for (j = 0; j < 2; j++)
  1092.     enc_field_picture[j] = NULL;
  1094.   if ((frame_pic = (Picture**)malloc(img->frm_iter * sizeof(Picture*))) == NULL)
  1095.     no_mem_exit("init_global_buffers: *frame_pic");
  1097.   for (j = 0; j < img->frm_iter; j++)
  1098.     frame_pic[j] = malloc_picture();
  1100.   if (params->si_frame_indicator || params->sp_periodicity)
  1101.   {
  1102.     si_frame_indicator=0; //indicates whether the frame is SP or SI
  1103.     number_sp2_frames=0;
  1105.     frame_pic_si = malloc_picture();//picture buffer for the encoded SI picture
  1106.     //allocation of lrec and lrec_uv for SI picture
  1107.     get_mem2Dint (&lrec, img->height, img->width);
  1108.     get_mem3Dint (&lrec_uv, 2, img->height, img->width);
  1109.   }
  1111.   // Allocate memory for field picture coding
  1112.   if (params->PicInterlace != FRAME_CODING)
  1113.   { 
  1114.     if ((field_pic = (Picture**)malloc(2 * sizeof(Picture*))) == NULL)
  1115.       no_mem_exit("init_global_buffers: *field_pic");
  1117.     for (j = 0; j < 2; j++)
  1118.       field_pic[j] = malloc_picture();
  1119.   }
  1121.   memory_size += init_orig_buffers();
  1123.   memory_size += get_mem2Dint(&PicPos, img->FrameSizeInMbs + 1, 2);
  1125.   for (j = 0; j < (int) img->FrameSizeInMbs + 1; j++)
  1126.   {
  1127.     PicPos[j][0] = (j % img->PicWidthInMbs);
  1128.     PicPos[j][1] = (j / img->PicWidthInMbs);
  1129.   }
  1131.   if (params->WeightedPrediction || params->WeightedBiprediction || params->GenerateMultiplePPS)
  1132.   {
  1133.     // Currently only use up to 32 references. Need to use different indicator such as maximum num of references in list
  1134.     memory_size += get_mem3Dint(&wp_weight, 6, MAX_REFERENCE_PICTURES, 3);
  1135.     memory_size += get_mem3Dint(&wp_offset, 6, MAX_REFERENCE_PICTURES, 3);
  1137.     memory_size += get_mem4Dint(&wbp_weight, 6, MAX_REFERENCE_PICTURES, MAX_REFERENCE_PICTURES, 3);
  1138.   }
  1140.   // allocate memory for reference frames of each block: refFrArr
  1142.   if ((params->successive_Bframe != 0) || (params->BRefPictures > 0) || (params->ProfileIDC != 66))
  1143.   {
  1144.     memory_size += get_mem3D((byte ****)(void*)(&direct_ref_idx), 2, img->height_blk, img->width_blk);
  1145.     memory_size += get_mem2D((byte ***)(void*)&direct_pdir, img->height_blk, img->width_blk);
  1146.   }
  1148.   if (params->rdopt == 3)
  1149.   {
  1150.     decs->dec_mbY = NULL;
  1151.     decs->dec_mbY8x8 = NULL;
  1152.     memory_size += get_mem3Dpel(&decs->dec_mbY, params->NoOfDecoders, 16, 16);
  1153.     memory_size += get_mem3Dpel(&decs->dec_mbY8x8, params->NoOfDecoders, 16, 16);
  1154.   }
  1155.   if (params->RestrictRef)
  1156.   {
  1157.     memory_size += get_mem2D(&pixel_map,   img->height,   img->width);
  1158.     memory_size += get_mem2D(&refresh_map, img->height/8, img->width/8);
  1159.   }
  1161.   if (!active_sps->frame_mbs_only_flag)
  1162.   {
  1163.     memory_size += get_mem2Dpel(&imgY_com, img->height, img->width);
  1165.     if (img->yuv_format != YUV400)
  1166.     {
  1167.       memory_size += get_mem3Dpel(&imgUV_com, 2, img->height_cr, img->width_cr);
  1168.     }
  1169.   }
  1171.   // allocate and set memory relating to motion estimation
  1172.   if (!params->IntraProfile)
  1173.   {  
  1174.     if (params->SearchMode == UM_HEX)
  1175.     {
  1176.       memory_size += UMHEX_get_mem();
  1177.     }
  1178.     else if (params->SearchMode == UM_HEX_SIMPLE)
  1179.     {
  1180.       smpUMHEX_init();
  1181.       memory_size += smpUMHEX_get_mem();
  1182.     }
  1183.     else if (params->SearchMode == EPZS)
  1184.       memory_size += EPZSInit(params, img);
  1185.   }
  1187.   if (params->RCEnable)
  1188.     rc_allocate_memory();
  1190.   if (params->redundant_pic_flag)
  1191.   {
  1192.     memory_size += get_mem2Dpel(&imgY_tmp, img->height, img->width);
  1193.     memory_size += get_mem2Dpel(&imgUV_tmp[0], img->height_cr, img->width_cr);
  1194.     memory_size += get_mem2Dpel(&imgUV_tmp[1], img->height_cr, img->width_cr);
  1195.   }
  1197.   memory_size += get_mem2Dint (&imgY_sub_tmp, img->height_padded, img->width_padded);
  1199.   if ( params->ChromaMCBuffer )
  1200.     chroma_mc_setup();
  1202.   img_padded_size_x       = (img->width + 2 * IMG_PAD_SIZE);
  1203.   img_padded_size_x2      = (img_padded_size_x << 1);
  1204.   img_padded_size_x4      = (img_padded_size_x << 2);
  1205.   img_padded_size_x_m8    = (img_padded_size_x - 8);
  1206.   img_padded_size_x_m8x8  = (img_padded_size_x - BLOCK_SIZE_8x8);
  1207.   img_padded_size_x_m4x4  = (img_padded_size_x - BLOCK_SIZE);
  1208.   img_cr_padded_size_x    = (img->width_cr + 2 * img_pad_size_uv_x);
  1209.   img_cr_padded_size_x2   = (img_cr_padded_size_x << 1);
  1210.   img_cr_padded_size_x4   = (img_cr_padded_size_x << 2);
  1211.   img_cr_padded_size_x_m8 = (img_cr_padded_size_x - 8);
  1213.   // RGB images for distortion calculation
  1214.   // Recommended to do this allocation (and de-allocation) in 
  1215.   // the appropriate file instead of here.
  1216.   if(params->DistortionYUVtoRGB)
  1217.   {
  1218.     memory_size += create_RGB_memory(img);
  1219.   }
  1221.   pWPX = NULL;
  1222.   if ( params->WPMCPrecision )
  1223.   {
  1224.     wpxInitWPXObject();
  1225.   }
  1227.   return memory_size;
  1228. }
  1231. /*!
  1232.  ************************************************************************
  1233.  * brief
  1234.  *    Free allocated memory of original picture buffers
  1235.  ************************************************************************
  1236.  */
  1237. void free_orig_planes(void)
  1238. {
  1239.   if( IS_INDEPENDENT(params) )
  1240.   {
  1241.     int nplane;
  1242.     for( nplane=0; nplane<MAX_PLANE; nplane++ )
  1243.     {
  1244.       free_mem2Dpel(img_org_frm[nplane]);      // free ref frame buffers
  1245.     }
  1246.   }
  1247.   else
  1248.   {
  1249.     free_mem2Dpel(img_org_frm[0]);      // free ref frame buffers
  1250.     if (img->yuv_format != YUV400)
  1251.     {
  1252.       free_mem2Dpel(img_org_frm[1]);
  1253.       free_mem2Dpel(img_org_frm[2]);
  1254.     }
  1255.   }
  1257.   if (!active_sps->frame_mbs_only_flag)
  1258.   {
  1259.     free_top_bot_planes(img_org_top[0], img_org_bot[0]);
  1261.     if (img->yuv_format != YUV400)
  1262.     {
  1263.       free_top_bot_planes(img_org_top[1], img_org_bot[1]);
  1264.       free_top_bot_planes(img_org_top[2], img_org_bot[2]);
  1265.     }
  1266.   }
  1267. }
  1270. /*!
  1271.  ************************************************************************
  1272.  * brief
  1273.  *    Free allocated memory of frame size related global buffers
  1274.  *    buffers are defined in global.h, allocated memory is allocated in
  1275.  *    int get_mem4global_buffers()
  1276.  * par Input:
  1277.  *    Input Parameters struct inp_par *inp,                             n
  1278.  *    Image Parameters ImageParameters *img
  1279.  * par Output:
  1280.  *    none
  1281.  ************************************************************************
  1282.  */
  1283. void free_global_buffers(void)
  1284. {
  1285.   int  i,j;
  1287. #ifdef _ADAPT_LAST_GROUP_
  1288.   extern int *last_P_no_frm;
  1289.   extern int *last_P_no_fld;
  1290.   free (last_P_no_frm);
  1291.   free (last_P_no_fld);
  1292. #endif
  1294.   if (enc_frame_picture)
  1295.     free (enc_frame_picture);
  1296.   if (frame_pic)
  1297.   {
  1298.     for (j = 0; j < img->frm_iter; j++)
  1299.     {
  1300.       if (frame_pic[j])
  1301.         free_picture (frame_pic[j]);
  1302.     }
  1303.     free (frame_pic);
  1304.   }
  1306.   if (enc_field_picture)
  1307.     free (enc_field_picture);
  1308.   if (field_pic)
  1309.   {
  1310.     for (j = 0; j < 2; j++)
  1311.     {
  1312.       if (field_pic[j])
  1313.         free_picture (field_pic[j]);
  1314.     }
  1315.     free (field_pic);
  1316.   }
  1318.   // Deallocation of SI picture related memory
  1319.   if (params->si_frame_indicator || params->sp_periodicity)
  1320.   {
  1321.     free_picture (frame_pic_si);
  1322.     //deallocation of lrec and lrec_uv for SI frames
  1323.     free_mem2Dint (lrec);
  1324.     free_mem3Dint (lrec_uv);
  1325.   }
  1327.   free_orig_planes();
  1328.   // free lookup memory which helps avoid divides with PicWidthInMbs
  1329.   free_mem2Dint(PicPos);
  1330.   // Free Qmatrices and offsets
  1331.   free_QMatrix();
  1332.   free_QOffsets();
  1334.   if ( params->WPMCPrecision )
  1335.   {
  1336.     wpxFreeWPXObject();
  1337.   }
  1339.   if (params->WeightedPrediction || params->WeightedBiprediction || params->GenerateMultiplePPS)
  1340.   {
  1341.     free_mem3Dint(wp_weight );
  1342.     free_mem3Dint(wp_offset );
  1343.     free_mem4Dint(wbp_weight);
  1344.   }
  1346.   if ((stats->successive_Bframe != 0) || (params->BRefPictures > 0)||(params->ProfileIDC != 66))
  1347.   {
  1348.     free_mem3D((byte ***)direct_ref_idx);
  1349.     free_mem2D((byte **) direct_pdir);
  1350.   } // end if B frame
  1352.   if (imgY_sub_tmp) // free temp quarter pel frame buffers
  1353.   {
  1354.     free_mem2Dint (imgY_sub_tmp);
  1355.     imgY_sub_tmp=NULL;
  1356.   }
  1358.   // free mem, allocated in init_img()
  1359.   // free intra pred mode buffer for blocks
  1360.   free_mem2D((byte**)img->ipredmode);
  1361.   free_mem2D((byte**)img->ipredmode8x8);
  1362.   free(img->b8x8info);
  1364.   if( IS_INDEPENDENT(params) )
  1365.   {
  1366.     for( i=0; i<MAX_PLANE; i++ ){
  1367.       free(img->mb_data_JV[i]);
  1368.     }
  1369.   }
  1370.   else
  1371.   {
  1372.     free(img->mb_data);
  1373.   }
  1375.   free_mem2D((byte**)rddata_top_frame_mb.ipredmode);
  1376.   free_mem2D((byte**)rddata_trellis_curr.ipredmode);
  1377.   free_mem2D((byte**)rddata_trellis_best.ipredmode);
  1379.   if(params->UseConstrainedIntraPred)
  1380.   {
  1381.     free (img->intra_block);
  1382.   }
  1384.   if (params->CtxAdptLagrangeMult == 1)
  1385.   {
  1386.     free(mb16x16_cost_frame);
  1387.   }
  1389.   if (params->rdopt == 3)
  1390.   {
  1391.     if (decs->dec_mbY)
  1392.     {
  1393.        free_mem3Dpel(decs->dec_mbY);
  1394.     }
  1395.     if (decs->dec_mbY8x8)
  1396.     {
  1397.        free_mem3Dpel(decs->dec_mbY8x8);
  1398.     }
  1399.   }
  1401.   if (params->RestrictRef)
  1402.   {
  1403.     free(pixel_map[0]);
  1404.     free(pixel_map);
  1405.     free(refresh_map[0]);
  1406.     free(refresh_map);
  1407.   }
  1409.   if (!active_sps->frame_mbs_only_flag)
  1410.   {
  1411.     free_mem2Dpel(imgY_com);
  1412.     if (img->yuv_format != YUV400)
  1413.     {
  1414.       free_mem3Dpel(imgUV_com);
  1415.     }
  1416.   }
  1418.   free_mem3Dint(img->nz_coeff);
  1420.   free_mem2Dolm     (img->lambda, img->bitdepth_luma_qp_scale);
  1421.   free_mem2Dodouble (img->lambda_md, img->bitdepth_luma_qp_scale);
  1422.   free_mem3Dodouble (img->lambda_me, 10, 52 + img->bitdepth_luma_qp_scale, img->bitdepth_luma_qp_scale);
  1423.   free_mem3Doint    (img->lambda_mf, 10, 52 + img->bitdepth_luma_qp_scale, img->bitdepth_luma_qp_scale);
  1425.   if (params->CtxAdptLagrangeMult == 1)
  1426.   {
  1427.     free_mem2Dodouble(img->lambda_mf_factor, img->bitdepth_luma_qp_scale);
  1428.   }
  1430.   if (!params->IntraProfile)
  1431.   {
  1432.     if (params->SearchMode == UM_HEX)
  1433.     {
  1434.       UMHEX_free_mem();
  1435.     }
  1436.     else if (params->SearchMode == UM_HEX_SIMPLE)
  1437.     {
  1438.       smpUMHEX_free_mem();
  1439.     }
  1440.     else if (params->SearchMode == EPZS)
  1441.     {
  1442.       EPZSDelete(params);
  1443.     }
  1444.   }
  1447.   if (params->RCEnable)
  1448.     rc_free_memory();
  1450.   if (params->redundant_pic_flag)
  1451.   {
  1452.     free_mem2Dpel(imgY_tmp);
  1453.     free_mem2Dpel(imgUV_tmp[0]);
  1454.     free_mem2Dpel(imgUV_tmp[1]);
  1455.   }
  1457.   // Again process should be moved into cconv_yuv2rgb.c file for cleanliness
  1458.   // These should not be globals but instead only be visible through that code.
  1459.   if(params->DistortionYUVtoRGB)
  1460.   {
  1461.     delete_RGB_memory();
  1462.   }
  1463. }
  1465. /*!
  1466.  ************************************************************************
  1467.  * brief
  1468.  *    Allocate memory for mv
  1469.  * par Input:
  1470.  *    Image Parameters ImageParameters *img                             n
  1471.  *    int****** mv
  1472.  * return memory size in bytes
  1473.  ************************************************************************
  1474.  */
  1475. int get_mem_mv (short ******* mv)
  1476. {
  1477.   // LIST, reference, block_type, block_y, block_x, component
  1478.   get_mem6Dshort(mv, 2, img->max_num_references, 9, 4, 4, 2);
  1480.   return 2 * img->max_num_references * 9 * 4 * 4 * 2 * sizeof(short);
  1481. }
  1483. /*!
  1484.  ************************************************************************
  1485.  * brief
  1486.  *    Allocate memory for bipredictive mv 
  1487.  * par Input:
  1488.  *    Image Parameters ImageParameters *img                             n
  1489.  *    int****** mv
  1490.  * return memory size in bytes
  1491.  ************************************************************************
  1492.  */
  1493. int get_mem_bipred_mv (short******** bipred_mv) 
  1494. {
  1495.   if(((*bipred_mv) = (short*******)calloc(2, sizeof(short******))) == NULL)
  1496.     no_mem_exit("get_mem_bipred_mv: bipred_mv");
  1497.   
  1498.   get_mem6Dshort(*bipred_mv, 2 * 2, img->max_num_references, 9, 4, 4, 2);
  1499.   (*bipred_mv)[1] =  (*bipred_mv)[0] + 2;
  1500.   
  1501.   return 2 * 2 * img->max_num_references * 9 * 4 * 4 * 2 * sizeof(short);
  1502. }
  1504. /*!
  1505.  ************************************************************************
  1506.  * brief
  1507.  *    Free memory from mv
  1508.  * par Input:
  1509.  *    int****** mv
  1510.  ************************************************************************
  1511.  */
  1512. void free_mem_mv (short****** mv)
  1513. {
  1514.   free_mem6Dshort(mv);
  1515. }
  1518. /*!
  1519.  ************************************************************************
  1520.  * brief
  1521.  *    Free memory from mv
  1522.  * par Input:
  1523.  *    int****** mv
  1524.  ************************************************************************
  1525.  */
  1526. void free_mem_bipred_mv (short******* bipred_mv) 
  1527. {
  1528.   if (bipred_mv)
  1529.   {
  1530.     free_mem6Dshort(*bipred_mv);
  1531.     free (bipred_mv);
  1532.   }
  1533.   else
  1534.   {
  1535.     error ("free_mem_bipred_mv: trying to free unused memory",100);
  1536.   }
  1537. }
  1539. /*!
  1540.  ************************************************************************
  1541.  * brief
  1542.  *    Allocate memory for AC coefficients
  1543.  ************************************************************************
  1544.  */
  1545. int get_mem_ACcoeff (int***** cofAC)
  1546. {
  1547.   int num_blk8x8 = 4 + img->num_blk8x8_uv;
  1548.   
  1549.   get_mem4Dint(cofAC, num_blk8x8, 4, 2, 65);
  1550.   return num_blk8x8*4*2*65*sizeof(int);// 18->65 for ABT
  1551. }
  1553. /*!
  1554.  ************************************************************************
  1555.  * brief
  1556.  *    Allocate memory for DC coefficients
  1557.  ************************************************************************
  1558.  */
  1559. int get_mem_DCcoeff (int**** cofDC)
  1560. {
  1561.   get_mem3Dint(cofDC, 3, 2, 18);
  1562.   return 3 * 2 * 18 * sizeof(int); 
  1563. }
  1566. /*!
  1567.  ************************************************************************
  1568.  * brief
  1569.  *    Free memory of AC coefficients
  1570.  ************************************************************************
  1571.  */
  1572. void free_mem_ACcoeff (int**** cofAC)
  1573. {
  1574.   free_mem4Dint(cofAC);
  1575. }
  1577. /*!
  1578.  ************************************************************************
  1579.  * brief
  1580.  *    Free memory of DC coefficients
  1581.  ************************************************************************
  1582.  */
  1583. void free_mem_DCcoeff (int*** cofDC)
  1584. {
  1585.   free_mem3Dint(cofDC);
  1586. }
  1590. /*!
  1591.  ************************************************************************
  1592.  * brief
  1593.  *    Set the image type for I,P and SP pictures (not B!)
  1594.  ************************************************************************
  1595.  */
  1596. static void SetImgType(void)
  1597. {
  1598.   int intra_refresh = (params->intra_period == 0) ? (IMG_NUMBER == 0) : (( ( img->frm_number - img->lastIntraNumber) % params->intra_period ) == 0);
  1599.   int idr_refresh;
  1601.   if ( params->idr_period && !params->adaptive_idr_period )
  1602.     idr_refresh = (( ( img->frm_number - img->lastIDRnumber  ) % params->idr_period   ) == 0);
  1603.   else if ( params->idr_period && params->adaptive_idr_period == 1 )
  1604.     idr_refresh = (( ( img->frm_number - imax(img->lastIntraNumber, img->lastIDRnumber)  ) % params->idr_period   ) == 0);
  1605.   else
  1606.     idr_refresh = (IMG_NUMBER == 0);
  1608.   if (intra_refresh || idr_refresh)
  1609.   {
  1610.     set_slice_type( I_SLICE );        // set image type for first image to I-frame
  1611.   }
  1612.   else
  1613.   {
  1614.     set_slice_type((params->sp_periodicity && ((IMG_NUMBER % params->sp_periodicity) == 0))
  1615.       ? SP_SLICE  : ((params->BRefPictures == 2) ? B_SLICE : P_SLICE) );
  1616.   }
  1617. }
  1619. /*!
  1620.  ************************************************************************
  1621.  * brief
  1622.  *    Sets indices to appropriate level constraints, depending on 
  1623.  *    current level_idc
  1624.  ************************************************************************
  1625.  */
  1626. void SetLevelIndices(void)
  1627. {
  1628.   switch(active_sps->level_idc)
  1629.   {
  1630.   case 9:
  1631.     img->LevelIndex=1;
  1632.     break;
  1633.   case 10:
  1634.     img->LevelIndex=0;
  1635.     break;
  1636.   case 11:
  1637.     if (!IS_FREXT_PROFILE(active_sps->profile_idc) && (active_sps->constrained_set3_flag == 0))
  1638.       img->LevelIndex=2;
  1639.     else
  1640.       img->LevelIndex=1;
  1641.     break;
  1642.   case 12:
  1643.     img->LevelIndex=3;
  1644.     break;
  1645.   case 13:
  1646.     img->LevelIndex=4;
  1647.     break;
  1648.   case 20:
  1649.     img->LevelIndex=5;
  1650.     break;
  1651.   case 21:
  1652.     img->LevelIndex=6;
  1653.     break;
  1654.   case 22:
  1655.     img->LevelIndex=7;
  1656.     break;
  1657.   case 30:
  1658.     img->LevelIndex=8;
  1659.     break;
  1660.   case 31:
  1661.     img->LevelIndex=9;
  1662.     break;
  1663.   case 32:
  1664.     img->LevelIndex=10;
  1665.     break;
  1666.   case 40:
  1667.     img->LevelIndex=11;
  1668.     break;
  1669.   case 41:
  1670.     img->LevelIndex=12;
  1671.     break;
  1672.   case 42:
  1673.     if (!IS_FREXT_PROFILE(active_sps->profile_idc))
  1674.       img->LevelIndex=13;
  1675.     else
  1676.       img->LevelIndex=14;
  1677.     break;
  1678.   case 50:
  1679.     img->LevelIndex=15;
  1680.     break;
  1681.   case 51:
  1682.     img->LevelIndex=16;
  1683.     break;
  1684.   default:
  1685.     fprintf ( stderr, "Warning: unknown LevelIDC, using maximum level 5.1 n" );
  1686.     img->LevelIndex=16;
  1687.     break;
  1688.   }
  1689. }
  1691. /*!
  1692.  ************************************************************************
  1693.  * brief
  1694.  *    initialize key frames and corresponding redundant frames.
  1695.  ************************************************************************
  1696.  */
  1697. void Init_redundant_frame()
  1698. {
  1699.   if (params->redundant_pic_flag)
  1700.   {
  1701.     if (params->successive_Bframe)
  1702.     {
  1703.       error("B frame not supported when redundant picture used!", 100);
  1704.     }
  1706.     if (params->PicInterlace)
  1707.     {
  1708.       error("Interlace not supported when redundant picture used!", 100);
  1709.     }
  1711.     if (params->num_ref_frames < params->PrimaryGOPLength)
  1712.     {
  1713.       error("NumberReferenceFrames must be no less than PrimaryGOPLength", 100);
  1714.     }
  1716.     if ((1<<params->NumRedundantHierarchy) > params->PrimaryGOPLength)
  1717.     {
  1718.       error("PrimaryGOPLength must be greater than 2^NumRedundantHeirarchy", 100);
  1719.     }
  1721.     if (params->Verbose != 1)
  1722.     {
  1723.       error("Redundant slices not supported when Verbose != 1", 100);
  1724.     }
  1725.   }
  1727.   key_frame = 0;
  1728.   redundant_coding = 0;
  1729.   img->redundant_pic_cnt = 0;
  1730.   frameNuminGOP = img->frm_number % params->PrimaryGOPLength;
  1731.   if (img->frm_number == 0)
  1732.   {
  1733.     frameNuminGOP = -1;
  1734.   }
  1735. }
  1737. /*!
  1738.  ************************************************************************
  1739.  * brief
  1740.  *    allocate redundant frames in a primary GOP.
  1741.  ************************************************************************
  1742.  */
  1743. void Set_redundant_frame()
  1744. {
  1745.   int GOPlength = params->PrimaryGOPLength;
  1747.   //start frame of GOP
  1748.   if (frameNuminGOP == 0)
  1749.   {
  1750.     redundant_coding = 0;
  1751.     key_frame = 1;
  1752.     redundant_ref_idx = GOPlength;
  1753.   }
  1755.   //1/2 position
  1756.   if (params->NumRedundantHierarchy > 0)
  1757.   {
  1758.     if (frameNuminGOP == GOPlength/2)
  1759.     {
  1760.       redundant_coding = 0;
  1761.       key_frame = 1;
  1762.       redundant_ref_idx = GOPlength/2;
  1763.     }
  1764.   }
  1766.   //1/4, 3/4 position
  1767.   if (params->NumRedundantHierarchy > 1)
  1768.   {
  1769.     if (frameNuminGOP == GOPlength/4 || frameNuminGOP == GOPlength*3/4)
  1770.     {
  1771.       redundant_coding = 0;
  1772.       key_frame = 1;
  1773.       redundant_ref_idx = GOPlength/4;
  1774.     }
  1775.   }
  1777.   //1/8, 3/8, 5/8, 7/8 position
  1778.   if (params->NumRedundantHierarchy > 2)
  1779.   {
  1780.     if (frameNuminGOP == GOPlength/8 || frameNuminGOP == GOPlength*3/8
  1781.       || frameNuminGOP == GOPlength*5/8 || frameNuminGOP == GOPlength*7/8)
  1782.     {
  1783.       redundant_coding = 0;
  1784.       key_frame = 1;
  1785.       redundant_ref_idx = GOPlength/8;
  1786.     }
  1787.   }
  1789.   //1/16, 3/16, 5/16, 7/16, 9/16, 11/16, 13/16 position
  1790.   if (params->NumRedundantHierarchy > 3)
  1791.   {
  1792.     if (frameNuminGOP == GOPlength/16 || frameNuminGOP == GOPlength*3/16
  1793.       || frameNuminGOP == GOPlength*5/16 || frameNuminGOP == GOPlength*7/16
  1794.       || frameNuminGOP == GOPlength*9/16 || frameNuminGOP == GOPlength*11/16
  1795.       || frameNuminGOP == GOPlength*13/16)
  1796.     {
  1797.       redundant_coding = 0;
  1798.       key_frame = 1;
  1799.       redundant_ref_idx = GOPlength/16;
  1800.     }
  1801.   }
  1802. }
  1804. /*!
  1805.  ************************************************************************
  1806.  * brief
  1807.  *    encode on redundant frame.
  1808.  ************************************************************************
  1809.  */
  1810. void encode_one_redundant_frame()
  1811. {
  1812.   key_frame = 0;
  1813.   redundant_coding = 1;
  1814.   img->redundant_pic_cnt = 1;
  1816.   if (img->type == I_SLICE)
  1817.   {
  1818.     set_slice_type( P_SLICE );
  1819.   }
  1821.   encode_one_frame();
  1822. }
  1824. /*!
  1825.  ************************************************************************
  1826.  * brief
  1827.  *    Setup Chroma MC Variables
  1828.  ************************************************************************
  1829.  */
  1830. void chroma_mc_setup(void)
  1831. {
  1832.   // initialize global variables used for chroma interpolation and buffering
  1833.   if ( img->yuv_format == YUV420 )
  1834.   {
  1835.     img_pad_size_uv_x = IMG_PAD_SIZE >> 1;
  1836.     img_pad_size_uv_y = IMG_PAD_SIZE >> 1;
  1837.     chroma_mask_mv_y = 7;
  1838.     chroma_mask_mv_x = 7;
  1839.     chroma_shift_x = 3;
  1840.     chroma_shift_y = 3;
  1841.   }
  1842.   else if ( img->yuv_format == YUV422 )
  1843.   {
  1844.     img_pad_size_uv_x = IMG_PAD_SIZE >> 1;
  1845.     img_pad_size_uv_y = IMG_PAD_SIZE;
  1846.     chroma_mask_mv_y = 3;
  1847.     chroma_mask_mv_x = 7;
  1848.     chroma_shift_y = 2;
  1849.     chroma_shift_x = 3;
  1850.   }
  1851.   else
  1852.   { // YUV444
  1853.     img_pad_size_uv_x = IMG_PAD_SIZE;
  1854.     img_pad_size_uv_y = IMG_PAD_SIZE;
  1855.     chroma_mask_mv_y = 3;
  1856.     chroma_mask_mv_x = 3;
  1857.     chroma_shift_y = 2;
  1858.     chroma_shift_x = 2;
  1859.   }
  1860.   shift_cr_y  = chroma_shift_y - 2;
  1861.   shift_cr_x  = chroma_shift_x - 2;
  1862. }