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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rdopt.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：53k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rdopt.c：源码内容
  1. /*
  2. ***********************************************************************
  3. * COPYRIGHT AND WARRANTY INFORMATION
  4. *
  5. * Copyright 2001, International Telecommunications Union, Geneva
  6. *
  7. * DISCLAIMER OF WARRANTY
  8. *
  9. * These software programs are available to the user without any
  10. * license fee or royalty on an "as is" basis. The ITU disclaims
  11. * any and all warranties, whether express, implied, or
  12. * statutory, including any implied warranties of merchantability
  13. * or of fitness for a particular purpose.  In no event shall the
  14. * contributor or the ITU be liable for any incidental, punitive, or
  15. * consequential damages of any kind whatsoever arising from the
  16. * use of these programs.
  17. *
  18. * This disclaimer of warranty extends to the user of these programs
  19. * and user's customers, employees, agents, transferees, successors,
  20. * and assigns.
  21. *
  22. * The ITU does not represent or warrant that the programs furnished
  23. * hereunder are free of infringement of any third-party patents.
  24. * Commercial implementations of ITU-T Recommendations, including
  25. * shareware, may be subject to royalty fees to patent holders.
  26. * Information regarding the ITU-T patent policy is available from
  27. * the ITU Web site at http://www.itu.int.
  28. *
  29. * THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE ITU-T PATENT POLICY.
  30. ************************************************************************
  31. */
  33. /*!
  34.  ***************************************************************************
  35.  * file rdopt.c
  36.  *
  37.  * brief
  38.  *    Rate-Distortion optimized mode decision
  39.  *
  40.  * author
  41.  *    Heiko Schwarz <hschwarz@hhi.de>
  42.  *
  43.  * date
  44.  *    12. April 2001
  45.  **************************************************************************
  46.  */
  48. #include <stdlib.h>
  49. #include <math.h>
  50. #include <memory.h>
  51. #include "rdopt.h"
  52. #include "refbuf.h"
  54. extern const byte PRED_IPRED[7][7][6];
  55. extern       int  QP2QUANT  [32];
  57. //=== static parameters ===
  58. RDOpt  *rdopt     = NULL;
  61. int    *forward_me_done[9];
  62. int    *tot_for_sad[9];
  65. /*!
  66.  ************************************************************************
  67.  * brief
  68.  *    delete structure for RD-optimized mode decision
  69.  ************************************************************************
  70.  */
  71. void clear_rdopt ()
  72. {
  73.   int i;
  75.   // rd-optimization structure
  76.   if (rdopt != NULL)
  77.   {
  78.     free (rdopt);
  79.     rdopt = NULL;
  81.     for (i=0; i<9; i++)
  82.     {
  83.       free (forward_me_done[i]);
  84.       free (tot_for_sad    [i]);
  85.     }
  86.   }
  88.   // structure for saving the coding state
  89.   clear_coding_state ();
  90. }
  93. /*!
  94.  ************************************************************************
  95.  * brief
  96.  *    create structure for RD-optimized mode decision
  97.  ************************************************************************
  98.  */
  99. void
  100. init_rdopt ()
  101. {
  102.   int i;
  104.   if (!input->rdopt)
  105.     return;
  107.   clear_rdopt ();
  109.   // rd-optimization structure
  110.   if ((rdopt = (RDOpt*) calloc (1, sizeof(RDOpt))) == NULL)
  111.   {
  112.     no_mem_exit ("init_rdopt: rdopt");
  113.   }
  115.   for (i=0; i<9; i++)
  116.   {
  117.     if ((forward_me_done[i] = (int*)malloc (img->buf_cycle*sizeof(int))) == NULL) no_mem_exit ("init_rdopt: forward_me_done");
  118.     if ((tot_for_sad    [i] = (int*)malloc (img->buf_cycle*sizeof(int))) == NULL) no_mem_exit ("init_rdopt: tot_for_sad");
  119.   }
  122.   // structure for saving the coding state
  123.   init_coding_state ();
  124. }
  128. /*!
  129.  ************************************************************************
  130.  * brief
  131.  *    set Rate-Distortion cost of 4x4 Intra modes
  132.  ************************************************************************
  133.  */
  134. void
  135. RDCost_Intra4x4_Block (int block_x,
  136.                        int block_y,
  137.                        int ipmode)
  138. {
  139.   int             dummy, left_ipmode, upper_ipmode, curr_ipmode, x, y;
  140.   int             i            = block_x >> 2;
  141.   int             j            = block_y >> 2;
  142.   int             pic_block_x  = (img->pix_x+block_x) / BLOCK_SIZE;
  143.   int             pic_block_y  = (img->pix_y+block_y) / BLOCK_SIZE;
  144.   int             even_block   = ((i & 1) == 1);
  145.   Slice          *currSlice    =  img->currentSlice;
  146.   Macroblock     *currMB       = &img->mb_data[img->current_mb_nr];
  147.   SyntaxElement  *currSE       = &img->MB_SyntaxElements[currMB->currSEnr];
  148.   int            *partMap      = assignSE2partition[input->partition_mode];
  149.   DataPartition  *dataPart;
  152.   //===== perform DCT, Q, IQ, IDCT =====
  153.   dct_luma (block_x, block_y, &dummy);
  155.   //===== get distortion (SSD) of 4x4 block =====
  156.   for   (y=0; y < BLOCK_SIZE; y++)
  157.     for (x=0; x < BLOCK_SIZE; x++)
  158.     {
  159.       dummy = imgY_org[img->pix_y+block_y+y][img->pix_x+block_x+x] - img->m7[x][y];
  160.       rdopt->distortion_4x4[j][i][ipmode] += img->quad[abs(dummy)];
  161.     }
  162.   rdopt->rdcost_4x4[j][i][ipmode] = (double)rdopt->distortion_4x4[j][i][ipmode];
  163.   if (rdopt->rdcost_4x4[j][i][ipmode] >= rdopt->min_rdcost_4x4[j][i])
  164.     return;
  166.   //===== store the coding state =====
  167.   store_coding_state ();
  169.   //===== get (estimate) rate for intra prediction mode =====
  170.   //--- set or estimate the values of syntax element ---
  171.   if (even_block)
  172.     // EVEN BLOCK: the values the of syntax element can be set correctly
  173.   {
  174.     // value of last block
  175.     upper_ipmode   =  img->ipredmode [pic_block_x  ][pic_block_y  ];
  176.     left_ipmode    =  img->ipredmode [pic_block_x-1][pic_block_y+1];
  177.     curr_ipmode    =  img->ipredmode [pic_block_x  ][pic_block_y+1];
  178.     currSE->value1 =  PRED_IPRED [upper_ipmode+1][left_ipmode+1][curr_ipmode];
  179.     // value of this block
  180.     upper_ipmode   =  img->ipredmode [pic_block_x+1][pic_block_y  ];
  181.     currSE->value2 =  PRED_IPRED [upper_ipmode+1][curr_ipmode+1][ipmode];
  182.   }
  183.   else
  184.   /* ODD BLOCK:  the second value of the syntax element cannot be set, since
  185.    *             it will be known only after the next step. For estimating
  186.    *             the rate the corresponding prediction mode is set to zero
  187.    *             (minimum rate). */
  188.   {
  189.     upper_ipmode   =  img->ipredmode [pic_block_x+1][pic_block_y  ];
  190.     left_ipmode    =  img->ipredmode [pic_block_x  ][pic_block_y+1];
  191.     currSE->value1 =  PRED_IPRED [upper_ipmode+1][left_ipmode+1][ipmode];
  192.     currSE->value2 =  0; // value with maximum probability
  193.   }
  194.   //--- set function pointers for syntax element ---
  195.   if (input->symbol_mode == UVLC)   currSE->mapping = intrapred_linfo;
  196.   else                currSE->writing = writeIntraPredMode2Buffer_CABAC;
  197.   currSE->type = SE_INTRAPREDMODE;
  198.   //--- choose the appropriate data partition ---
  199.   if (img->type != B_IMG)     dataPart = &(currSlice->partArr[partMap[SE_INTRAPREDMODE]]);
  200.   else                        dataPart = &(currSlice->partArr[partMap[SE_BFRAME]]);
  201.   //--- get length of syntax element ---
  202.   dataPart->writeSyntaxElement (currSE, dataPart);
  203.   rdopt->rate_imode_4x4[j][i][ipmode] = currSE->len;
  204.   rdopt->rdcost_4x4[j][i][ipmode] += rdopt->lambda_intra*(double)rdopt->rate_imode_4x4[j][i][ipmode];
  205.   if (rdopt->rdcost_4x4[j][i][ipmode] >= rdopt->min_rdcost_4x4[j][i])
  206.   {
  207.     restore_coding_state ();
  208.     return;
  209.   }
  210.   currSE++;
  211.   currMB->currSEnr++;
  213.   //===== get rate for luminance coefficients =====
  214.   rdopt->rate_luma_4x4[j][i][ipmode] = writeMB_bits_for_4x4_luma (i, j, 0);
  215.   rdopt->rdcost_4x4[j][i][ipmode] += rdopt->lambda_intra*(double)rdopt->rate_luma_4x4[j][i][ipmode];
  217.   //===== restore the saved coding state =====
  218.   restore_coding_state ();
  220.   //===== update best mode =====
  221.   if (rdopt->rdcost_4x4[j][i][ipmode] < rdopt->min_rdcost_4x4[j][i])
  222.   {
  223.     rdopt->best_mode_4x4 [j][i] = ipmode;
  224.     rdopt->min_rdcost_4x4[j][i] = rdopt->rdcost_4x4[j][i][ipmode];
  225.   }
  226. }
  229. /*!
  230.  ************************************************************************
  231.  * brief
  232.  *    Get best 4x4 Intra mode by rate-dist-based decision
  233.  ************************************************************************
  234.  */
  235. int
  236. RD_Intra4x4_Mode_Decision (int block_x,
  237.                            int block_y)
  238. {
  239.   int  ipmode, i, j;
  240.   int  index_y     = block_y >> 2;
  241.   int  index_x     = block_x >> 2;
  242.   int  pic_pix_y   = img->pix_y + block_y;
  243.   int  pic_pix_x   = img->pix_x + block_x;
  244.   int  pic_block_y = pic_pix_y / BLOCK_SIZE;
  245.   int  pic_block_x = pic_pix_x / BLOCK_SIZE;
  247.   typedef int (*WRITE_SE)(SyntaxElement*, struct datapartition*);
  248.   WRITE_SE     *writeSE=0;
  249.   int           symbol_mode;
  253.   /*=== set symbol mode to UVLC (CABAC does not work correctly -> wrong coding order) ===*
  254.    *=== and store the original symbol mode and function pointers                      ===*/
  255.   symbol_mode = input->symbol_mode;
  256.   if (input->symbol_mode != UVLC)
  257.   {
  258.     input->symbol_mode = UVLC;
  259.     if ((writeSE = (WRITE_SE*) calloc (img->currentSlice->max_part_nr, sizeof (WRITE_SE))) == NULL)
  260.     {
  261.       no_mem_exit ("RD_Intra4x4_Mode_Decision: writeSE");
  262.     }
  263.     for (i=0; i<img->currentSlice->max_part_nr; i++)
  264.     {
  265.       writeSE[i] = img->currentSlice->partArr[i].writeSyntaxElement;
  266.       img->currentSlice->partArr[i].writeSyntaxElement = writeSyntaxElement_UVLC;
  267.     }
  268.   }
  271.   //=== LOOP OVER ALL 4x4 INTRA PREDICTION MODES ===
  272.   rdopt->best_mode_4x4 [index_y][index_x] = -1;
  273.   rdopt->min_rdcost_4x4[index_y][index_x] =  1e30;
  274.   for (ipmode=0; ipmode < NO_INTRA_PMODE; ipmode++)
  275.   {
  276.     rdopt->rdcost_4x4    [index_y][index_x][ipmode] = -1;
  277.     rdopt->distortion_4x4[index_y][index_x][ipmode] =  0;
  278.     rdopt->rate_imode_4x4[index_y][index_x][ipmode] =  0;
  279.     rdopt->rate_luma_4x4 [index_y][index_x][ipmode] =  0;
  281.     // Horizontal pred from Y neighbour pix , vertical use X pix, diagonal needs both
  282.     if (ipmode==DC_PRED || ipmode==HOR_PRED || img->ipredmode[pic_block_x+1][pic_block_y] >= 0)
  283.       // DC or vert pred or hor edge
  284.     {
  285.       if (ipmode==DC_PRED || ipmode==VERT_PRED || img->ipredmode[pic_block_x][pic_block_y+1] >= 0)
  286.         // DC or hor pred or vert edge
  287.       {
  288.         // find diff
  289.         for   (j=0; j < BLOCK_SIZE; j++)
  290.           for (i=0; i < BLOCK_SIZE; i++)
  291.             img->m7[i][j] = imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mprr[ipmode][j][i];
  292.           // copy intra prediction block
  293.           for   (j=0; j < BLOCK_SIZE; j++)
  294.             for (i=0; i < BLOCK_SIZE; i++)
  295.               img->mpr[i+block_x][j+block_y] = img->mprr[ipmode][j][i];
  296.           // get lagrangian cost
  297.           RDCost_Intra4x4_Block (block_x, block_y, ipmode);
  298.       }
  299.     }
  300.   }
  302.   //=== restore the original symbol mode and function pointers ===
  303.   if (symbol_mode != UVLC)
  304.   {
  305.     input->symbol_mode = symbol_mode;
  306.     for (i=0; i<img->currentSlice->max_part_nr; i++)
  307.     {
  308.       img->currentSlice->partArr[i].writeSyntaxElement = writeSE[i];
  309.     }
  310.     free (writeSE);
  311.   }
  313.   return rdopt->best_mode_4x4[index_y][index_x];
  314. }
  317. /*!
  318.  ************************************************************************
  319.  * brief
  320.  *    Rate-Distortion opt. mode decision for 4x4 intra blocks
  321.  ************************************************************************
  322.  */
  323. void
  324. Intra4x4_Mode_Decision ()
  325. {
  326.   int i,j;
  327.   int block_x, block_y;
  328.   int best_ipmode;
  329.   int coeff_cost; // not used
  330.   int pic_pix_y,pic_pix_x,pic_block_y,pic_block_x;
  331.   int last_ipred=0;           // keeps last chosen intra prediction mode for 4x4 intra pred
  332.   int nonzero;                          // keep track of nonzero coefficients
  333.   int cbp_mask;
  334.   Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  336.   // start making 4x4 intra prediction
  337.   currMB->cbp=0;
  338.   img->mb_data[img->current_mb_nr].intraOrInter = INTRA_MB_4x4;
  340.   for(block_y = 0 ; block_y < MB_BLOCK_SIZE ; block_y += BLOCK_MULTIPLE)
  341.   {
  342.     pic_pix_y=img->pix_y+block_y;
  343.     pic_block_y=pic_pix_y/BLOCK_SIZE;
  345.     for(block_x = 0 ; block_x < MB_BLOCK_SIZE  ; block_x += BLOCK_MULTIPLE)
  346.     {
  347.       cbp_mask=(1<<(2*(block_y/8)+block_x/8));
  348.       pic_pix_x=img->pix_x+block_x;
  349.       pic_block_x=pic_pix_x/BLOCK_SIZE;
  351.       /*
  352.       intrapred_luma() makes and returns 4x4 blocks with all 5 intra prediction modes.
  353.       Notice that some modes are not possible at frame edges.
  354.       */
  355.       intrapred_luma (pic_pix_x,pic_pix_y);
  357.       //=== rate-constrained mode decision ===
  358.       best_ipmode = RD_Intra4x4_Mode_Decision (block_x, block_y);
  360.       img->ipredmode[pic_block_x+1][pic_block_y+1]=best_ipmode;
  362.       if ((pic_block_x & 1) == 1) // just even blocks, two and two predmodes are sent together
  363.       {
  364.         currMB->intra_pred_modes[block_x/4+block_y]=PRED_IPRED[img->ipredmode[pic_block_x+1][pic_block_y]+1][img->ipredmode[pic_block_x][pic_block_y+1]+1][best_ipmode];
  365.         currMB->intra_pred_modes[block_x/4-1+block_y]=last_ipred;
  366.       }
  367.       last_ipred=PRED_IPRED[img->ipredmode[pic_block_x+1][pic_block_y]+1][img->ipredmode[pic_block_x][pic_block_y+1]+1][best_ipmode];
  369.       //  Make difference from prediction to be transformed
  370.       for (j=0; j < BLOCK_SIZE; j++)
  371.         for (i=0; i < BLOCK_SIZE; i++)
  372.         {
  373.           img->mpr[i+block_x][j+block_y]=img->mprr[best_ipmode][j][i];
  374.           img->m7[i][j] =imgY_org[pic_pix_y+j][pic_pix_x+i] - img->mprr[best_ipmode][j][i];
  375.         }
  377.         nonzero = dct_luma(block_x,block_y,&coeff_cost);
  379.         if (nonzero)
  380.         {
  381.           currMB->cbp |= cbp_mask;// set coded block pattern if there are nonzero coeffs
  382.         }
  383.     }
  384.   }
  385. }
  389. /*!
  390.  ************************************************************************
  391.  * brief
  392.  *    Rate-Distortion cost of a macroblock
  393.  ************************************************************************
  394.  * note
  395.  * the following parameters have to be set before using this function:  n
  396.  * -------------------------------------------------------------------  n
  397.  *   for INTRA4x4  : img->imod,
  398.  *                   img->cof,
  399.  *                   currMB->cbp,
  400.  *                   currMB->intra_pred_modes,
  401.  *                   currMB->intraOrInter
  402.  *                                                                      n
  403.  *   for INTRA16x16: img->imod,
  404.  *                   img->mprr_2
  405.  *                   currMB->intraOrInter
  406.  *                                                                      n
  407.  *   for INTER     : img->imod,
  408.  *                   img->mv,   (predictors)
  409.  *                   tmp_mv,    (motion vectors)
  410.  *                   currMB->intraOrInter
  411.  *                                                                      n
  412.  *   for FORWARD   : img->imod,
  413.  *                   img->p_fwMV,
  414.  *                   tmp_fwMV,
  415.  *                   currMB->intraOrInter
  416.  *                                                                      n
  417.  *   for BACKWARD  : img->imod,
  418.  *                   img->p_bwMV,
  419.  *                   tmp_bwMV,
  420.  *                   currMB->intraOrInter
  421.  *                                                                      n
  422.  *   for BIDIRECT  : img->imod,
  423.  *                   img->p_fwMV,
  424.  *                   img->p_bwMV,
  425.  *                   tmp_fwMV,
  426.  *                   tmp_bwMV,
  427.  *                   currMB->intraOrInter
  428.  *                                                                      n
  429.  *   for DIRECT    : img->imod,
  430.  *                   dfMV,
  431.  *                   dbMV,
  432.  *                   currMB->intraOrInter
  433.  *                                                                      n
  434.  *   for COPY      : currMB->intraOrInter
  435.  *
  436.  ************************************************************************
  437.  */
  438. int
  439. RDCost_Macroblock (RateDistortion  *rd,
  440.                    int              mode,
  441.                    int              ref_or_i16mode,
  442.                    int              blocktype,
  443.                    int              blocktype_back)
  444. {
  445.   Slice          *currSlice =  img->currentSlice;
  446.   Macroblock     *currMB    = &img->mb_data[img->current_mb_nr];
  447.   SyntaxElement  *currSE    = &img->MB_SyntaxElements[currMB->currSEnr];
  448.   int            *partMap   = assignSE2partition[input->partition_mode];
  449.   DataPartition  *dataPart;
  451.   int  i, j, refidx=0, cr_cbp, mb_mode;
  452.   int  bframe       =  (img->type == B_IMG);
  453.   int  copy         =  (mode == MBMODE_COPY);
  454.   int  intra4       =  (mode == MBMODE_INTRA4x4);
  455.   int  intra16      =  (mode == MBMODE_INTRA16x16);
  456.   int  inter        =  (mode >= MBMODE_INTER16x16    && mode <= MBMODE_INTER4x4    && !bframe);
  457.   int  inter_for    =  (mode >= MBMODE_INTER16x16    && mode <= MBMODE_INTER4x4    &&  bframe);
  458.   int  inter_back   =  (mode >= MBMODE_BACKWARD16x16 && mode <= MBMODE_BACKWARD4x4);
  459.   int  inter_bidir  =  (mode == MBMODE_BIDIRECTIONAL);
  460.   int  inter_direct =  (mode == MBMODE_DIRECT);
  461.   int  inter_bframe =  (inter_for || inter_back || inter_bidir || inter_direct);
  464.   //=== init rd-values ===
  465.   rd->rdcost        = 0.0;
  466.   rd->distortion    = 0;
  467.   rd->distortion_UV = 0;
  468.   rd->rate_mode     = 0;
  469.   rd->rate_motion   = 0;
  470.   rd->rate_cbp      = 0;
  471.   rd->rate_luma     = 0;
  472.   rd->rate_chroma   = 0;
  475.   /*======================================================*
  476.    *=====                                            =====*
  477.    *=====   DCT, QUANT, DEQUANT, IDCT OF LUMINANCE   =====*
  478.    *=====                                            =====*
  479.    *======================================================*/
  480.   /*
  481.    * note: - for intra4x4, dct have to be done already
  482.    *       - for copy_mb,  no dct coefficients are needed
  483.    */
  484.   if (intra16)
  485.   {
  486.     //===== INTRA 16x16 MACROBLOCK =====
  487.     dct_luma2 (ref_or_i16mode);
  488.     currMB->cbp = 0;
  489.   }
  490.   else if (inter)
  491.   {
  492.     //===== INTER MACROBLOCK =====
  493.     img->multframe_no = (img->number-ref_or_i16mode-1) % img->buf_cycle;
  494.     LumaResidualCoding_P ();
  495.   }
  496.   else if (inter_bframe)
  497.   {
  498.     //===== INTER MACROBLOCK in B-FRAME =====
  499.     img->fw_multframe_no = (img->number-ref_or_i16mode-1) % img->buf_cycle;
  500.     LumaResidualCoding_B ();
  501.   }
  504.   /*==============================================================*
  505.    *=====   PREDICTION, DCT, QUANT, DEQUANT OF CHROMINANCE   =====*
  506.    *==============================================================*/
  507.   if (!copy)
  508.   {
  509.     if (bframe)  ChromaCoding_B (&cr_cbp);
  510.     else         ChromaCoding_P (&cr_cbp);
  511.   }
  516.   /*=========================================================*
  517.    *=====                                               =====*
  518.    *=====   GET DISTORTION OF LUMINANCE AND INIT COST   =====*
  519.    *=====                                               =====*
  520.    *=========================================================*/
  521.   if (input->rdopt==2)
  522.   {
  523.     int k;
  524.     for (k=0; k < input->NoOfDecoders ;k++)
  525.     {
  526.       decode_one_macroblock(k, mode, ref_or_i16mode);
  527.       for (j=img->pix_y; j<img->pix_y+MB_BLOCK_SIZE; j++)
  528.         for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
  529.         {
  530.           rd->distortion += img->quad[abs (imgY_org[j][i] - decY[k][j][i])];
  531.         }
  532.     }
  533.     rd->distortion /= input->NoOfDecoders;
  534.     refidx = (img->number-1) % img->buf_cycle; /* reference frame index */
  535.   }
  536.   else
  537.   {
  538.     if (copy)
  539.     {
  540.       refidx = (img->number-1) % img->buf_cycle; // reference frame index
  541.       for   (j=img->pix_y; j<img->pix_y+MB_BLOCK_SIZE; j++)
  542.         for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
  543.           rd->distortion += img->quad [abs (imgY_org[j][i] - FastPelY_14(mref[refidx], j<<2, i<<2))];
  544.     }
  545.     else
  546.     {
  547.       for   (j=img->pix_y; j<img->pix_y+MB_BLOCK_SIZE; j++)
  548.         for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
  549.           rd->distortion += img->quad [abs (imgY_org[j][i] - imgY[j][i])];
  550.     }
  551.   }
  552.   //=== init and check rate-distortion cost ===
  553.   rd->rdcost = (double)rd->distortion;
  554.   if (rd->rdcost >= rdopt->min_rdcost)
  555.     return 0;
  558.   /*=============================================================*
  559.    *=====                                                   =====*
  560.    *=====   GET DISTORTION OF CHROMINANCE AND UPDATE COST   =====*
  561.    *=====                                                   =====*
  562.    *=============================================================*/
  563.   if (copy)
  564.   {
  565.     for   (j=img->pix_c_y; j<img->pix_c_y+MB_BLOCK_SIZE/2; j++)
  566.       for (i=img->pix_c_x; i<img->pix_c_x+MB_BLOCK_SIZE/2; i++)
  567.       {
  568.         rd->distortion_UV += img->quad[abs (imgUV_org[0][j][i] - mcef[refidx][0][j][i])];
  569.         rd->distortion_UV += img->quad[abs (imgUV_org[1][j][i] - mcef[refidx][1][j][i])];
  570.       }
  571.   }
  572.   else
  573.   {
  574.     for   (j=img->pix_c_y; j<img->pix_c_y+MB_BLOCK_SIZE/2; j++)
  575.       for (i=img->pix_c_x; i<img->pix_c_x+MB_BLOCK_SIZE/2; i++)
  576.       {
  577.         rd->distortion_UV += img->quad[abs (imgUV_org[0][j][i] - imgUV[0][j][i])];
  578.         rd->distortion_UV += img->quad[abs (imgUV_org[1][j][i] - imgUV[1][j][i])];
  579.       }
  580.   }
  581.   //=== init and check rate-distortion cost ===
  582.   rd->rdcost += (double)rd->distortion_UV;
  583.   if (rd->rdcost >= rdopt->min_rdcost)
  584.     return 0;
  587.   /*================================================*
  588.    *=====                                      =====*
  589.    *=====   GET CODING RATES AND UPDATE COST   =====*
  590.    *=====                                      =====*
  591.    *================================================*/
  593.   //=== store encoding environment ===
  594.   store_coding_state ();
  597.   /*===================================================*
  598.    *=====   GET RATE OF MB-MODE AND UPDATE COST   =====*
  599.    *===================================================*/
  600.   //--- set mode constants ---
  601.   if      (copy || inter_direct)  mb_mode = 0;
  602.   else if (inter)     mb_mode = blocktype;
  603.   else if (intra4)      mb_mode = (img->type<<3);
  604.   else if (intra16)     mb_mode = (img->type<<3) + (cr_cbp<<2) + 12*img->kac + 1 + ref_or_i16mode;
  605.   else if (inter_bidir)     mb_mode = 3;
  606.   else if (inter_for)     mb_mode = (blocktype     ==1 ? blocktype        : (blocktype     <<1));
  607.   else /*  inter_back */    mb_mode = (blocktype_back==1 ? blocktype_back+1 : (blocktype_back<<1)+1);
  608.   currSE->value1 = mb_mode;
  609.   //--- set symbol type and function pointers ---
  610.   if (input->symbol_mode == UVLC)     currSE->mapping = n_linfo2;
  611.   else          currSE->writing = writeMB_typeInfo2Buffer_CABAC;
  612.   currSE->type = SE_MBTYPE;
  613.   //--- choose data partition ---
  614.   if (bframe)   dataPart = &(currSlice->partArr[partMap[SE_MBTYPE]]);
  615.   else          dataPart = &(currSlice->partArr[partMap[SE_BFRAME]]);
  616.   //--- encode and set rate ---
  617.   dataPart->writeSyntaxElement (currSE, dataPart);
  618.   rd->rate_mode = currSE->len;
  619.   currSE++;
  620.   currMB->currSEnr++;
  621.   //=== encode intra prediction modes ===
  622.   if (intra4)
  623.     for (i=0; i < (MB_BLOCK_SIZE>>1); i++)
  624.     {
  625.       currSE->value1 = currMB->intra_pred_modes[ i<<1   ];
  626.       currSE->value2 = currMB->intra_pred_modes[(i<<1)+1];
  627.       //--- set symbol type and function pointers ---
  628.       if (input->symbol_mode == UVLC)   currSE->mapping = intrapred_linfo;
  629.       else                currSE->writing = writeIntraPredMode2Buffer_CABAC;
  630.       currSE->type = SE_INTRAPREDMODE;
  631.       //--- choose data partition ---
  632.       if (bframe)   dataPart = &(currSlice->partArr[partMap[SE_INTRAPREDMODE]]);
  633.       else          dataPart = &(currSlice->partArr[partMap[SE_BFRAME]]);
  634.       //--- encode and update rate ---
  635.       dataPart->writeSyntaxElement (currSE, dataPart);
  636.       rd->rate_mode += currSE->len;
  637.       currSE++;
  638.       currMB->currSEnr++;
  639.     }
  640.     //=== update and check rate-distortion cost ===
  641.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_mode;
  642.     if (rd->rdcost >= rdopt->min_rdcost)
  643.     {
  644.       restore_coding_state ();
  645.       return 0;
  646.     }
  649.   /*=======================================================*
  650.    *=====   GET RATE OF MOTION INFO AND UPDATE COST   =====*
  651.    *=======================================================*/
  652.   if (inter)
  653.   {
  654.     //=== set some parameters ===
  655.     currMB->ref_frame = ref_or_i16mode;
  656.     currMB->mb_type   = mb_mode;
  657.     img->mb_mode      = mb_mode;
  658.     img->blc_size_h   = input->blc_size[blocktype][0];
  659.     img->blc_size_v   = input->blc_size[blocktype][1];
  660.     //=== get rate ===
  661.     rd->rate_motion = writeMotionInfo2NAL_Pframe ();
  662.     //=== update and check rate-distortion cost ===
  663.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_motion;
  664.     if (rd->rdcost >= rdopt->min_rdcost)
  665.     {
  666.       restore_coding_state ();
  667.       return 0;
  668.     }
  669.   }
  670.   else if (inter_bframe && !inter_direct)
  671.   {
  672.     //=== set some parameters ===
  673.     currMB->ref_frame  = ref_or_i16mode;
  674.     currMB->mb_type    = mb_mode;
  675.     img->mb_mode       = mb_mode;
  676.     img->fw_blc_size_h = input->blc_size[blocktype     ][0];
  677.     img->fw_blc_size_v = input->blc_size[blocktype     ][1];
  678.     img->bw_blc_size_h = input->blc_size[blocktype_back][0];
  679.     img->bw_blc_size_v = input->blc_size[blocktype_back][1];
  680.     //=== get rate ===
  681.     rd->rate_motion = writeMotionInfo2NAL_Bframe ();
  682.     //=== update and check rate-distortion cost ===
  683.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_motion;
  684.     if (rd->rdcost >= rdopt->min_rdcost)
  685.     {
  686.       restore_coding_state ();
  687.       return 0;
  688.     }
  689.   }
  693.   //===== GET RATE FOR CBP, LUMA and CHROMA =====
  694.   if (intra16)
  695.   {
  696.   /*========================================================*
  697.    *=====   GET RATE OF LUMA (16x16) AND UPDATE COST   =====*
  698.    *========================================================*/
  699.     rd->rate_luma = writeMB_bits_for_16x16_luma ();
  700.     //=== update and check rate-distortion cost ===
  701.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_luma;
  702.     if (rd->rdcost >= rdopt->min_rdcost)
  703.     {
  704.       restore_coding_state ();
  705.       return 0;
  706.     }
  707.   }
  708.   else if (!copy)
  709.   {
  710.   /*===============================================*
  711.    *=====   GET RATE OF CBP AND UPDATE COST   =====*
  712.    *===============================================*/
  713.     rd->rate_cbp = writeMB_bits_for_CBP ();
  714.     //=== update and check rate-distortion cost ===
  715.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_cbp;
  716.     if (rd->rdcost >= rdopt->min_rdcost)
  717.     {
  718.       restore_coding_state ();
  719.       return 0;
  720.     }
  722.     /*=========================================================*
  723.      *=====   GET RATE OF LUMA (16x(4x4)) AND UPDATE COST   =====*
  724.      *=========================================================*/
  725.     rd->rate_luma = writeMB_bits_for_luma (0);
  726.     //=== update and check rate-distortion cost ===
  727.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_luma;
  728.     if (rd->rdcost >= rdopt->min_rdcost)
  729.     {
  730.       restore_coding_state ();
  731.       return 0;
  732.     }
  733.   }
  736.   if (!copy)
  737.   {
  738.   /*==================================================*
  739.    *=====   GET RATE OF CHROMA AND UPDATE COST   =====*
  740.    *==================================================*/
  741.     rd->rate_chroma  = writeMB_bits_for_DC_chroma (0);
  742.     rd->rate_chroma += writeMB_bits_for_AC_chroma (0);
  743.     //=== update and check rate-distortion cost ===
  744.     rd->rdcost += rdopt->lambda_mode * (double)rd->rate_chroma;
  745.     if (rd->rdcost >= rdopt->min_rdcost)
  746.     {
  747.       restore_coding_state ();
  748.       return 0;
  749.     }
  750.   }
  753.   //=== restore encoding environment ===
  754.   restore_coding_state ();
  757.   /*=================================================*
  758.    *=====                                       =====*
  759.    *=====   STORE PARAMETERS OF NEW BEST MODE   =====*
  760.    *=====                                       =====*
  761.    *=================================================*/
  762.   rdopt->min_rdcost     = rd->rdcost;
  763.   rdopt->best_mode      = mode;
  764.   rdopt->ref_or_i16mode = ref_or_i16mode;
  765.   rdopt->blocktype      = blocktype;
  766.   rdopt->blocktype_back = blocktype_back;
  768.   //=== LUMINANCE OF RECONSTRUCTED MACROBLOCK ===
  769.   if (copy)
  770.     for   (j=0; j<MB_BLOCK_SIZE; j++)
  771.       for (i=0; i<MB_BLOCK_SIZE; i++)
  772.         rdopt->rec_mb_Y[j][i] = FastPelY_14(mref[refidx], (img->pix_y+j)<<2, (img->pix_x+i)<<2);
  773.   else
  774.     for   (j=0; j<MB_BLOCK_SIZE; j++)
  775.       for (i=0; i<MB_BLOCK_SIZE; i++)
  776.         rdopt->rec_mb_Y[j][i] = imgY[img->pix_y+j][img->pix_x+i];
  778.   //=== CHROMINANCE OF RECONSTRUCTED MACROBLOCK ===
  779.   if (copy)
  780.     for   (j=0; j<(BLOCK_SIZE<<1); j++)
  781.       for (i=0; i<(BLOCK_SIZE<<1); i++)
  782.       {
  783.         rdopt->rec_mb_U[j][i] = mcef[refidx][0][img->pix_c_y+j][img->pix_c_x+i];
  784.         rdopt->rec_mb_V[j][i] = mcef[refidx][1][img->pix_c_y+j][img->pix_c_x+i];
  785.       }
  786.   else
  787.     for   (j=0; j<(BLOCK_SIZE<<1); j++)
  788.       for (i=0; i<(BLOCK_SIZE<<1); i++)
  789.       {
  790.         rdopt->rec_mb_U[j][i] = imgUV[0][img->pix_c_y+j][img->pix_c_x+i];
  791.         rdopt->rec_mb_V[j][i] = imgUV[1][img->pix_c_y+j][img->pix_c_x+i];
  792.       }
  794.   //=== CBP, KAC, DCT-COEFFICIENTS ===
  795.   if (!copy)
  796.   {
  797.     rdopt->cbp         = currMB->cbp;
  798.     rdopt->cbp_blk     = currMB->cbp_blk;
  799.     rdopt->kac         = img->kac;
  800.     memcpy (rdopt->cof,  img->cof,  1728*sizeof(int));
  801.     memcpy (rdopt->cofu, img->cofu,   20*sizeof(int));
  802.   }
  803.   else
  804.       rdopt->cbp_blk     = 0 ;
  807.   //=== INTRA PREDICTION MODES ===
  808.   if (intra4)
  809.   {
  810.     memcpy (rdopt->ipredmode, currMB->intra_pred_modes, 16*sizeof(int));
  811.   }
  813.   //=== MOTION VECTORS ===
  814.   if (inter)
  815.     for   (j=0; j<BLOCK_SIZE; j++)
  816.       for (i=0; i<BLOCK_SIZE; i++)
  817.       {
  818.         rdopt->   mv[j][i][0] = tmp_mv  [0][img->block_y+j][img->block_x+4+i];
  819.         rdopt->   mv[j][i][1] = tmp_mv  [1][img->block_y+j][img->block_x+4+i];
  820.       }
  821.   else if (inter_for)
  822.     for   (j=0; j<BLOCK_SIZE; j++)
  823.       for (i=0; i<BLOCK_SIZE; i++)
  824.       {
  825.         rdopt->   mv[j][i][0] = tmp_fwMV[0][img->block_y+j][img->block_x+4+i];
  826.         rdopt->   mv[j][i][1] = tmp_fwMV[1][img->block_y+j][img->block_x+4+i];
  827.       }
  828.   else if (inter_back)
  829.     for   (j=0; j<BLOCK_SIZE; j++)
  830.       for (i=0; i<BLOCK_SIZE; i++)
  831.       {
  832.         rdopt->bw_mv[j][i][0] = tmp_bwMV[0][img->block_y+j][img->block_x+4+i];
  833.         rdopt->bw_mv[j][i][1] = tmp_bwMV[1][img->block_y+j][img->block_x+4+i];
  834.       }
  835.   else if (inter_bidir)
  836.     for   (j=0; j<BLOCK_SIZE; j++)
  837.       for (i=0; i<BLOCK_SIZE; i++)
  838.       {
  839.         rdopt->   mv[j][i][0] = tmp_fwMV[0][img->block_y+j][img->block_x+4+i];
  840.         rdopt->   mv[j][i][1] = tmp_fwMV[1][img->block_y+j][img->block_x+4+i];
  841.         rdopt->bw_mv[j][i][0] = tmp_bwMV[0][img->block_y+j][img->block_x+4+i];
  842.         rdopt->bw_mv[j][i][1] = tmp_bwMV[1][img->block_y+j][img->block_x+4+i];
  843.       }
  845.   if (input->rdopt==2)
  846.   {
  847.     int k;
  848.     for (k=0; k<input->NoOfDecoders; k++)
  849.     {
  850.       for (j=img->pix_y; j<img->pix_y+MB_BLOCK_SIZE; j++)
  851.         for (i=img->pix_x; i<img->pix_x+MB_BLOCK_SIZE; i++)
  852.         {
  853.           /* Keep the decoded values of each MB for updating the ref frames*/
  854.           decY_best[k][j][i] = decY[k][j][i];
  855.         }
  856.     }
  857.   }
  859.   return 1; // new best mode
  860. }
  864. #define PFRAME    0
  865. #define B_FORWARD 1
  866. #define B_BACKWARD  2
  868. /*!
  869.  ************************************************************************
  870.  * brief
  871.  *    Rate-Distortion optimized mode decision
  872.  ************************************************************************
  873.  */
  874. void
  875. RD_Mode_Decision ()
  876. {
  877.   int             i, j, k, k0 = 0, dummy;
  878.   int             mode, intra16mode, refframe, blocktype, blocktype_back;
  879.   int             valid_mode [NO_MAX_MBMODES], valid_intra16mode[4];
  880.   int             bframe, intra_macroblock, any_inter_mode = 0;
  881.   int             tot_inter_sad, min_inter_sad;
  882.   int             backward_me_done[9];
  883.   double          forward_rdcost[9], backward_rdcost[9];
  884.   double          min_rdcost;
  885.   int             max_ref_frame, best_refframe[9];
  886.   RateDistortion  rd;
  887.   int             k1 = 1;
  888.   int             mb_nr           = img->current_mb_nr;
  889.   Macroblock     *currMB          = &img->mb_data[mb_nr];
  892.   /*==============================================*
  893.    *===  INIT PARAMETERS OF RD-OPT. STRUCTURE  ===*
  894.    *==============================================*/
  896.   //--- set lagrange parameters ---
  897.   double qp = (double)img->qp;
  899.   rdopt->lambda_mode = 5.0 * exp (0.1 * qp) * (qp + 5.0) / (34.0 - qp);
  900.   
  901.   if (img->type == B_IMG || img->types == SP_IMG)
  902.     rdopt->lambda_mode *= 4;
  904.   rdopt->lambda_motion = sqrt (rdopt->lambda_mode);
  905.   rdopt->lambda_intra  = rdopt->lambda_mode;
  907.   if (input->rdopt == 2)
  908.   {
  909.     rdopt->lambda_mode=(1.0-input->LossRate/100.0)*rdopt->lambda_mode;
  910.     rdopt->lambda_motion = sqrt (1.0-input->LossRate/100.0) * rdopt->lambda_motion;
  911.   }
  913.   //--- cost values ---
  914.   rdopt->best_mode   = -1;
  915.   rdopt->min_rdcost  =  1e30;
  916.   for (i = 0; i < 9; i++)
  917.   {
  918.     forward_rdcost  [i] = backward_rdcost [i] = -1.0;
  919.     backward_me_done[i] =  0;
  920.     for (j = 0; j < img->buf_cycle; j++)
  921.     {
  922.       forward_me_done[i][j] = 0;
  923.     }
  924.   }
  927.   /*========================*
  928.    *===  SET SOME FLAGS  ===*
  929.    *========================*/
  930.   bframe           = (img->type==B_IMG);
  931.   intra_macroblock = (img->mb_y==img->mb_y_upd && img->mb_y_upd!=img->mb_y_intra) || img->type==INTRA_IMG;
  932.   max_ref_frame    = min (img->number, img->buf_cycle);
  934.   /*========================================*
  935.    *===  MARK POSSIBLE MACROBLOCK MODES  ===*
  936.    *========================================*/
  937.   //--- reset arrays ---
  938.   memset (valid_mode,        0, sizeof(int)*NO_MAX_MBMODES);
  939.   memset (valid_intra16mode, 0, sizeof(int)*4);
  940.   //--- set intra modes ---
  941.   valid_mode [MBMODE_INTRA4x4  ] = 1;
  942.   valid_mode [MBMODE_INTRA16x16] = 1;
  943.   //--- set inter modes ---
  944.   if (!intra_macroblock || bframe)
  945.   {
  946.     for (i=MBMODE_INTER16x16; i <= MBMODE_INTER4x4; i++)
  947.       if (input->blc_size [i][0] > 0)
  948.         any_inter_mode = valid_mode [i] = 1;
  949.       if (bframe)
  950.       {
  951.         memcpy (valid_mode+MBMODE_BACKWARD16x16,
  952.                 valid_mode+MBMODE_INTER16x16,   NO_INTER_MBMODES*sizeof(int));
  953.         valid_mode[MBMODE_BIDIRECTIONAL] = valid_mode[MBMODE_DIRECT] = any_inter_mode;
  954.       }
  955.       else
  956.       {
  957.         valid_mode[MBMODE_COPY] = valid_mode[MBMODE_INTER16x16];
  958.       }
  959.   }
  961.   if (img->type==INTER_IMG && img->types== SP_IMG)
  962.     valid_mode[MBMODE_COPY] =0;
  964.   //===== LOOP OVER ALL MACROBLOCK MODES =====
  965.   for (mode = 0; mode < NO_MAX_MBMODES; mode++)
  966.     if (valid_mode[mode])
  967.     {
  968.     /*==================================================================*
  969.      *===  MOTION ESTIMATION, INTRA PREDICTION and COST CALCULATION  ===*
  970.      *==================================================================*/
  971.        if (mode == MBMODE_INTRA4x4)
  972.        {
  973.        /*======================*
  974.         *=== INTRA 4x4 MODE ===*
  975.         *======================*/
  976.          currMB->intraOrInter = INTRA_MB_4x4;
  977.          img->imod            = INTRA_MB_OLD;
  978.          Intra4x4_Mode_Decision ();   // intra 4x4 prediction, dct, etc.
  979.          RDCost_Macroblock (&rd, mode, 0, 0, 0);
  980.        }
  981.        else if (mode == MBMODE_INTRA16x16)
  982.        {
  983.        /*========================*
  984.         *=== INTRA 16x16 MODE ===*
  985.         *========================*/
  986.          currMB->intraOrInter = INTRA_MB_16x16;
  987.          img->imod            = INTRA_MB_NEW;
  988.          intrapred_luma_2 ();   // make intra pred for all 4 new modes
  989.          find_sad2 (&k);        // get best new intra mode
  990.          RDCost_Macroblock (&rd, mode, k, 0, 0);
  991.        }
  992.        else if (mode == MBMODE_COPY)
  993.        {
  994.        /*=======================*
  995.         *=== COPY MACROBLOCK ===*
  996.         *=======================*/
  997.          currMB->intraOrInter = INTER_MB;
  998.          img->imod            = INTRA_MB_INTER;
  999.          RDCost_Macroblock (&rd, mode, 0, 0, 0);
  1000.        }
  1001.        else if (!bframe && (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4))
  1002.        {
  1003.        /*===================================*
  1004.         *=== INTER MACROBLOCK in P-FRAME ===*
  1005.         *===================================*/
  1006.          currMB->intraOrInter = INTER_MB;
  1007.          img->imod            = INTRA_MB_INTER;
  1009.          min_inter_sad = MAX_VALUE;
  1010.          for (k=0; k<max_ref_frame; k++)
  1011. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  1012.            if (k <  input->no_multpred ||
  1013.                k == input->add_ref_frame)
  1014. #endif
  1015.            {
  1016.              tot_inter_sad  = (int)floor(rdopt->lambda_motion * (1+2*floor(log(k+1)/log(2)+1e-10)));
  1017.              tot_inter_sad += SingleUnifiedMotionSearch (k, mode,
  1018.                             refFrArr, tmp_mv, img->mv, PFRAME, img->all_mv,
  1019.                             rdopt->lambda_motion);
  1020.              if (tot_inter_sad <  min_inter_sad)
  1021.              {
  1022.                k0 = k;
  1023.                min_inter_sad = tot_inter_sad;
  1024.              }
  1025.            }
  1026.          for (  i=0; i < 4; i++)
  1027.            for (j=0; j < 4; j++)
  1028.            {
  1029.              tmp_mv[0][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][k0][mode][0];
  1030.              tmp_mv[1][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][k0][mode][1];
  1031.            }
  1032.          RDCost_Macroblock (&rd, mode, k0, mode, 0);
  1033.        }
  1034.        else if (bframe && (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4))
  1035.        {
  1036.         /*===============================================*
  1037.          *=== FORWARD PREDICTED MACROBLOCK in B-FRAME ===*
  1038.          *===============================================*/
  1039.          if (forward_rdcost[mode] < 0.0)
  1040.          {
  1041.            currMB->intraOrInter = INTER_MB;
  1042.            img->imod            = B_Forward;
  1044.            min_inter_sad = MAX_VALUE;
  1045.            for (k=0; k<max_ref_frame; k++)
  1046. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  1047.              if (k <  input->no_multpred ||
  1048.                  k == input->add_ref_frame)
  1049. #endif
  1050.              {
  1051.                if (!forward_me_done[mode][k])
  1052.                {
  1053.                  tot_for_sad[mode][k]  = (int)floor(rdopt->lambda_motion * (1+2*floor(log(k+1)/log(2)+1e-10)));
  1054.                  tot_for_sad[mode][k] += SingleUnifiedMotionSearch (k, mode,
  1055.                                          fw_refFrArr, tmp_fwMV, img->p_fwMV,
  1056.                                          B_FORWARD, img->all_mv,
  1057.                                          rdopt->lambda_motion);
  1058.                                          forward_me_done[mode][k] = 1;
  1059.                }
  1060.                if (tot_for_sad[mode][k] < min_inter_sad)
  1061.                {
  1062.                  k0 = k;
  1063.                  min_inter_sad = tot_for_sad[mode][k];
  1064.                }
  1065.              }
  1066.            for (  i=0; i < 4; i++)
  1067.              for (j=0; j < 4; j++)
  1068.              {
  1069.                tmp_fwMV[0][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][k0][mode][0];
  1070.                tmp_fwMV[1][img->block_y+j][img->block_x+i+4]=img->all_mv[i][j][k0][mode][1];
  1071.              }
  1072.            RDCost_Macroblock (&rd, mode, k0, mode, 0);
  1073.            forward_rdcost[mode] = rd.rdcost;
  1074.            best_refframe [mode] = k0;
  1075.          }
  1076.        }
  1077.        else if (mode >= MBMODE_BACKWARD16x16 && mode <= MBMODE_BACKWARD4x4)
  1078.        {
  1079.         /*================================================*
  1080.          *=== BACKWARD PREDICTED MACROBLOCK in B-FRAME ===*
  1081.          *================================================*/
  1082.          if (backward_rdcost [mode-NO_INTER_MBMODES] < 0.0)
  1083.          {
  1084.            currMB->intraOrInter = INTER_MB;
  1085.            img->imod            = B_Backward;
  1086.            if (!backward_me_done[mode-NO_INTER_MBMODES])
  1087.            {
  1088.              SingleUnifiedMotionSearch (0, mode-NO_INTER_MBMODES,
  1089.                bw_refFrArr, tmp_bwMV, img->p_bwMV, B_BACKWARD, img->all_bmv,
  1090.                rdopt->lambda_motion);
  1091.              backward_me_done[mode-NO_INTER_MBMODES]=1;
  1092.            }
  1093.            else
  1094.              for (j = 0; j < 4; j++)
  1095.                for (i = 0; i < 4; i++)
  1096.                {
  1097.                  tmp_bwMV[0][img->block_y+j][img->block_x+i+4]=
  1098.                    img->all_bmv[i][j][0][mode-NO_INTER_MBMODES][0];
  1099.                  tmp_bwMV[1][img->block_y+j][img->block_x+i+4]=
  1100.                    img->all_bmv[i][j][0][mode-NO_INTER_MBMODES][1];
  1101.                }
  1102.            RDCost_Macroblock (&rd, mode, 0, 0, mode-NO_INTER_MBMODES);
  1103.            backward_rdcost[mode-NO_INTER_MBMODES] = rd.rdcost;
  1104.          }
  1105.        }
  1106.        else if (mode == MBMODE_DIRECT)
  1107.        {
  1108.        /*==============================================*
  1109.         *=== DIRECT PREDICTED MACROBLOCK in B-FRAME ===*
  1110.         *==============================================*/
  1111.          currMB->intraOrInter = INTER_MB;
  1112.          img->imod            = B_Direct;
  1113.          get_dir (&dummy);
  1114.          if (dummy != 100000000 /*MAX_DIR_SAD*/)
  1115.          {
  1116.            RDCost_Macroblock (&rd, mode, 0, 0, 0);
  1117.          }
  1118.        }
  1119.        else
  1120.        {
  1121.         /*=====================================================*
  1122.          *=== BIDIRECTIONAL PREDICTED MACROBLOCK in B-FRAME ===*
  1123.          *=====================================================*/
  1124.         //--- get best backward prediction ---
  1125.          min_rdcost = 1e30;
  1126.          for (blocktype = 1; blocktype < 8; blocktype++)
  1127.            if (valid_mode[blocktype+NO_INTER_MBMODES])
  1128.            {
  1129.              if (backward_rdcost[blocktype] < 0.0)
  1130.              {
  1131.                //--- get rd-cost's ---
  1132.                currMB->intraOrInter = INTER_MB;
  1133.                img->imod            = B_Backward;
  1134.                if (!backward_me_done[blocktype])
  1135.                {
  1136.                  SingleUnifiedMotionSearch (0, blocktype,
  1137.                    bw_refFrArr, tmp_bwMV, img->p_bwMV, B_BACKWARD, img->all_bmv,
  1138.                    rdopt->lambda_motion);
  1139.                  backward_me_done[mode]=1;
  1140.                }
  1141.                else
  1142.                  for (j = 0; j < 4; j++)
  1143.                    for (i = 0; i < 4; i++)
  1144.                    {
  1145.                      tmp_bwMV[0][img->block_y+j][img->block_x+i+4]=
  1146.                        img->all_bmv[i][j][0][blocktype][0];
  1147.                      tmp_bwMV[1][img->block_y+j][img->block_x+i+4]=
  1148.                        img->all_bmv[i][j][0][blocktype][1];
  1149.                    }
  1150.                RDCost_Macroblock (&rd, blocktype+NO_INTER_MBMODES, 0, 0, blocktype);
  1151.                backward_rdcost[blocktype] = rd.rdcost;
  1152.              }
  1153.              if (backward_rdcost[blocktype] < min_rdcost)
  1154.              {
  1155.                min_rdcost = backward_rdcost[blocktype];
  1156.                k0         = blocktype;
  1157.              }
  1158.            }
  1159.          blocktype_back = k0;
  1161.          //--- get best forward prediction ---
  1162.          min_rdcost = 1e30;
  1163.          for (blocktype = 1; blocktype < 8; blocktype++)
  1164.            if (valid_mode[blocktype])
  1165.            {
  1166.              if (forward_rdcost[blocktype] < 0.0)
  1167.              {
  1168.                //--- get rd-cost's ---
  1169.                currMB->intraOrInter = INTER_MB;
  1170.                img->imod            = B_Forward;
  1171.                min_inter_sad        = MAX_VALUE;
  1172.                for (k=0; k<max_ref_frame; k++)
  1173. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  1174.                if (k <  input->no_multpred ||
  1175.                    k == input->add_ref_frame)
  1176. #endif
  1177.                {
  1178.                  if (!forward_me_done[blocktype][k])
  1179.                  {
  1180.                    tot_for_sad[blocktype][k]  = (int)floor(rdopt->lambda_motion * (1+2*floor(log(k+1)/log(2)+1e-10)));
  1181.                    tot_for_sad[blocktype][k] += SingleUnifiedMotionSearch (k, blocktype,
  1182.                      fw_refFrArr, tmp_fwMV, img->p_fwMV,
  1183.                      B_FORWARD, img->all_mv,
  1184.                      rdopt->lambda_motion);
  1185.                    forward_me_done[blocktype][k] = 1;
  1186.                  }
  1187.                  if (tot_for_sad[blocktype][k] < min_inter_sad)
  1188.                  {
  1189.                    k0 = k;
  1190.                    min_inter_sad = tot_for_sad[blocktype][k];
  1191.                  }
  1192.                }
  1193.                for (  i=0; i < 4; i++)
  1194.                  for (j=0; j < 4; j++)
  1195.                  {
  1196.                    tmp_fwMV[0][img->block_y+j][img->block_x+i+4]=
  1197.                      img->all_mv[i][j][k0][blocktype][0];
  1198.                    tmp_fwMV[1][img->block_y+j][img->block_x+i+4]=
  1199.                      img->all_mv[i][j][k0][blocktype][1];
  1200.                  }
  1201.                RDCost_Macroblock (&rd, blocktype, k0, blocktype, 0);
  1202.                forward_rdcost[blocktype] = rd.rdcost;
  1203.                best_refframe [blocktype] = k0;
  1204.              }
  1205.              if (forward_rdcost[blocktype] < min_rdcost)
  1206.              {
  1207.                min_rdcost = forward_rdcost[blocktype];
  1208.                k1         = blocktype;
  1209.              }
  1210.            }
  1211.          blocktype = k1;
  1212.          k0        = best_refframe[blocktype];
  1214.          //===== COST CALCULATION =====
  1215.          for (j = 0; j < 4; j++)
  1216.            for (i = 0; i < 4; i++)
  1217.            {
  1218.              tmp_bwMV[0][img->block_y+j][img->block_x+i+4]=
  1219.                img->all_bmv[i][j][0][blocktype_back][0];
  1220.              tmp_bwMV[1][img->block_y+j][img->block_x+i+4]=
  1221.                img->all_bmv[i][j][0][blocktype_back][1];
  1222.              tmp_fwMV[0][img->block_y+j][img->block_x+i+4]=
  1223.                img->all_mv[i][j][k0][blocktype][0];
  1224.              tmp_fwMV[1][img->block_y+j][img->block_x+i+4]=
  1225.                img->all_mv[i][j][k0][blocktype][1];
  1226.            }
  1227.          img->fw_blc_size_h = input->blc_size[blocktype][0];
  1228.          img->fw_blc_size_v = input->blc_size[blocktype][1];
  1229.          img->bw_blc_size_h = input->blc_size[blocktype_back][0];
  1230.          img->bw_blc_size_v = input->blc_size[blocktype_back][1];
  1231.          currMB->intraOrInter = INTER_MB;
  1232.          img->imod            = B_Bidirect;
  1233.          RDCost_Macroblock (&rd, mode, k0, blocktype, blocktype_back);
  1234.        }
  1235.    }
  1239.   /*======================================*
  1240.    *===  SET PARAMETERS FOR BEST MODE  ===*
  1241.    *======================================*/
  1242.   mode           = rdopt->best_mode;
  1243.   refframe       = rdopt->ref_or_i16mode;
  1244.   intra16mode    = rdopt->ref_or_i16mode;
  1245.   blocktype      = rdopt->blocktype;
  1246.   blocktype_back = rdopt->blocktype_back;
  1249.   //=== RECONSTRUCTED MACROBLOCK ===
  1250.   for   (j=0; j<MB_BLOCK_SIZE; j++)
  1251.     for (i=0; i<MB_BLOCK_SIZE; i++)
  1252.       imgY[img->pix_y+j][img->pix_x+i] = rdopt->rec_mb_Y[j][i];
  1253.   for   (j=0; j<(BLOCK_SIZE<<1); j++)
  1254.     for (i=0; i<(BLOCK_SIZE<<1); i++)
  1255.     {
  1256.       imgUV[0][img->pix_c_y+j][img->pix_c_x+i] = rdopt->rec_mb_U[j][i];
  1257.       imgUV[1][img->pix_c_y+j][img->pix_c_x+i] = rdopt->rec_mb_V[j][i];
  1258.     }
  1260.   //=== INTRAORINTER and IMOD ===
  1261.   if (mode == MBMODE_INTRA4x4)
  1262.   {
  1263.     currMB->intraOrInter = INTRA_MB_4x4;
  1264.     img->imod            = INTRA_MB_OLD;
  1265.   }
  1266.   else if (mode == MBMODE_INTRA16x16)
  1267.   {
  1268.     currMB->intraOrInter = INTRA_MB_16x16;
  1269.     img->imod            = INTRA_MB_NEW;
  1270.   }
  1271.   else if (!bframe && (mode >= MBMODE_COPY && mode <= MBMODE_INTER4x4))
  1272.   {
  1273.     currMB->intraOrInter = INTER_MB;
  1274.     img->imod            = INTRA_MB_INTER;
  1275.   }
  1276.   else if (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4)
  1277.   {
  1278.     currMB->intraOrInter = INTER_MB;
  1279.     img->imod            = B_Forward;
  1280.   }
  1281.   else if (mode >= MBMODE_BACKWARD16x16 && mode <= MBMODE_BACKWARD4x4)
  1282.   {
  1283.     currMB->intraOrInter = INTER_MB;
  1284.     img->imod            = B_Backward;
  1285.   }
  1286.   else if (mode == MBMODE_BIDIRECTIONAL)
  1287.   {
  1288.     currMB->intraOrInter = INTER_MB;
  1289.     img->imod            = B_Bidirect;
  1290.   }
  1291.   else // mode == MBMODE_DIRECT
  1292.   {
  1293.     currMB->intraOrInter = INTER_MB;
  1294.     img->imod            = B_Direct;
  1295.   }
  1297.   //=== DCT-COEFFICIENTS, CBP and KAC ===
  1298.   if (mode != MBMODE_COPY)
  1299.   {
  1300.     memcpy (img->cof,  rdopt->cof,  1728*sizeof(int));
  1301.     memcpy (img->cofu, rdopt->cofu,   20*sizeof(int));
  1302.     currMB->cbp     = rdopt->cbp;
  1303.     currMB->cbp_blk = rdopt->cbp_blk;
  1304.     img->kac        = rdopt->kac;
  1306.     if (img->imod==INTRA_MB_NEW)
  1307.       currMB->cbp += 15*img->kac; // correct cbp for new intra modes: needed by CABAC
  1308.   }
  1309.   else
  1310.   {
  1311.     memset (img->cof,  0, 1728*sizeof(int));
  1312.     memset (img->cofu, 0,   20*sizeof(int));
  1313.     currMB->cbp     = 0;
  1314.     currMB->cbp_blk = 0;
  1315.     img->kac        = 0;
  1316.   }
  1318.   //=== INTRA PREDICTION MODES ===
  1319.   if (mode == MBMODE_INTRA4x4)
  1320.     memcpy (currMB->intra_pred_modes, rdopt->ipredmode, 16*sizeof(int));
  1321.   else
  1322.   {
  1323.     for (i=0;i<4;i++)
  1324.       for (j=0;j<4;j++)
  1325.         img->ipredmode[img->block_x+i+1][img->block_y+j+1]=0;
  1326.   }
  1328.   //=== MOTION VECTORS, REFERENCE FRAME and BLOCK DIMENSIONS ===
  1329.   //--- init all motion vectors with (0,0) ---
  1330.   currMB->ref_frame = 0;
  1331.   if (bframe)
  1332.     for   (j=0; j<BLOCK_SIZE; j++)
  1333.       for (i=0; i<BLOCK_SIZE; i++)
  1334.       {
  1335.         tmp_fwMV[0][img->block_y+j][img->block_x+4+i] = 0;
  1336.         tmp_fwMV[1][img->block_y+j][img->block_x+4+i] = 0;
  1337.         tmp_bwMV[0][img->block_y+j][img->block_x+4+i] = 0;
  1338.         tmp_bwMV[1][img->block_y+j][img->block_x+4+i] = 0;
  1339.       }
  1340.   else
  1341.     for   (j=0; j<BLOCK_SIZE; j++)
  1342.       for (i=0; i<BLOCK_SIZE; i++)
  1343.       {
  1344.         tmp_mv  [0][img->block_y+j][img->block_x+4+i] = 0;
  1345.         tmp_mv  [1][img->block_y+j][img->block_x+4+i] = 0;
  1346.       }
  1347.   //--- set used motion vectors ---
  1348.   if (!bframe && (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4))
  1349.   {
  1350.     for   (j=0; j<BLOCK_SIZE; j++)
  1351.       for (i=0; i<BLOCK_SIZE; i++)
  1352.       {
  1353.         tmp_mv[0][img->block_y+j][img->block_x+4+i] = rdopt->mv[j][i][0];
  1354.         tmp_mv[1][img->block_y+j][img->block_x+4+i] = rdopt->mv[j][i][1];
  1355.       }
  1356.     currMB->ref_frame = refframe;
  1357.     img->blc_size_h   = input->blc_size[blocktype][0];
  1358.     img->blc_size_v   = input->blc_size[blocktype][1];
  1359.   }
  1360.   else if (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4)
  1361.   {
  1362.     for   (j=0; j<BLOCK_SIZE; j++)
  1363.       for (i=0; i<BLOCK_SIZE; i++)
  1364.       {
  1365.         tmp_fwMV[0][img->block_y+j][img->block_x+4+i] = rdopt->mv[j][i][0];
  1366.         tmp_fwMV[1][img->block_y+j][img->block_x+4+i] = rdopt->mv[j][i][1];
  1367.         dfMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1368.         dfMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1369.         dbMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1370.         dbMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1371.       }
  1372.     currMB->ref_frame  = refframe;
  1373.     img->fw_blc_size_h = input->blc_size[blocktype][0];
  1374.     img->fw_blc_size_v = input->blc_size[blocktype][1];
  1375.   }
  1376.   else if (mode >= MBMODE_BACKWARD16x16 && mode <= MBMODE_BACKWARD4x4)
  1377.   {
  1378.     for   (j=0; j<BLOCK_SIZE; j++)
  1379.       for (i=0; i<BLOCK_SIZE; i++)
  1380.       {
  1381.         tmp_bwMV[0][img->block_y+j][img->block_x+4+i] = rdopt->bw_mv[j][i][0];
  1382.         tmp_bwMV[1][img->block_y+j][img->block_x+4+i] = rdopt->bw_mv[j][i][1];
  1383.         dfMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1384.         dfMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1385.         dbMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1386.         dbMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1387.       }
  1388.     currMB->ref_frame  = refframe;
  1389.     img->bw_blc_size_h = input->blc_size[blocktype_back][0];
  1390.     img->bw_blc_size_v = input->blc_size[blocktype_back][1];
  1391.   }
  1392.   else if (mode == MBMODE_BIDIRECTIONAL)
  1393.   {
  1394.     for   (j=0; j<BLOCK_SIZE; j++)
  1395.       for (i=0; i<BLOCK_SIZE; i++)
  1396.       {
  1397.         tmp_fwMV[0][img->block_y+j][img->block_x+4+i] = rdopt->   mv[j][i][0];
  1398.         tmp_fwMV[1][img->block_y+j][img->block_x+4+i] = rdopt->   mv[j][i][1];
  1399.         tmp_bwMV[0][img->block_y+j][img->block_x+4+i] = rdopt->bw_mv[j][i][0];
  1400.         tmp_bwMV[1][img->block_y+j][img->block_x+4+i] = rdopt->bw_mv[j][i][1];
  1401.         dfMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1402.         dfMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1403.         dbMV    [0][img->block_y+j][img->block_x+4+i] = 0;
  1404.         dbMV    [1][img->block_y+j][img->block_x+4+i] = 0;
  1405.       }
  1406.     currMB->ref_frame  = refframe;
  1407.     img->fw_blc_size_h = input->blc_size[blocktype     ][0];
  1408.     img->fw_blc_size_v = input->blc_size[blocktype     ][1];
  1409.     img->bw_blc_size_h = input->blc_size[blocktype_back][0];
  1410.     img->bw_blc_size_v = input->blc_size[blocktype_back][1];
  1411.   }
  1413.   //=== MACROBLOCK MODE ===
  1414.   if      (mode == MBMODE_COPY || mode == MBMODE_DIRECT)
  1415.     img->mb_mode = 0;
  1416.   else if (mode == MBMODE_INTRA4x4)
  1417.     img->mb_mode = 8*img->type + img->imod;
  1418.   else if (mode == MBMODE_INTRA16x16)
  1419.     img->mb_mode = 8*img->type + img->imod + intra16mode + 12*img->kac + 4*((currMB->cbp&0xF0)>>4);
  1420.   else if (mode == MBMODE_BIDIRECTIONAL)
  1421.     img->mb_mode = 3;
  1422.   else if (mode >= MBMODE_BACKWARD16x16 && mode <= MBMODE_BACKWARD4x4)
  1423.     img->mb_mode = (blocktype_back == 1 ? blocktype_back+1 : 2*blocktype_back+1);
  1424.   else if (mode >= MBMODE_INTER16x16 && mode <= MBMODE_INTER4x4 && bframe)
  1425.     img->mb_mode = (blocktype == 1 ? blocktype : 2*blocktype);
  1426.   else if (blocktype                         == M16x16_MB &&
  1427.      currMB->cbp                             == 0         &&
  1428.      currMB->ref_frame                       == 0         &&
  1429.      tmp_mv[0][img->block_y][img->block_x+4] == 0         &&
  1430.      tmp_mv[1][img->block_y][img->block_x+4] == 0)
  1431.     img->mb_mode = 0;
  1432.   else
  1433.     img->mb_mode = blocktype;
  1434.   currMB->mb_type = img->mb_mode;
  1437.   /*===========================================================*
  1438.    *===  SET LOOP FILTER STRENGTH and REFERENCE FRAME INFO  ===*
  1439.    *===========================================================*/
  1440.   if (!bframe)
  1441.   {
  1442.     // Set reference frame information for motion vector prediction of future MBs
  1443.     SetRefFrameInfo_P();
  1444.   }
  1445.   else
  1446.   {
  1447.     // Set reference frame information for motion vector prediction of future MBs
  1448.     SetRefFrameInfo_B();
  1449.   }
  1450.   currMB->qp       = img->qp ;    // this should (or has to be) done somewere else, but where???
  1451.   DeblockMb(img, imgY, imgUV) ;   // filter this macroblock ( pixels to the right and above the MB are affected )
  1452.   if (input->rdopt == 2)
  1453.   {
  1454.     for (j=0 ; j<input->NoOfDecoders ; j++)
  1455.       DeblockMb(img, decY_best[j],NULL);
  1456.   }
  1458.   if (img->current_mb_nr==0)
  1459.     intras=0;
  1460.   if (img->number && (mode==MBMODE_INTRA4x4 || mode==MBMODE_INTRA16x16))
  1461.     intras++;
  1463. }