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

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

Audio

开发平台：

Visual C++

rdopt.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file rdopt.c
  5.  *
  6.  * brief
  7.  *    Rate-Distortion optimized mode decision
  8.  *
  9.  * author
  10.  *    - Heiko Schwarz              <hschwarz@hhi.de>
  11.  *    - Valeri George              <george@hhi.de>
  12.  *    - Lowell Winger              <lwinger@lsil.com>
  13.  *    - Alexis Michael Tourapis    <alexismt@ieee.org>
  14.  * date
  15.  *    12. April 2001
  16.  **************************************************************************
  17.  */
  19. #include <math.h>
  20. #include <limits.h>
  22. #include "global.h"
  24. #include "rdopt.h"
  25. #include "q_around.h"
  26. #include "rdopt_coding_state.h"
  27. #include "memalloc.h"
  28. #include "mb_access.h"
  29. #include "elements.h"
  30. #include "intrarefresh.h"
  31. #include "image.h"
  32. #include "transform8x8.h"
  33. #include "cabac.h"
  34. #include "vlc.h"
  35. #include "me_umhex.h"
  36. #include "ratectl.h"            // head file for rate control
  37. #include "mode_decision.h"
  38. #include "rd_intra_jm.h"
  39. #include "fmo.h"
  40. #include "macroblock.h"
  41. #include "symbol.h"
  42. #include "q_offsets.h"
  43. #include "conformance.h"
  44. #include "errdo.h"
  46. imgpel pred[16][16];
  48. #define FASTMODE 1
  49. //#define RESET_STATE
  52. imgpel   rec_mbY[16][16], rec_mb_cr[2][16][16];    // reconstruction values
  54. int lrec_rec[MB_BLOCK_SIZE][MB_BLOCK_SIZE],lrec_rec_uv[2][MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // store the transf. and quantized coefficients for SP frames
  56. static int diff[16];
  57. static int diff4x4[64];
  58. static int diff8x8[64];
  59. RD_8x8DATA tr4x4, tr8x8;
  62. int   ****cofAC=NULL, ****cofAC8x8=NULL;        // [8x8block][4x4block][level/run][scan_pos]
  63. int   ***cofDC=NULL;                       // [yuv][level/run][scan_pos]
  64. int   **cofAC4x4=NULL, ****cofAC4x4intern=NULL; // [level/run][scan_pos]
  65. int   cbp, cbp8x8, cnt_nonz_8x8;
  66. int   cbp_blk8x8;
  67. char  l0_refframe[4][4], l1_refframe[4][4];
  68. short b8mode[4], b8pdir[4], b8bipred_me[4];
  70. CSptr cs_mb=NULL, cs_b8=NULL, cs_cm=NULL, cs_ib8=NULL, cs_ib4=NULL;
  71. int   best_c_imode;
  72. int   best_i16offset;
  73. short best_mode;
  76. //mixed transform sizes definitions
  77. int   luma_transform_size_8x8_flag;
  79. short all_mv8x8[2][2][4][4][2];       //[8x8_data/temp_data][LIST][block_x][block_y][MVx/MVy]
  80. short pred_mv8x8[2][2][4][4][2];
  82. int   ****cofAC8x8ts[3] = {NULL, NULL, NULL};        // [plane][8x8block][4x4block][level/run][scan_pos]
  83. int   ****cofAC8x8CbCr[2];
  84. int   **cofAC4x4CbCr[2];
  85. int   ****cofAC4x4CbCrintern[2];
  87. int64    cbp_blk8_8x8ts;
  88. int      cbp8_8x8ts;
  89. int      cost8_8x8ts;
  90. int      cnt_nonz8_8x8ts;
  92. // adaptive langrangian parameters
  93. double mb16x16_cost;
  94. double lambda_mf_factor;
  96. void StoreMV8x8(int dir);
  97. void RestoreMV8x8(int dir);
  98. // end of mixed transform sizes definitions
  100. char  b4_ipredmode[16], b4_intra_pred_modes[16];
  102. /*!
  103.  ************************************************************************
  104.  * brief
  105.  *    delete structure for RD-optimized mode decision
  106.  ************************************************************************
  107.  */
  108. void clear_rdopt (InputParameters *params)
  109. {
  110.   free_mem_DCcoeff (cofDC);
  111.   free_mem_ACcoeff (cofAC);
  112.   free_mem_ACcoeff (cofAC8x8);
  113.   free_mem_ACcoeff (cofAC4x4intern);
  115.   if (params->Transform8x8Mode)
  116.   {
  117.     free_mem_ACcoeff (cofAC8x8ts[0]);
  118.     //if (img->P444_joined)
  119.     {
  120.       free_mem_ACcoeff (cofAC8x8ts[1]);
  121.       free_mem_ACcoeff (cofAC8x8ts[2]);
  122.     }
  123.   }
  124.   //if (img->P444_joined)
  125.   {
  126.     free_mem_ACcoeff (cofAC8x8CbCr[0]);
  127.     free_mem_ACcoeff (cofAC8x8CbCr[1]);
  128.     free_mem_ACcoeff (cofAC4x4CbCrintern[0]);
  129.     free_mem_ACcoeff (cofAC4x4CbCrintern[1]);
  130.   }
  132.   if (params->AdaptiveRounding)
  133.   {
  134.     clear_adaptive_rounding (params);
  135.   }
  137.   // structure for saving the coding state
  138.   delete_coding_state (cs_mb);
  139.   delete_coding_state (cs_b8);
  140.   delete_coding_state (cs_cm);
  141.   delete_coding_state (cs_ib8);
  142.   delete_coding_state (cs_ib4);
  143. }
  146. /*!
  147.  ************************************************************************
  148.  * brief
  149.  *    create structure for RD-optimized mode decision
  150.  ************************************************************************
  151.  */
  152. void init_rdopt (InputParameters *params)
  153. {
  154.   rdopt = NULL;
  156.   get_mem_DCcoeff (&cofDC);
  157.   get_mem_ACcoeff (&cofAC);
  158.   get_mem_ACcoeff (&cofAC8x8);
  159.   get_mem_ACcoeff (&cofAC4x4intern);
  160.   cofAC4x4 = cofAC4x4intern[0][0];
  162.   if (params->Transform8x8Mode)
  163.   {
  164.     get_mem_ACcoeff (&cofAC8x8ts[0]);
  165.     //if (img->P444_joined)
  166.     {
  167.       get_mem_ACcoeff (&cofAC8x8ts[1]);
  168.       get_mem_ACcoeff (&cofAC8x8ts[2]);
  169.     }
  170.   }
  172.   //if (img->P444_joined)
  173.   {
  174.     get_mem_ACcoeff (&cofAC8x8CbCr[0]);
  175.     get_mem_ACcoeff (&cofAC8x8CbCr[1]);
  177.     get_mem_ACcoeff (&cofAC4x4CbCrintern[0]);
  178.     get_mem_ACcoeff (&cofAC4x4CbCrintern[1]);
  179.     cofAC4x4CbCr[0] = cofAC4x4CbCrintern[0][0][0];
  180.     cofAC4x4CbCr[1] = cofAC4x4CbCrintern[1][0][0];    
  181.   }
  183.   SetLagrangianMultipliers = params->rdopt == 0 ? SetLagrangianMultipliersOff : SetLagrangianMultipliersOn;
  185.   switch (params->rdopt)
  186.   {
  187.   case 0:
  188.     encode_one_macroblock = encode_one_macroblock_low;
  189.     break;
  190.   case 1:
  191.   default:
  192.     encode_one_macroblock = encode_one_macroblock_high;
  193.     break;
  194.   case 2:
  195.     encode_one_macroblock = encode_one_macroblock_highfast;
  196.     break;
  197.   case 3:
  198.     encode_one_macroblock = encode_one_macroblock_highloss;
  199.     break;
  200.   }
  201.   if (params->AdaptiveRounding)
  202.   {
  203.     setup_adaptive_rounding (params);
  204.   }
  206.   // structure for saving the coding state
  207.   cs_mb  = create_coding_state ();
  208.   cs_b8  = create_coding_state ();
  209.   cs_cm  = create_coding_state ();
  210.   cs_ib8 = create_coding_state ();
  211.   cs_ib4 = create_coding_state ();
  213.   if (params->CtxAdptLagrangeMult == 1)
  214.   {
  215.     mb16x16_cost = CALM_MF_FACTOR_THRESHOLD;
  216.     lambda_mf_factor = 1.0;
  217.   }
  219.   getDistortion = distortionSSE;
  220. }
  224. /*!
  225.  *************************************************************************************
  226.  * brief
  227.  *    Updates the pixel map that shows, which reference frames are reliable for
  228.  *    each MB-area of the picture.
  229.  *
  230.  * note
  231.  *    The new values of the pixel_map are taken from the temporary buffer refresh_map
  232.  *
  233.  *************************************************************************************
  234.  */
  235. void UpdatePixelMap()
  236. {
  237.   int mx,my,y,x,i,j;
  238.   if (img->type==I_SLICE)
  239.   {
  240.     memset(pixel_map, 1, img->height * img->width * sizeof(byte));
  241.   }
  242.   else
  243.   {
  244.     for (my=0; my<img->height >> 3; my++)
  245.       for (mx=0; mx<img->width >> 3;  mx++)
  246.       {
  247.         j = my*8 + 8;
  248.         i = mx*8 + 8;
  249.         if (refresh_map[my][mx])
  250.         {
  251.           for (y=my*8; y<j; y++)
  252.             memset(&pixel_map[y][mx*8], 1, 8 * sizeof(byte));
  253.         }
  254.         else
  255.         {
  256.           for (y=my*8; y<j; y++)
  257.             for (x=mx*8; x<i; x++)
  258.             {
  259.               pixel_map[y][x] = imin(pixel_map[y][x] + 1, params->num_ref_frames+1);
  260.             }
  261.         }
  262.       }
  263.   }
  264. }
  266. /*!
  267.  *************************************************************************************
  268.  * brief
  269.  *    Checks if a given reference frame is reliable for the current
  270.  *    macroblock, given the motion vectors that the motion search has
  271.  *    returned.
  272.  *
  273.  * return
  274.  *    If the return value is 1, the reference frame is reliable. If it
  275.  *    is 0, then it is not reliable.
  276.  *
  277.  * note
  278.  *    A specific area in each reference frame is assumed to be unreliable
  279.  *    if the same area has been intra-refreshed in a subsequent frame.
  280.  *    The information about intra-refreshed areas is kept in the pixel_map.
  281.  *
  282.  *************************************************************************************
  283.  */
  284. int CheckReliabilityOfRef (int block, int list_idx, int ref, int mode)
  285. {
  286.   int y,x, block_y, block_x, dy, dx, y_pos, x_pos, yy, xx, pres_x, pres_y;
  287.   int maxold_x  = img->width-1;
  288.   int maxold_y  = img->height-1;
  289.   int ref_frame = ref + 1;
  291.   int by0 = (mode>=4?2*(block >> 1):mode==2?2*block:0);
  292.   int by1 = by0 + (mode>=4||mode==2?2:4);
  293.   int bx0 = (mode>=4?2*(block & 0x01):mode==3?2*block:0);
  294.   int bx1 = bx0 + (mode>=4||mode==3?2:4);
  296.   for (block_y=by0; block_y<by1; block_y++)
  297.   {
  298.     for (block_x=bx0; block_x<bx1; block_x++)
  299.     {
  300.       y_pos  = img->all_mv[list_idx][ref][mode][block_y][block_x][1];
  301.       y_pos += (img->block_y + block_y) * BLOCK_SIZE * 4;
  302.       x_pos  = img->all_mv[list_idx][ref][mode][block_y][block_x][0];
  303.       x_pos += (img->block_x + block_x) * BLOCK_SIZE * 4;
  305.       /* Here we specify which pixels of the reference frame influence
  306.       the reference values and check their reliability. This is
  307.       based on the function Get_Reference_Pixel */
  309.       dy = y_pos & 3;
  310.       dx = x_pos & 3;
  312.       y_pos = (y_pos - dy) >> 2;
  313.       x_pos = (x_pos - dx) >> 2;
  315.       if (dy==0 && dx==0) //full-pel
  316.       {
  317.         for (y=y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  318.           for (x=x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  319.             if (pixel_map[iClip3(0,maxold_y,y)][iClip3(0,maxold_x,x)] < ref_frame)
  320.               return 0;
  321.       }
  322.       else  /* other positions */
  323.       {
  324.         if (dy == 0)
  325.         {
  326.           for (y = y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  327.           {
  328.             pres_y = iClip3(0, maxold_y, y);
  329.             for (x = x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  330.             {
  331.               for(xx = -2 ; xx < 4 ; xx++) 
  332.               {
  333.                 pres_x = iClip3(0, maxold_x, x + xx);
  334.                 if (pixel_map[pres_y][pres_x] < ref_frame)
  335.                   return 0;
  336.               }
  337.             }
  338.           }
  339.         }
  340.         else if (dx == 0)
  341.         {
  342.           for (y = y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  343.             for (x=x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  344.             {
  345.               pres_x = iClip3(0,maxold_x,x);
  346.               for(yy=-2;yy<4;yy++) 
  347.               {
  348.                 pres_y = iClip3(0,maxold_y, yy + y);
  349.                 if (pixel_map[pres_y][pres_x] < ref_frame)
  350.                   return 0;
  351.               }
  352.             }
  353.         }
  354.         else if (dx == 2)
  355.         {
  356.           for (y = y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  357.             for (x = x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  358.             {
  359.               for(yy=-2;yy<4;yy++) 
  360.               {
  361.                 pres_y = iClip3(0,maxold_y, yy + y);
  362.                 for(xx=-2;xx<4;xx++) 
  363.                 {
  364.                   pres_x = iClip3(0,maxold_x, xx + x);
  365.                   if (pixel_map[pres_y][pres_x] < ref_frame)
  366.                     return 0;
  367.                 }
  368.               }
  369.             }
  370.         }
  371.         else if (dy == 2)
  372.         {
  373.           for (y = y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  374.             for (x = x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  375.             {
  376.               for(xx=-2;xx<4;xx++) 
  377.               {
  378.                 pres_x = iClip3(0,maxold_x, xx + x);
  379.                 for(yy=-2;yy<4;yy++) 
  380.                 {
  381.                   pres_y = iClip3(0,maxold_y, yy + y);
  382.                   if (pixel_map[pres_y][pres_x] < ref_frame)
  383.                     return 0;
  384.                 }
  385.               }
  386.             }
  387.         }
  388.         else
  389.         {
  390.           for (y = y_pos ; y < y_pos + BLOCK_SIZE ; y++)
  391.           {
  392.             for (x = x_pos ; x < x_pos + BLOCK_SIZE ; x++)
  393.             {
  394.               pres_y = dy == 1 ? y : y + 1;
  395.               pres_y = iClip3(0,maxold_y,pres_y);
  397.               for(xx=-2;xx<4;xx++)
  398.               {
  399.                 pres_x = iClip3(0,maxold_x,xx + x);
  400.                 if (pixel_map[pres_y][pres_x] < ref_frame)
  401.                   return 0;
  402.               }
  404.               pres_x = dx == 1 ? x : x + 1;
  405.               pres_x = iClip3(0,maxold_x,pres_x);
  407.               for(yy=-2;yy<4;yy++)
  408.               {
  409.                 pres_y = iClip3(0,maxold_y, yy + y);
  410.                 if (pixel_map[pres_y][pres_x] < ref_frame)
  411.                   return 0;
  412.               }
  413.             }
  414.           }
  415.         }
  416.       }
  417.     }
  418.   }
  419.   return 1;
  420. }
  424. /*!
  425.  *************************************************************************************
  426.  * brief
  427.  *    R-D Cost for an 4x4 Intra block
  428.  *************************************************************************************
  429.  */
  430. double RDCost_for_4x4IntraBlocks (Macroblock    *currMB,
  431.                                   int*    nonzero,
  432.                                   int     b8,
  433.                                   int     b4,
  434.                                   int     ipmode,
  435.                                   double  lambda,
  436.                                   int     mostProbableMode,
  437.                                   int     c_nzCbCr[3],
  438.                                   int     is_cavlc)
  439. {
  440.   double  rdcost;
  441.   int     dummy = 0, rate;
  442.   int64   distortion  = 0;
  443.   int     block_x     = ((b8 & 0x01) << 3) + ((b4 & 0x01) << 2);
  444.   int     block_y     = ((b8 >> 1) << 3) + ((b4 >> 1) << 2);
  445.   int     pic_pix_x   = img->pix_x  + block_x;
  446.   int     pic_pix_y   = img->pix_y  + block_y;
  447.   int     pic_opix_y  = img->opix_y + block_y;
  449.   Slice          *currSlice = img->currentSlice;
  450.   SyntaxElement  se;
  451.   const int      *partMap   = assignSE2partition[params->partition_mode];
  452.   DataPartition  *dataPart;
  454.   //===== perform DCT, Q, IQ, IDCT, Reconstruction =====
  455.   //select_dct(img, currMB);
  456.   *nonzero = pDCT_4x4 (currMB, PLANE_Y, block_x, block_y, &dummy, 1, is_cavlc);
  458.   //===== get distortion (SSD) of 4x4 block =====
  459.   distortion += compute_SSE(&pCurImg[pic_opix_y], &enc_picture->imgY[pic_pix_y], pic_pix_x, pic_pix_x, 4, 4);
  461.   if(img->P444_joined)
  462.   {
  463.     ColorPlane k;
  464.     for (k = PLANE_U; k <= PLANE_V; k++)
  465.     {
  466.       select_plane(k);
  467.       c_nzCbCr[k] = pDCT_4x4(currMB, k, block_x, block_y, &dummy, 1, is_cavlc);
  468.       distortion += compute_SSE(&pCurImg[pic_opix_y], &enc_picture->p_curr_img[pic_pix_y], pic_pix_x, pic_pix_x, 4, 4);
  469.     }
  470.     select_plane(PLANE_Y);
  471.   }
  472.   ipmode_DPCM=NO_INTRA_PMODE;
  474.   //===== RATE for INTRA PREDICTION MODE  (SYMBOL MODE MUST BE SET TO CAVLC) =====
  475.   se.value1 = (mostProbableMode == ipmode) ? -1 : ipmode < mostProbableMode ? ipmode : ipmode - 1;
  477.   //--- set position and type ---
  478.   se.context = (b8 << 2) + b4;
  479.   se.type    = SE_INTRAPREDMODE;
  481.   //--- choose data partition ---
  482.   dataPart = &(currSlice->partArr[partMap[SE_INTRAPREDMODE]]);
  483.   //--- encode and update rate ---
  484.   writeIntraPredMode (&se, dataPart);
  485.   rate = se.len;
  487.   //===== RATE for LUMINANCE COEFFICIENTS =====
  488.   if (is_cavlc)
  489.   {
  490.     rate  += writeCoeff4x4_CAVLC (currMB, LUMA, b8, b4, 0);
  491.     if(img->P444_joined) 
  492.     {
  493.       rate  += writeCoeff4x4_CAVLC (currMB, CB, b8, b4, 0);
  494.       rate  += writeCoeff4x4_CAVLC (currMB, CR, b8, b4, 0);
  495.     }
  496.   }
  497.   else
  498.   {
  499.     rate  += writeCoeff4x4_CABAC (currMB, PLANE_Y, b8, b4, 1);
  500.     if(img->P444_joined) 
  501.     {
  502.       rate  += writeCoeff4x4_CABAC (currMB, PLANE_U, b8, b4, 1);
  503.       rate  += writeCoeff4x4_CABAC (currMB, PLANE_V, b8, b4, 1);
  504.     }
  505.   }
  506.   //reset_coding_state (currMB, cs_cm);
  507.   rdcost = (double)distortion + lambda * (double) rate;
  509.   return rdcost;
  510. }
  512. /*!
  513. *************************************************************************************
  514. * brief
  515. *    R-D Cost for an 8x8 Partition
  516. *************************************************************************************
  517. */
  518. double RDCost_for_8x8blocks (Macroblock *currMB, // --> Current macroblock to code
  519.                              int*    cnt_nonz,   // --> number of nonzero coefficients
  520.                              int64*  cbp_blk,    // --> cbp blk
  521.                              double  lambda,     // <-- lagrange multiplier
  522.                              int     block,      // <-- 8x8 block number
  523.                              int     mode,       // <-- partitioning mode
  524.                              short   pdir,       // <-- prediction direction
  525.                              short   l0_ref,     // <-- L0 reference picture
  526.                              short   l1_ref,     // <-- L1 reference picture
  527.                              short   bipred_me,  // <-- bi prediction mode
  528.                              int     is_cavlc
  529.                              )     
  530. {
  531.   int  k;
  532.   int  rate=0;
  533.   int64 distortion=0;
  534.   int  dummy = 0, mrate;
  535.   int  fw_mode, bw_mode;
  536.   int  cbp     = 0;
  537.   int  pax     = 8*(block & 0x01);
  538.   int  pay     = 8*(block >> 1);
  539.   int  i0      = pax >> 2;
  540.   int  j0      = pay >> 2;
  541.   int  bframe  = (img->type==B_SLICE);
  542.   int  direct  = (bframe && mode==0);
  543.   int  b8value = B8Mode2Value (mode, pdir);
  545.   SyntaxElement se;
  546.   Slice         *currSlice = img->currentSlice;
  547.   DataPartition *dataPart;
  548.   const int     *partMap   = assignSE2partition[params->partition_mode];
  550.   EncodingEnvironmentPtr eep_dp;
  552.   //=====
  553.   //=====  GET COEFFICIENTS, RECONSTRUCTIONS, CBP
  554.   //=====
  555.   currMB->bipred_me[block] = bipred_me;
  556.   
  557.   if (direct)
  558.   {
  559.     if (direct_pdir[img->block_y+j0][img->block_x+i0]<0) // mode not allowed
  560.       return (1e20);
  561.     else
  562.       *cnt_nonz = LumaResidualCoding8x8 (currMB, &cbp, cbp_blk, block, direct_pdir[img->block_y+j0][img->block_x+i0], 0, 0,
  563.       (short)imax(0,direct_ref_idx[LIST_0][img->block_y+j0][img->block_x+i0]),
  564.       direct_ref_idx[LIST_1][img->block_y+j0][img->block_x+i0], is_cavlc);
  565.   }
  566.   else
  567.   {
  568.     if (pdir == 2 && active_pps->weighted_bipred_idc == 1)
  569.     {
  570.       int weight_sum = (active_pps->weighted_bipred_idc == 1)? wbp_weight[0][l0_ref][l1_ref][0] + wbp_weight[1][l0_ref][l1_ref][0] : 0;
  571.       if (weight_sum < -128 ||  weight_sum > 127)
  572.       {
  573.         return (1e20);
  574.       }
  575.     }
  577.     fw_mode   = (pdir==0||pdir==2 ? mode : 0);
  578.     bw_mode   = (pdir==1||pdir==2 ? mode : 0);
  579.     *cnt_nonz = LumaResidualCoding8x8 (currMB, &cbp, cbp_blk, block, pdir, fw_mode, bw_mode, l0_ref, l1_ref, is_cavlc);
  580.   }
  582.   if(img->P444_joined) 
  583.   {
  584.     *cnt_nonz += ( coeff_cost_cr[1] + coeff_cost_cr[2] );
  585.   }
  587.   // RDOPT with losses
  588.   if (params->rdopt==3 && img->type!=B_SLICE)
  589.   {
  590.     //===== get residue =====
  591.     // We need the reconstructed prediction residue for the simulated decoders.
  592.     //compute_residue_b8block (img, &enc_picture->p_img[0][img->pix_y], decs->res_img[0], block, -1);
  593.     compute_residue_block (img, &enc_picture->p_img[0][img->pix_y], decs->res_img[0], img->mb_pred[0], block, 8);
  595.     //=====
  596.     //=====   GET DISTORTION
  597.     //=====
  598.     for (k=0; k<params->NoOfDecoders ;k++)
  599.     {
  600.       decode_one_b8block (img, enc_picture, k, P8x8, block, mode, l0_ref);
  601.       distortion += compute_SSE(&pCurImg[img->opix_y+pay], &enc_picture->p_dec_img[0][k][img->opix_y+pay], img->opix_x+pax, img->opix_x+pax, 8, 8);
  602.     }
  603.     distortion /= params->NoOfDecoders;
  604.   }
  605.   else
  606.   {    
  607.     distortion += compute_SSE(&pCurImg[img->opix_y + pay], &enc_picture->imgY[img->pix_y + pay], img->opix_x + pax, img->pix_x + pax, 8, 8);
  609.     if (img->P444_joined)
  610.     {
  611.       distortion += compute_SSE(&pImgOrg[1][img->opix_y + pay], &enc_picture->imgUV[0][img->pix_y + pay], img->opix_x + pax, img->pix_x + pax, 8, 8);
  612.       distortion += compute_SSE(&pImgOrg[2][img->opix_y + pay], &enc_picture->imgUV[1][img->pix_y + pay], img->opix_x + pax, img->pix_x + pax, 8, 8);
  613.     }    
  614.   }
  616.   if(img->P444_joined) 
  617.   {   
  618.     cbp |= cmp_cbp[1];
  619.     cbp |= cmp_cbp[2];
  621.     cmp_cbp[1] = cbp;
  622.     cmp_cbp[2] = cbp;
  623.   }
  625.   //=====
  626.   //=====   GET RATE
  627.   //=====
  628.   //----- block 8x8 mode -----
  629.   if (is_cavlc)
  630.   {
  631.     ue_linfo (b8value, dummy, &mrate, &dummy);
  632.     rate += mrate;
  633.   }
  634.   else
  635.   {
  636.     se.value1 = b8value;
  637.     se.type   = SE_MBTYPE;
  638.     dataPart  = &(currSlice->partArr[partMap[se.type]]);
  639.     writeB8_typeInfo(&se, dataPart);
  640.     rate += se.len;
  641.   }
  643.   //----- motion information -----
  644.   if (!direct)
  645.   {
  646.     if ((img->num_ref_idx_l0_active > 1 ) && (pdir==0 || pdir==2))
  647.       rate  += writeReferenceFrame (currMB, mode, i0, j0, 1, l0_ref);
  649.     if ((img->num_ref_idx_l1_active > 1 && img->type== B_SLICE ) && (pdir==1 || pdir==2))
  650.     {
  651.       rate  += writeReferenceFrame (currMB, mode, i0, j0, 0, l1_ref);
  652.     }
  654.     if (pdir==0 || pdir==2)
  655.     {
  656.       rate  += writeMotionVector8x8 (currMB, i0, j0, i0 + 2, j0 + 2, l0_ref, LIST_0, mode, currMB->bipred_me[block]);
  657.     }
  658.     if (pdir==1 || pdir==2)
  659.     {
  660.       rate  += writeMotionVector8x8 (currMB, i0, j0, i0 + 2, j0 + 2, l1_ref, LIST_1, mode, currMB->bipred_me[block]);
  661.     }
  662.   }
  664.   //----- coded block pattern (for CABAC only) -----
  665.   if (!is_cavlc)
  666.   {
  667.     dataPart = &(currSlice->partArr[partMap[SE_CBP]]);
  668.     eep_dp   = &(dataPart->ee_cabac);
  669.     mrate    = arienco_bits_written (eep_dp);
  670.     writeCBP_BIT_CABAC (currMB, block, ((*cnt_nonz>0)?1:0), cbp8x8, 1, eep_dp, img->currentSlice->tex_ctx);
  671.     mrate    = arienco_bits_written (eep_dp) - mrate;
  672.     rate    += mrate;
  673.   }
  675.   //----- luminance coefficients -----
  676.   if (*cnt_nonz)
  677.   {
  678.     rate += writeCoeff8x8 (currMB, PLANE_Y, block, mode, currMB->luma_transform_size_8x8_flag);
  679.   }
  681.   if(img->P444_joined)
  682.   {
  683.     rate += writeCoeff8x8( currMB, PLANE_U, block, mode, currMB->luma_transform_size_8x8_flag );
  684.     rate += writeCoeff8x8( currMB, PLANE_V, block, mode, currMB->luma_transform_size_8x8_flag );
  685.   }
  687.   return (double)distortion + lambda * (double)rate;
  688. }
  691. /*!
  692.  *************************************************************************************
  693.  * brief
  694.  *    Gets mode offset for intra16x16 mode
  695.  *************************************************************************************
  696.  */
  697. int I16Offset (int cbp, int i16mode)
  698. {
  699.   return (cbp&15?13:1) + i16mode + ((cbp&0x30)>>2);
  700. }
  703. /*!
  704.  *************************************************************************************
  705.  * brief
  706.  *    Sets modes and reference frames for a macroblock
  707.  *************************************************************************************
  708.  */
  709. void SetModesAndRefframeForBlocks (Macroblock *currMB, int mode)
  710. {
  711.   int i,j,k,l; 
  712.   int  bframe  = (img->type==B_SLICE);
  713.   int  block_x, block_y, block8x8, block4x4;
  714.   int  cur_ref;
  715.   int  clist;
  716.   char cref[2], curref, bestref;
  717.   Block8x8Info *b8x8info = img->b8x8info;
  719.   //--- macroblock type ---
  720.   currMB->mb_type = mode;
  721.   
  722.    for( i = 0; i < 4; i++) 
  723.    {
  724.      currMB->bipred_me[i] = b8x8info->bipred8x8me[mode][i];
  725.    }
  727.   //--- block 8x8 mode and prediction direction ---
  728.   switch (mode)
  729.   {
  730.   case 0:
  731.     memset(currMB->b8mode, 0, 4 * sizeof(short));
  732.     if (bframe)
  733.     {      
  734.       for(i=0;i<4;i++)
  735.       {
  736.         currMB->b8pdir[i] = direct_pdir[img->block_y + ((i >> 1)<<1)][img->block_x + ((i & 0x01)<<1)];
  737.       }
  738.     }
  739.     else
  740.     {
  741.       memset(currMB->b8pdir, 0, 4 * sizeof(short));
  742.     }
  743.     break;
  744.   case 1:
  745.   case 2:
  746.   case 3:
  747.     for(i=0;i<4;i++)
  748.     {
  749.       currMB->b8mode[i] = mode;
  750.       currMB->b8pdir[i] = b8x8info->best8x8pdir[mode][i];
  751.     }
  752.     break;
  753.   case P8x8:
  754.     memcpy(currMB->b8mode, b8x8info->best8x8mode, 4 * sizeof(short));
  755.     for(i=0;i<4;i++)
  756.     {
  757.       currMB->b8pdir[i]   = b8x8info->best8x8pdir[mode][i];
  758.     }
  759.     break;
  760.   case I4MB:
  761.     for(i=0;i<4;i++)
  762.     {
  763.       currMB->b8mode[i] = IBLOCK;
  764.       currMB->b8pdir[i] = -1;
  765.     }
  766.     break;
  767.   case I16MB:
  768.     memset(currMB->b8mode, 0, 4 * sizeof(short));
  769.     for(i=0;i<4;i++)
  770.     {
  771.       currMB->b8pdir[i] = -1;
  772.     }
  773.     break;
  774.   case I8MB:
  775.     for(i=0;i<4;i++)
  776.     {
  777.       currMB->b8mode[i] = I8MB;
  778.       currMB->b8pdir[i] = -1;
  779.     }
  780.     //switch to 8x8 transform
  781.     currMB->luma_transform_size_8x8_flag = 1;
  782.     break;
  783.   case IPCM:
  784.     for(i=0;i<4;i++)
  785.     {
  786.       currMB->b8mode[i] = IPCM;
  787.       currMB->b8pdir[i] = -1;
  788.     }
  789.     currMB->luma_transform_size_8x8_flag = 0;
  790.     break;
  791.   default:
  792.     printf ("Unsupported mode in SetModesAndRefframeForBlocks!n");
  793.     exit (1);
  794.   }
  796. #define IS_FW ((b8x8info->best8x8pdir[mode][k]==0 || b8x8info->best8x8pdir[mode][k]==2) && (mode!=P8x8 || b8x8info->best8x8mode[k]!=0 || !bframe))
  797. #define IS_BW ((b8x8info->best8x8pdir[mode][k]==1 || b8x8info->best8x8pdir[mode][k]==2) && (mode!=P8x8 || b8x8info->best8x8mode[k]!=0))
  798.   
  799.   //--- reference frame arrays ---
  800.   if (mode==0 || mode==I4MB || mode==I16MB || mode==I8MB)
  801.   {
  802.     if (bframe)
  803.     {
  804.       if (!mode) // Direct
  805.       {
  806.         for (clist = LIST_0; clist <= LIST_1; clist++)
  807.         {
  808.           for (j = img->block_y; j < img->block_y + 4; j++)
  809.           {
  810.             memcpy(&enc_picture->motion.ref_idx[clist][j][img->block_x], &direct_ref_idx[clist][j][img->block_x], 4 * sizeof(char));
  811.           }
  812.         }
  813.       }
  814.       else // Intra
  815.       {
  816.         for (clist = LIST_0; clist <= LIST_1; clist++)
  817.         {
  818.           for (j = img->block_y; j < img->block_y + 4; j++)
  819.           {
  820.             memset(&enc_picture->motion.ref_idx[clist][j][img->block_x],-1, 4 * sizeof(char));
  821.           }
  822.         }
  823.       }
  824.     }
  825.     else
  826.     {
  827.       if (!mode) // Skip
  828.       {
  829.         for (j = img->block_y; j < img->block_y + 4; j++)
  830.           memset(&enc_picture->motion.ref_idx[LIST_0][j][img->block_x],0, 4 * sizeof(char));
  831.       }
  832.       else // Intra
  833.       {
  834.         for (j = img->block_y; j < img->block_y + 4; j++)
  835.           memset(&enc_picture->motion.ref_idx[LIST_0][j][img->block_x],-1, 4 * sizeof(char));
  836.       }
  837.     }
  838.   }
  839.   else
  840.   {
  841.     if (bframe)
  842.     {
  843.       if (mode == 1 || mode == 2 || mode == 3) 
  844.       {
  845.         for (block8x8 = 0; block8x8 < 4; block8x8++)
  846.         {
  847.           for (clist = LIST_0; clist <= LIST_1; clist++)
  848.           {
  849.             bestref = (clist == LIST_0) ? b8x8info->best8x8l0ref[mode][block8x8] :  b8x8info->best8x8l1ref[mode][block8x8];
  850.             if ( b8x8info->best8x8pdir[mode][block8x8] == 2)
  851.             {
  852.               if (b8x8info->bipred8x8me[mode][block8x8])
  853.                 curref = 0;
  854.               else  
  855.                 curref = bestref;
  856.             }
  857.             else
  858.             {
  859.               curref = (clist == b8x8info->best8x8pdir[mode][block8x8]) ? bestref : -1;
  860.             }
  861.             for (block4x4 = 0; block4x4 < 4; block4x4++)
  862.             {
  863.               block_x = img->block_x + 2 * (block8x8 & 0x01) + (block4x4 & 0x01);
  864.               block_y = img->block_y + 2 * (block8x8 >> 1) + (block4x4 >> 1);
  865.               enc_picture->motion.ref_idx[clist][block_y][block_x] = curref;
  866.             }
  867.           }
  868.         }
  869.       }
  870.       else
  871.       {
  872.         for (j=0;j<4;j++)
  873.         {
  874.           block_y = img->block_y + j;
  875.           for (i=0;i<4;i++)
  876.           {
  877.             block_x = img->block_x + i;
  878.             k = 2*(j >> 1) + (i >> 1);
  879.             l = 2*(j & 0x01) + (i & 0x01);
  881.             if(mode == P8x8 && b8x8info->best8x8mode[k]==0)
  882.             {
  883.               enc_picture->motion.ref_idx[LIST_0][block_y][block_x] = direct_ref_idx[LIST_0][block_y][block_x];
  884.               enc_picture->motion.ref_idx[LIST_1][block_y][block_x] = direct_ref_idx[LIST_1][block_y][block_x];
  885.             }
  886.             else
  887.             {
  888.               enc_picture->motion.ref_idx[LIST_0][block_y][block_x] = (IS_FW ? b8x8info->best8x8l0ref[mode][k] : -1);
  889.               enc_picture->motion.ref_idx[LIST_1][block_y][block_x] = (IS_BW ? b8x8info->best8x8l1ref[mode][k] : -1);
  890.             }
  891.           }        
  892.         }
  893.       }
  894.     }
  895.     else
  896.     {
  897.       if (mode == 1)
  898.       {
  899.         cref[0] = b8x8info->best8x8pdir[mode][0] == 0 ? b8x8info->best8x8l0ref[mode][0] : -1;
  900.         j = img->block_y;
  901.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  902.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  903.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  904.         memset(&enc_picture->motion.ref_idx[LIST_0][j  ][img->block_x], cref[0], 4 * sizeof(char));
  905.       }
  906.       else if (mode == 2)
  907.       {
  908.         cref[0] = b8x8info->best8x8pdir[mode][0] == 0 ? b8x8info->best8x8l0ref[mode][0] : -1;
  909.         j = img->block_y;
  910.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  911.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  912.         cref[0] = b8x8info->best8x8pdir[mode][2] == 0 ? b8x8info->best8x8l0ref[mode][2] : -1;
  913.         memset(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], cref[0], 4 * sizeof(char));
  914.         memset(&enc_picture->motion.ref_idx[LIST_0][j  ][img->block_x], cref[0], 4 * sizeof(char));
  915.       }      
  916.       else if (mode == 3)
  917.       {
  918.         j = img->block_y;
  919.         i = img->block_x;
  920.         cref[0] = (b8x8info->best8x8pdir[mode][0] == 0) ? b8x8info->best8x8l0ref[mode][0] : -1;
  921.         enc_picture->motion.ref_idx[LIST_0][j  ][i++] = cref[0];
  922.         enc_picture->motion.ref_idx[LIST_0][j  ][i++] = cref[0];
  923.         cref[0] = (b8x8info->best8x8pdir[mode][1] == 0) ? b8x8info->best8x8l0ref[mode][1] : -1;
  924.         enc_picture->motion.ref_idx[LIST_0][j  ][i++] = cref[0];
  925.         enc_picture->motion.ref_idx[LIST_0][j++][i  ] = cref[0];
  926.         memcpy(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], &enc_picture->motion.ref_idx[LIST_0][img->block_y][img->block_x], 4 * sizeof(char));
  927.         memcpy(&enc_picture->motion.ref_idx[LIST_0][j++][img->block_x], &enc_picture->motion.ref_idx[LIST_0][img->block_y][img->block_x], 4 * sizeof(char));
  928.         memcpy(&enc_picture->motion.ref_idx[LIST_0][j  ][img->block_x], &enc_picture->motion.ref_idx[LIST_0][img->block_y][img->block_x], 4 * sizeof(char));
  929.       }      
  930.       else
  931.       {
  932.         for (j=0;j<4;j++)
  933.         {
  934.           block_y = img->block_y + j;
  935.           for (i=0;i<4;i++)
  936.           {
  937.             block_x = img->block_x + i;
  938.             k = 2*(j >> 1) + (i >> 1);
  939.             l = 2*(j & 0x01) + (i & 0x01);
  940.             enc_picture->motion.ref_idx[LIST_0][block_y][block_x] = (IS_FW ? b8x8info->best8x8l0ref[mode][k] : -1);
  941.           }
  942.         }
  943.       }
  944.     }
  945.   }
  947.   if (bframe)
  948.   {
  949.     for (clist = LIST_0; clist <= LIST_1; clist++)
  950.     {
  951.       for (j = img->block_y; j < img->block_y + 4; j++)
  952.         for (i = img->block_x; i < img->block_x + 4;i++)
  953.         {
  954.           cur_ref = (int) enc_picture->motion.ref_idx[clist][j][i];
  955.           enc_picture->motion.ref_pic_id [clist][j][i] = (cur_ref>=0
  956.             ? enc_picture->ref_pic_num[clist + currMB->list_offset][cur_ref]
  957.             : -1);
  958.         }
  959.     }
  960.   }
  961.   else
  962.   {
  963.     for (j = img->block_y; j < img->block_y + 4; j++)
  964.       for (i = img->block_x; i < img->block_x + 4;i++)
  965.       {
  966.         cur_ref = (int) enc_picture->motion.ref_idx[LIST_0][j][i];
  967.         enc_picture->motion.ref_pic_id [LIST_0][j][i] = (cur_ref>=0
  968.           ? enc_picture->ref_pic_num[LIST_0 + currMB->list_offset][cur_ref]
  969.           : -1);
  970.       }
  971.   }
  973. #undef IS_FW
  974. #undef IS_BW
  975. }
  981. /*!
  982.  *************************************************************************************
  983.  * brief
  984.  *    Sets Coefficients and reconstruction for an 8x8 block
  985.  *************************************************************************************
  986.  */
  987. void SetCoeffAndReconstruction8x8 (Macroblock* currMB)
  988. {
  989.   int block, k, j, i, uv;
  990.   int cur_ref;
  992.   //============= MIXED TRANSFORM SIZES FOR 8x8 PARTITION ==============
  993.   //--------------------------------------------------------------------
  994.   int l;
  995.   int bframe = img->type==B_SLICE;
  997.   if (currMB->luma_transform_size_8x8_flag)
  998.   {
  999.     //============= set mode and ref. frames ==============
  1000.     for(i = 0;i<4;i++)
  1001.     {
  1002.       currMB->b8mode[i]    = tr8x8.part8x8mode[i];
  1003.       currMB->b8pdir[i]    = tr8x8.part8x8pdir[i];
  1004.       currMB->bipred_me[i] = tr8x8.part8x8bipred[i];
  1005.      }
  1007.     if (bframe)
  1008.     {
  1009.       for (j = 0;j<4;j++)
  1010.       {
  1011.         for (i = 0;i<4;i++)
  1012.         {
  1013.           k = 2*(j >> 1)+(i >> 1);
  1014.           l = 2*(j & 0x01)+(i & 0x01);
  1015.           enc_picture->motion.ref_idx[LIST_0][img->block_y+j][img->block_x+i] = ((currMB->b8pdir[k] & 0x01) == 0) ? tr8x8.part8x8l0ref[k] : - 1;
  1016.           enc_picture->motion.ref_idx[LIST_1][img->block_y+j][img->block_x+i] =  (currMB->b8pdir[k] > 0)          ? tr8x8.part8x8l1ref[k] : - 1;
  1017.         }
  1018.       }
  1019.     }
  1020.     else
  1021.     {
  1022.       for (j = 0;j<4;j++)
  1023.       {
  1024.         for (i = 0;i<4;i++)
  1025.         {
  1026.           k = 2*(j >> 1)+(i >> 1);
  1027.           l = 2*(j & 0x01)+(i & 0x01);
  1028.           enc_picture->motion.ref_idx[LIST_0][img->block_y+j][img->block_x+i] = tr8x8.part8x8l0ref[k];
  1029.         }
  1030.       }
  1031.     }
  1034.     for (j = img->block_y;j<img->block_y + BLOCK_MULTIPLE;j++)
  1035.     {
  1036.       for (i = img->block_x;i<img->block_x + BLOCK_MULTIPLE;i++)
  1037.       {
  1038.         cur_ref = (int) enc_picture->motion.ref_idx[LIST_0][j][i];
  1040.         enc_picture->motion.ref_pic_id [LIST_0][j][i] =(cur_ref>=0
  1041.           ? enc_picture->ref_pic_num[LIST_0 + currMB->list_offset][cur_ref]
  1042.           : -1);
  1043.       }
  1044.     }
  1046.     if (bframe)
  1047.     {
  1048.       for (j = img->block_y; j < img->block_y + BLOCK_MULTIPLE; j++)
  1049.       {
  1050.         for (i = img->block_x;i<img->block_x + BLOCK_MULTIPLE;i++)
  1051.         {
  1052.           cur_ref = (int) enc_picture->motion.ref_idx[LIST_1][j][i];
  1054.           enc_picture->motion.ref_pic_id [LIST_1][j][i] = (cur_ref>=0
  1055.             ? enc_picture->ref_pic_num[LIST_1 + currMB->list_offset][cur_ref]
  1056.             : -1);
  1057.         }
  1059.       }
  1060.     }
  1062.     //====== set the mv's for 8x8 partition with transform size 8x8 ======
  1063.     //save the mv data for 4x4 transform
  1065.     StoreMV8x8(1);
  1066.     //set new mv data for 8x8 transform
  1067.     RestoreMV8x8(0);
  1069.     //============= get pre-calculated data ==============
  1070.     //restore coefficients from 8x8 transform
  1072.     memcpy (img->cofAC[0][0][0],cofAC8x8ts[0][0][0][0], 4 * 4 * 2 * 65 * sizeof(int));
  1074.     if (img->P444_joined)
  1075.     {
  1076.       for (uv=0; uv<2; uv++)
  1077.       {
  1078.         for (block = 0; block<4; block++)
  1079.         {
  1080.           memcpy (img->cofAC[4+block+uv*4][0][0],cofAC8x8ts[uv + 1][block][0][0], 4 * 2 * 65 * sizeof(int));
  1081.         }
  1082.       }
  1083.     }
  1084.     //restore reconstruction
  1085.     if (cnt_nonz8_8x8ts <= _LUMA_8x8_COEFF_COST_ &&
  1086.       ((currMB->qp_scaled[0])!=0 || img->lossless_qpprime_flag==0) &&
  1087.       (img->type!=SP_SLICE))// modif ES added last condition (we probably never go there so is the next modification useful ? check)
  1088.     {
  1089.       currMB->cbp     = 0;
  1090.       currMB->cbp_blk = 0;
  1092.       for (j = 0; j < MB_BLOCK_SIZE; j++)
  1093.       {
  1094.         memcpy(&enc_picture->imgY[img->pix_y+j][img->pix_x], tr8x8.mpr8x8[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1095.       }
  1096.       if(img->type==SP_SLICE &&(!si_frame_indicator && !sp2_frame_indicator ))
  1097.       {
  1098.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1099.         {
  1100.           memcpy(&lrec[img->pix_y+j][img->pix_x],tr8x8.lrec[j], MB_BLOCK_SIZE * sizeof(int));
  1101.         }
  1102.       }
  1104.       memset( img->cofAC[0][0][0], 0, 4 * 4 * 2 * 65 * sizeof(int));
  1106.       if(img->P444_joined)
  1107.       {
  1108.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1109.         {
  1110.           memcpy(&enc_picture->imgUV[0][img->pix_y+j][img->pix_x], tr8x8.mpr8x8CbCr[0][j], MB_BLOCK_SIZE * sizeof(imgpel));
  1111.           memcpy(&enc_picture->imgUV[1][img->pix_y+j][img->pix_x], tr8x8.mpr8x8CbCr[1][j], MB_BLOCK_SIZE * sizeof(imgpel));
  1112.         }
  1113.         for (uv=0; uv<2; uv++)
  1114.         {
  1115.           for (block = 0; block<4; block++)
  1116.           {
  1117.              memset( img->cofAC[4+block+uv*4][0][0], 0, 4 * 2 * 65 * sizeof(int));
  1118.           }
  1119.         }
  1120.       }
  1121.     }
  1122.     else
  1123.     {
  1124.       currMB->cbp     = cbp8_8x8ts;
  1125.       currMB->cbp_blk = cbp_blk8_8x8ts;
  1126.       for (j = 0; j < MB_BLOCK_SIZE; j++)
  1127.       {
  1128.         memcpy (&enc_picture->imgY[img->pix_y+j][img->pix_x],tr8x8.rec_mbY8x8[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1129.       }
  1131.       if(img->type==SP_SLICE &&(!si_frame_indicator && !sp2_frame_indicator))
  1132.       {
  1133.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1134.         {
  1135.           memcpy (&lrec[img->pix_y+j][img->pix_x],tr8x8.lrec[j], MB_BLOCK_SIZE * sizeof(int));
  1136.         }
  1137.       }
  1139.       if (img->P444_joined) 
  1140.       {
  1141.         cmp_cbp[1] = cmp_cbp[2] = cbp8_8x8ts;
  1142.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1143.         {
  1144.           memcpy (&enc_picture->imgUV[0][img->pix_y+j][img->pix_x],tr8x8.rec_mb8x8_cr[0][j], MB_BLOCK_SIZE * sizeof(imgpel)); 
  1145.           memcpy (&enc_picture->imgUV[1][img->pix_y+j][img->pix_x],tr8x8.rec_mb8x8_cr[1][j], MB_BLOCK_SIZE * sizeof(imgpel)); 
  1146.         }
  1147.       }
  1148.     }
  1149.   }
  1150.   else
  1151.   {
  1152.     //============= get pre-calculated data ==============
  1153.     //---------------------------------------------------
  1154.     //--- restore coefficients ---
  1155.     memcpy (img->cofAC[0][0][0],cofAC8x8[0][0][0], (4+img->num_blk8x8_uv) * 4 * 2 * 65 * sizeof(int));
  1157.     if (img->P444_joined) 
  1158.     {
  1159.       for (block = 0; block<4; block++)
  1160.       {
  1161.         memcpy (img->cofAC[block+4][0][0],cofAC8x8CbCr[0][block][0][0], 4 * 2 * 65 * sizeof(int));     
  1162.         memcpy (img->cofAC[block+8][0][0],cofAC8x8CbCr[1][block][0][0], 4 * 2 * 65 * sizeof(int));   
  1163.       }
  1164.     }
  1166.     if (cnt_nonz_8x8<=5 && img->type!=SP_SLICE &&
  1167.       ((currMB->qp_scaled[0])!=0 || img->lossless_qpprime_flag==0))
  1168.     {
  1169.       currMB->cbp     = 0;
  1170.       currMB->cbp_blk = 0;
  1171.       for (j = 0; j < MB_BLOCK_SIZE; j++)
  1172.       {
  1173.         memcpy (&enc_picture->imgY[img->pix_y+j][img->pix_x],tr4x4.mpr8x8[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1174.       }
  1175.       if(img->type ==SP_SLICE &&(!si_frame_indicator && !sp2_frame_indicator))
  1176.       {
  1177.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1178.         {
  1179.           memcpy (&lrec[img->pix_y+j][img->pix_x],tr4x4.lrec[j], MB_BLOCK_SIZE * sizeof(int)); // restore coeff. SP frame
  1180.         }
  1181.       }
  1183.       memset( img->cofAC[0][0][0], 0, 4 * 4 * 2 * 65 * sizeof(int));
  1185.       if (img->P444_joined)
  1186.       {
  1187.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1188.         {
  1189.           memcpy (&enc_picture->imgUV[0][img->pix_y+j][img->pix_x],tr4x4.mpr8x8CbCr[0][j], MB_BLOCK_SIZE * sizeof(imgpel));    
  1190.           memcpy (&enc_picture->imgUV[1][img->pix_y+j][img->pix_x],tr4x4.mpr8x8CbCr[1][j], MB_BLOCK_SIZE * sizeof(imgpel));  
  1191.         }
  1192.         for (uv=0; uv<2; uv++)
  1193.         {
  1194.           for (block = 0; block<4; block++)
  1195.           {
  1196.             memset( img->cofAC[4+block+uv*4][0][0], 0, 4 * 2 * 65 * sizeof(int));
  1197.           }
  1198.         }
  1199.       }
  1200.     }
  1201.     else
  1202.     {
  1203.       currMB->cbp     = cbp8x8;
  1204.       currMB->cbp_blk = cbp_blk8x8;
  1205.       for (j = 0; j < MB_BLOCK_SIZE; j++)
  1206.       {
  1207.         memcpy (&enc_picture->imgY[img->pix_y+j][img->pix_x],tr4x4.rec_mbY8x8[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1208.       }
  1210.       if (params->rdopt == 3)
  1211.       {
  1212.         errdo_get_best_block(img, enc_picture->p_dec_img[0], decs->dec_mbY8x8, 0, MB_BLOCK_SIZE);
  1213.       }
  1215.       if(img->type==SP_SLICE &&(!si_frame_indicator && !sp2_frame_indicator))
  1216.       {
  1217.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1218.         {
  1219.           memcpy (&lrec[img->pix_y+j][img->pix_x],tr4x4.lrec[j], MB_BLOCK_SIZE * sizeof(int));
  1220.         }
  1221.       }
  1222.       if (img->P444_joined)
  1223.       {
  1224.         cmp_cbp[1] = cmp_cbp[2] = cbp8x8;
  1225.         for (j = 0; j < MB_BLOCK_SIZE; j++)
  1226.         {
  1227.           memcpy (&enc_picture->imgUV[0][img->pix_y+j][img->pix_x],tr4x4.rec_mb8x8_cr[0][j], MB_BLOCK_SIZE * sizeof(imgpel));
  1228.           memcpy (&enc_picture->imgUV[1][img->pix_y+j][img->pix_x],tr4x4.rec_mb8x8_cr[1][j], MB_BLOCK_SIZE * sizeof(imgpel));
  1229.         }
  1230.       }
  1231.     }
  1232.   }
  1233. }
  1236. /*!
  1237.  *************************************************************************************
  1238.  * brief
  1239.  *    Sets motion vectors for a macroblock
  1240.  *************************************************************************************
  1241.  */
  1242. void SetMotionVectorsMB (Macroblock* currMB, int bframe)
  1243. {
  1244.   int i, j, k, l, mode8, pdir8, ref, by, bx;
  1245.   short ******all_mv  = img->all_mv;
  1246.   short ******pred_mv = img->pred_mv;
  1247.   short bipred_me8;
  1248.   int  l1_ref;
  1249.   int jdiv, jmod;
  1251.   // copy all the motion vectors into rdopt structure
  1252.   // Can simplify this by copying the MV's of the best mode (TBD)
  1253.   // Should maybe add code to check for Intra only profiles
  1254.   if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1255.   {
  1256.     memcpy(&rdopt->pred_mv [0][0][0][0][0][0], &pred_mv [0][0][0][0][0][0], 2 * img->max_num_references * 9 * 4 * 4 * 2 * sizeof(short));
  1257.     memcpy(&rdopt->all_mv  [0][0][0][0][0][0], &all_mv  [0][0][0][0][0][0], 2 * img->max_num_references * 9 * 4 * 4 * 2 * sizeof(short));
  1258.   }
  1260.   if (!bframe)
  1261.   {
  1262.     for (j = 0; j<4; j++)
  1263.     {
  1264.       jmod = j & 0x01;
  1265.       jdiv = j >>   1;
  1266.       by    = img->block_y+j;
  1267.       for (i = 0; i<4; i++)
  1268.       {
  1269.         mode8 = currMB->b8mode[k=2*jdiv+(i>>1)];
  1270.         l     = 2*jmod + (i & 0x01);
  1272.         bx   = img->block_x+i;
  1274.         pdir8 = currMB->b8pdir[k];
  1275.         ref    = enc_picture->motion.ref_idx[LIST_0][by][bx];
  1277.         if (pdir8>=0)
  1278.         {
  1279.           enc_picture->motion.mv[LIST_0][by][bx][0] = all_mv [LIST_0][ ref][mode8][j][i][0];
  1280.           enc_picture->motion.mv[LIST_0][by][bx][1] = all_mv [LIST_0][ ref][mode8][j][i][1];
  1281.         }
  1282.         else
  1283.         {
  1284.           enc_picture->motion.mv[LIST_0][by][bx][0] = 0;
  1285.           enc_picture->motion.mv[LIST_0][by][bx][1] = 0;
  1286.         }
  1287.       }
  1288.     }
  1289.   }
  1290.   else
  1291.   {
  1292.     for (j = 0; j<4; j++)
  1293.     {
  1294.       jmod = j & 0x01;
  1295.       jdiv = j >>   1;
  1296.       by    = img->block_y+j;
  1297.       for (i = 0; i<4; i++)
  1298.       {
  1299.         mode8 = currMB->b8mode[k=2*jdiv+(i>>1)];
  1300.         bipred_me8  = currMB->bipred_me[k]; 
  1301.         l     = 2*jmod + (i & 0x01);
  1303.         bx    = img->block_x+i;
  1305.         pdir8 = currMB->b8pdir[k];
  1306.         ref    = enc_picture->motion.ref_idx[LIST_0][by][bx];
  1307.         l1_ref = enc_picture->motion.ref_idx[LIST_1][by][bx];
  1309.         if ( bipred_me8 && (pdir8 == 2) && is_bipred_enabled(currMB->mb_type))
  1310.         {
  1311.           all_mv  = img->bipred_mv[bipred_me8 - 1]; 
  1312.           ref = 0;
  1313.           l1_ref = 0;
  1314.         }
  1315.         else
  1316.         {
  1317.           all_mv  = img->all_mv;
  1318.         }
  1320.         if (pdir8==-1) // intra
  1321.         {
  1322.           enc_picture->motion.mv[LIST_0][by][bx][0] = 0;
  1323.           enc_picture->motion.mv[LIST_0][by][bx][1] = 0;
  1324.           enc_picture->motion.mv[LIST_1][by][bx][0] = 0;
  1325.           enc_picture->motion.mv[LIST_1][by][bx][1] = 0;
  1326.         }
  1327.         else if (pdir8==0) // list 0
  1328.         {
  1329.           enc_picture->motion.mv[LIST_0][by][bx][0]   = all_mv [LIST_0][ ref][mode8][j][i][0];
  1330.           enc_picture->motion.mv[LIST_0][by][bx][1]   = all_mv [LIST_0][ ref][mode8][j][i][1];
  1331.           enc_picture->motion.mv[LIST_1][by][bx][0]   = 0;
  1332.           enc_picture->motion.mv[LIST_1][by][bx][1]   = 0;
  1333.           enc_picture->motion.ref_idx[LIST_1][by][bx] = -1;
  1334.         }
  1335.         else if (pdir8==1) // list 1
  1336.         {
  1337.           enc_picture->motion.mv[LIST_0][by][bx][0]   = 0;
  1338.           enc_picture->motion.mv[LIST_0][by][bx][1]   = 0;
  1339.           enc_picture->motion.ref_idx[LIST_0][by][bx] = -1;
  1340.           enc_picture->motion.mv[LIST_1][by][bx][0]   = all_mv [LIST_1][l1_ref][mode8][j][i][0];
  1341.           enc_picture->motion.mv[LIST_1][by][bx][1]   = all_mv [LIST_1][l1_ref][mode8][j][i][1];
  1342.         }
  1343.         else if (pdir8==2) // bipredictive
  1344.         {
  1345.           enc_picture->motion.mv[LIST_0][by][bx][0] = all_mv [LIST_0][   ref][mode8][j][i][0];
  1346.           enc_picture->motion.mv[LIST_0][by][bx][1] = all_mv [LIST_0][   ref][mode8][j][i][1];
  1347.           enc_picture->motion.mv[LIST_1][by][bx][0] = all_mv [LIST_1][l1_ref][mode8][j][i][0];
  1348.           enc_picture->motion.mv[LIST_1][by][bx][1] = all_mv [LIST_1][l1_ref][mode8][j][i][1];
  1350.           // copy all the motion vectors into rdopt structure
  1351.           // Can simplify this by copying the MV's of the best mode (TBD)
  1352.           // Should maybe add code to check for Intra only profiles
  1353.           if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1354.           {
  1355.             rdopt->all_mv [LIST_0][   ref][mode8][j][i][0] = all_mv [LIST_0][   ref][mode8][j][i][0];
  1356.             rdopt->all_mv [LIST_0][   ref][mode8][j][i][1] = all_mv [LIST_0][   ref][mode8][j][i][1];
  1357.             rdopt->all_mv [LIST_1][l1_ref][mode8][j][i][0] = all_mv [LIST_1][l1_ref][mode8][j][i][0];
  1358.             rdopt->all_mv [LIST_1][l1_ref][mode8][j][i][1] = all_mv [LIST_1][l1_ref][mode8][j][i][1];
  1359.           }
  1360.         }
  1361.         else
  1362.         {
  1363.           error("invalid direction mode", 255);
  1364.         }
  1365.       }
  1366.     }
  1367.   }
  1368. }
  1372. /*!
  1373.  *************************************************************************************
  1374.  * brief
  1375.  *    R-D Cost for a macroblock
  1376.  *************************************************************************************
  1377.  */
  1378. int RDCost_for_macroblocks (Macroblock  *currMB,   // <-- Current Macroblock to code
  1379.                             double   lambda,       // <-- lagrange multiplier
  1380.                             int      mode,         // <-- modus (0-COPY/DIRECT, 1-16x16, 2-16x8, 3-8x16, 4-8x8(+), 5-Intra4x4, 6-Intra16x16)
  1381.                             double*  min_rdcost,   // <-> minimum rate-distortion cost
  1382.                             double*  min_dcost,   // <-> distortion of mode which has minimum rate-distortion cost.
  1383.                             double*  min_rate,     // --> bitrate of mode which has minimum rate-distortion cost.
  1384.                             int i16mode,
  1385.                             int is_cavlc)
  1386. {
  1387.   int         i, j, k; //, k, ****ip4;
  1388.   int         j1, j2;
  1389.   int         rate = 0, coeff_rate = 0;
  1390.   int64       distortion = 0;
  1391.   double      rdcost;
  1392.   int         prev_mb_nr  = FmoGetPreviousMBNr(img->current_mb_nr);  
  1393.   Macroblock  *prevMB   = (prev_mb_nr >= 0) ? &img->mb_data[prev_mb_nr] : NULL;
  1394.   int         bframe    = (img->type==B_SLICE);
  1395.   int         tmp_cc;
  1396.   int         use_of_cc =  (img->type!=I_SLICE &&  is_cavlc);
  1397.   int         cc_rate, dummy;
  1398.   double      dummy_d;
  1399.   imgpel     (*mb_pred)[16] = img->mb_pred[0];
  1400.   imgpel     (*curr_mpr_16x16)[16][16] = img->mpr_16x16[0];
  1402.   //=====
  1403.   //=====  SET REFERENCE FRAMES AND BLOCK MODES
  1404.   //=====
  1405.   SetModesAndRefframeForBlocks (currMB, mode);
  1406.   
  1407.   //=====
  1408.   //=====  GET COEFFICIENTS, RECONSTRUCTIONS, CBP
  1409.   //=====
  1410.   if (bframe && mode==0)
  1411.   {
  1412.     int block_x = (img->pix_x >> 2);
  1413.     int block_y = (img->pix_y >> 2);
  1414.     for (j = block_y; j < block_y + 4;j++)
  1415.       for (i = block_x; i < block_x + 4;i++)
  1416.         if (direct_pdir[j][i] < 0)
  1417.           return 0;
  1418.   }
  1420.   // Test MV limits for Skip Mode. This could be necessary for MBAFF case Frame MBs.
  1421.   if ((img->MbaffFrameFlag) && (!currMB->mb_field) && (img->type==P_SLICE) && (mode==0) )
  1422.   {
  1423.     if (out_of_bounds_mvs(img, img->all_mv[0][0][0][0][0], Q_PEL))
  1424.       return 0;
  1425.   }
  1427.   if (img->AdaptiveRounding)
  1428.   {
  1429.     memset(&(img->fadjust4x4[0][0][0]), 0, MB_PIXELS * sizeof(int));
  1430.     memset(&(img->fadjust8x8[0][0][0]), 0, MB_PIXELS * sizeof(int));
  1431.     if (img->yuv_format != 0)
  1432.     {
  1433.       memset(&(img->fadjust4x4Cr[0][0][0][0]), 0, img->mb_cr_size_y * img->mb_cr_size_x * sizeof(int));
  1434.       memset(&(img->fadjust4x4Cr[1][0][0][0]), 0, img->mb_cr_size_y * img->mb_cr_size_x  * sizeof(int));
  1435.       memset(&(img->fadjust8x8Cr[0][0][0][0]), 0, img->mb_cr_size_y * img->mb_cr_size_x  * sizeof(int));
  1436.       memset(&(img->fadjust8x8Cr[1][0][0][0]), 0, img->mb_cr_size_y * img->mb_cr_size_x  * sizeof(int));
  1437.     }
  1438.   }
  1440.   if (mode<P8x8)
  1441.   {
  1442.     LumaResidualCoding (currMB, is_cavlc);
  1444.     // This code seems unnecessary 
  1445.     if(mode==0 && currMB->cbp!=0 && (img->type != B_SLICE || img->NoResidueDirect==1))
  1446.       return 0;
  1447.     if (img->P444_joined)      
  1448.     {
  1449.       if(mode==0 && (currMB->cbp==0 && cmp_cbp[1] == 0 && cmp_cbp[2] == 0)&& currMB->luma_transform_size_8x8_flag == 1) //for B_skip, luma_transform_size_8x8_flag=0 only
  1450.         return 0;
  1451.     }
  1452.     else
  1453.     {
  1454.       if(mode==0 && currMB->cbp==0 && currMB->luma_transform_size_8x8_flag == 1) //for B_skip, luma_transform_size_8x8_flag=0 only        
  1455.         return 0;
  1456.     }
  1457.   }
  1458.   else if (mode==P8x8)
  1459.   {
  1460.     SetCoeffAndReconstruction8x8 (currMB);
  1461.   }
  1462.   else if (mode==I4MB)
  1463.   {
  1464.     currMB->cbp = Mode_Decision_for_Intra4x4Macroblock (currMB, lambda, &dummy_d, is_cavlc);
  1465.   }
  1466.   else if (mode==I16MB)
  1467.   {
  1468.     Intra16x16_Mode_Decision  (currMB, &i16mode, is_cavlc);
  1469.   }
  1470.   else if(mode==I8MB)
  1471.   {
  1472.     currMB->cbp = Mode_Decision_for_new_Intra8x8Macroblock(currMB, lambda, &dummy_d);
  1473.   }
  1474.   else if(mode==IPCM)
  1475.   {
  1476.     for (j = 0; j < MB_BLOCK_SIZE; j++)
  1477.     {
  1478.       memcpy(&enc_picture->imgY[j + img->pix_y][img->opix_x], &pCurImg[j + img->opix_y][img->opix_x], MB_BLOCK_SIZE * sizeof(imgpel));
  1479.     }
  1480.     if ((img->yuv_format != YUV400) && !IS_INDEPENDENT(params))
  1481.     {
  1482.       // CHROMA
  1483.       for (j = 0; j<img->mb_cr_size_y; j++)
  1484.       {
  1485.         j1 = j + img->opix_c_y;
  1486.         j2 = j + img->pix_c_y;
  1487.         memcpy(&enc_picture->imgUV[0][j2][img->opix_c_x], &pImgOrg[1][j1][img->opix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  1488.         memcpy(&enc_picture->imgUV[1][j2][img->opix_c_x], &pImgOrg[2][j1][img->opix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  1489.       }
  1490.     }
  1491.     for (j=0;j<4;j++)
  1492.       for (i=0; i<(4+img->num_blk8x8_uv); i++)
  1493.         img->nz_coeff[img->current_mb_nr][j][i] = 16;
  1495.   }
  1497.   if (params->rdopt==3 && img->type!=B_SLICE)
  1498.   {
  1499.     // We need the reconstructed prediction residue for the simulated decoders.
  1500.     // Should we be handing imgY here or p_curr_img instead of p_img[0]? This could make it more generic
  1501.     ////compute_residue_mb (img, &enc_picture->p_img[0][img->pix_y], decs->res_img[0], mode == I16MB ? i16mode : -1);
  1502.     compute_residue_block (img, &enc_picture->p_curr_img[img->pix_y], decs->res_img[0], mode == I16MB ? img->mpr_16x16[0][i16mode] : img->mb_pred[0], 0, 16);
  1503.   }
  1505.   //Rate control
  1506.   if (params->RCEnable)
  1507.   {
  1508.     if (mode == I16MB)
  1509.       memcpy(pred, curr_mpr_16x16[i16mode], MB_PIXELS * sizeof(imgpel));
  1510.     else
  1511.       memcpy(pred, mb_pred, MB_PIXELS * sizeof(imgpel));
  1512.   }
  1514.   img->i16offset = 0;
  1515.   dummy = 0;
  1517.   if (((img->yuv_format!=YUV400) && (active_sps->chroma_format_idc != YUV444)) && (mode != IPCM))
  1518.     ChromaResidualCoding (currMB, is_cavlc);
  1520.   if (mode==I16MB)
  1521.     img->i16offset = I16Offset  (currMB->cbp, i16mode);
  1523.   //=====
  1524.   //=====   GET DISTORTION
  1525.   //=====
  1526.   // LUMA
  1527.   if (params->rdopt == 3 && img->type!=B_SLICE)
  1528.   {
  1529.     if (mode != P8x8)
  1530.     {
  1531.       for (k = 0; k<params->NoOfDecoders ;k++)
  1532.       {
  1533.         decode_one_mb (img, enc_picture, k, currMB);
  1534.         distortion += compute_SSE(&pCurImg[img->opix_y], &enc_picture->p_dec_img[0][k][img->opix_y], img->opix_x, img->opix_x, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  1535.       }
  1536.     }
  1537.     else
  1538.     {
  1539.       for (k = 0; k<params->NoOfDecoders ;k++)
  1540.       {
  1541.         distortion += compute_SSE(&pCurImg[img->opix_y], &enc_picture->p_dec_img[0][k][img->opix_y], img->opix_x, img->opix_x, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  1542.       }
  1543.     }
  1544.     distortion /= params->NoOfDecoders;
  1546.     if ((img->yuv_format != YUV400) && (active_sps->chroma_format_idc != YUV444))
  1547.     {
  1548.       // CHROMA
  1549.       distortion += compute_SSE(&pImgOrg[1][img->opix_c_y], &enc_picture->imgUV[0][img->pix_c_y], img->opix_c_x, img->pix_c_x, img->mb_cr_size_y, img->mb_cr_size_x);
  1550.       distortion += compute_SSE(&pImgOrg[2][img->opix_c_y], &enc_picture->imgUV[1][img->pix_c_y], img->opix_c_x, img->pix_c_x, img->mb_cr_size_y, img->mb_cr_size_x);
  1551.     }
  1552.   }
  1553.   else
  1554.   {
  1555.     distortion = getDistortion(currMB);
  1556.   }
  1558.   //=====   S T O R E   C O D I N G   S T A T E   =====
  1559.   //---------------------------------------------------
  1560.   store_coding_state (currMB, cs_cm);
  1562.   //=====
  1563.   //=====   GET RATE
  1564.   //=====
  1565.   //----- macroblock header -----
  1566.   if (use_of_cc)
  1567.   {
  1568.     if (currMB->mb_type!=0 || (bframe && currMB->cbp!=0))
  1569.     {
  1570.       // cod counter and macroblock mode are written ==> do not consider code counter
  1571.       tmp_cc = img->cod_counter;
  1572.       rate   = writeMBLayer (currMB, 1, &coeff_rate);
  1573.       ue_linfo (tmp_cc, dummy, &cc_rate, &dummy);
  1574.       rate  -= cc_rate;
  1575.       img->cod_counter = tmp_cc;
  1576.     }
  1577.     else
  1578.     {
  1579.       // cod counter is just increased  ==> get additional rate
  1580.       ue_linfo (img->cod_counter + 1, dummy, &rate,    &dummy);
  1581.       ue_linfo (img->cod_counter    , dummy, &cc_rate, &dummy);
  1582.       rate -= cc_rate;
  1583.     }
  1584.   }
  1585.   else
  1586.   {
  1587.     rate = writeMBLayer (currMB, 1, &coeff_rate);
  1588.   }
  1590.   //=====   R E S T O R E   C O D I N G   S T A T E   =====
  1591.   //-------------------------------------------------------
  1592.   reset_coding_state (currMB, cs_cm);
  1594.   rdcost = (double)distortion + lambda * dmax(0.5,(double)rate);
  1596.   if (rdcost >= *min_rdcost ||
  1597.     ((currMB->qp_scaled[0]) == 0 && img->lossless_qpprime_flag == 1 && distortion != 0))
  1598.   {
  1599. #if FASTMODE
  1600.     // Reordering RDCost comparison order of mode 0 and mode 1 in P_SLICE
  1601.     // if RDcost of mode 0 and mode 1 is same, we choose best_mode is 0
  1602.     // This might not always be good since mode 0 is more biased towards rate than quality.
  1603.     if((img->type!=P_SLICE || mode != 0 || rdcost != *min_rdcost) || IS_FREXT_PROFILE(params->ProfileIDC))
  1604. #endif
  1605.       return 0;
  1606.   }
  1609.   if ((img->MbaffFrameFlag) && (mode ? 0: ((img->type == B_SLICE) ? !currMB->cbp:1)))  // AFF and current is skip
  1610.   {
  1611.     if (img->current_mb_nr & 0x01) //bottom
  1612.     {
  1613.       if (prevMB->mb_type ? 0:((img->type == B_SLICE) ? !prevMB->cbp:1)) //top is skip
  1614.       {
  1615.         if (!(field_flag_inference(currMB) == currMB->mb_field)) //skip only allowed when correct inference
  1616.           return 0;
  1617.       }
  1618.     }
  1619.   }
  1621.   //=====   U P D A T E   M I N I M U M   C O S T   =====
  1622.   //-----------------------------------------------------
  1623.   *min_rdcost = rdcost;
  1624.   *min_dcost = (double) distortion;
  1625.   *min_rate = lambda * (double)coeff_rate;
  1627. #ifdef BEST_NZ_COEFF
  1628.   for (j=0;j<4;j++)
  1629.     memcpy(&gaaiMBAFF_NZCoeff[j][0], &img->nz_coeff[img->current_mb_nr][j][0], (4 + img->num_blk8x8_uv) * sizeof(int));
  1630. #endif
  1632.   return 1;
  1633. }
  1636. /*!
  1637.  *************************************************************************************
  1638.  * brief
  1639.  *    Store macroblock parameters
  1640.  *************************************************************************************
  1641.  */
  1642. void store_macroblock_parameters (Macroblock *currMB, int mode)
  1643. {
  1644.   int  j, ****i4p, ***i3p;
  1645.   int  bframe   = (img->type==B_SLICE);
  1647.   //--- store best mode ---
  1648.   best_mode = mode;
  1649.   best_c_imode = currMB->c_ipred_mode;
  1650.   best_i16offset = img->i16offset;
  1652.   
  1653.   memcpy(b8mode, currMB->b8mode, BLOCK_MULTIPLE * sizeof(short));
  1654.   memcpy(b8bipred_me, currMB->bipred_me, BLOCK_MULTIPLE * sizeof(short));
  1655.   memcpy(b8pdir, currMB->b8pdir, BLOCK_MULTIPLE * sizeof(short));
  1656.   memcpy(b4_intra_pred_modes,   currMB->intra_pred_modes, MB_BLOCK_PARTITIONS * sizeof(char));
  1657.   memcpy(b8_intra_pred_modes8x8,currMB->intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  1659.   for (j = 0 ; j < BLOCK_MULTIPLE; j++)
  1660.   {
  1661.     memcpy(&b4_ipredmode[j * BLOCK_MULTIPLE],&img->ipredmode   [img->block_y + j][img->block_x],BLOCK_MULTIPLE * sizeof(char));
  1662.     memcpy(b8_ipredmode8x8[j],               &img->ipredmode8x8[img->block_y + j][img->block_x],BLOCK_MULTIPLE * sizeof(char));
  1663.   }
  1664.   //--- reconstructed blocks ----
  1665.   for (j = 0; j < MB_BLOCK_SIZE; j++)
  1666.   {
  1667.     memcpy(rec_mbY[j], &enc_picture->imgY[img->pix_y+j][img->pix_x], MB_BLOCK_SIZE * sizeof(imgpel));
  1668.   }
  1669.   if((img->type==SP_SLICE) && (si_frame_indicator==0 && sp2_frame_indicator==0))
  1670.   {
  1671.     for (j = 0; j < MB_BLOCK_SIZE; j++)
  1672.     {
  1673.       memcpy(lrec_rec[j], &lrec[img->pix_y+j][img->pix_x], MB_BLOCK_SIZE * sizeof(int));//store coefficients SP frame
  1674.     }
  1675.   }
  1677.   if (img->AdaptiveRounding)
  1678.     store_adaptive_rounding_parameters (currMB, mode);
  1680.   if (img->yuv_format != YUV400)
  1681.   {
  1682.     int k;
  1683.     for (k = 0; k < 2; k++)
  1684.     {
  1685.       for (j = 0; j<img->mb_cr_size_y; j++)
  1686.       {
  1687.         memcpy(rec_mb_cr[k][j], &enc_picture->imgUV[k][img->pix_c_y+j][img->pix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  1688.       }
  1689.     }
  1691.     if((img->type==SP_SLICE) && (si_frame_indicator==0 && sp2_frame_indicator==0))
  1692.     {
  1693.       //store uv coefficients SP frame
  1694.       for (k = 0; k < 2; k++)
  1695.       {
  1696.         for (j = 0; j<img->mb_cr_size_y; j++)
  1697.         {
  1698.           memcpy(lrec_rec_uv[k][j],&lrec_uv[k][img->pix_c_y+j][img->pix_c_x], img->mb_cr_size_x * sizeof(int));
  1699.         }
  1700.       }
  1701.     }
  1702.   }
  1704.   //--- store results of decoders ---
  1705.   if (params->rdopt == 3 && img->type!=B_SLICE)
  1706.   {
  1707.     errdo_store_best_block(img, decs->dec_mbY, enc_picture->p_dec_img[0], 0, 0, MB_BLOCK_SIZE);
  1708.   }
  1710.   //--- coeff, cbp, kac ---
  1711.   if (mode || bframe)
  1712.   {
  1713.     i4p=cofAC; cofAC=img->cofAC; img->cofAC=i4p;
  1714.     i3p=cofDC; cofDC=img->cofDC; img->cofDC=i3p;
  1715.     cbp     = currMB->cbp;
  1716.     curr_cbp[0] = cmp_cbp[1];  
  1717.     curr_cbp[1] = cmp_cbp[2]; 
  1719.     cur_cbp_blk[0] = currMB->cbp_blk;
  1720.   }
  1721.   else
  1722.   {
  1723.     cur_cbp_blk[0] = cbp = 0;
  1724.     cmp_cbp[1] = cmp_cbp[2] = 0; 
  1725.   }
  1727.   //--- store transform size ---
  1728.   luma_transform_size_8x8_flag = currMB->luma_transform_size_8x8_flag;
  1731.   for (j = 0; j<4; j++)
  1732.     memcpy(l0_refframe[j],&enc_picture->motion.ref_idx[LIST_0][img->block_y+j][img->block_x], BLOCK_MULTIPLE * sizeof(char));
  1734.   if (bframe)
  1735.   {
  1736.     for (j = 0; j<4; j++)
  1737.       memcpy(l1_refframe[j],&enc_picture->motion.ref_idx[LIST_1][img->block_y+j][img->block_x], BLOCK_MULTIPLE * sizeof(char));
  1738.   }
  1739. }
  1742. /*!
  1743.  *************************************************************************************
  1744.  * brief
  1745.  *    Set stored macroblock parameters
  1746.  *************************************************************************************
  1747.  */
  1748. void set_stored_macroblock_parameters (Macroblock *currMB)
  1749. {
  1750.   imgpel     **imgY  = enc_picture->imgY;
  1751.   imgpel    ***imgUV = enc_picture->imgUV;
  1753.   int         mode   = best_mode;
  1754.   int         bframe = (img->type==B_SLICE);
  1755.   int         i, j, k, ****i4p, ***i3p;
  1756.   int         block_x, block_y;
  1757.   char    **ipredmodes = img->ipredmode;
  1758.   short   *cur_mv, total_bipred_me;
  1760.   //===== reconstruction values =====
  1762.   // Luma
  1763.   for (j = 0; j < MB_BLOCK_SIZE; j++)
  1764.   {
  1765.     memcpy(&imgY[img->pix_y+j][img->pix_x],rec_mbY[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1766.   }
  1768.   if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1769.   {
  1770.     for (j = 0; j < MB_BLOCK_SIZE; j++)
  1771.       memcpy(rdopt->rec_mbY[j],rec_mbY[j], MB_BLOCK_SIZE * sizeof(imgpel));
  1772.   }
  1774.   if((img->type==SP_SLICE) &&(si_frame_indicator==0 && sp2_frame_indicator==0 ))
  1775.   {
  1776.     for (j = 0; j < MB_BLOCK_SIZE; j++)
  1777.       memcpy(&lrec[img->pix_y+j][img->pix_x],lrec_rec[j], MB_BLOCK_SIZE * sizeof(int)); //restore coeff SP frame
  1778.   }
  1780.   if (img->AdaptiveRounding)
  1781.   {
  1782.     update_offset_params(currMB, mode,luma_transform_size_8x8_flag);
  1783.   }
  1785.   if (img->yuv_format != YUV400)
  1786.   {
  1787.     int k;
  1788.     for (k = 0; k < 2; k++)
  1789.     {
  1790.       for (j = 0; j<img->mb_cr_size_y; j++)
  1791.       {
  1792.         memcpy(&imgUV[k][img->pix_c_y+j][img->pix_c_x], rec_mb_cr[k][j], img->mb_cr_size_x * sizeof(imgpel));
  1793.       }
  1794.     }
  1796.     if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1797.     {
  1798.       for (k = 0; k < 2; k++)
  1799.       {
  1800.         for (j = 0; j<img->mb_cr_size_y; j++)
  1801.         {
  1802.           memcpy(rdopt->rec_mb_cr[k][j],rec_mb_cr[k][j], img->mb_cr_size_x * sizeof(imgpel));
  1803.         }
  1804.       }
  1805.     }
  1807.     if((img->type==SP_SLICE) &&(!si_frame_indicator && !sp2_frame_indicator))
  1808.     {
  1809.       for (k = 0; k < 2; k++)
  1810.       {
  1811.         for (j = 0; j<img->mb_cr_size_y; j++)
  1812.         {
  1813.           memcpy(&lrec_uv[k][img->pix_c_y+j][img->pix_c_x],lrec_rec_uv[k][j], img->mb_cr_size_x * sizeof(int));
  1814.         }
  1815.       }
  1816.     }
  1817.   }
  1819.   //===== coefficients and cbp =====
  1820.   i4p=cofAC; cofAC=img->cofAC; img->cofAC=i4p;
  1821.   i3p=cofDC; cofDC=img->cofDC; img->cofDC=i3p;
  1822.   currMB->cbp      = cbp;
  1823.   currMB->cbp_blk = cur_cbp_blk[0];
  1824.   cmp_cbp[1] = curr_cbp[0]; 
  1825.   cmp_cbp[2] = curr_cbp[1]; 
  1826.   currMB->cbp |= cmp_cbp[1];
  1827.   currMB->cbp |= cmp_cbp[2];
  1828.   cmp_cbp[1] = currMB->cbp; 
  1829.   cmp_cbp[2] = currMB->cbp;
  1831.   //==== macroblock type ====
  1832.   currMB->mb_type = mode;
  1834.   memcpy(currMB->b8mode, b8mode, BLOCK_MULTIPLE * sizeof(short));
  1835.   memcpy(currMB->b8pdir, b8pdir, BLOCK_MULTIPLE * sizeof(short));
  1836.   memcpy(currMB->bipred_me, b8bipred_me, BLOCK_MULTIPLE * sizeof(short));
  1838.   if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1839.   {
  1840.     rdopt->mode = mode;
  1841.     rdopt->i16offset = img->i16offset;
  1842.     rdopt->cbp = cbp;
  1843.     rdopt->cbp_blk = cur_cbp_blk[0];
  1844.     rdopt->mb_type  = mode;
  1846.     rdopt->prev_qp  = currMB->prev_qp;
  1847.     rdopt->prev_dqp = currMB->prev_dqp;
  1848.     rdopt->delta_qp = currMB->delta_qp;
  1849.     rdopt->qp       = currMB->qp;
  1850.     rdopt->prev_cbp = currMB->prev_cbp;
  1852.     memcpy(rdopt->cofAC[0][0][0], img->cofAC[0][0][0], (4+img->num_blk8x8_uv) * 4 * 2 * 65 * sizeof(int));
  1853.     memcpy(rdopt->cofDC[0][0], img->cofDC[0][0], 3 * 2 * 18 * sizeof(int));
  1855.     memcpy(rdopt->b8mode,b8mode, BLOCK_MULTIPLE * sizeof(short));
  1856.     memcpy(rdopt->b8pdir,b8pdir, BLOCK_MULTIPLE * sizeof(short));
  1857.   }
  1859.   //if P8x8 mode and transform size 4x4 choosen, restore motion vector data for this transform size
  1860.   if (mode == P8x8 && !luma_transform_size_8x8_flag && params->Transform8x8Mode)
  1861.     RestoreMV8x8(1);
  1863.   //==== transform size flag ====
  1864.   if (img->P444_joined)
  1865.   {
  1866.     if (((currMB->cbp == 0) && cmp_cbp[1] == 0 && cmp_cbp[2] == 0) && !(IS_OLDINTRA(currMB) || currMB->mb_type == I8MB))
  1867.       currMB->luma_transform_size_8x8_flag = 0;
  1868.     else
  1869.       currMB->luma_transform_size_8x8_flag = luma_transform_size_8x8_flag;
  1870.   }
  1871.   else
  1872.   {
  1874.     if (((currMB->cbp & 15) == 0) && !(IS_OLDINTRA(currMB) || currMB->mb_type == I8MB))
  1875.       currMB->luma_transform_size_8x8_flag = 0;
  1876.     else
  1877.       currMB->luma_transform_size_8x8_flag = luma_transform_size_8x8_flag;
  1878.   }
  1880.   rdopt->luma_transform_size_8x8_flag  = currMB->luma_transform_size_8x8_flag;
  1882.   if (params->rdopt == 3 && img->type!=B_SLICE)  
  1883.   {
  1884.     errdo_get_best_block(img, enc_picture->p_dec_img[0], decs->dec_mbY, 0, MB_BLOCK_SIZE);
  1885.   }
  1887.   //==== reference frames =====
  1888.   for (j = 0; j < 4; j++)
  1889.   {
  1890.     block_y = img->block_y + j;
  1891.     for (i = 0; i < 4; i++)
  1892.     {
  1893.       block_x = img->block_x + i;
  1894.       k = 2*(j >> 1)+(i >> 1);
  1896.       // backward prediction or intra
  1897.       if ((currMB->b8pdir[k] == 1) || IS_INTRA(currMB))
  1898.       {
  1899.         enc_picture->motion.ref_idx    [LIST_0][block_y][block_x]    = -1;
  1900.         enc_picture->motion.ref_pic_id [LIST_0][block_y][block_x]    = -1;
  1901.         enc_picture->motion.mv         [LIST_0][block_y][block_x][0] = 0;
  1902.         enc_picture->motion.mv         [LIST_0][block_y][block_x][1] = 0;
  1904.         if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1905.           rdopt->refar[LIST_0][j][i] = -1;
  1906.       }
  1907.       else
  1908.       {
  1909.         if (currMB->bipred_me[k] && (currMB->b8pdir[k] == 2) && is_bipred_enabled(currMB->mb_type))
  1910.         {
  1911.           cur_mv = img->bipred_mv[currMB->bipred_me[k] - 1][LIST_0][0][currMB->b8mode[k]][j][i]; 
  1913.           enc_picture->motion.ref_idx    [LIST_0][block_y][block_x] = 0;
  1914.           enc_picture->motion.ref_pic_id [LIST_0][block_y][block_x] = enc_picture->ref_pic_num[LIST_0 + currMB->list_offset][0];
  1915.           enc_picture->motion.mv         [LIST_0][block_y][block_x][0] = cur_mv[0];
  1916.           enc_picture->motion.mv         [LIST_0][block_y][block_x][1] = cur_mv[1];
  1918.           if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1919.             rdopt->refar[LIST_0][j][i] = 0;
  1920.         }
  1921.         else
  1922.         {
  1923.           char cur_ref = l0_refframe[j][i];
  1924.           enc_picture->motion.ref_idx    [LIST_0][block_y][block_x] = cur_ref;
  1925.           enc_picture->motion.ref_pic_id [LIST_0][block_y][block_x] = enc_picture->ref_pic_num[LIST_0 + currMB->list_offset][(short)cur_ref];
  1926.           memcpy(enc_picture->motion.mv  [LIST_0][block_y][block_x], img->all_mv[LIST_0][(short)cur_ref][currMB->b8mode[k]][j][i], 2 * sizeof(short));
  1928.           if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1929.             rdopt->refar[LIST_0][j][i] = cur_ref;
  1930.         }
  1931.       }
  1933.       // forward prediction or intra
  1934.       if ((currMB->b8pdir[k] == 0) || IS_INTRA(currMB))
  1935.       {
  1936.         enc_picture->motion.ref_idx    [LIST_1][block_y][block_x]    = -1;
  1937.         enc_picture->motion.ref_pic_id [LIST_1][block_y][block_x]    = -1;
  1938.         enc_picture->motion.mv         [LIST_1][block_y][block_x][0] = 0;
  1939.         enc_picture->motion.mv         [LIST_1][block_y][block_x][1] = 0;
  1941.         if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1942.           rdopt->refar[LIST_1][j][i] = -1;
  1943.       }
  1944.     }
  1945.   }
  1947.   if (bframe)
  1948.   {
  1949.     for (j=0; j<4; j++)
  1950.     {
  1951.       block_y = img->block_y + j;
  1952.       for (i=0; i<4; i++)
  1953.       {
  1954.         block_x = img->block_x + i;
  1955.         k = 2*(j >> 1)+(i >> 1);
  1957.         // forward
  1958.         if (IS_INTRA(currMB)||(currMB->b8pdir[k] == 0))
  1959.         {
  1960.           enc_picture->motion.ref_idx    [LIST_1][block_y][block_x]    = -1;
  1961.           enc_picture->motion.ref_pic_id [LIST_1][block_y][block_x]    = -1;
  1962.           enc_picture->motion.mv         [LIST_1][block_y][block_x][0] = 0;
  1963.           enc_picture->motion.mv         [LIST_1][block_y][block_x][1] = 0;
  1965.           if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1966.             rdopt->refar[LIST_1][j][i] = -1;
  1967.         }
  1968.         else
  1969.         {
  1970.           if (currMB->bipred_me[k] && (currMB->b8pdir[k] == 2) && is_bipred_enabled(currMB->mb_type))
  1971.           {
  1972.             cur_mv = img->bipred_mv[currMB->bipred_me[k] - 1][LIST_1][0][currMB->b8mode[k]][j][i]; 
  1974.             enc_picture->motion.ref_idx    [LIST_1][block_y][block_x] = 0;
  1975.             enc_picture->motion.ref_pic_id [LIST_1][block_y][block_x] = enc_picture->ref_pic_num[LIST_1 + currMB->list_offset][0];
  1976.             enc_picture->motion.mv         [LIST_1][block_y][block_x][0] = cur_mv[0];
  1977.             enc_picture->motion.mv         [LIST_1][block_y][block_x][1] = cur_mv[1];
  1979.             if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1980.               rdopt->refar[LIST_1][j][i] = 0;
  1981.           }
  1982.           else
  1983.           {
  1984.             enc_picture->motion.ref_idx    [LIST_1][block_y][block_x] = l1_refframe[j][i];
  1985.             enc_picture->motion.ref_pic_id [LIST_1][block_y][block_x] = enc_picture->ref_pic_num[LIST_1 + currMB->list_offset][(short)l1_refframe[j][i]];
  1986.             memcpy(enc_picture->motion.mv  [LIST_1][block_y][block_x], img->all_mv[LIST_1][(short)l1_refframe[j][i]][currMB->b8mode[k]][j][i], 2 * sizeof(short));
  1988.             if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  1989.               rdopt->refar[LIST_1][j][i] = l1_refframe[j][i];
  1990.           }
  1991.         }
  1992.       }
  1993.     }
  1994.   }
  1996.   //==== intra prediction modes ====
  1997.   currMB->c_ipred_mode = best_c_imode;
  1998.   img->i16offset = best_i16offset;
  2000.   if(currMB->mb_type == I8MB)
  2001.   {
  2002.     memcpy(currMB->intra_pred_modes8x8,b8_intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  2003.     memcpy(currMB->intra_pred_modes,b8_intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  2004.     for(j = 0; j < BLOCK_MULTIPLE; j++)
  2005.     {
  2006.       memcpy(&img->ipredmode[img->block_y+j][img->block_x],    b8_ipredmode8x8[j], BLOCK_MULTIPLE * sizeof(char));
  2007.       memcpy(&img->ipredmode8x8[img->block_y+j][img->block_x], b8_ipredmode8x8[j], BLOCK_MULTIPLE * sizeof(char));
  2008.     }
  2009.   }
  2010.   else if (mode!=I4MB && mode!=I8MB)
  2011.   {
  2012.     memset(currMB->intra_pred_modes,DC_PRED, MB_BLOCK_PARTITIONS * sizeof(char));
  2013.     for(j = img->block_y; j < img->block_y + BLOCK_MULTIPLE; j++)
  2014.       memset(&img->ipredmode[j][img->block_x], DC_PRED, BLOCK_MULTIPLE * sizeof(char));
  2015.   }
  2016.   // Residue Color Transform
  2017.   else if (mode == I4MB)
  2018.   {
  2019.     memcpy(currMB->intra_pred_modes,b4_intra_pred_modes, MB_BLOCK_PARTITIONS * sizeof(char));
  2020.     for(j = 0; j < BLOCK_MULTIPLE; j++)
  2021.       memcpy(&img->ipredmode[img->block_y + j][img->block_x],&b4_ipredmode[BLOCK_MULTIPLE * j], BLOCK_MULTIPLE * sizeof(char));
  2022.   }
  2024.   if (img->MbaffFrameFlag || (params->UseRDOQuant && params->RDOQ_QP_Num > 1))
  2025.   {
  2026.     rdopt->c_ipred_mode = currMB->c_ipred_mode;
  2027.     rdopt->i16offset = img->i16offset;
  2028.     memcpy(rdopt->intra_pred_modes,currMB->intra_pred_modes, MB_BLOCK_PARTITIONS * sizeof(char));
  2029.     memcpy(rdopt->intra_pred_modes8x8,currMB->intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  2030.     for(j = img->block_y; j < img->block_y +BLOCK_MULTIPLE; j++)
  2031.       memcpy(&rdopt->ipredmode[j][img->block_x],&ipredmodes[j][img->block_x], BLOCK_MULTIPLE * sizeof(char));
  2032.   }
  2034.   //==== motion vectors =====
  2035.   SetMotionVectorsMB (currMB, bframe);
  2036.   total_bipred_me  = 0;
  2037.  
  2038.   for (i = 0; i < 4; i++)
  2039.   {
  2040.     total_bipred_me += currMB->bipred_me[i];
  2041.   }
  2042.   if (total_bipred_me && currMB->mb_type > 1 && currMB->mb_type < 4)
  2043.   {
  2044.      UpdateMotionVectorPredictor(currMB, currMB->mb_type);
  2045.   }
  2046. }
  2048. /*!
  2049.  *************************************************************************************
  2050.  * brief
  2051.  *    Update motion vector predictors if biprediction mode is selected (B_SLICE only)
  2052.  *************************************************************************************
  2053.  */
  2054. void UpdateMotionVectorPredictor(Macroblock* currMB, int mb_type) 
  2055. {
  2056.   int v = 0, h = 0, block_x, block_y, list, i, ref;
  2057.   short * pred_mv;
  2058.   int   parttype  = (mb_type<4?mb_type:4);
  2059.   int   bsx       = params->blc_size[parttype][0];
  2060.   int   bsy       = params->blc_size[parttype][1];
  2061.   int   step_h    = (params->part_size[parttype][0]);
  2062.   int   step_v    = (params->part_size[parttype][1]);
  2064.   for (i = 0; i < 4; i++)
  2065.   {
  2066.     if (currMB->bipred_me[i])
  2067.     {
  2068.       v = i >> 1;
  2069.       h = i & 0x01;
  2070.       break;
  2071.     }
  2072.   }
  2074.   while(1)
  2075.   {
  2076.     block_x = img->block_x + h;
  2077.     block_y = img->block_y + v;
  2078.     for (list = 0; list < 2; list++)
  2079.     {
  2080.       ref = enc_picture->motion.ref_idx[list][block_y][block_x];
  2081.       ref = (ref < 0 )? 0 : ref;
  2082.       pred_mv = img->pred_mv[list][ref][parttype][v][h];
  2083.       SetMotionVectorPredictor (currMB, pred_mv, enc_picture->motion.ref_idx[list], enc_picture->motion.mv[list], ref, list, h << 2, v << 2, bsx, bsy);
  2084.     }
  2086.     v += step_v;
  2087.     h += step_h;
  2088.     if (v >= 4 && h >= 4)
  2089.       break;
  2090.     if (v >= 4)
  2091.       v = 0;
  2092.     if (h >= 4)
  2093.       h = 0;
  2094.   }
  2095. }
  2096.  
  2098. /*!
  2099.  *************************************************************************************
  2100.  * brief
  2101.  *    Set reference frames and motion vectors
  2102.  *************************************************************************************
  2103.  */
  2104. void SetRefAndMotionVectors (Macroblock *currMB, int block, int mode, int pdir, int fwref, int bwref, short bipred_me)
  2105. {
  2106.   int     k, i, j=0;
  2107.   int     bslice  = (img->type==B_SLICE);
  2108.   int     pmode   = (mode==1||mode==2||mode==3?mode:4);
  2109.   int     j0      = ((block >> 1)<<1);
  2110.   int     i0      = ((block & 0x01)<<1);
  2111.   int     j1      = j0 + (params->part_size[pmode][1]);
  2112.   int     i1      = i0 + (params->part_size[pmode][0]);
  2113.   int     block_x, block_y;
  2114.   short   *cur_mv;
  2115.   int64 ref_pic_num;
  2116.   char *ref_idx;
  2118.   if (pdir < 0)
  2119.   {
  2120.     for (k = LIST_0; k <= LIST_1; k++)
  2121.     {
  2122.       for (j = img->block_y + j0; j < img->block_y + j1; j++)
  2123.       {
  2124.         for (i=img->block_x + i0; i<img->block_x +i1; i++)
  2125.           enc_picture->motion.ref_pic_id[k][j][i] = -1;
  2127.         memset(&enc_picture->motion.ref_idx[k][j][img->block_x + i0], -1, (params->part_size[pmode][0]) * sizeof(char));
  2128.         memset(enc_picture->motion.mv      [k][j][img->block_x + i0], 0, 2*(params->part_size[pmode][0]) * sizeof(short));
  2129.       }
  2130.     }
  2131.     return;
  2132.   }
  2134.   if (!bslice)
  2135.   {
  2136.     int64 ref_pic_num = enc_picture->ref_pic_num[LIST_0+currMB->list_offset][fwref];
  2137.     for (j = j0; j < j1; j++)
  2138.     {
  2139.       block_y = img->block_y + j;
  2140.       for (block_x = img->block_x + i0; block_x < img->block_x + i1; block_x++)
  2141.         enc_picture->motion.ref_pic_id[LIST_0][block_y][block_x] = ref_pic_num;
  2143.       memset(&enc_picture->motion.ref_idx[LIST_0][block_y][img->block_x + i0], fwref, (params->part_size[pmode][0]) * sizeof(char));
  2144.       memcpy(enc_picture->motion.mv      [LIST_0][block_y][img->block_x + i0], img->all_mv[LIST_0][fwref][mode][j][i0], 2 * (i1 - i0) * sizeof(short));
  2145.     }
  2146.     return;
  2147.   }
  2148.   else //bslice
  2149.   {
  2150.     if ((pdir == 0 || pdir == 2))
  2151.     {
  2152.       if (bipred_me && (pdir == 2) && is_bipred_enabled(mode))
  2153.       {
  2154.         for (j=j0; j<j1; j++)
  2155.         {
  2156.           block_y = img->block_y + j;
  2157.           for (i=i0; i<i1; i++)
  2158.           {
  2159.             block_x = img->block_x + i;
  2161.             cur_mv = img->bipred_mv[bipred_me - 1][LIST_0][0][mode][j][i]; 
  2163.             enc_picture->motion.mv        [LIST_0][block_y][block_x][0] = cur_mv[0];
  2164.             enc_picture->motion.mv        [LIST_0][block_y][block_x][1] = cur_mv[1];
  2165.             enc_picture->motion.ref_idx   [LIST_0][block_y][block_x]    = 0;
  2166.             enc_picture->motion.ref_pic_id[LIST_0][block_y][block_x]    = enc_picture->ref_pic_num[LIST_0+currMB->list_offset][0];
  2167.           }
  2168.         }
  2169.       }
  2170.       else
  2171.       {
  2172.         if (mode==0)
  2173.         {
  2174.           for (j=j0; j<j1; j++)
  2175.           {
  2176.             block_y = img->block_y + j;
  2177.             ref_idx = enc_picture->motion.ref_idx[LIST_0][block_y];
  2178.             memcpy(&ref_idx[img->block_x + i0], &direct_ref_idx[LIST_0][block_y][img->block_x + i0], (i1 - i0) * sizeof(char));
  2179.             memcpy(&enc_picture->motion.mv[LIST_0][block_y][img->block_x + i0][0], img->all_mv[LIST_0][fwref][mode][j][i0], 2 * (i1 - i0) * sizeof(short));
  2180.             for (block_x = img->block_x + i0; block_x < img->block_x + i1; block_x++)
  2181.             {              
  2182.               enc_picture->motion.ref_pic_id[LIST_0][block_y][block_x] = 
  2183.                 enc_picture->ref_pic_num[LIST_0+currMB->list_offset][(short)ref_idx[block_x]];
  2184.             }            
  2185.           }
  2186.         }
  2187.         else
  2188.         {
  2189.           for (j=j0; j<j1; j++)
  2190.           {
  2191.             block_y = img->block_y + j;
  2192.             ref_pic_num = enc_picture->ref_pic_num[LIST_0+currMB->list_offset][fwref];
  2193.             memcpy(&enc_picture->motion.mv[LIST_0][block_y][img->block_x + i0][0], img->all_mv[LIST_0][fwref][mode][j][i0], 2 * (i1 - i0) * sizeof(short));
  2194.             memset(&enc_picture->motion.ref_idx[LIST_0][block_y][img->block_x + i0], fwref, (i1 - i0) * sizeof(char));
  2195.             for (block_x = img->block_x + i0; block_x < img->block_x + i1; block_x++)
  2196.             {              
  2197.               enc_picture->motion.ref_pic_id[LIST_0][block_y][block_x] = ref_pic_num ;
  2198.             }
  2199.           }
  2200.         }
  2201.       }  
  2202.     }
  2203.     else
  2204.     {
  2205.       for (j=j0; j<j1; j++)
  2206.       {
  2207.         block_y = img->block_y + j;
  2208.         for (i=img->block_x + i0; i<img->block_x +i1; i++)
  2209.           enc_picture->motion.ref_pic_id[LIST_0][block_y][i] = -1;
  2211.         memset(&enc_picture->motion.ref_idx[LIST_0][block_y][img->block_x + i0], -1, (i1 - i0) * sizeof(char));
  2212.         memset(enc_picture->motion.mv[LIST_0][block_y][img->block_x + i0], 0, 2 * (i1 - i0) * sizeof(short));
  2213.       }
  2214.     }
  2217.     if ((pdir==1 || pdir==2))
  2218.     {
  2219.       if (bipred_me && (pdir == 2) && is_bipred_enabled(mode))
  2220.       {
  2221.         for (j=j0; j<j1; j++)
  2222.         {
  2223.           block_y = img->block_y + j;
  2225.           for (i=i0; i<i1; i++)
  2226.           {
  2227.             block_x = img->block_x + i;
  2229.             cur_mv = img->bipred_mv[bipred_me - 1][LIST_1][0][mode][j][i]; 
  2231.             enc_picture->motion.mv        [LIST_1][block_y][block_x][0] = cur_mv[0];
  2232.             enc_picture->motion.mv        [LIST_1][block_y][block_x][1] = cur_mv[1];
  2233.             enc_picture->motion.ref_idx   [LIST_1][block_y][block_x]    = 0;
  2234.             enc_picture->motion.ref_pic_id[LIST_1][block_y][block_x]    = enc_picture->ref_pic_num[LIST_1+currMB->list_offset][0];
  2235.           }
  2236.         }        
  2237.       }
  2238.       else
  2239.       {
  2240.         if (mode==0)
  2241.         {
  2242.           for (j=j0; j<j1; j++)
  2243.           {
  2244.             block_y = img->block_y + j;
  2246.             ref_idx = enc_picture->motion.ref_idx[LIST_1][block_y];
  2247.             memcpy(&ref_idx[img->block_x + i0], &direct_ref_idx[LIST_1][block_y][img->block_x + i0], (i1 - i0) * sizeof(char));            
  2248.             memcpy(&enc_picture->motion.mv[LIST_1][block_y][img->block_x + i0][0], img->all_mv[LIST_1][(int) ref_idx[img->block_x + i0]][mode][j][i0], 2 * (i1 - i0) * sizeof(short));
  2249.             for (i=i0; i<i1; i++)
  2250.             {
  2251.               block_x = img->block_x + i;
  2252.               enc_picture->motion.ref_pic_id[LIST_1][block_y][block_x] = enc_picture->ref_pic_num[LIST_1+currMB->list_offset][(short)ref_idx[block_x]];
  2253.             }            
  2254.           }
  2255.         }
  2256.         else
  2257.         {
  2258.           for (j=j0; j<j1; j++)
  2259.           {
  2260.             block_y = img->block_y + j;
  2261.             ref_pic_num = enc_picture->ref_pic_num[LIST_1+currMB->list_offset][bwref];
  2262.             memcpy(&enc_picture->motion.mv[LIST_1][block_y][img->block_x + i0][0], img->all_mv[LIST_1][bwref][mode][j][i0], 2 * (i1 - i0) * sizeof(short));
  2263.             memset(&enc_picture->motion.ref_idx[LIST_1][block_y][img->block_x + i0], bwref, (i1 - i0) * sizeof(char));
  2264.             for (block_x = img->block_x + i0; block_x < img->block_x + i1; block_x++)
  2265.             {
  2266.               enc_picture->motion.ref_pic_id[LIST_1][block_y][block_x] = ref_pic_num ;
  2267.             }
  2268.           }
  2269.         }
  2270.       }  
  2271.     }
  2272.     else
  2273.     {
  2274.       for (j=j0; j<j1; j++)
  2275.       {
  2276.         block_y = img->block_y + j;
  2277.         memset(enc_picture->motion.mv[LIST_1][block_y][img->block_x + i0], 0, 2 * (i1 - i0) * sizeof(short));
  2278.         memset(&enc_picture->motion.ref_idx[LIST_1][block_y][img->block_x + i0], -1, (i1 - i0)  * sizeof(char));
  2279.         for (block_x = img->block_x + i0; block_x < img->block_x + i1; block_x++)
  2280.         {
  2281.           enc_picture->motion.ref_pic_id[LIST_1][block_y][block_x]    = -1;
  2282.         }
  2283.       }
  2284.     }
  2285.   }
  2286. }
  2288. /*!
  2289.  *************************************************************************************
  2290.  * brief
  2291.  *    skip macroblock field inference
  2292.  * return
  2293.  *    inferred field flag
  2294.  *************************************************************************************
  2295.  */
  2296. byte field_flag_inference(Macroblock *currMB)
  2297. {
  2298.   byte mb_field;
  2300.   if (currMB->mbAvailA)
  2301.   {
  2302.     mb_field = img->mb_data[currMB->mbAddrA].mb_field;
  2303.   }
  2304.   else
  2305.   {
  2306.     // check top macroblock pair
  2307.     if (currMB->mbAvailB)
  2308.       mb_field = img->mb_data[currMB->mbAddrB].mb_field;
  2309.     else
  2310.       mb_field = 0;
  2311.   }
  2313.   return mb_field;
  2314. }
  2316. /*!
  2317.  *************************************************************************************
  2318.  * brief
  2319.  *    Store motion vectors for 8x8 partition
  2320.  *************************************************************************************
  2321.  */
  2323. void StoreMVBlock8x8(int dir, int block8x8, int mode, int l0_ref, int l1_ref, int pdir8, int bipred_me, int bframe)
  2324. {
  2325.   int j, i0, j0, ii, jj;
  2326.   short ******all_mv  = img->all_mv;
  2327.   short ******pred_mv = img->pred_mv;
  2328.   short (*lc_l0_mv8x8)[4][2] = all_mv8x8[dir][LIST_0];
  2329.   short (*lc_l1_mv8x8)[4][2] = all_mv8x8[dir][LIST_1];
  2330.   short (*lc_pr_mv8x8)[4][2] = NULL;
  2332.   if (bframe && bipred_me)
  2333.   {
  2334.     all_mv = img->bipred_mv[bipred_me - 1];
  2335.   }
  2337.   i0 = (block8x8 & 0x01) << 1;
  2338.   j0 = (block8x8 >> 1) << 1;
  2339.   ii = i0+2;
  2340.   jj = j0+2;
  2342.   if (!bframe)
  2343.   {
  2344.     if (pdir8>=0) //(mode8!=IBLOCK)&&(mode8!=I16MB))  // && ref != -1)
  2345.     {
  2346.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2347.       for (j=j0; j<jj; j++)
  2348.       {
  2349.         memcpy(&lc_l0_mv8x8[j][i0][0], &all_mv[LIST_0][l0_ref][4][j][i0][0],  (ii - i0) * 2 * sizeof(short));
  2350.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_0][l0_ref][4][j][i0][0], (ii - i0) * 2 * sizeof(short));
  2351.       }
  2352.     }
  2353.   }
  2354.   else
  2355.   {
  2356.     if (pdir8 == 0) // list0
  2357.     {
  2358.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2359.       for (j=j0; j<jj; j++)
  2360.       {
  2361.         memcpy(&lc_l0_mv8x8[j][i0][0], &all_mv[LIST_0][l0_ref][mode][j][i0][0],  (ii - i0) * 2 * sizeof(short));
  2362.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_0][l0_ref][mode][j][i0][0], (ii - i0) * 2 * sizeof(short));
  2363.       }
  2364.     }
  2365.     else if (pdir8 == 1) // list1
  2366.     {
  2367.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_1];
  2368.       for (j=j0; j<jj; j++)
  2369.       {
  2370.         memcpy(&lc_l1_mv8x8[j][i0][0], &all_mv[LIST_1][l1_ref][mode][j][i0][0],  (ii - i0) * 2 * sizeof(short));
  2371.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_1][l1_ref][mode][j][i0][0], (ii - i0) * 2 * sizeof(short));
  2372.       }
  2373.     }
  2374.     else if (pdir8==2) // bipred
  2375.     {
  2376.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2377.       for (j=j0; j<jj; j++)
  2378.       {
  2379.         memcpy(&lc_l0_mv8x8[j][i0][0], &all_mv[LIST_0][l0_ref][mode][j][i0][0],  (ii - i0) * 2 * sizeof(short));
  2380.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_0][l0_ref][mode][j][i0][0], (ii - i0) * 2 * sizeof(short));
  2381.       }
  2382.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_1];
  2383.       for (j=j0; j<jj; j++)
  2384.       {        
  2385.         memcpy(&lc_l1_mv8x8[j][i0][0], &all_mv[LIST_1][l1_ref][mode][j][i0][0],  (ii - i0) * 2 * sizeof(short));
  2386.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_1][l1_ref][mode][j][i0][0], (ii - i0) * 2 * sizeof(short));
  2387.       }
  2388.     }
  2389.     else
  2390.     {
  2391.       error("invalid direction mode", 255);
  2392.     }
  2393.   }
  2394. }
  2398. /*!
  2399.  *************************************************************************************
  2400.  * brief
  2401.  *    Store motion vectors of 8x8 partitions of one macroblock
  2402.  *************************************************************************************
  2403.  */
  2404. void StoreMV8x8(int dir)
  2405. {
  2406.   int block8x8;
  2408.   int bframe = (img->type == B_SLICE);
  2410.   for (block8x8=0; block8x8<4; block8x8++)
  2411.     StoreMVBlock8x8(dir, block8x8, tr8x8.part8x8mode[block8x8], tr8x8.part8x8l0ref[block8x8],
  2412.     tr8x8.part8x8l1ref[block8x8], tr8x8.part8x8pdir[block8x8], tr8x8.part8x8bipred[block8x8], bframe);
  2413. }
  2415. /*!
  2416. *************************************************************************************
  2417. * brief
  2418. *    Restore motion vectors for 8x8 partition
  2419. *************************************************************************************
  2420. */
  2421. void RestoreMVBlock8x8(int dir, int block8x8, RD_8x8DATA tr, int bframe)
  2422. {
  2423.   int j, i0, j0, ii, jj;
  2424.   short ******all_mv  = img->all_mv;
  2425.   short ******pred_mv = img->pred_mv;
  2426.   short (*lc_l0_mv8x8)[4][2] = all_mv8x8[dir][LIST_0];
  2427.   short (*lc_l1_mv8x8)[4][2] = all_mv8x8[dir][LIST_1];
  2428.   short (*lc_pr_mv8x8)[4][2] = NULL;
  2430.   short pdir8     = tr.part8x8pdir [block8x8];
  2431.   short mode      = tr.part8x8mode [block8x8];
  2432.   short l0_ref    = tr.part8x8l0ref[block8x8];
  2433.   short l1_ref    = tr.part8x8l1ref[block8x8];
  2434.   short bipred_me = tr.part8x8bipred[block8x8];
  2436.   if(bframe && bipred_me)
  2437.   {
  2438.     all_mv = img->bipred_mv[bipred_me - 1];
  2439.   }
  2441.   i0 = (block8x8 & 0x01) << 1;
  2442.   j0 = (block8x8 >> 1) << 1;
  2443.   ii = i0+2;
  2444.   jj = j0+2;
  2446.   if (!bframe)
  2447.   {
  2448.     if (pdir8>=0) //(mode8!=IBLOCK)&&(mode8!=I16MB))  // && ref != -1)
  2449.     {
  2450.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2451.       for (j=j0; j<jj; j++)
  2452.       {
  2453.         memcpy(&all_mv[LIST_0][l0_ref][4][j][i0][0],  &lc_l0_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2454.         memcpy(&pred_mv[LIST_0][l0_ref][4][j][i0][0], &lc_pr_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2455.       }
  2456.     }
  2457.   }
  2458.   else
  2459.   {
  2460.     if (pdir8==0) // forward
  2461.     {
  2462.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2463.       for (j=j0; j<jj; j++)
  2464.       {
  2465.         memcpy(&all_mv[LIST_0][l0_ref][mode][j][i0][0],  &lc_l0_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2466.         memcpy(&pred_mv[LIST_0][l0_ref][mode][j][i0][0], &lc_pr_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2467.       }
  2468.     }
  2469.     else if (pdir8==1) // backward
  2470.     {
  2471.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_1];
  2472.       for (j=j0; j<jj; j++)
  2473.       {
  2474.         memcpy(&all_mv[LIST_1][l1_ref][mode][j][i0][0],  &lc_l1_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2475.         memcpy(&pred_mv[LIST_1][l1_ref][mode][j][i0][0], &lc_pr_mv8x8[j][i0][0], 2 * 2 * sizeof(short));
  2476.       }
  2477.     }
  2478.     else if (pdir8==2) // bidir
  2479.     {
  2480.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2481.       for (j=j0; j<jj; j++)
  2482.       {
  2483.         memcpy(&all_mv[LIST_0][l0_ref][mode][j][i0][0],  &lc_l0_mv8x8[j][i0][0], (ii - i0) * 2 * sizeof(short));
  2484.         memcpy(&pred_mv[LIST_0][l0_ref][mode][j][i0][0], &lc_pr_mv8x8[j][i0][0], (ii - i0) * 2 * sizeof(short));
  2485.       }
  2486.       
  2487.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_1];
  2488.       for (j=j0; j<jj; j++)
  2489.       {        
  2490.         memcpy(&all_mv[LIST_1][l1_ref][mode][j][i0][0],  &lc_l1_mv8x8[j][i0][0], (ii - i0) * 2 * sizeof(short));
  2491.         memcpy(&pred_mv[LIST_1][l1_ref][mode][j][i0][0], &lc_pr_mv8x8[j][i0][0], (ii - i0) * 2 * sizeof(short));
  2492.       }
  2493.     }
  2494.     else
  2495.     {
  2496.       error("invalid direction mode", 255);
  2497.     }
  2498.   }
  2499. }
  2501. /*!
  2502.  *************************************************************************************
  2503.  * brief
  2504.  *    Restore motion vectors of 8x8 partitions of one macroblock
  2505.  *************************************************************************************
  2506.  */
  2507. void RestoreMV8x8(int dir)
  2508. {
  2509.   int block8x8;
  2511.   int bframe = (img->type == B_SLICE);
  2513.   for (block8x8=0; block8x8<4; block8x8++)
  2514.     RestoreMVBlock8x8(dir, block8x8, tr8x8, bframe);
  2515. }
  2518. /*!
  2519.  *************************************************************************************
  2520.  * brief
  2521.  *    Store predictors for 8x8 partition
  2522.  *************************************************************************************
  2523.  */
  2525. void StoreNewMotionVectorsBlock8x8(int dir, int block8x8, int mode, int l0_ref, int l1_ref, int pdir8, int bipred_me, int bframe)
  2526. {
  2527.   int j, i0, j0, ii, jj;
  2528.   short ******all_mv  = img->all_mv;
  2529.   short ******pred_mv = img->pred_mv;
  2530.   short (*lc_l0_mv8x8)[4][2] = all_mv8x8[dir][LIST_0];
  2531.   short (*lc_l1_mv8x8)[4][2] = all_mv8x8[dir][LIST_1];
  2532.   short (*lc_pr_mv8x8)[4][2] = NULL;
  2533.   
  2534.   if (bframe && bipred_me)
  2535.   {
  2536.     all_mv  = img->bipred_mv[bipred_me - 1];
  2537.   }
  2539.   i0 = (block8x8 & 0x01) << 1;
  2540.   j0 = (block8x8 >> 1) << 1;
  2541.   ii = i0+2;
  2542.   jj = j0+2;
  2544.   if (pdir8<0)
  2545.   {
  2546.     for (j=j0; j<jj; j++)
  2547.     {
  2548.       memset(&lc_l0_mv8x8[j][i0], 0, 4 * sizeof(short));
  2549.     }
  2550.     for (j=j0; j<jj; j++)
  2551.     {
  2552.       memset(&lc_l1_mv8x8[j][i0], 0, 4 * sizeof(short));
  2553.     }
  2554.     return;
  2555.   }
  2557.   if (!bframe)
  2558.   {
  2560.     lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2561.     for (j=j0; j<jj; j++)
  2562.     {
  2563.       memcpy(&lc_l0_mv8x8[j][i0][0], &all_mv [LIST_0][l0_ref][4][j][i0][0], 4 * sizeof(short));
  2564.       memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_0][l0_ref][4][j][i0][0], 4 * sizeof(short));
  2565.     }
  2567.     
  2568.     for (j=j0; j<jj; j++)
  2569.     {
  2570.       memset(&lc_l1_mv8x8[j][i0], 0, 4 * sizeof(short));
  2571.     }
  2572.     return;
  2573.   }
  2574.   else
  2575.   {
  2576.     if ((pdir8==0 || pdir8==2))
  2577.     {
  2578.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_0];
  2580.       for (j=j0; j<jj; j++)
  2581.       {
  2582.         memcpy(&lc_l0_mv8x8[j][i0][0], &all_mv[LIST_0][l0_ref][mode][j][i0][0],  4 * sizeof(short));
  2583.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_0][l0_ref][mode][j][i0][0], 4 * sizeof(short));
  2584.       }
  2585.     }
  2586.     else
  2587.     {
  2588.       for (j=j0; j<jj; j++)
  2589.         memset(&lc_l0_mv8x8[j][i0], 0, 4 * sizeof(short));
  2590.     }
  2592.     if ((pdir8==1 || pdir8==2))
  2593.     {
  2594.       lc_pr_mv8x8 = pred_mv8x8[dir][LIST_1];
  2596.       for (j=j0; j<jj; j++)
  2597.       {
  2598.         memcpy(&lc_l1_mv8x8[j][i0][0], &all_mv[LIST_1][l1_ref][mode][j][i0][0],  4 * sizeof(short));
  2599.         memcpy(&lc_pr_mv8x8[j][i0][0], &pred_mv[LIST_1][l1_ref][mode][j][i0][0], 4 * sizeof(short));
  2600.       }
  2601.     }
  2602.     else
  2603.     {
  2604.       for (j=j0; j<jj; j++)
  2605.         memset(&lc_l1_mv8x8[j][i0], 0, 4 * sizeof(short));
  2606.     }
  2607.   }
  2608. }
  2610. /*!
  2611.  ************************************************************************
  2612.  * brief
  2613.  *    Makes the decision if 8x8 tranform will be used (for RD-off)
  2614.  ************************************************************************
  2615.  */
  2616. int GetBestTransformP8x8()
  2617. {
  2618.   int    block_y, block_x, pic_pix_y, pic_pix_x, i, j, k;
  2619.   int    mb_y, mb_x, block8x8;
  2620.   int    cost8x8=0, cost4x4=0;
  2621.   int    *diff_ptr;
  2623.   if(params->Transform8x8Mode==2) //always allow 8x8 transform
  2624.     return 1;
  2626.   for (block8x8=0; block8x8<4; block8x8++)
  2627.   {
  2628.     mb_y = (block8x8 >>   1) << 3;
  2629.     mb_x = (block8x8 & 0x01) << 3;
  2630.     //===== loop over 4x4 blocks =====
  2631.     k=0;
  2632.     for (block_y = mb_y; block_y < mb_y + 8; block_y += 4)
  2633.     {
  2634.       pic_pix_y = img->opix_y + block_y;
  2636.       //get cost for transform size 4x4
  2637.       for (block_x = mb_x; block_x<mb_x + 8; block_x += 4)
  2638.       {
  2639.         pic_pix_x = img->opix_x + block_x;
  2641.         //===== get displaced frame difference ======
  2642.         diff_ptr=&diff4x4[k];
  2643.         for (j=0; j<4; j++)
  2644.         {
  2645.           for (i=0; i<4; i++, k++)
  2646.           {
  2647.             //4x4 transform size
  2648.             diff4x4[k] = pCurImg[pic_pix_y+j][pic_pix_x+i] - tr4x4.mpr8x8[j+block_y][i+block_x];
  2649.             //8x8 transform size
  2650.             diff8x8[k] = pCurImg[pic_pix_y+j][pic_pix_x+i] - tr8x8.mpr8x8[j+block_y][i+block_x];
  2651.           }
  2652.         }
  2654.         cost4x4 += distortion4x4 (diff_ptr);
  2655.       }
  2656.     }
  2657.     cost8x8 += distortion8x8 (diff8x8);
  2658.   }
  2659.   return (cost8x8 < cost4x4);
  2660. }
  2662. /*!
  2663. ************************************************************************
  2664. * brief
  2665. *    Sets MBAFF RD parameters
  2666. ************************************************************************
  2667. */
  2668. void set_mbaff_parameters(Macroblock  *currMB)
  2669. {
  2670.   int  j;
  2671.   int  mode         = best_mode;
  2672.   int  bframe       = (img->type==B_SLICE);
  2673.   char **ipredmodes = img->ipredmode;
  2676.   //===== reconstruction values =====
  2677.   for (j=0; j < MB_BLOCK_SIZE; j++)
  2678.     memcpy(rdopt->rec_mbY[j],&enc_picture->imgY[img->pix_y + j][img->pix_x], MB_BLOCK_SIZE * sizeof(imgpel));
  2680.   if (img->yuv_format != YUV400)
  2681.   {
  2682.     for (j=0; j<img->mb_cr_size_y; j++)
  2683.     {
  2684.       memcpy(rdopt->rec_mb_cr[0][j], &enc_picture->imgUV[0][img->pix_c_y + j][img->pix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  2685.       memcpy(rdopt->rec_mb_cr[1][j], &enc_picture->imgUV[1][img->pix_c_y + j][img->pix_c_x], img->mb_cr_size_x * sizeof(imgpel));
  2686.     }
  2687.   }
  2689.   //===== coefficients and cbp =====
  2690.   rdopt->mode      = mode;
  2691.   rdopt->i16offset = img->i16offset;
  2692.   rdopt->cbp       = currMB->cbp;
  2693.   rdopt->cbp_blk   = currMB->cbp_blk;
  2694.   rdopt->mb_type   = currMB->mb_type;
  2696.   rdopt->luma_transform_size_8x8_flag = currMB->luma_transform_size_8x8_flag;
  2698.   if(rdopt->mb_type == 0 && mode != 0)
  2699.   {
  2700.     mode=0;
  2701.     rdopt->mode=0;
  2702.   }
  2704.   memcpy(rdopt->cofAC[0][0][0], img->cofAC[0][0][0], (4+img->num_blk8x8_uv) * 4 * 2 * 65 * sizeof(int));
  2705.   memcpy(rdopt->cofDC[0][0], img->cofDC[0][0], 3 * 2 * 18 * sizeof(int));
  2707.   memcpy(rdopt->b8mode, currMB->b8mode, BLOCK_MULTIPLE * sizeof(short));
  2708.   memcpy(rdopt->b8pdir, currMB->b8pdir, BLOCK_MULTIPLE * sizeof(short));
  2710.   //==== reference frames =====
  2711.   if (bframe)
  2712.   {
  2713.     if (params->BiPredMERefinements == 1)
  2714.     {      
  2715.       int i, j, k;
  2716.       for (j = 0; j < BLOCK_MULTIPLE; j++)
  2717.       {
  2718.         for (i = 0; i < BLOCK_MULTIPLE; i++)
  2719.         {
  2720.           k = 2*(j >> 1)+(i >> 1);
  2721.           if (currMB->bipred_me[k] == 0)
  2722.           {
  2723.             rdopt->refar[LIST_0][j][i] = enc_picture->motion.ref_idx[LIST_0][img->block_y + j][img->block_x + i];
  2724.             rdopt->refar[LIST_1][j][i] = enc_picture->motion.ref_idx[LIST_1][img->block_y + j][img->block_x + i];
  2725.           }
  2726.           else
  2727.           {
  2728.             rdopt->refar[LIST_0][j][i] = 0;
  2729.             rdopt->refar[LIST_1][j][i] = 0;
  2730.           }
  2731.         }
  2732.       }
  2733.     }
  2734.     else
  2735.     {
  2736.       for (j = 0; j < BLOCK_MULTIPLE; j++)
  2737.       {
  2738.         memcpy(rdopt->refar[LIST_0][j],&enc_picture->motion.ref_idx[LIST_0][img->block_y + j][img->block_x] , BLOCK_MULTIPLE * sizeof(char));
  2739.         memcpy(rdopt->refar[LIST_1][j],&enc_picture->motion.ref_idx[LIST_1][img->block_y + j][img->block_x] , BLOCK_MULTIPLE * sizeof(char));
  2740.       }
  2741.     }
  2742.   }
  2743.   else
  2744.   {
  2745.     for (j = 0; j < BLOCK_MULTIPLE; j++)
  2746.       memcpy(rdopt->refar[LIST_0][j],&enc_picture->motion.ref_idx[LIST_0][img->block_y + j][img->block_x] , BLOCK_MULTIPLE * sizeof(char));
  2747.   }
  2749.   memcpy(rdopt->intra_pred_modes,currMB->intra_pred_modes, MB_BLOCK_PARTITIONS * sizeof(char));
  2750.   memcpy(rdopt->intra_pred_modes8x8,currMB->intra_pred_modes8x8, MB_BLOCK_PARTITIONS * sizeof(char));
  2751.   for (j = img->block_y; j < img->block_y + 4; j++)
  2752.   {
  2753.     memcpy(&rdopt->ipredmode[j][img->block_x],&ipredmodes[j][img->block_x], BLOCK_MULTIPLE * sizeof(char));
  2754.   }
  2755. }
  2757. /*!
  2758. ************************************************************************
  2759. * brief
  2760. *    store coding state (for rd-optimized mode decision), used for 8x8 transformation
  2761. ************************************************************************
  2762. */
  2763. void store_coding_state_cs_cm(Macroblock *currMB)
  2764. {
  2765.   store_coding_state(currMB, cs_cm);
  2766. }
  2768. /*!
  2769. ************************************************************************
  2770. * brief
  2771. *    restore coding state (for rd-optimized mode decision), used for 8x8 transformation
  2772. ************************************************************************
  2773. */
  2774. void reset_coding_state_cs_cm(Macroblock *currMB)
  2775. {
  2776.   reset_coding_state(currMB, cs_cm);
  2777. }
  2779. void assign_enc_picture_params(int mode, char best_pdir, int block, int list_offset, int best_l0_ref, int best_l1_ref, int bframe, short bipred_me)
  2780. {
  2781.   int i,j;
  2782.   int block_x, block_y;
  2783.   int list, maxlist, bestref;
  2784.   short ***curr_mv = NULL;
  2785.   int64 curr_ref_idx = 0;
  2786.  
  2787.   int start_x = 0, start_y = 0, end_x = BLOCK_MULTIPLE, end_y = BLOCK_MULTIPLE; 
  2788.   switch (mode)
  2789.   {
  2790.     case 1:
  2791.       start_x = 0;
  2792.       start_y = 0;
  2793.       end_x   = BLOCK_MULTIPLE;
  2794.       end_y   = BLOCK_MULTIPLE;
  2795.       break;
  2796.     case 2:
  2797.       start_x = 0;
  2798.       start_y = block * 2;
  2799.       end_x   = BLOCK_MULTIPLE;
  2800.       end_y   = (block + 1) * 2;
  2801.       break;
  2802.     case 3:
  2803.       start_x = block * 2;
  2804.       start_y = 0;
  2805.       end_x   = (block + 1) * 2;
  2806.       end_y   = BLOCK_MULTIPLE;
  2807.       break;
  2808.     default:
  2809.       break;
  2810.   }
  2812.   maxlist  = bframe ? 1: 0;
  2813.   for (list = 0; list <= maxlist; list++)
  2814.   {
  2815.     bestref = (list == 0) ? best_l0_ref : best_l1_ref;
  2816.     switch (bipred_me)
  2817.     {
  2818.       case 0:
  2819.         curr_mv = img->all_mv[list][bestref][mode];
  2820.         curr_ref_idx = enc_picture->ref_pic_num[list + list_offset][bestref];
  2821.         break;
  2822.       case 1:
  2823.         curr_mv = img->bipred_mv[0][list][0][mode] ; //best_l0_ref has to be zero in this case
  2824.         curr_ref_idx = enc_picture->ref_pic_num[list + list_offset][0];
  2825.         break;
  2826.       case 2:
  2827.         curr_mv = img->bipred_mv[1][list][0][mode] ; //best_l0_ref has to be zero in this case
  2828.         curr_ref_idx = enc_picture->ref_pic_num[list + list_offset][0];
  2829.         break;
  2830.       default:
  2831.         break;
  2832.     }
  2834.     for (j = start_y; j < end_y; j++)
  2835.     {
  2836.       block_y = img->block_y + j;
  2837.       for (i = start_x; i < end_x; i++)
  2838.       {
  2839.         block_x = img->block_x + i;
  2840.         if ((best_pdir != 2) && (best_pdir != list))
  2841.         {
  2842.             enc_picture->motion.ref_idx    [list][block_y][block_x]    = -1;
  2843.             enc_picture->motion.ref_pic_id [list][block_y][block_x]    = -1;
  2844.             enc_picture->motion.mv         [list][block_y][block_x][0] = 0;
  2845.             enc_picture->motion.mv         [list][block_y][block_x][1] = 0;
  2846.         }
  2847.         else
  2848.       {
  2849.           enc_picture->motion.ref_pic_id [list][block_y][block_x]    = curr_ref_idx;
  2850.           enc_picture->motion.mv         [list][block_y][block_x][0] = curr_mv[j][i][0];
  2851.           enc_picture->motion.mv         [list][block_y][block_x][1] = curr_mv[j][i][1];
  2852.         }
  2853.       }
  2854.     }
  2855.   }
  2856. }
  2859. /*!
  2860.  *************************************************************************************
  2861.  * brief
  2862.  *    Set block 8x8 mode information
  2863.  *************************************************************************************
  2864.  */
  2865. void set_block8x8_info(Block8x8Info *b8x8info, int mode, int block,  char best_ref[2], char best_pdir, short bipred_me)
  2866. {
  2867.   int i;
  2868.   //----- set reference frame and direction parameters -----
  2869.   if (mode==3)
  2870.   {
  2871.     b8x8info->best8x8l0ref [3][block  ] = b8x8info->best8x8l0ref [3][  block+2] = best_ref[LIST_0];
  2872.     b8x8info->best8x8pdir  [3][block  ] = b8x8info->best8x8pdir  [3][  block+2] = best_pdir;
  2873.     b8x8info->best8x8l1ref [3][block  ] = b8x8info->best8x8l1ref [3][  block+2] = best_ref[LIST_1];
  2874.     b8x8info->bipred8x8me  [3][block  ] = b8x8info->bipred8x8me  [3][  block+2] = bipred_me;
  2875.   }
  2876.   else if (mode==2)
  2877.   {
  2878.     b8x8info->best8x8l0ref [2][2*block] = b8x8info->best8x8l0ref [2][2*block+1] = best_ref[LIST_0];
  2879.     b8x8info->best8x8pdir  [2][2*block] = b8x8info->best8x8pdir  [2][2*block+1] = best_pdir;
  2880.     b8x8info->best8x8l1ref [2][2*block] = b8x8info->best8x8l1ref [2][2*block+1] = best_ref[LIST_1];
  2881.     b8x8info->bipred8x8me  [2][2*block] = b8x8info->bipred8x8me  [2][2*block+1] = bipred_me;
  2882.   }
  2883.   else
  2884.   {
  2885.     memset(&b8x8info->best8x8l0ref [1][0], best_ref[LIST_0], 4 * sizeof(char));
  2886.     memset(&b8x8info->best8x8l1ref [1][0], best_ref[LIST_1], 4 * sizeof(char));
  2887.     memset(&b8x8info->best8x8pdir  [1][0], best_pdir, 4 * sizeof(char));
  2888.     for (i = 0; i< 4; i++)
  2889.       b8x8info->bipred8x8me  [1][i] =  bipred_me;
  2890.   }
  2891. }
  2893. /*!
  2894.  *************************************************************************************
  2895.  * brief
  2896.  *    Set block 8x8 mode information for P8x8 mode
  2897.  *************************************************************************************
  2898.  */
  2899. void set_subblock8x8_info(Block8x8Info *b8x8info,int mode, int block, RD_8x8DATA *tr)
  2900. {          
  2901.   b8x8info->best8x8mode         [block] = tr->part8x8mode  [block];
  2902.   b8x8info->best8x8pdir   [mode][block] = tr->part8x8pdir  [block];
  2903.   b8x8info->best8x8l0ref  [mode][block] = tr->part8x8l0ref [block];
  2904.   b8x8info->best8x8l1ref  [mode][block] = tr->part8x8l1ref [block];
  2905.   b8x8info->bipred8x8me   [mode][block] = tr->part8x8bipred[block];
  2906. }
  2910. void update_refresh_map(int intra, int intra1, Macroblock *currMB)
  2911. {
  2912.   if (params->RestrictRef==1)
  2913.   {
  2914.     // Modified for Fast Mode Decision. Inchoon Choi, SungKyunKwan Univ.
  2915.     if (params->rdopt<2)
  2916.     {
  2917.       refresh_map[2*img->mb_y  ][2*img->mb_x  ] = (intra ? 1 : 0);
  2918.       refresh_map[2*img->mb_y  ][2*img->mb_x+1] = (intra ? 1 : 0);
  2919.       refresh_map[2*img->mb_y+1][2*img->mb_x  ] = (intra ? 1 : 0);
  2920.       refresh_map[2*img->mb_y+1][2*img->mb_x+1] = (intra ? 1 : 0);
  2921.     }
  2922.     else if (params->rdopt == 3)
  2923.     {
  2924.       refresh_map[2*img->mb_y  ][2*img->mb_x  ] = (intra1==0 && (currMB->mb_type==I16MB || currMB->mb_type==I4MB) ? 1 : 0);
  2925.       refresh_map[2*img->mb_y  ][2*img->mb_x+1] = (intra1==0 && (currMB->mb_type==I16MB || currMB->mb_type==I4MB) ? 1 : 0);
  2926.       refresh_map[2*img->mb_y+1][2*img->mb_x  ] = (intra1==0 && (currMB->mb_type==I16MB || currMB->mb_type==I4MB) ? 1 : 0);
  2927.       refresh_map[2*img->mb_y+1][2*img->mb_x+1] = (intra1==0 && (currMB->mb_type==I16MB || currMB->mb_type==I4MB) ? 1 : 0);
  2928.     }
  2929.   }
  2930.   else if (params->RestrictRef==2)
  2931.   {
  2932.     refresh_map[2*img->mb_y  ][2*img->mb_x  ] = (currMB->mb_type==I16MB || currMB->mb_type==I4MB ? 1 : 0);
  2933.     refresh_map[2*img->mb_y  ][2*img->mb_x+1] = (currMB->mb_type==I16MB || currMB->mb_type==I4MB ? 1 : 0);
  2934.     refresh_map[2*img->mb_y+1][2*img->mb_x  ] = (currMB->mb_type==I16MB || currMB->mb_type==I4MB ? 1 : 0);
  2935.     refresh_map[2*img->mb_y+1][2*img->mb_x+1] = (currMB->mb_type==I16MB || currMB->mb_type==I4MB ? 1 : 0);
  2936.   }
  2937. }
  2939. int valid_intra_mode(int ipmode)
  2940. {
  2941.   if (params->IntraDisableInterOnly==0 || img->type != I_SLICE)
  2942.   {
  2943.     if (params->Intra4x4ParDisable && (ipmode==VERT_PRED||ipmode==HOR_PRED))
  2944.       return 0;
  2946.     if (params->Intra4x4DiagDisable && (ipmode==DIAG_DOWN_LEFT_PRED||ipmode==DIAG_DOWN_RIGHT_PRED))
  2947.       return 0;
  2949.     if (params->Intra4x4DirDisable && ipmode>=VERT_RIGHT_PRED)
  2950.       return 0;
  2951.   }
  2952.   return 1;
  2953. }
  2955. void compute_comp_cost(imgpel **cur_img, imgpel prd_img[16][16], int pic_opix_x, int *cost)
  2956. {
  2957.   int j, i, *d;
  2958.   imgpel *cur_line, *prd_line;
  2959.   d = &diff[0];
  2961.   for (j = 0; j < BLOCK_SIZE; j++)
  2962.   {
  2963.     cur_line = &cur_img[j][pic_opix_x];
  2964.     prd_line = prd_img[j];
  2966.     for (i = 0; i < BLOCK_SIZE; i++)
  2967.     {
  2968.       *d++ = *cur_line++ - *prd_line++;
  2969.     }
  2970.   }      
  2971.   *cost += distortion4x4 (diff);
  2972. }
  2975. void generate_pred_error(imgpel **cur_img, imgpel prd_img[16][16], imgpel cur_prd[16][16], 
  2976.                          int m7[16][16], int pic_opix_x, int block_x)
  2977. {
  2978.   int j, i, *m7_line;
  2979.   imgpel *cur_line, *prd_line;
  2981.   for (j = 0; j < BLOCK_SIZE; j++)
  2982.   {
  2983.     m7_line = &m7[j][block_x];
  2984.     cur_line = &cur_img[j][pic_opix_x];
  2985.     prd_line = prd_img[j];
  2986.     memcpy(&cur_prd[j][block_x], prd_line, BLOCK_SIZE * sizeof(imgpel));
  2988.     for (i = 0; i < BLOCK_SIZE; i++)
  2989.     {
  2990.       *m7_line++ = (int) (*cur_line++ - *prd_line++);
  2991.     }
  2992.   }        
  2993. }