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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

block.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 block.c
  36.  *
  37.  * brief
  38.  *    Process one block
  39.  *
  40.  * author
  41.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  42.  *    - Inge Lille-Lang鴜               <inge.lille-langoy@telenor.com>
  43.  *    - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  44.  *    - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  45.  *    - Jani Lainema                    <jani.lainema@nokia.com>
  46.  *    - Detlev Marpe                    <marpe@hhi.de>
  47.  *    - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  48.  *    - Ragip Kurceren                  <ragip.kurceren@nokia.com>
  49.  *************************************************************************************
  50.  */
  52. #include "contributors.h"
  55. #include <math.h>
  56. #include <stdlib.h>
  57. #include <assert.h>
  59. #include "block.h"
  60. #include "refbuf.h"
  63. /*!
  64.  ************************************************************************
  65.  * brief
  66.  *    Make intra 4x4 prediction according to all 6 prediction modes.
  67.  *    The routine uses left and upper neighbouring points from
  68.  *    previous coded blocks to do this (if available). Notice that
  69.  *    inaccessible neighbouring points are signalled with a negative
  70.  *    value i the predmode array .
  71.  *
  72.  *  para Input:
  73.  *     Starting point of current 4x4 block image posision
  74.  *
  75.  *  para Output:
  76.  *      none
  77.  ************************************************************************
  78.  */
  79. void intrapred_luma(int img_x,int img_y)
  80. {
  81.   int i,j,s0=0,s1,s2,ia[7][3],s[4][2];
  83.   int block_available_up = (img->ipredmode[img_x/BLOCK_SIZE+1][img_y/BLOCK_SIZE] >=0);
  84.   int block_available_left = (img->ipredmode[img_x/BLOCK_SIZE][img_y/BLOCK_SIZE+1] >=0);
  86.   s1=0;
  87.   s2=0;
  89.   // make DC prediction
  90.   for (i=0; i < BLOCK_SIZE; i++)
  91.   {
  92.     if (block_available_up)
  93.       s1 += imgY[img_y-1][img_x+i];    // sum hor pix
  94.     if (block_available_left)
  95.       s2 += imgY[img_y+i][img_x-1];    // sum vert pix
  96.   }
  97.   if (block_available_up && block_available_left)
  98.     s0=(s1+s2+4)/(2*BLOCK_SIZE);      // no edge
  99.   if (!block_available_up && block_available_left)
  100.     s0=(s2+2)/BLOCK_SIZE;             // upper edge
  101.   if (block_available_up && !block_available_left)
  102.     s0=(s1+2)/BLOCK_SIZE;             // left edge
  103.   if (!block_available_up && !block_available_left)
  104.     s0=128;                           // top left corner, nothing to predict from
  106.   for (i=0; i < BLOCK_SIZE; i++)
  107.   {
  108.     // vertical prediction
  109.     if (block_available_up)
  110.       s[i][0]=imgY[img_y-1][img_x+i];
  111.     // horizontal prediction
  112.     if (block_available_left)
  113.       s[i][1]=imgY[img_y+i][img_x-1];
  114.   }
  116.   for (j=0; j < BLOCK_SIZE; j++)
  117.   {
  118.     for (i=0; i < BLOCK_SIZE; i++)
  119.     {
  120.       img->mprr[DC_PRED][i][j]=s0;      // store DC prediction
  121.       img->mprr[VERT_PRED][i][j]=s[j][0]; // store vertical prediction
  122.       img->mprr[HOR_PRED][i][j]=s[i][1]; // store horizontal prediction
  123.     }
  124.   }
  126.   //  Prediction according to 'diagonal' modes
  127.   if (block_available_up && block_available_left)
  128.   {
  129.     int A = imgY[img_y-1][img_x];
  130.     int B = imgY[img_y-1][img_x+1];
  131.     int C = imgY[img_y-1][img_x+2];
  132.     int D = imgY[img_y-1][img_x+3];
  133.     int E = imgY[img_y  ][img_x-1];
  134.     int F = imgY[img_y+1][img_x-1];
  135.     int G = imgY[img_y+2][img_x-1];
  136.     int H = imgY[img_y+3][img_x-1];
  137.     int I = imgY[img_y-1][img_x-1];
  138.     ia[0][0]=(H+2*G+F+2)/4;
  139.     ia[1][0]=(G+2*F+E+2)/4;
  140.     ia[2][0]=(F+2*E+I+2)/4;
  141.     ia[3][0]=(E+2*I+A+2)/4;
  142.     ia[4][0]=(I+2*A+B+2)/4;
  143.     ia[5][0]=(A+2*B+C+2)/4;
  144.     ia[6][0]=(B+2*C+D+2)/4;
  145.     for (i=0;i<4;i++)
  146.       for (j=0;j<4;j++)
  147.         img->mprr[DIAG_PRED_LR_45][i][j]=ia[j-i+3][0];
  148.   }
  149.   if (block_available_up)
  150.   { // Do prediction 1
  151.     int A = imgY[img_y-1][img_x+0];
  152.     int B = imgY[img_y-1][img_x+1];
  153.     int C = imgY[img_y-1][img_x+2];
  154.     int D = imgY[img_y-1][img_x+3];
  156.     img->mprr[DIAG_PRED_RL][0][0] = (A+B)/2; // a
  157.     img->mprr[DIAG_PRED_RL][1][0] = B;       // e
  158.     img->mprr[DIAG_PRED_RL][0][1] = img->mprr[DIAG_PRED_RL][2][0] = (B+C)/2; // b i
  159.     img->mprr[DIAG_PRED_RL][1][1] = img->mprr[DIAG_PRED_RL][3][0] = C;       // f m
  160.     img->mprr[DIAG_PRED_RL][0][2] = img->mprr[DIAG_PRED_RL][2][1] = (C+D)/2; // c j
  161.     img->mprr[DIAG_PRED_RL][3][1] =
  162.         img->mprr[DIAG_PRED_RL][1][2] =
  163.             img->mprr[DIAG_PRED_RL][2][2] =
  164.                 img->mprr[DIAG_PRED_RL][3][2] =
  165.                     img->mprr[DIAG_PRED_RL][0][3] =
  166.                         img->mprr[DIAG_PRED_RL][1][3] =
  167.                             img->mprr[DIAG_PRED_RL][2][3] =
  168.                                 img->mprr[DIAG_PRED_RL][3][3] = D; // d g h k l n o p
  169.   }
  171.   if (block_available_left)
  172.   { // Do prediction 5
  173.     int E = imgY[img_y+0][img_x-1];
  174.     int F = imgY[img_y+1][img_x-1];
  175.     int G = imgY[img_y+2][img_x-1];
  176.     int H = imgY[img_y+3][img_x-1];
  178.     img->mprr[DIAG_PRED_LR][0][0] = (E+F)/2; // a
  179.     img->mprr[DIAG_PRED_LR][0][1] = F;       // b
  180.     img->mprr[DIAG_PRED_LR][1][0] = img->mprr[DIAG_PRED_LR][0][2] = (F+G)/2; // e c
  181.     img->mprr[DIAG_PRED_LR][1][1] = img->mprr[DIAG_PRED_LR][0][3] = G;       // f d
  182.     img->mprr[DIAG_PRED_LR][2][0] = img->mprr[DIAG_PRED_LR][1][2] = (G+H)/2; // i g
  184.     img->mprr[DIAG_PRED_LR][1][3] =
  185.         img->mprr[DIAG_PRED_LR][2][1] =
  186.             img->mprr[DIAG_PRED_LR][2][2] =
  187.                 img->mprr[DIAG_PRED_LR][2][3] =
  188.                     img->mprr[DIAG_PRED_LR][3][0] =
  189.                         img->mprr[DIAG_PRED_LR][3][1] =
  190.                             img->mprr[DIAG_PRED_LR][3][2] =
  191.                                 img->mprr[DIAG_PRED_LR][3][3] = H;
  192.   }
  193. }
  195. /*!
  196.  ************************************************************************
  197.  * brief
  198.  *    16x16 based luma prediction
  199.  *
  200.  * para Input:
  201.  *    Image parameters
  202.  *
  203.  * para Output:
  204.  *    none
  205.  ************************************************************************
  206.  */
  207. void intrapred_luma_2()
  208. {
  209.   int s0=0,s1,s2;
  210.   int i,j;
  211.   int s[16][2];
  213.   int ih,iv;
  214.   int ib,ic,iaa;
  216.   int mb_nr = img->current_mb_nr;
  217.   int mb_width = img->width/16;
  218.   int mb_available_up = (img->mb_y == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width]);
  219.   int mb_available_left = (img->mb_x == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-1]);
  221.   if(input->UseConstrainedIntraPred)
  222.   {
  223.     if (mb_available_up && (img->intra_mb[mb_nr-mb_width] ==0))
  224.       mb_available_up = 0;
  225.     if (mb_available_left && (img->intra_mb[mb_nr-1] ==0))
  226.       mb_available_left = 0;
  227.   }
  229.   s1=s2=0;
  230.   // make DC prediction
  231.   for (i=0; i < MB_BLOCK_SIZE; i++)
  232.   {
  233.     if (mb_available_up)
  234.       s1 += imgY[img->pix_y-1][img->pix_x+i];    // sum hor pix
  235.     if (mb_available_left)
  236.       s2 += imgY[img->pix_y+i][img->pix_x-1];    // sum vert pix
  237.   }
  238.   if (mb_available_up && mb_available_left)
  239.     s0=(s1+s2+16)/(2*MB_BLOCK_SIZE);             // no edge
  240.   if (!mb_available_up && mb_available_left)
  241.     s0=(s2+8)/MB_BLOCK_SIZE;                     // upper edge
  242.   if (mb_available_up && !mb_available_left)
  243.     s0=(s1+8)/MB_BLOCK_SIZE;                     // left edge
  244.   if (!mb_available_up && !mb_available_left)
  245.     s0=128;                                      // top left corner, nothing to predict from
  247.   for (i=0; i < MB_BLOCK_SIZE; i++)
  248.   {
  249.     // vertical prediction
  250.     if (mb_available_up)
  251.       s[i][0]=imgY[img->pix_y-1][img->pix_x+i];
  252.     // horizontal prediction
  253.     if (mb_available_left)
  254.       s[i][1]=imgY[img->pix_y+i][img->pix_x-1];
  255.   }
  257.   for (j=0; j < MB_BLOCK_SIZE; j++)
  258.   {
  259.     for (i=0; i < MB_BLOCK_SIZE; i++)
  260.     {
  261.       img->mprr_2[VERT_PRED_16][j][i]=s[i][0]; // store vertical prediction
  262.       img->mprr_2[HOR_PRED_16 ][j][i]=s[j][1]; // store horizontal prediction
  263.       img->mprr_2[DC_PRED_16  ][j][i]=s0;      // store DC prediction
  264.     }
  265.   }
  266.   if (!mb_available_up || !mb_available_left) // edge
  267.     return;
  269.   // 16 bit integer plan pred
  271.   ih=0;
  272.   iv=0;
  273.   for (i=1;i<9;i++)
  274.   {
  275.     ih += i*(imgY[img->pix_y-1][img->pix_x+7+i] - imgY[img->pix_y-1][img->pix_x+7-i]);
  276.     iv += i*(imgY[img->pix_y+7+i][img->pix_x-1] - imgY[img->pix_y+7-i][img->pix_x-1]);
  277.   }
  278.   ib=5*(ih/4)/16;
  279.   ic=5*(iv/4)/16;
  281.   iaa=16*(imgY[img->pix_y-1][img->pix_x+15]+imgY[img->pix_y+15][img->pix_x-1]);
  282.   for (j=0;j< MB_BLOCK_SIZE;j++)
  283.   {
  284.     for (i=0;i< MB_BLOCK_SIZE;i++)
  285.     {
  286.       img->mprr_2[PLANE_16][j][i]=max(0,min(255,(iaa+(i-7)*ib +(j-7)*ic + 16)/32));/* store plane prediction */                              
  287.     }
  288.   }
  289. }
  291. /*!
  292.  ************************************************************************
  293.  * brief
  294.  *    For new intra pred routines
  295.  *
  296.  * para Input:
  297.  *    Image par, 16x16 based intra mode
  298.  *
  299.  * para Output:
  300.  *    none
  301.  ************************************************************************
  302.  */
  303. void dct_luma2(int new_intra_mode)
  304. {
  305. #ifndef NO_RDQUANT
  306.   int jq0;
  307. #endif
  308. #ifdef NO_RDQUANT
  309.   int qp_const;
  310. #endif
  311.   int i,j;
  312.   int ii,jj;
  313.   int i1,j1;
  315.   int M1[16][16];
  316.   int M4[4][4];
  317.   int M5[4],M6[4];
  318.   int M0[4][4][4][4];
  319. #ifndef NO_RDQUANT
  320.   int coeff[16];
  321. #endif
  322.   int quant_set,run,scan_pos,coeff_ctr,level;
  324. #ifndef NO_RDQUANT
  325.   jq0=JQQ3;
  326. #endif
  327. #ifdef NO_RDQUANT
  328.   qp_const = JQQ3;
  329. #endif
  331.   for (j=0;j<16;j++)
  332.   {
  333.     for (i=0;i<16;i++)
  334.     {
  335.       M1[i][j]=imgY_org[img->pix_y+j][img->pix_x+i]-img->mprr_2[new_intra_mode][j][i];
  336.       M0[i%4][i/4][j%4][j/4]=M1[i][j];
  337.     }
  338.   }
  340.   for (jj=0;jj<4;jj++)
  341.   {
  342.     for (ii=0;ii<4;ii++)
  343.     {
  344.       for (j=0;j<4;j++)
  345.       {
  346.         for (i=0;i<2;i++)
  347.         {
  348.           i1=3-i;
  349.           M5[i]=  M0[i][ii][j][jj]+M0[i1][ii][j][jj];
  350.           M5[i1]= M0[i][ii][j][jj]-M0[i1][ii][j][jj];
  351.         }
  352.         M0[0][ii][j][jj]=(M5[0]+M5[1])*13;
  353.         M0[2][ii][j][jj]=(M5[0]-M5[1])*13;
  354.         M0[1][ii][j][jj]=M5[3]*17+M5[2]*7;
  355.         M0[3][ii][j][jj]=M5[3]*7-M5[2]*17;
  356.       }
  357.       // vertical
  358.       for (i=0;i<4;i++)
  359.       {
  360.         for (j=0;j<2;j++)
  361.         {
  362.           j1=3-j;
  363.           M5[j] = M0[i][ii][j][jj]+M0[i][ii][j1][jj];
  364.           M5[j1]= M0[i][ii][j][jj]-M0[i][ii][j1][jj];
  365.         }
  366.         M0[i][ii][0][jj]=(M5[0]+M5[1])*13;
  367.         M0[i][ii][2][jj]=(M5[0]-M5[1])*13;
  368.         M0[i][ii][1][jj]= M5[3]*17+M5[2]*7;
  369.         M0[i][ii][3][jj]= M5[3]*7 -M5[2]*17;
  370.       }
  371.     }
  372.   }
  374.   // pick out DC coeff
  376.   for (j=0;j<4;j++)
  377.     for (i=0;i<4;i++)
  378.       M4[i][j]= 49 * M0[0][i][0][j]/32768;
  380.   for (j=0;j<4;j++)
  381.   {
  382.     for (i=0;i<2;i++)
  383.     {
  384.       i1=3-i;
  385.       M5[i]= M4[i][j]+M4[i1][j];
  386.       M5[i1]=M4[i][j]-M4[i1][j];
  387.     }
  388.     M4[0][j]=(M5[0]+M5[1])*13;
  389.     M4[2][j]=(M5[0]-M5[1])*13;
  390.     M4[1][j]= M5[3]*17+M5[2]*7;
  391.     M4[3][j]= M5[3]*7 -M5[2]*17;
  392.   }
  394.   // vertical
  396.   for (i=0;i<4;i++)
  397.   {
  398.     for (j=0;j<2;j++)
  399.     {
  400.       j1=3-j;
  401.       M5[j]= M4[i][j]+M4[i][j1];
  402.       M5[j1]=M4[i][j]-M4[i][j1];
  403.     }
  404.     M4[i][0]=(M5[0]+M5[1])*13;
  405.     M4[i][2]=(M5[0]-M5[1])*13;
  406.     M4[i][1]= M5[3]*17+M5[2]*7;
  407.     M4[i][3]= M5[3]*7 -M5[2]*17;
  408.   }
  410.   // quant
  412.   quant_set=img->qp;
  413.   run=-1;
  414.   scan_pos=0;
  415. #ifndef NO_RDQUANT
  417.   for (coeff_ctr=0;coeff_ctr<16;coeff_ctr++)
  418.   {
  419.     i=SNGL_SCAN[coeff_ctr][0];
  420.     j=SNGL_SCAN[coeff_ctr][1];
  421.     coeff[coeff_ctr]=M4[i][j];
  422.   }
  423.   rd_quant(QUANT_LUMA_SNG,coeff);
  425.   for (coeff_ctr=0;coeff_ctr<16;coeff_ctr++)
  426.   {
  427.     i=SNGL_SCAN[coeff_ctr][0];
  428.     j=SNGL_SCAN[coeff_ctr][1];
  430.     run++;
  432.     level=abs(coeff[coeff_ctr]);
  434.     if (level != 0)
  435.     {
  436.       img->cof[0][0][scan_pos][0][1]=sign(level,M4[i][j]);
  437.       img->cof[0][0][scan_pos][1][1]=run;
  438.       ++scan_pos;
  439.       run=-1;
  440.     }
  441. #endif
  442. #ifdef NO_RDQUANT
  444.   for (coeff_ctr=0;coeff_ctr<16;coeff_ctr++)
  445.   {
  446.     i=SNGL_SCAN[coeff_ctr][0];
  447.     j=SNGL_SCAN[coeff_ctr][1];
  449.     run++;
  451.     level= (abs(M4[i][j]) * JQ[quant_set][0]+qp_const)/JQQ1;
  453.     if (level != 0)
  454.     {
  455.       img->cof[0][0][scan_pos][0][1]=sign(level,M4[i][j]);
  456.       img->cof[0][0][scan_pos][1][1]=run;
  457.       ++scan_pos;
  458.       run=-1;
  459.     }
  460. #endif
  461.     M4[i][j]=sign(level,M4[i][j]);
  462.   }
  463.   img->cof[0][0][scan_pos][0][1]=0;
  465.   // invers DC transform
  467.   for (j=0;j<4;j++)
  468.   {
  469.     for (i=0;i<4;i++)
  470.       M5[i]=M4[i][j];
  472.     M6[0]=(M5[0]+M5[2])*13;
  473.     M6[1]=(M5[0]-M5[2])*13;
  474.     M6[2]= M5[1]*7 -M5[3]*17;
  475.     M6[3]= M5[1]*17+M5[3]*7;
  477.     for (i=0;i<2;i++)
  478.     {
  479.       i1=3-i;
  480.       M4[i][j]= M6[i]+M6[i1];
  481.       M4[i1][j]=M6[i]-M6[i1];
  482.     }
  483.   }
  485.   for (i=0;i<4;i++)
  486.   {
  487.     for (j=0;j<4;j++)
  488.       M5[j]=M4[i][j];
  490.     M6[0]=(M5[0]+M5[2])*13;
  491.     M6[1]=(M5[0]-M5[2])*13;
  492.     M6[2]= M5[1]*7 -M5[3]*17;
  493.     M6[3]= M5[1]*17+M5[3]*7;
  495.     for (j=0;j<2;j++)
  496.     {
  497.       j1=3-j;
  498.       M0[0][i][0][j] = ((M6[j]+M6[j1])/8) *JQ[quant_set][1];
  499.       M0[0][i][0][j1]= ((M6[j]-M6[j1])/8) *JQ[quant_set][1];
  500.     }
  501.   }
  502.   for (j=0;j<4;j++)
  503.   {
  504.     for (i=0;i<4;i++)
  505.     {
  506.       M0[0][i][0][j] = 3 * M0[0][i][0][j]/256;
  507.     }
  508.   }
  510.   // AC invers trans/quant for MB
  511.   img->kac=0;
  512.   for (jj=0;jj<4;jj++)
  513.   {
  514.     for (ii=0;ii<4;ii++)
  515.     {
  516.       run=-1;
  517.       scan_pos=0;
  518. #ifndef NO_RDQUANT
  519.       for (coeff_ctr=1;coeff_ctr<16;coeff_ctr++) // set in AC coeff
  520.       {
  521.         i=SNGL_SCAN[coeff_ctr][0];
  522.         j=SNGL_SCAN[coeff_ctr][1];
  523.         coeff[coeff_ctr-1]=M0[i][ii][j][jj];
  524.       }
  525.       rd_quant(QUANT_LUMA_AC,coeff);
  527.       for (coeff_ctr=1;coeff_ctr<16;coeff_ctr++) // set in AC coeff
  528.       {
  529.         i=SNGL_SCAN[coeff_ctr][0];
  530.         j=SNGL_SCAN[coeff_ctr][1];
  531.         run++;
  533.         level=abs(coeff[coeff_ctr-1]);
  535.         if (level != 0)
  536.         {
  537.           img->kac=1;
  538.           img->cof[ii][jj][scan_pos][0][0]=sign(level,M0[i][ii][j][jj]);
  539.           img->cof[ii][jj][scan_pos][1][0]=run;
  540.           ++scan_pos;
  541.           run=-1;
  542.         }
  543.         M0[i][ii][j][jj]=sign(level*JQ[quant_set][1],M0[i][ii][j][jj]);
  544.       }
  545.       img->cof[ii][jj][scan_pos][0][0]=0;
  546. #endif
  547. #ifdef NO_RDQUANT
  548.       for (coeff_ctr=1;coeff_ctr<16;coeff_ctr++) // set in AC coeff
  549.       {
  550.         i=SNGL_SCAN[coeff_ctr][0];
  551.         j=SNGL_SCAN[coeff_ctr][1];
  552.         run++;
  554.         level= ( abs( M0[i][ii][j][jj]) * JQ[quant_set][0]+qp_const)/JQQ1;
  556.         if (level != 0)
  557.         {
  558.           img->kac=1;
  559.           img->cof[ii][jj][scan_pos][0][0]=sign(level,M0[i][ii][j][jj]);
  560.           img->cof[ii][jj][scan_pos][1][0]=run;
  561.           ++scan_pos;
  562.           run=-1;
  563.         }
  564.         M0[i][ii][j][jj]=sign(level*JQ[quant_set][1],M0[i][ii][j][jj]);
  565.       }
  566.       img->cof[ii][jj][scan_pos][0][0]=0;
  567. #endif
  570.       // IDCT horizontal
  572.       for (j=0;j<4;j++)
  573.       {
  574.         for (i=0;i<4;i++)
  575.         {
  576.           M5[i]=M0[i][ii][j][jj];
  577.         }
  579.         M6[0]=(M5[0]+M5[2])*13;
  580.         M6[1]=(M5[0]-M5[2])*13;
  581.         M6[2]=M5[1]*7 -M5[3]*17;
  582.         M6[3]=M5[1]*17+M5[3]*7;
  584.         for (i=0;i<2;i++)
  585.         {
  586.           i1=3-i;
  587.           M0[i][ii][j][jj] =M6[i]+M6[i1];
  588.           M0[i1][ii][j][jj]=M6[i]-M6[i1];
  589.         }
  590.       }
  592.       // vert
  593.       for (i=0;i<4;i++)
  594.       {
  595.         for (j=0;j<4;j++)
  596.           M5[j]=M0[i][ii][j][jj];
  598.         M6[0]=(M5[0]+M5[2])*13;
  599.         M6[1]=(M5[0]-M5[2])*13;
  600.         M6[2]=M5[1]*7 -M5[3]*17;
  601.         M6[3]=M5[1]*17+M5[3]*7;
  603.         for (j=0;j<2;j++)
  604.         {
  605.           j1=3-j;
  606.           M0[i][ii][ j][jj]=M6[j]+M6[j1];
  607.           M0[i][ii][j1][jj]=M6[j]-M6[j1];
  609.         }
  610.       }
  612.     }
  613.   }
  615.   for (j=0;j<16;j++)
  616.   {
  617.     for (i=0;i<16;i++)
  618.     {
  619.       M1[i][j]=M0[i%4][i/4][j%4][j/4];
  620.     }
  621.   }
  623.   for (j=0;j<16;j++)
  624.     for (i=0;i<16;i++)
  625.       imgY[img->pix_y+j][img->pix_x+i]=min(255,max(0,(M1[i][j]+img->mprr_2[new_intra_mode][j][i]*JQQ1+JQQ2)/JQQ1));
  627. }
  630. /*!
  631.  ************************************************************************
  632.  * brief
  633.  *    Intra prediction for chroma.  There is only one prediction mode,
  634.  *    corresponding to 'DC prediction' for luma. However,since 2x2 transform
  635.  *    of DC levels are used,all predictions are made from neighbouring MBs.
  636.  *    Prediction also depends on whether the block is at a frame edge.
  637.  *
  638.  *  para Input:
  639.  *     Starting point of current chroma macro block image posision
  640.  *
  641.  *  para Output:
  642.  *     8x8 array with DC intra chroma prediction and diff array
  643.  ************************************************************************
  644.  */
  645. void intrapred_chroma(int img_c_x,int img_c_y,int uv)
  646. {
  647.   int s[2][2],s0,s1,s2,s3;
  648.   int i,j;
  650.   int mb_nr = img->current_mb_nr;
  651.   int mb_width = img->width/16;
  652.   int mb_available_up = (img_c_y/BLOCK_SIZE == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-mb_width]);
  653.   int mb_available_left = (img_c_x/BLOCK_SIZE == 0) ? 0 : (img->slice_numbers[mb_nr] == img->slice_numbers[mb_nr-1]);
  654.   if(input->UseConstrainedIntraPred)
  655.   {
  656.     if (mb_available_up && (img->intra_mb[mb_nr-mb_width] ==0))
  657.       mb_available_up = 0;
  658.     if (mb_available_left && (img->intra_mb[mb_nr-1] ==0))
  659.       mb_available_left = 0;
  660.   }
  661.   s0=s1=s2=s3=0;          // reset counters
  663.   for (i=0; i < BLOCK_SIZE; i++)
  664.   {
  665.     if(mb_available_up)
  666.     {
  667.       s0 += imgUV[uv][img_c_y-1][img_c_x+i];
  668.       s1 += imgUV[uv][img_c_y-1][img_c_x+i+BLOCK_SIZE];
  669.     }
  670.     if(mb_available_left)
  671.     {
  672.       s2 += imgUV[uv][img_c_y+i][img_c_x-1];
  673.       s3 += imgUV[uv][img_c_y+i+BLOCK_SIZE][img_c_x-1];
  674.     }
  675.   }
  677.   if(mb_available_up && mb_available_left)
  678.   {
  679.     s[0][0]=(s0+s2+4)/(2*BLOCK_SIZE);
  680.     s[1][0]=(s1+2)/BLOCK_SIZE;
  681.     s[0][1]=(s3+2)/BLOCK_SIZE;
  682.     s[1][1]=(s1+s3+4)/(2*BLOCK_SIZE);
  683.   }
  684.   else
  685.     if(mb_available_up && !mb_available_left)
  686.     {
  687.       s[0][0]=(s0+2)/BLOCK_SIZE;
  688.       s[1][0]=(s1+2)/BLOCK_SIZE;
  689.       s[0][1]=(s0+2)/BLOCK_SIZE;
  690.       s[1][1]=(s1+2)/BLOCK_SIZE;
  691.     }
  692.     else
  693.       if(!mb_available_up && mb_available_left)
  694.       {
  695.         s[0][0]=(s2+2)/BLOCK_SIZE;
  696.         s[1][0]=(s2+2)/BLOCK_SIZE;
  697.         s[0][1]=(s3+2)/BLOCK_SIZE;
  698.         s[1][1]=(s3+2)/BLOCK_SIZE;
  699.       }
  700.       else
  701.         if(!mb_available_up && !mb_available_left)
  702.         {
  703.           s[0][0]=128;
  704.           s[1][0]=128;
  705.           s[0][1]=128;
  706.           s[1][1]=128;
  707.         }
  708.   for (j=0; j < MB_BLOCK_SIZE/2; j++)
  709.   {
  710.     for (i=0; i < MB_BLOCK_SIZE/2; i++)
  711.     {
  712.       img->mpr[i][j]=s[i/BLOCK_SIZE][j/BLOCK_SIZE];
  713.       img->m7[i][j]=imgUV_org[uv][img_c_y+j][img_c_x+i]-img->mpr[i][j];
  714.     }
  715.   }
  716. }
  719. /*!
  720.  ************************************************************************
  721.  * brief
  722.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  723.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  724.  *    RD constrained quantization also.
  725.  *
  726.  * para Input:
  727.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  728.  *
  729.  * para Output_
  730.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.             n
  731.  *    coeff_cost: Counter for nonzero coefficients, used to discard expencive levels.
  732.  ************************************************************************
  733.  */
  734. int dct_luma(int block_x,int block_y,int *coeff_cost)
  735. {
  736.   int sign(int a,int b);
  738.   int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr,scan_loop_ctr;
  739.   int qp_const,pos_x,pos_y,quant_set,level,scan_pos,run;
  740.   int nonzero;
  741.   int idx;
  743.   int scan_mode;
  744.   int loop_rep;
  745. #ifndef NO_RDQUANT
  746.   int coeff[16];
  747. #endif
  749.   if (img->type == INTRA_IMG)
  750.     qp_const=JQQ3;    // intra
  751.   else
  752.     qp_const=JQQ4;    // inter
  754.   pos_x=block_x/BLOCK_SIZE;
  755.   pos_y=block_y/BLOCK_SIZE;
  757.   //  Horizontal transform
  759.   for (j=0; j < BLOCK_SIZE; j++)
  760.   {
  761.     for (i=0; i < 2; i++)
  762.     {
  763.       i1=3-i;
  764.       m5[i]=img->m7[i][j]+img->m7[i1][j];
  765.       m5[i1]=img->m7[i][j]-img->m7[i1][j];
  766.     }
  767.     img->m7[0][j]=(m5[0]+m5[1])*13;
  768.     img->m7[2][j]=(m5[0]-m5[1])*13;
  769.     img->m7[1][j]=m5[3]*17+m5[2]*7;
  770.     img->m7[3][j]=m5[3]*7-m5[2]*17;
  771.   }
  773.   //  Vertival transform
  775.   for (i=0; i < BLOCK_SIZE; i++)
  776.   {
  777.     for (j=0; j < 2; j++)
  778.     {
  779.       j1=3-j;
  780.       m5[j]=img->m7[i][j]+img->m7[i][j1];
  781.       m5[j1]=img->m7[i][j]-img->m7[i][j1];
  782.     }
  783.     img->m7[i][0]=(m5[0]+m5[1])*13;
  784.     img->m7[i][2]=(m5[0]-m5[1])*13;
  785.     img->m7[i][1]=m5[3]*17+m5[2]*7;
  786.     img->m7[i][3]=m5[3]*7-m5[2]*17;
  787.   }
  789.   // Quant
  791.   quant_set=img->qp;
  792.   nonzero=FALSE;
  794.   if (img->imod == INTRA_MB_OLD && img->qp < 24)
  795.   {
  796.     scan_mode=DOUBLE_SCAN;
  797.     loop_rep=2;
  798.     idx=1;
  799.   }
  800.   else
  801.   {
  802.     scan_mode=SINGLE_SCAN;
  803.     loop_rep=1;
  804.     idx=0;
  805.   }
  807. #ifndef NO_RDQUANT
  808.   for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
  809.   {
  810.     for (coeff_ctr=0;coeff_ctr < 16/loop_rep;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  811.     {
  812.       if (scan_mode==DOUBLE_SCAN)
  813.       {
  814.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  815.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  816.       }
  817.       else
  818.       {
  819.         i=SNGL_SCAN[coeff_ctr][0];
  820.         j=SNGL_SCAN[coeff_ctr][1];
  821.       }
  822.       coeff[coeff_ctr]=img->m7[i][j];
  823.     }
  824.     if (scan_mode==DOUBLE_SCAN)
  825.       rd_quant(QUANT_LUMA_DBL,coeff);
  826.     else
  827.       rd_quant(QUANT_LUMA_SNG,coeff);
  829.     run=-1;
  830.     scan_pos=scan_loop_ctr*9;   // for double scan; set first or second scan posision
  831.     for (coeff_ctr=0; coeff_ctr<16/loop_rep; coeff_ctr++)
  832.     {
  833.       if (scan_mode==DOUBLE_SCAN)
  834.       {
  835.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  836.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  837.       }
  838.       else
  839.       {
  840.         i=SNGL_SCAN[coeff_ctr][0];
  841.         j=SNGL_SCAN[coeff_ctr][1];
  842.       }
  843.       run++;
  844.       ilev=0;
  846.       level= absm(coeff[coeff_ctr]);
  847.       if (level != 0)
  848.       {
  849.         nonzero=TRUE;
  850.         if (level > 1)
  851.           *coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  852.         else
  853.           *coeff_cost += COEFF_COST[run];
  854.         img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=sign(level,img->m7[i][j]);
  855.         img->cof[pos_x][pos_y][scan_pos][1][scan_mode]=run;
  856.         ++scan_pos;
  857.         run=-1;                     // reset zero level counter
  858.         ilev=level*JQ[quant_set][1];
  859.       }
  860.       img->m7[i][j]=sign(ilev,img->m7[i][j]);
  861.     }
  862.     img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=0;  // end of block
  863.   }
  864. #endif
  866. #ifdef NO_RDQUANT
  867.   for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
  868.   {
  869.   run=-1;
  870.   scan_pos=scan_loop_ctr*9;
  872.     for (coeff_ctr=0;coeff_ctr < 16/loop_rep;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  873.     {
  874.       if (scan_mode==DOUBLE_SCAN)
  875.       {
  876.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  877.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  878.       }
  879.       else
  880.       {
  881.         i=SNGL_SCAN[coeff_ctr][0];
  882.         j=SNGL_SCAN[coeff_ctr][1];
  883.       }
  885.       run++;
  886.       ilev=0;
  887.       level = (abs (img->m7[i][j]) * JQ[quant_set][0] +qp_const) / JQQ1;
  889.       if (level != 0)
  890.       {
  891.         nonzero=TRUE;
  892.         if (level > 1)
  893.           *coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  894.         else
  895.           *coeff_cost += COEFF_COST[run];
  896.         img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=sign(level,img->m7[i][j]);
  897.         img->cof[pos_x][pos_y][scan_pos][1][scan_mode]=run;
  898.         ++scan_pos;
  899.         run=-1;                     // reset zero level counter
  900.         ilev=level*JQ[quant_set][1];
  901.       }
  902.       img->m7[i][j]=sign(ilev,img->m7[i][j]);
  903.     }
  904.     img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=0;  // end of block
  905.   }
  906. #endif
  911.   //     IDCT.
  912.   //     horizontal
  914.   for (j=0; j < BLOCK_SIZE; j++)
  915.   {
  916.     for (i=0; i < BLOCK_SIZE; i++)
  917.     {
  918.       m5[i]=img->m7[i][j];
  919.     }
  920.     m6[0]=(m5[0]+m5[2])*13;
  921.     m6[1]=(m5[0]-m5[2])*13;
  922.     m6[2]=m5[1]*7-m5[3]*17;
  923.     m6[3]=m5[1]*17+m5[3]*7;
  925.     for (i=0; i < 2; i++)
  926.     {
  927.       i1=3-i;
  928.       img->m7[i][j]=m6[i]+m6[i1];
  929.       img->m7[i1][j]=m6[i]-m6[i1];
  930.     }
  931.   }
  933.   //  vertical
  935.   for (i=0; i < BLOCK_SIZE; i++)
  936.   {
  937.     for (j=0; j < BLOCK_SIZE; j++)
  938.     {
  939.       m5[j]=img->m7[i][j];
  940.     }
  941.     m6[0]=(m5[0]+m5[2])*13;
  942.     m6[1]=(m5[0]-m5[2])*13;
  943.     m6[2]=m5[1]*7-m5[3]*17;
  944.     m6[3]=m5[1]*17+m5[3]*7;
  946.     for (j=0; j < 2; j++)
  947.     {
  948.       j1=3-j;
  949.       img->m7[i][j] =min(255,max(0,(m6[j]+m6[j1]+img->mpr[i+block_x][j+block_y] *JQQ1+JQQ2)/JQQ1));
  950.       img->m7[i][j1]=min(255,max(0,(m6[j]-m6[j1]+img->mpr[i+block_x][j1+block_y] *JQQ1+JQQ2)/JQQ1));
  951.     }
  952.   }
  954.   //  Decoded block moved to frame memory
  956.   for (j=0; j < BLOCK_SIZE; j++)
  957.     for (i=0; i < BLOCK_SIZE; i++)
  958.       imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=img->m7[i][j];
  961.   return nonzero;
  962. }
  964. /*!
  965.  ************************************************************************
  966.  * brief
  967.  *    Transform,quantization,inverse transform for chroma.
  968.  *    The main reason why this is done in a separate routine is the
  969.  *    additional 2x2 transform of DC-coeffs. This routine is called
  970.  *    ones for each of the chroma components.
  971.  *
  972.  * para Input:
  973.  *    uv    : Make difference between the U and V chroma component  n
  974.  *    cr_cbp: chroma coded block pattern
  975.  *
  976.  * para Output:
  977.  *    cr_cbp: Updated chroma coded block pattern.
  978.  ************************************************************************
  979.  */
  980. #ifndef NO_RDQUANT
  982. int dct_chroma(int uv,int cr_cbp)
  983. {
  984.   int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,qp_const,pos_x,pos_y,quant_set,level ,scan_pos,run;
  985.   int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
  986.   int coeff[16];
  988.   if (img->type == INTRA_IMG)
  989.     qp_const=JQQ3;
  990.   else
  991.     qp_const=JQQ4;
  993.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  994.   {
  995.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  996.     {
  998.       //  Horizontal transform.
  999.       for (j=0; j < BLOCK_SIZE; j++)
  1000.       {
  1001.         mb_y=n2+j;
  1002.         for (i=0; i < 2; i++)
  1003.         {
  1004.           i1=3-i;
  1005.           m5[i]=img->m7[i+n1][mb_y]+img->m7[i1+n1][mb_y];
  1006.           m5[i1]=img->m7[i+n1][mb_y]-img->m7[i1+n1][mb_y];
  1007.         }
  1008.         img->m7[n1][mb_y]=(m5[0]+m5[1])*13;
  1009.         img->m7[n1+2][mb_y]=(m5[0]-m5[1])*13;
  1010.         img->m7[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  1011.         img->m7[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  1012.       }
  1014.       //  Vertical transform.
  1016.       for (i=0; i < BLOCK_SIZE; i++)
  1017.       {
  1018.         j1=n1+i;
  1019.         for (j=0; j < 2; j++)
  1020.         {
  1021.           j2=3-j;
  1022.           m5[j]=img->m7[j1][n2+j]+img->m7[j1][n2+j2];
  1023.           m5[j2]=img->m7[j1][n2+j]-img->m7[j1][n2+j2];
  1024.         }
  1025.         img->m7[j1][n2+0]=(m5[0]+m5[1])*13;
  1026.         img->m7[j1][n2+2]=(m5[0]-m5[1])*13;
  1027.         img->m7[j1][n2+1]=m5[3]*17+m5[2]*7;
  1028.         img->m7[j1][n2+3]=m5[3]*7-m5[2]*17;
  1029.       }
  1030.     }
  1031.   }
  1033.   //     2X2 transform of DC coeffs.
  1034.   m1[0]=(img->m7[0][0]+img->m7[4][0]+img->m7[0][4]+img->m7[4][4])/2;
  1035.   m1[1]=(img->m7[0][0]-img->m7[4][0]+img->m7[0][4]-img->m7[4][4])/2;
  1036.   m1[2]=(img->m7[0][0]+img->m7[4][0]-img->m7[0][4]-img->m7[4][4])/2;
  1037.   m1[3]=(img->m7[0][0]-img->m7[4][0]-img->m7[0][4]+img->m7[4][4])/2;
  1039.   //     Quant of chroma 2X2 coeffs.
  1040.   quant_set=QP_SCALE_CR[img->qp];
  1041.   run=-1;
  1042.   scan_pos=0;
  1044.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  1045.     coeff[coeff_ctr]=m1[coeff_ctr];
  1047.   rd_quant(QUANT_CHROMA_DC,coeff);
  1049.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  1050.   {
  1051.     run++;
  1052.     ilev=0;
  1053.     level =0;
  1055.     level =(absm(coeff[coeff_ctr]));
  1056.     if (level  != 0)
  1057.     {
  1058.       currMB->cbp_blk |= 0xf0000 << (uv << 2) ;  // if one of the 2x2-DC levels is != 0 the coded-bit
  1059.       cr_cbp=max(1,cr_cbp);                      // for all 4 4x4 blocks is set (bit 16-19 or 20-23)
  1060.       img->cofu[scan_pos][0][uv]=sign(level ,m1[coeff_ctr]);
  1061.       img->cofu[scan_pos][1][uv]=run;
  1062.       scan_pos++;
  1063.       run=-1;
  1064.       ilev=level*JQ[quant_set][1];
  1065.     }
  1066.     m1[coeff_ctr]=sign(ilev,m1[coeff_ctr]);
  1067.   }
  1069.   img->cofu[scan_pos][0][uv]=0;
  1071.   //  Invers transform of 2x2 DC levels
  1073.   img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
  1074.   img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
  1075.   img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
  1076.   img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;
  1078.   //     Quant of chroma AC-coeffs.
  1080.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1081.   {
  1082.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1083.     {
  1084.       pos_x=n1/BLOCK_SIZE + 2*uv;
  1085.       pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
  1086.       run=-1;
  1087.       scan_pos=0;
  1089.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
  1090.       {
  1091.         i=SNGL_SCAN[coeff_ctr][0];
  1092.         j=SNGL_SCAN[coeff_ctr][1];
  1093.         coeff[coeff_ctr-1]=img->m7[n1+i][n2+j];
  1094.       }
  1095.       rd_quant(QUANT_CHROMA_AC,coeff);
  1097.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
  1098.       {
  1099.         i=SNGL_SCAN[coeff_ctr][0];
  1100.         j=SNGL_SCAN[coeff_ctr][1];
  1101.         ++run;
  1102.         ilev=0;
  1104.         level=absm(coeff[coeff_ctr-1]);
  1105.         if (level  != 0)
  1106.         {
  1107.           currMB->cbp_blk |=  1 << (16 + (uv << 2) + ((n2 >> 1) + (n1 >> 2))) ;
  1108.           cr_cbp = 2;
  1109.           img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,img->m7[n1+i][n2+j]);
  1110.           img->cof[pos_x][pos_y][scan_pos][1][0]=run;
  1111.           ++scan_pos;
  1112.           run=-1;
  1113.           ilev=level*JQ[quant_set][1];
  1114.         }
  1115.         img->m7[n1+i][n2+j]=sign(ilev,img->m7[n1+i][n2+j]); // for use in IDCT
  1116.       }
  1117.       img->cof[pos_x][pos_y][scan_pos][0][0]=0; // EOB
  1120.       //     IDCT.
  1122.       //     Horizontal.
  1123.       for (j=0; j < BLOCK_SIZE; j++)
  1124.       {
  1125.         for (i=0; i < BLOCK_SIZE; i++)
  1126.         {
  1127.           m5[i]=img->m7[n1+i][n2+j];
  1128.         }
  1129.         m6[0]=(m5[0]+m5[2])*13;
  1130.         m6[1]=(m5[0]-m5[2])*13;
  1131.         m6[2]=m5[1]*7-m5[3]*17;
  1132.         m6[3]=m5[1]*17+m5[3]*7;
  1134.         for (i=0; i < 2; i++)
  1135.         {
  1136.           i1=3-i;
  1137.           img->m7[n1+i][n2+j]=m6[i]+m6[i1];
  1138.           img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
  1139.         }
  1140.       }
  1142.       //     Vertical.
  1143.       for (i=0; i < BLOCK_SIZE; i++)
  1144.       {
  1145.         for (j=0; j < BLOCK_SIZE; j++)
  1146.         {
  1147.           m5[j]=img->m7[n1+i][n2+j];
  1148.         }
  1149.         m6[0]=(m5[0]+m5[2])*13;
  1150.         m6[1]=(m5[0]-m5[2])*13;
  1151.         m6[2]=m5[1]*7-m5[3]*17;
  1152.         m6[3]=m5[1]*17+m5[3]*7;
  1154.         for (j=0; j < 2; j++)
  1155.         {
  1156.           j2=3-j;
  1157.           img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+img->mpr[n1+i][n2+j]*JQQ1+JQQ2)/JQQ1));
  1158.           img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+img->mpr[n1+i][n2+j2]*JQQ1+JQQ2)/JQQ1));
  1159.         }
  1160.       }
  1161.     }
  1162.   }
  1164.   //  Decoded block moved to memory
  1165.   for (j=0; j < BLOCK_SIZE*2; j++)
  1166.     for (i=0; i < BLOCK_SIZE*2; i++)
  1167.     {
  1168.       imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
  1169.     }
  1171.   return cr_cbp;
  1172. }
  1173. #endif
  1175. //************************************************************************
  1177. #ifdef NO_RDQUANT
  1178. int dct_chroma(int uv,int cr_cbp)
  1179. {
  1180.   int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,qp_const,pos_x,pos_y,quant_set,level ,scan_pos,run;
  1181.   int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
  1182. // int coeff[16];
  1183.   int coeff_cost;
  1184.   int cr_cbp_tmp;
  1185.   int nn0,nn1;
  1186.   int DCcoded=0 ;
  1187.   Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  1189.   if (img->type == INTRA_IMG)
  1190.     qp_const=JQQ3;
  1191.   else
  1192.     qp_const=JQQ4;
  1194.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1195.   {
  1196.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1197.     {
  1199.       //  Horizontal transform.
  1200.       for (j=0; j < BLOCK_SIZE; j++)
  1201.       {
  1202.         mb_y=n2+j;
  1203.         for (i=0; i < 2; i++)
  1204.         {
  1205.           i1=3-i;
  1206.           m5[i]=img->m7[i+n1][mb_y]+img->m7[i1+n1][mb_y];
  1207.           m5[i1]=img->m7[i+n1][mb_y]-img->m7[i1+n1][mb_y];
  1208.         }
  1209.         img->m7[n1][mb_y]=(m5[0]+m5[1])*13;
  1210.         img->m7[n1+2][mb_y]=(m5[0]-m5[1])*13;
  1211.         img->m7[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  1212.         img->m7[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  1213.       }
  1215.       //  Vertical transform.
  1217.       for (i=0; i < BLOCK_SIZE; i++)
  1218.       {
  1219.         j1=n1+i;
  1220.         for (j=0; j < 2; j++)
  1221.         {
  1222.           j2=3-j;
  1223.           m5[j]=img->m7[j1][n2+j]+img->m7[j1][n2+j2];
  1224.           m5[j2]=img->m7[j1][n2+j]-img->m7[j1][n2+j2];
  1225.         }
  1226.         img->m7[j1][n2+0]=(m5[0]+m5[1])*13;
  1227.         img->m7[j1][n2+2]=(m5[0]-m5[1])*13;
  1228.         img->m7[j1][n2+1]=m5[3]*17+m5[2]*7;
  1229.         img->m7[j1][n2+3]=m5[3]*7-m5[2]*17;
  1230.       }
  1231.     }
  1232.   }
  1234.   //     2X2 transform of DC coeffs.
  1235.   m1[0]=(img->m7[0][0]+img->m7[4][0]+img->m7[0][4]+img->m7[4][4])/2;
  1236.   m1[1]=(img->m7[0][0]-img->m7[4][0]+img->m7[0][4]-img->m7[4][4])/2;
  1237.   m1[2]=(img->m7[0][0]+img->m7[4][0]-img->m7[0][4]-img->m7[4][4])/2;
  1238.   m1[3]=(img->m7[0][0]-img->m7[4][0]-img->m7[0][4]+img->m7[4][4])/2;
  1240. //     Quant of chroma 2X2 coeffs.
  1241.   quant_set=QP_SCALE_CR[img->qp];
  1242.   run=-1;
  1243.   scan_pos=0;
  1245.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  1246.   {
  1247.     run++;
  1248.     ilev=0;
  1250.     level =(abs(m1[coeff_ctr])*JQ[quant_set][0]+qp_const)/JQQ1;// CHANGE rd_quant removed
  1251.     if (level  != 0)
  1252.     {
  1253.       currMB->cbp_blk |= 0xf0000 << (uv << 2) ;    // if one of the 2x2-DC levels is != 0 set the
  1254.       cr_cbp=max(1,cr_cbp);                     // coded-bit all 4 4x4 blocks (bit 16-19 or 20-23)
  1255.       DCcoded = 1 ;
  1256.       img->cofu[scan_pos][0][uv]=sign(level ,m1[coeff_ctr]);
  1257.       img->cofu[scan_pos][1][uv]=run;
  1258.       scan_pos++;
  1259.       run=-1;
  1260.       ilev=level*JQ[quant_set][1];
  1261.     }
  1262.     m1[coeff_ctr]=sign(ilev,m1[coeff_ctr]);
  1263.   }
  1264.   img->cofu[scan_pos][0][uv]=0;
  1266.   //  Invers transform of 2x2 DC levels
  1268.   img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
  1269.   img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
  1270.   img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
  1271.   img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;
  1273.   //     Quant of chroma AC-coeffs.
  1274.   coeff_cost=0;
  1275.   cr_cbp_tmp=0;
  1277.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1278.   {
  1279.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1280.     {
  1281.       pos_x=n1/BLOCK_SIZE + 2*uv;
  1282.       pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
  1283.       run=-1;
  1284.       scan_pos=0;
  1286.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// start change rd_quant
  1287.       {
  1288.         i = SNGL_SCAN[coeff_ctr][0];
  1289.         j = SNGL_SCAN[coeff_ctr][1];
  1290.         ++run;
  1291.         ilev=0;
  1293.         level=(abs(img->m7[n1+i][n2+j])*JQ[quant_set][0]+qp_const)/JQQ1;// CHANGE rd_quant removed
  1294.         if (level  != 0)
  1295.         {
  1296.           currMB->cbp_blk |= 1 << (16 + (uv << 2) + ((n2 >> 1) + (n1 >> 2))) ;
  1297.           if (level > 1)
  1298.             coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  1299.           else
  1300.             coeff_cost += COEFF_COST[run];
  1302.           cr_cbp_tmp=2;
  1303.           img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,img->m7[n1+i][n2+j]);
  1304.           img->cof[pos_x][pos_y][scan_pos][1][0]=run;
  1305.           ++scan_pos;
  1306.           run=-1;
  1307.           ilev=level*JQ[quant_set][1];
  1308.         }
  1309.         img->m7[n1+i][n2+j]=sign(ilev,img->m7[n1+i][n2+j]); // for use in IDCT
  1310.       }
  1311.       img->cof[pos_x][pos_y][scan_pos][0][0]=0; // EOB
  1312.     }
  1313.   }
  1315.   // * reset chroma coeffs
  1316.   if(coeff_cost<7)
  1317.   {
  1318.     cr_cbp_tmp = 0 ;
  1319.     for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1320.     {
  1321.       for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1322.       {
  1323.         if( DCcoded == 0)                                   // if no chroma DC's: then reset
  1324.          currMB->cbp_blk &= ~(0xf0000 << (uv << 2)) ; // coded-bits of this chroma subblock
  1325.         nn0 = (n1>>2) + (uv<<1);
  1326.         nn1 = 4 + (n2>>2) ;
  1327.         img->cof[nn0][nn1][0][0][0] = 0;// dc coeff
  1328.         for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// ac coeff
  1329.         {
  1330.           i=SNGL_SCAN[coeff_ctr][0];
  1331.           j=SNGL_SCAN[coeff_ctr][1];
  1332.           img->m7[n1+i][n2+j]=0;
  1333.           img->cof[nn0][nn1][coeff_ctr][0][0]=0;
  1334.         }
  1335.       }
  1336.     }
  1337.   }
  1338.   if(cr_cbp_tmp==2)
  1339.       cr_cbp = 2;
  1340.   //     IDCT.
  1342.       //     Horizontal.
  1343.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1344.   {
  1345.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1346.     {
  1347.       for (j=0; j < BLOCK_SIZE; j++)
  1348.       {
  1349.         for (i=0; i < BLOCK_SIZE; i++)
  1350.         {
  1351.           m5[i]=img->m7[n1+i][n2+j];
  1352.         }
  1353.         m6[0]=(m5[0]+m5[2])*13;
  1354.         m6[1]=(m5[0]-m5[2])*13;
  1355.         m6[2]=m5[1]*7-m5[3]*17;
  1356.         m6[3]=m5[1]*17+m5[3]*7;
  1358.         for (i=0; i < 2; i++)
  1359.         {
  1360.           i1=3-i;
  1361.           img->m7[n1+i][n2+j]=m6[i]+m6[i1];
  1362.           img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
  1363.         }
  1364.       }
  1366.       //     Vertical.
  1367.       for (i=0; i < BLOCK_SIZE; i++)
  1368.       {
  1369.         for (j=0; j < BLOCK_SIZE; j++)
  1370.         {
  1371.           m5[j]=img->m7[n1+i][n2+j];
  1372.         }
  1373.         m6[0]=(m5[0]+m5[2])*13;
  1374.         m6[1]=(m5[0]-m5[2])*13;
  1375.         m6[2]=m5[1]*7-m5[3]*17;
  1376.         m6[3]=m5[1]*17+m5[3]*7;
  1378.         for (j=0; j < 2; j++)
  1379.         {
  1380.           j2=3-j;
  1381.           img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+img->mpr[n1+i][n2+j]*JQQ1+JQQ2)/JQQ1));
  1382.           img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+img->mpr[n1+i][n2+j2]*JQQ1+JQQ2)/JQQ1));
  1383.         }
  1384.       }
  1385.     }
  1386.   }
  1388.   //  Decoded block moved to memory
  1389.   for (j=0; j < BLOCK_SIZE*2; j++)
  1390.     for (i=0; i < BLOCK_SIZE*2; i++)
  1391.       imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
  1393.   return cr_cbp;
  1394. }
  1397. #endif
  1402. void rd_quant(int scan_type,int *coeff)
  1403. {
  1404.   int idx,coeff_ctr;
  1405.   int qp_const,intra_add;
  1407.   int dbl_coeff_ctr;
  1408.   int level0,level1;
  1409.   int snr0;
  1410.   int dbl_coeff,k,k1,k2,rd_best,best_coeff_comb,rd_curr,snr1;
  1411.   int k0;
  1412.   int quant_set;
  1413.   int ilev,run,level;
  1414.   int no_coeff;
  1416.   if (img->type == INTRA_IMG)
  1417.   {
  1418.     qp_const=JQQ3;
  1419.     intra_add=2;
  1420.   }
  1421.   else
  1422.   {
  1423.     qp_const=JQQ4;
  1424.     intra_add=0;
  1425.   }
  1426.   quant_set=img->qp;
  1428.   switch (scan_type)
  1429.   {
  1430.   case  QUANT_LUMA_SNG:
  1431.     quant_set=img->qp;
  1432.     idx=2;
  1433.     no_coeff=16;
  1434.     break;
  1435.   case  QUANT_LUMA_AC:
  1436.     quant_set=img->qp;
  1437.     idx=2;
  1438.     no_coeff=15;
  1439.     break;
  1440.   case QUANT_LUMA_DBL:
  1441.     quant_set=img->qp;
  1442.     idx=1;
  1443.     no_coeff=8;
  1444.     break;
  1445.   case QUANT_CHROMA_DC:
  1446.     quant_set=QP_SCALE_CR[img->qp];
  1447.     idx=0;
  1448.     no_coeff=4;
  1449.     break;
  1450.   case QUANT_CHROMA_AC:
  1451.     quant_set=QP_SCALE_CR[img->qp];
  1452.     idx=2;
  1453.     no_coeff=15;
  1454.     break;
  1455.   default:
  1456.     error("rd_quant: unsupported scan_type", 600);
  1457.     break;
  1458.   }
  1460.   dbl_coeff_ctr=0;
  1461.   for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
  1462.   {
  1463.     k0=coeff[coeff_ctr];
  1464.     k1=abs(k0);
  1466.     if (dbl_coeff_ctr < MAX_TWO_LEVEL_COEFF)  // limit the number of 'twin' levels
  1467.     {
  1468.       level0 = (k0*JQ[quant_set][0])/J20;
  1469.       level1 = (k1*JQ[quant_set][0]+JQ4)/J20; // make positive summation
  1470.       level1 = sign(level1,k0);// set back sign on level
  1471.     }
  1472.     else
  1473.     {
  1474.       level0 = (k1*JQ[quant_set][0]+qp_const)/J20;
  1475.       level0 = sign(level0,k0);
  1476.       level1 = level0;
  1477.     }
  1479.     if (level0 != level1)
  1480.     {
  1481.       dbl_coeff = TRUE;     // decision is still open
  1482.       dbl_coeff_ctr++;      // count number of coefficients with 2 possible levels
  1483.     }
  1484.     else
  1485.       dbl_coeff = FALSE;    // level is decided
  1488.     snr0 = (12+intra_add)*level0*(64*level0 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13); // find SNR improvement
  1490.     level_arr[coeff_ctr][MTLC_POW]=0; // indicates that all coefficients are decided
  1492.     for (k=0; k< MTLC_POW; k++)
  1493.     {
  1494.       level_arr[coeff_ctr][k]=level0;
  1495.       snr_arr[coeff_ctr][k]=snr0;
  1496.     }
  1497.     if (dbl_coeff)
  1498.     {
  1499.       snr1 = (12+intra_add)*level1*(64*level1 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13);
  1500.       ilev= (int)pow(2,dbl_coeff_ctr-1);
  1501.       for (k1=ilev; k1<MTLC_POW; k1+=ilev*2)
  1502.       {
  1503.         for (k2=k1; k2<k1+ilev; k2++)
  1504.         {
  1505.           level_arr[coeff_ctr][k2]=level1;
  1506.           snr_arr[coeff_ctr][k2]=snr1;
  1507.         }
  1508.       }
  1509.     }
  1510.   }
  1512.   rd_best=0;
  1513.   best_coeff_comb= MTLC_POW;      // initial setting, used if no double decision coefficients
  1514.   for (k=0; k < pow(2,dbl_coeff_ctr);k++) // go through all combinations
  1515.   {
  1516.     rd_curr=0;
  1517.     run=-1;
  1518.     for (coeff_ctr=0;coeff_ctr < no_coeff;coeff_ctr++)
  1519.     {
  1520.       run++;
  1521.       level=min(16,absm(level_arr[coeff_ctr][k]));
  1522.       if (level != 0)
  1523.       {
  1524.         rd_curr += 64*COEFF_BIT_COST[idx][run][level-1]+snr_arr[coeff_ctr][k];
  1525.         run = -1;
  1526.       }
  1527.     }
  1528.     if (rd_curr < rd_best)
  1529.     {
  1530.       rd_best=rd_curr;
  1531.       best_coeff_comb=k;
  1532.     }
  1533.   }
  1534.   for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
  1535.     coeff[coeff_ctr]=level_arr[coeff_ctr][best_coeff_comb];
  1537.   return;
  1538. }
  1540. /*!
  1541.  ************************************************************************
  1542.  * brief
  1543.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  1544.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  1545.  *    RD constrained quantization also.
  1546.  *
  1547.  * para Input:
  1548.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  1549.  *
  1550.  * para Output:
  1551.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.              n
  1552.  *    coeff_cost: Counter for nonzero coefficients, used to discard expencive levels.
  1553.  *
  1554.  *
  1555. ************************************************************************/
  1556. #ifndef NO_RDQUANT
  1557. int dct_luma_sp(int block_x,int block_y,int *coeff_cost)
  1558. {
  1559.   int sign(int a,int b);
  1561.   int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr,scan_loop_ctr;
  1562.   int pos_x,pos_y,quant_set,level,scan_pos,run;
  1563.   int nonzero;
  1564.   int idx;
  1566.   int scan_mode;
  1567.   int loop_rep;
  1568.   int predicted_block[BLOCK_SIZE][BLOCK_SIZE],alpha,quant_set1,Fq1q2;
  1569.   int coeff[16],coeff2[16];
  1571.   pos_x=block_x/BLOCK_SIZE;
  1572.   pos_y=block_y/BLOCK_SIZE;
  1574.   //  Horizontal transform
  1575.   for (j=0; j< BLOCK_SIZE; j++)
  1576.     for (i=0; i< BLOCK_SIZE; i++)
  1577.     {
  1578.       img->m7[i][j]+=img->mpr[i+block_x][j+block_y];
  1579.       predicted_block[i][j]=img->mpr[i+block_x][j+block_y];
  1580.     }
  1582.   for (j=0; j < BLOCK_SIZE; j++)
  1583.   {
  1584.     for (i=0; i < 2; i++)
  1585.     {
  1586.       i1=3-i;
  1587.       m5[i]=img->m7[i][j]+img->m7[i1][j];
  1588.       m5[i1]=img->m7[i][j]-img->m7[i1][j];
  1589.     }
  1590.     img->m7[0][j]=(m5[0]+m5[1])*13;
  1591.     img->m7[2][j]=(m5[0]-m5[1])*13;
  1592.     img->m7[1][j]=m5[3]*17+m5[2]*7;
  1593.     img->m7[3][j]=m5[3]*7-m5[2]*17;
  1594.   }
  1596.   //  Vertival transform
  1598.   for (i=0; i < BLOCK_SIZE; i++)
  1599.   {
  1600.     for (j=0; j < 2; j++)
  1601.     {
  1602.       j1=3-j;
  1603.       m5[j]=img->m7[i][j]+img->m7[i][j1];
  1604.       m5[j1]=img->m7[i][j]-img->m7[i][j1];
  1605.     }
  1606.     img->m7[i][0]=(m5[0]+m5[1])*13;
  1607.     img->m7[i][2]=(m5[0]-m5[1])*13;
  1608.     img->m7[i][1]=m5[3]*17+m5[2]*7;
  1609.     img->m7[i][3]=m5[3]*7-m5[2]*17;
  1610.   }
  1612.   for (j=0; j < BLOCK_SIZE; j++)
  1613.   {
  1614.     for (i=0; i < 2; i++)
  1615.     {
  1616.       i1=3-i;
  1617.       m5[i]=predicted_block[i][j]+predicted_block[i1][j];
  1618.       m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
  1619.     }
  1620.     predicted_block[0][j]=(m5[0]+m5[1])*13;
  1621.     predicted_block[2][j]=(m5[0]-m5[1])*13;
  1622.     predicted_block[1][j]=m5[3]*17+m5[2]*7;
  1623.     predicted_block[3][j]=m5[3]*7-m5[2]*17;
  1624.   }
  1626.   //  Vertival transform
  1628.   for (i=0; i < BLOCK_SIZE; i++)
  1629.   {
  1630.     for (j=0; j < 2; j++)
  1631.     {
  1632.       j1=3-j;
  1633.       m5[j]=predicted_block[i][j]+predicted_block[i][j1];
  1634.       m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
  1635.     }
  1636.     predicted_block[i][0]=(m5[0]+m5[1])*13;
  1637.     predicted_block[i][2]=(m5[0]-m5[1])*13;
  1638.     predicted_block[i][1]=m5[3]*17+m5[2]*7;
  1639.     predicted_block[i][3]=m5[3]*7-m5[2]*17;
  1640.   }
  1642.   // Quant
  1644.   quant_set=img->qp;
  1645.   quant_set1=img->qpsp;
  1646.   alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
  1647.   Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
  1648.   nonzero=FALSE;
  1650.     scan_mode=SINGLE_SCAN;
  1651.     loop_rep=1;
  1652.     idx=0;
  1654.   for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
  1655.   {
  1656.     for (coeff_ctr=0;coeff_ctr < 16/loop_rep;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  1657.     {
  1658.       if (scan_mode==DOUBLE_SCAN)
  1659.       {
  1660.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  1661.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  1662.       }
  1663.       else
  1664.       {
  1665.         i=SNGL_SCAN[coeff_ctr][0];
  1666.         j=SNGL_SCAN[coeff_ctr][1];
  1667.       }
  1668.       coeff[coeff_ctr]=img->m7[i][j];
  1669.       coeff2[coeff_ctr]=(img->m7[i][j]-sign(((abs (predicted_block[i][j]) * JQ[quant_set1][0] +JQQ2) / JQQ1),predicted_block[i][j])*alpha);
  1670.     }
  1671.     rd_quant(QUANT_LUMA_SNG,coeff2);
  1673.     run=-1;
  1674.     scan_pos=scan_loop_ctr*9;   // for double scan; set first or second scan posision
  1675.     for (coeff_ctr=0; coeff_ctr<16/loop_rep; coeff_ctr++)
  1676.     {
  1677.       if (scan_mode==DOUBLE_SCAN)
  1678.       {
  1679.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  1680.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  1681.       }
  1682.       else
  1683.       {
  1684.         i=SNGL_SCAN[coeff_ctr][0];
  1685.         j=SNGL_SCAN[coeff_ctr][1];
  1686.       }
  1687.       run++;
  1688.       ilev=0;
  1690.       level= absm(coeff2[coeff_ctr]);
  1691.       if (level != 0)
  1692.       {
  1693.         nonzero=TRUE;
  1694.         if (level > 1)
  1695.           *coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  1696.         else
  1697.           *coeff_cost += COEFF_COST[run];
  1698.         img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=sign(level,coeff2[coeff_ctr]);
  1699.         img->cof[pos_x][pos_y][scan_pos][1][scan_mode]=run;
  1700.         ++scan_pos;
  1701.         run=-1;                     // reset zero level counter
  1702.         ilev=level;
  1703.       }
  1704.       ilev=coeff2[coeff_ctr]*Fq1q2+predicted_block[i][j]*JQ[quant_set1][0];
  1705.       img->m7[i][j]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
  1706.     }
  1707.     img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=0;  // end of block
  1708.   }
  1710.   //     IDCT.
  1711.   //     horizontal
  1713.   for (j=0; j < BLOCK_SIZE; j++)
  1714.   {
  1715.     for (i=0; i < BLOCK_SIZE; i++)
  1716.     {
  1717.       m5[i]=img->m7[i][j];
  1718.     }
  1719.     m6[0]=(m5[0]+m5[2])*13;
  1720.     m6[1]=(m5[0]-m5[2])*13;
  1721.     m6[2]=m5[1]*7-m5[3]*17;
  1722.     m6[3]=m5[1]*17+m5[3]*7;
  1724.     for (i=0; i < 2; i++)
  1725.     {
  1726.       i1=3-i;
  1727.       img->m7[i][j]=m6[i]+m6[i1];
  1728.       img->m7[i1][j]=m6[i]-m6[i1];
  1729.     }
  1730.   }
  1732.   //  vertical
  1734.   for (i=0; i < BLOCK_SIZE; i++)
  1735.   {
  1736.     for (j=0; j < BLOCK_SIZE; j++)
  1737.     {
  1738.       m5[j]=img->m7[i][j];
  1739.     }
  1740.     m6[0]=(m5[0]+m5[2])*13;
  1741.     m6[1]=(m5[0]-m5[2])*13;
  1742.     m6[2]=m5[1]*7-m5[3]*17;
  1743.     m6[3]=m5[1]*17+m5[3]*7;
  1745.     for (j=0; j < 2; j++)
  1746.     {
  1747.       j1=3-j;
  1748.       img->m7[i][j] =min(255,max(0,(m6[j]+m6[j1]+JQQ2)/JQQ1));
  1749.       img->m7[i][j1]=min(255,max(0,(m6[j]-m6[j1]+JQQ2)/JQQ1));
  1750.     }
  1751.   }
  1753.   //  Decoded block moved to frame memory
  1755.   for (j=0; j < BLOCK_SIZE; j++)
  1756.     for (i=0; i < BLOCK_SIZE; i++)
  1757.       imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=img->m7[i][j];
  1760.   return nonzero;
  1761. }
  1762. #endif
  1763. #ifdef NO_RDQUANT
  1764. int dct_luma_sp(int block_x,int block_y,int *coeff_cost)
  1765. {
  1766.   int sign(int a,int b);
  1768.   int i,j,i1,j1,ilev,m5[4],m6[4],coeff_ctr,scan_loop_ctr;
  1769.   int qp_const,pos_x,pos_y,quant_set,level,scan_pos,run;
  1770.   int nonzero;
  1771.   int idx;
  1773.   int scan_mode;
  1774.   int loop_rep;
  1775.   int predicted_block[BLOCK_SIZE][BLOCK_SIZE],alpha,quant_set1,Fq1q2,c_err;
  1777.   qp_const=JQQ4;    // inter
  1779.   pos_x=block_x/BLOCK_SIZE;
  1780.   pos_y=block_y/BLOCK_SIZE;
  1782.   //  Horizontal transform
  1783.   for (j=0; j< BLOCK_SIZE; j++)
  1784.     for (i=0; i< BLOCK_SIZE; i++)
  1785.     {
  1786.       img->m7[i][j]+=img->mpr[i+block_x][j+block_y];
  1787.       predicted_block[i][j]=img->mpr[i+block_x][j+block_y];
  1788.     }
  1790.   for (j=0; j < BLOCK_SIZE; j++)
  1791.   {
  1792.     for (i=0; i < 2; i++)
  1793.     {
  1794.       i1=3-i;
  1795.       m5[i]=img->m7[i][j]+img->m7[i1][j];
  1796.       m5[i1]=img->m7[i][j]-img->m7[i1][j];
  1797.     }
  1798.     img->m7[0][j]=(m5[0]+m5[1])*13;
  1799.     img->m7[2][j]=(m5[0]-m5[1])*13;
  1800.     img->m7[1][j]=m5[3]*17+m5[2]*7;
  1801.     img->m7[3][j]=m5[3]*7-m5[2]*17;
  1802.   }
  1804.   //  Vertival transform
  1806.   for (i=0; i < BLOCK_SIZE; i++)
  1807.   {
  1808.     for (j=0; j < 2; j++)
  1809.     {
  1810.       j1=3-j;
  1811.       m5[j]=img->m7[i][j]+img->m7[i][j1];
  1812.       m5[j1]=img->m7[i][j]-img->m7[i][j1];
  1813.     }
  1814.     img->m7[i][0]=(m5[0]+m5[1])*13;
  1815.     img->m7[i][2]=(m5[0]-m5[1])*13;
  1816.     img->m7[i][1]=m5[3]*17+m5[2]*7;
  1817.     img->m7[i][3]=m5[3]*7-m5[2]*17;
  1818.   }
  1820.   for (j=0; j < BLOCK_SIZE; j++)
  1821.   {
  1822.     for (i=0; i < 2; i++)
  1823.     {
  1824.       i1=3-i;
  1825.       m5[i]=predicted_block[i][j]+predicted_block[i1][j];
  1826.       m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
  1827.     }
  1828.     predicted_block[0][j]=(m5[0]+m5[1])*13;
  1829.     predicted_block[2][j]=(m5[0]-m5[1])*13;
  1830.     predicted_block[1][j]=m5[3]*17+m5[2]*7;
  1831.     predicted_block[3][j]=m5[3]*7-m5[2]*17;
  1832.   }
  1834.   //  Vertival transform
  1836.   for (i=0; i < BLOCK_SIZE; i++)
  1837.   {
  1838.     for (j=0; j < 2; j++)
  1839.     {
  1840.       j1=3-j;
  1841.       m5[j]=predicted_block[i][j]+predicted_block[i][j1];
  1842.       m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
  1843.     }
  1844.     predicted_block[i][0]=(m5[0]+m5[1])*13;
  1845.     predicted_block[i][2]=(m5[0]-m5[1])*13;
  1846.     predicted_block[i][1]=m5[3]*17+m5[2]*7;
  1847.     predicted_block[i][3]=m5[3]*7-m5[2]*17;
  1848.   }
  1850.   // Quant
  1852.   quant_set=img->qp;
  1853.   quant_set1=img->qpsp;
  1854.   alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
  1855.   Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
  1856.   nonzero=FALSE;
  1858.     scan_mode=SINGLE_SCAN;
  1859.     loop_rep=1;
  1860.     idx=0;
  1862.   for(scan_loop_ctr=0;scan_loop_ctr<loop_rep;scan_loop_ctr++) // 2 times if double scan, 1 normal scan
  1863.   {
  1864.   run=-1;
  1865.   scan_pos=scan_loop_ctr*9;
  1867.     for (coeff_ctr=0;coeff_ctr < 16/loop_rep;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  1868.     {
  1869.       if (scan_mode==DOUBLE_SCAN)
  1870.       {
  1871.         i=DBL_SCAN[coeff_ctr][0][scan_loop_ctr];
  1872.         j=DBL_SCAN[coeff_ctr][1][scan_loop_ctr];
  1873.       }
  1874.       else
  1875.       {
  1876.         i=SNGL_SCAN[coeff_ctr][0];
  1877.         j=SNGL_SCAN[coeff_ctr][1];
  1878.       }
  1880.       run++;
  1881.       ilev=0;
  1883.       c_err=img->m7[i][j]-alpha*sign(((abs (predicted_block[i][j]) * JQ[quant_set1][0] +JQQ2) / JQQ1),predicted_block[i][j]);
  1884.       level = (abs (c_err) * JQ[quant_set][0] +qp_const) / JQQ1;
  1885.       if (level != 0)
  1886.       {
  1887.         nonzero=TRUE;
  1888.         if (level > 1)
  1889.           *coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  1890.         else
  1891.           *coeff_cost += COEFF_COST[run];
  1892.         img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=sign(level,c_err);
  1893.         img->cof[pos_x][pos_y][scan_pos][1][scan_mode]=run;
  1894.         ++scan_pos;
  1895.         run=-1;                     // reset zero level counter
  1896.         ilev=level;
  1897.       }
  1898.       ilev=sign(ilev,c_err)*Fq1q2+predicted_block[i][j]*JQ[quant_set1][0];
  1899.       img->m7[i][j]=sign((abs(ilev)+JQQ2)/ JQQ1*JQ[quant_set1][1],ilev);
  1900.     }
  1901.     img->cof[pos_x][pos_y][scan_pos][0][scan_mode]=0;  // end of block
  1902.   }
  1905.   //     IDCT.
  1906.   //     horizontal
  1908.   for (j=0; j < BLOCK_SIZE; j++)
  1909.   {
  1910.     for (i=0; i < BLOCK_SIZE; i++)
  1911.     {
  1912.       m5[i]=img->m7[i][j];
  1913.     }
  1914.     m6[0]=(m5[0]+m5[2])*13;
  1915.     m6[1]=(m5[0]-m5[2])*13;
  1916.     m6[2]=m5[1]*7-m5[3]*17;
  1917.     m6[3]=m5[1]*17+m5[3]*7;
  1919.     for (i=0; i < 2; i++)
  1920.     {
  1921.       i1=3-i;
  1922.       img->m7[i][j]=m6[i]+m6[i1];
  1923.       img->m7[i1][j]=m6[i]-m6[i1];
  1924.     }
  1925.   }
  1927.   //  vertical
  1929.   for (i=0; i < BLOCK_SIZE; i++)
  1930.   {
  1931.     for (j=0; j < BLOCK_SIZE; j++)
  1932.     {
  1933.       m5[j]=img->m7[i][j];
  1934.     }
  1935.     m6[0]=(m5[0]+m5[2])*13;
  1936.     m6[1]=(m5[0]-m5[2])*13;
  1937.     m6[2]=m5[1]*7-m5[3]*17;
  1938.     m6[3]=m5[1]*17+m5[3]*7;
  1940.     for (j=0; j < 2; j++)
  1941.     {
  1942.       j1=3-j;
  1943.       img->m7[i][j] =min(255,max(0,(m6[j]+m6[j1]+JQQ2)/JQQ1));
  1944.       img->m7[i][j1]=min(255,max(0,(m6[j]-m6[j1]+JQQ2)/JQQ1));
  1945.     }
  1946.   }
  1948.   //  Decoded block moved to frame memory
  1950.   for (j=0; j < BLOCK_SIZE; j++)
  1951.     for (i=0; i < BLOCK_SIZE; i++)
  1952.       imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=img->m7[i][j];
  1955.   return nonzero;
  1956. }
  1957. #endif
  1959. /*!
  1960.  ************************************************************************
  1961.  * brief
  1962.  *    Transform,quantization,inverse transform for chroma.
  1963.  *    The main reason why this is done in a separate routine is the
  1964.  *    additional 2x2 transform of DC-coeffs. This routine is called
  1965.  *    ones for each of the chroma components.
  1966.  *
  1967.  * para Input:
  1968.  *    uv    : Make difference between the U and V chroma component               n
  1969.  *    cr_cbp: chroma coded block pattern
  1970.  *
  1971.  * para Output:
  1972.  *    cr_cbp: Updated chroma coded block pattern.
  1973.  ************************************************************************
  1974.  */
  1975. #ifndef NO_RDQUANT
  1976. int dct_chroma_sp(int uv,int cr_cbp)
  1977. {
  1978.   int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,qp_const,pos_x,pos_y,quant_set,level ,scan_pos,run;
  1979.   int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
  1980.   int coeff[16];
  1981.   int predicted_chroma_block[MB_BLOCK_SIZE/2][MB_BLOCK_SIZE/2],alpha,Fq1q2,mp1[BLOCK_SIZE],quant_set1;
  1983.   qp_const=JQQ4;
  1985.   for (j=0; j < MB_BLOCK_SIZE/2; j++)
  1986.     for (i=0; i < MB_BLOCK_SIZE/2; i++)
  1987.     {
  1988.       img->m7[i][j]+=img->mpr[i][j];
  1989.       predicted_chroma_block[i][j]=img->mpr[i][j];
  1990.     }
  1992.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  1993.   {
  1994.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  1995.     {
  1997.       //  Horizontal transform.
  1998.       for (j=0; j < BLOCK_SIZE; j++)
  1999.       {
  2000.         mb_y=n2+j;
  2001.         for (i=0; i < 2; i++)
  2002.         {
  2003.           i1=3-i;
  2004.           m5[i]=img->m7[i+n1][mb_y]+img->m7[i1+n1][mb_y];
  2005.           m5[i1]=img->m7[i+n1][mb_y]-img->m7[i1+n1][mb_y];
  2006.         }
  2007.         img->m7[n1][mb_y]=(m5[0]+m5[1])*13;
  2008.         img->m7[n1+2][mb_y]=(m5[0]-m5[1])*13;
  2009.         img->m7[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  2010.         img->m7[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  2011.       }
  2013.       //  Vertical transform.
  2015.       for (i=0; i < BLOCK_SIZE; i++)
  2016.       {
  2017.         j1=n1+i;
  2018.         for (j=0; j < 2; j++)
  2019.         {
  2020.           j2=3-j;
  2021.           m5[j]=img->m7[j1][n2+j]+img->m7[j1][n2+j2];
  2022.           m5[j2]=img->m7[j1][n2+j]-img->m7[j1][n2+j2];
  2023.         }
  2024.         img->m7[j1][n2+0]=(m5[0]+m5[1])*13;
  2025.         img->m7[j1][n2+2]=(m5[0]-m5[1])*13;
  2026.         img->m7[j1][n2+1]=m5[3]*17+m5[2]*7;
  2027.         img->m7[j1][n2+3]=m5[3]*7-m5[2]*17;
  2028.       }
  2029.     }
  2030.   }
  2032.   //     2X2 transform of DC coeffs.
  2033.   m1[0]=(img->m7[0][0]+img->m7[4][0]+img->m7[0][4]+img->m7[4][4])/2;
  2034.   m1[1]=(img->m7[0][0]-img->m7[4][0]+img->m7[0][4]-img->m7[4][4])/2;
  2035.   m1[2]=(img->m7[0][0]+img->m7[4][0]-img->m7[0][4]-img->m7[4][4])/2;
  2036.   m1[3]=(img->m7[0][0]-img->m7[4][0]-img->m7[0][4]+img->m7[4][4])/2;
  2038.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2039.   {
  2040.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2041.     {
  2043.       //  Horizontal transform.
  2044.       for (j=0; j < BLOCK_SIZE; j++)
  2045.       {
  2046.         mb_y=n2+j;
  2047.         for (i=0; i < 2; i++)
  2048.         {
  2049.           i1=3-i;
  2050.           m5[i]=predicted_chroma_block[i+n1][mb_y]+predicted_chroma_block[i1+n1][mb_y];
  2051.           m5[i1]=predicted_chroma_block[i+n1][mb_y]-predicted_chroma_block[i1+n1][mb_y];
  2052.         }
  2053.         predicted_chroma_block[n1][mb_y]=(m5[0]+m5[1])*13;
  2054.         predicted_chroma_block[n1+2][mb_y]=(m5[0]-m5[1])*13;
  2055.         predicted_chroma_block[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  2056.         predicted_chroma_block[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  2057.       }
  2059.       //  Vertical transform.
  2061.       for (i=0; i < BLOCK_SIZE; i++)
  2062.       {
  2063.         j1=n1+i;
  2064.         for (j=0; j < 2; j++)
  2065.         {
  2066.           j2=3-j;
  2067.           m5[j]=predicted_chroma_block[j1][n2+j]+predicted_chroma_block[j1][n2+j2];
  2068.           m5[j2]=predicted_chroma_block[j1][n2+j]-predicted_chroma_block[j1][n2+j2];
  2069.         }
  2070.         predicted_chroma_block[j1][n2+0]=(m5[0]+m5[1])*13;
  2071.         predicted_chroma_block[j1][n2+2]=(m5[0]-m5[1])*13;
  2072.         predicted_chroma_block[j1][n2+1]=m5[3]*17+m5[2]*7;
  2073.         predicted_chroma_block[j1][n2+3]=m5[3]*7-m5[2]*17;
  2074.       }
  2075.     }
  2076.   }
  2078.   //     2X2 transform of DC coeffs.
  2079.   mp1[0]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]+predicted_chroma_block[0][4]+predicted_chroma_block[4][4])/2;
  2080.   mp1[1]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]+predicted_chroma_block[0][4]-predicted_chroma_block[4][4])/2;
  2081.   mp1[2]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]-predicted_chroma_block[0][4]-predicted_chroma_block[4][4])/2;
  2082.   mp1[3]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]-predicted_chroma_block[0][4]+predicted_chroma_block[4][4])/2;
  2084.   //     Quant of chroma 2X2 coeffs.
  2085.   quant_set=QP_SCALE_CR[img->qp];
  2086.   quant_set1=QP_SCALE_CR[img->qpsp];
  2087.   alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
  2088.   Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
  2090.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  2091.     coeff[coeff_ctr]=m1[coeff_ctr]-alpha*sign((abs (mp1[coeff_ctr]) * JQ[quant_set1][0] +JQQ2) / JQQ1,mp1[coeff_ctr]);
  2092.   rd_quant(QUANT_CHROMA_DC,coeff);
  2094.   run=-1;
  2095.   scan_pos=0;
  2097.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  2098.   {
  2099.     run++;
  2100.     ilev=0;
  2101.     level =0;
  2103.     level =(absm(coeff[coeff_ctr]));
  2104.     if (level  != 0)
  2105.     {
  2106.       cr_cbp=max(1,cr_cbp);
  2107.       img->cofu[scan_pos][0][uv]=sign(level ,coeff[coeff_ctr]);
  2108.       img->cofu[scan_pos][1][uv]=run;
  2109.       scan_pos++;
  2110.       run=-1;
  2111.       ilev=level;
  2112.     }
  2113.       ilev=coeff[coeff_ctr]*Fq1q2+mp1[coeff_ctr]*JQ[quant_set1][0];
  2114.       m1[coeff_ctr]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
  2115.   }
  2116.   img->cofu[scan_pos][0][uv]=0;
  2118.   //  Invers transform of 2x2 DC levels
  2120.   img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
  2121.   img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
  2122.   img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
  2123.   img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;
  2124.   //     Quant of chroma AC-coeffs.
  2126.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2127.   {
  2128.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2129.     {
  2130.       pos_x=n1/BLOCK_SIZE + 2*uv;
  2131.       pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
  2132.       run=-1;
  2133.       scan_pos=0;
  2135.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
  2136.       {
  2137.         i=SNGL_SCAN[coeff_ctr][0];
  2138.         j=SNGL_SCAN[coeff_ctr][1];
  2139.         coeff[coeff_ctr-1]=img->m7[n1+i][n2+j]-alpha*sign((abs (predicted_chroma_block[n1+i][n2+j]) * JQ[quant_set1][0] +JQQ2) / JQQ1,predicted_chroma_block[n1+i][n2+j]);
  2140.       }
  2141.       rd_quant(QUANT_CHROMA_AC,coeff);
  2143.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
  2144.       {
  2145.         i=SNGL_SCAN[coeff_ctr][0];
  2146.         j=SNGL_SCAN[coeff_ctr][1];
  2147.         ++run;
  2148.         ilev=0;
  2150.         level=absm(coeff[coeff_ctr-1]);
  2151.         if (level  != 0)
  2152.         {
  2153.           cr_cbp=2;
  2154.           img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,coeff[coeff_ctr-1]);
  2155.           img->cof[pos_x][pos_y][scan_pos][1][0]=run;
  2156.           ++scan_pos;
  2157.           run=-1;
  2158.           ilev=level;
  2159.         }
  2160.         ilev=sign(ilev,coeff[coeff_ctr-1])*Fq1q2+predicted_chroma_block[n1+i][n2+j]*JQ[quant_set1][0];
  2161.         img->m7[n1+i][n2+j]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
  2162.       }
  2163.       img->cof[pos_x][pos_y][scan_pos][0][0]=0; // EOB
  2165.       //     IDCT.
  2167.       //     Horizontal.
  2168.       for (j=0; j < BLOCK_SIZE; j++)
  2169.       {
  2170.         for (i=0; i < BLOCK_SIZE; i++)
  2171.         {
  2172.           m5[i]=img->m7[n1+i][n2+j];
  2173.         }
  2174.         m6[0]=(m5[0]+m5[2])*13;
  2175.         m6[1]=(m5[0]-m5[2])*13;
  2176.         m6[2]=m5[1]*7-m5[3]*17;
  2177.         m6[3]=m5[1]*17+m5[3]*7;
  2179.         for (i=0; i < 2; i++)
  2180.         {
  2181.           i1=3-i;
  2182.           img->m7[n1+i][n2+j]=m6[i]+m6[i1];
  2183.           img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
  2184.         }
  2185.       }
  2187.       //     Vertical.
  2188.       for (i=0; i < BLOCK_SIZE; i++)
  2189.       {
  2190.         for (j=0; j < BLOCK_SIZE; j++)
  2191.         {
  2192.           m5[j]=img->m7[n1+i][n2+j];
  2193.         }
  2194.         m6[0]=(m5[0]+m5[2])*13;
  2195.         m6[1]=(m5[0]-m5[2])*13;
  2196.         m6[2]=m5[1]*7-m5[3]*17;
  2197.         m6[3]=m5[1]*17+m5[3]*7;
  2199.         for (j=0; j < 2; j++)
  2200.         {
  2201.           j2=3-j;
  2202.           img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+JQQ2)/JQQ1));
  2203.           img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+JQQ2)/JQQ1));
  2204.         }
  2205.       }
  2206.     }
  2207.   }
  2209.   //  Decoded block moved to memory
  2210.   for (j=0; j < BLOCK_SIZE*2; j++)
  2211.     for (i=0; i < BLOCK_SIZE*2; i++)
  2212.     {
  2213.       imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
  2214.     }
  2216.   return cr_cbp;
  2217. }
  2218. #endif
  2219. #ifdef NO_RDQUANT
  2220. int dct_chroma_sp(int uv,int cr_cbp)
  2221. {
  2222.   int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,qp_const,pos_x,pos_y,quant_set,quant_set1,c_err,level ,scan_pos,run;
  2223.   int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
  2224. // int coeff[16];
  2225.   int coeff_cost;
  2226.   int cr_cbp_tmp;
  2227.   int predicted_chroma_block[MB_BLOCK_SIZE/2][MB_BLOCK_SIZE/2],alpha,Fq1q2,mp1[BLOCK_SIZE];
  2228.   Macroblock *currMB = &img->mb_data[img->current_mb_nr];
  2231.   qp_const=JQQ4;
  2233.   for (j=0; j < MB_BLOCK_SIZE/2; j++)
  2234.         for (i=0; i < MB_BLOCK_SIZE/2; i++)
  2235.         {
  2236.           img->m7[i][j]+=img->mpr[i][j];
  2237.           predicted_chroma_block[i][j]=img->mpr[i][j];
  2238.         }
  2240.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2241.   {
  2242.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2243.     {
  2245.       //  Horizontal transform.
  2246.       for (j=0; j < BLOCK_SIZE; j++)
  2247.       {
  2248.         mb_y=n2+j;
  2249.         for (i=0; i < 2; i++)
  2250.         {
  2251.           i1=3-i;
  2252.           m5[i]=img->m7[i+n1][mb_y]+img->m7[i1+n1][mb_y];
  2253.           m5[i1]=img->m7[i+n1][mb_y]-img->m7[i1+n1][mb_y];
  2254.         }
  2255.         img->m7[n1][mb_y]=(m5[0]+m5[1])*13;
  2256.         img->m7[n1+2][mb_y]=(m5[0]-m5[1])*13;
  2257.         img->m7[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  2258.         img->m7[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  2259.       }
  2261.       //  Vertical transform.
  2263.       for (i=0; i < BLOCK_SIZE; i++)
  2264.       {
  2265.         j1=n1+i;
  2266.         for (j=0; j < 2; j++)
  2267.         {
  2268.           j2=3-j;
  2269.           m5[j]=img->m7[j1][n2+j]+img->m7[j1][n2+j2];
  2270.           m5[j2]=img->m7[j1][n2+j]-img->m7[j1][n2+j2];
  2271.         }
  2272.         img->m7[j1][n2+0]=(m5[0]+m5[1])*13;
  2273.         img->m7[j1][n2+2]=(m5[0]-m5[1])*13;
  2274.         img->m7[j1][n2+1]=m5[3]*17+m5[2]*7;
  2275.         img->m7[j1][n2+3]=m5[3]*7-m5[2]*17;
  2276.       }
  2277.     }
  2278.   }
  2280.   //     2X2 transform of DC coeffs.
  2281.   m1[0]=(img->m7[0][0]+img->m7[4][0]+img->m7[0][4]+img->m7[4][4])/2;
  2282.   m1[1]=(img->m7[0][0]-img->m7[4][0]+img->m7[0][4]-img->m7[4][4])/2;
  2283.   m1[2]=(img->m7[0][0]+img->m7[4][0]-img->m7[0][4]-img->m7[4][4])/2;
  2284.   m1[3]=(img->m7[0][0]-img->m7[4][0]-img->m7[0][4]+img->m7[4][4])/2;
  2286. for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2287.   {
  2288.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2289.     {
  2291.       //  Horizontal transform.
  2292.       for (j=0; j < BLOCK_SIZE; j++)
  2293.       {
  2294.         mb_y=n2+j;
  2295.         for (i=0; i < 2; i++)
  2296.         {
  2297.           i1=3-i;
  2298.           m5[i]=predicted_chroma_block[i+n1][mb_y]+predicted_chroma_block[i1+n1][mb_y];
  2299.           m5[i1]=predicted_chroma_block[i+n1][mb_y]-predicted_chroma_block[i1+n1][mb_y];
  2300.         }
  2301.         predicted_chroma_block[n1][mb_y]=(m5[0]+m5[1])*13;
  2302.         predicted_chroma_block[n1+2][mb_y]=(m5[0]-m5[1])*13;
  2303.         predicted_chroma_block[n1+1][mb_y]=m5[3]*17+m5[2]*7;
  2304.         predicted_chroma_block[n1+3][mb_y]=m5[3]*7-m5[2]*17;
  2305.       }
  2307.       //  Vertical transform.
  2309.       for (i=0; i < BLOCK_SIZE; i++)
  2310.       {
  2311.         j1=n1+i;
  2312.         for (j=0; j < 2; j++)
  2313.         {
  2314.           j2=3-j;
  2315.           m5[j]=predicted_chroma_block[j1][n2+j]+predicted_chroma_block[j1][n2+j2];
  2316.           m5[j2]=predicted_chroma_block[j1][n2+j]-predicted_chroma_block[j1][n2+j2];
  2317.         }
  2318.         predicted_chroma_block[j1][n2+0]=(m5[0]+m5[1])*13;
  2319.         predicted_chroma_block[j1][n2+2]=(m5[0]-m5[1])*13;
  2320.         predicted_chroma_block[j1][n2+1]=m5[3]*17+m5[2]*7;
  2321.         predicted_chroma_block[j1][n2+3]=m5[3]*7-m5[2]*17;
  2322.       }
  2323.     }
  2324.   }
  2326.   //     2X2 transform of DC coeffs.
  2327.   mp1[0]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]+predicted_chroma_block[0][4]+predicted_chroma_block[4][4])/2;
  2328.   mp1[1]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]+predicted_chroma_block[0][4]-predicted_chroma_block[4][4])/2;
  2329.   mp1[2]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]-predicted_chroma_block[0][4]-predicted_chroma_block[4][4])/2;
  2330.   mp1[3]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]-predicted_chroma_block[0][4]+predicted_chroma_block[4][4])/2;
  2332. //     Quant of chroma 2X2 coeffs.
  2333.   quant_set=QP_SCALE_CR[img->qp];
  2334.   quant_set1=QP_SCALE_CR[img->qpsp];
  2335.   alpha=(JQQ1+JQ[quant_set1][0]/2)/JQ[quant_set1][0];
  2336.   Fq1q2=(JQQ1*JQ[quant_set1][0]+JQ[quant_set][0]/2)/JQ[quant_set][0];
  2338.   run=-1;
  2339.   scan_pos=0;
  2341.   for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  2342.   {
  2343.     run++;
  2344.     ilev=0;
  2346.     c_err=m1[coeff_ctr]-alpha*sign((abs (mp1[coeff_ctr]) * JQ[quant_set1][0] +JQQ2) / JQQ1,mp1[coeff_ctr]);
  2347.     level =(abs(c_err)*JQ[quant_set][0]+qp_const)/JQQ1;
  2348.     if (level  != 0)
  2349.     {
  2350.       currMB->cbp_blk |= 0xf0000 << (uv << 2) ;  // if one of the 2x2-DC levels is != 0 the coded-bit
  2351.       cr_cbp=max(1,cr_cbp);
  2352.       img->cofu[scan_pos][0][uv]=sign(level ,c_err);
  2353.       img->cofu[scan_pos][1][uv]=run;
  2354.       scan_pos++;
  2355.       run=-1;
  2356.       ilev=level;
  2357.     }
  2358.     ilev=sign(level,c_err)*Fq1q2+mp1[coeff_ctr]*JQ[quant_set1][0];
  2359.     m1[coeff_ctr]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
  2360.   }
  2361.   img->cofu[scan_pos][0][uv]=0;
  2363.   //  Invers transform of 2x2 DC levels
  2365.   img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
  2366.   img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
  2367.   img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
  2368.   img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;
  2370.   //     Quant of chroma AC-coeffs.
  2371.   coeff_cost=0;
  2372.   cr_cbp_tmp=0;
  2374.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2375.   {
  2376.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2377.     {
  2378.       pos_x=n1/BLOCK_SIZE + 2*uv;
  2379.       pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
  2380.       run=-1;
  2381.       scan_pos=0;
  2383.       for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)// start change rd_quant
  2384.       {
  2385.         i=SNGL_SCAN[coeff_ctr][0];
  2386.         j=SNGL_SCAN[coeff_ctr][1];
  2387.         ++run;
  2388.         ilev=0;
  2390.         c_err=img->m7[n1+i][n2+j]-alpha*sign((abs (predicted_chroma_block[n1+i][n2+j]) * JQ[quant_set1][0] +JQQ2) / JQQ1,predicted_chroma_block[n1+i][n2+j]);
  2391.         level= (abs(c_err)*JQ[quant_set][0]+qp_const)/JQQ1;
  2393.         if (level  != 0)
  2394.         {
  2395.           currMB->cbp_blk |=  1 << (16 + (uv << 2) + ((n2 >> 1) + (n1 >> 2))) ;
  2396.           if (level > 1)
  2397.             coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
  2398.           else
  2399.             coeff_cost += COEFF_COST[run];
  2401.           cr_cbp_tmp=2;
  2402.           img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,c_err);
  2403.           img->cof[pos_x][pos_y][scan_pos][1][0]=run;
  2404.           ++scan_pos;
  2405.           run=-1;
  2406.           ilev=level;
  2407.         }
  2408.         ilev=sign(ilev,c_err)*Fq1q2+predicted_chroma_block[n1+i][n2+j]*JQ[quant_set1][0];
  2409.         img->m7[n1+i][n2+j]=sign((abs(ilev)+JQQ2)/ JQQ1,ilev)*JQ[quant_set1][1];
  2410.       }
  2411.       img->cof[pos_x][pos_y][scan_pos][0][0]=0; // EOB
  2412.     }
  2413.   }
  2415.   // * reset chroma coeffs
  2417.   if(cr_cbp_tmp==2)
  2418.       cr_cbp=2;
  2419.   //     IDCT.
  2421.       //     Horizontal.
  2422.   for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
  2423.   {
  2424.     for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
  2425.     {
  2426.       for (j=0; j < BLOCK_SIZE; j++)
  2427.       {
  2428.         for (i=0; i < BLOCK_SIZE; i++)
  2429.         {
  2430.           m5[i]=img->m7[n1+i][n2+j];
  2431.         }
  2432.         m6[0]=(m5[0]+m5[2])*13;
  2433.         m6[1]=(m5[0]-m5[2])*13;
  2434.         m6[2]=m5[1]*7-m5[3]*17;
  2435.         m6[3]=m5[1]*17+m5[3]*7;
  2437.         for (i=0; i < 2; i++)
  2438.         {
  2439.           i1=3-i;
  2440.           img->m7[n1+i][n2+j]=m6[i]+m6[i1];
  2441.           img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
  2442.         }
  2443.       }
  2445.       //     Vertical.
  2446.       for (i=0; i < BLOCK_SIZE; i++)
  2447.       {
  2448.         for (j=0; j < BLOCK_SIZE; j++)
  2449.         {
  2450.           m5[j]=img->m7[n1+i][n2+j];
  2451.         }
  2452.         m6[0]=(m5[0]+m5[2])*13;
  2453.         m6[1]=(m5[0]-m5[2])*13;
  2454.         m6[2]=m5[1]*7-m5[3]*17;
  2455.         m6[3]=m5[1]*17+m5[3]*7;
  2457.         for (j=0; j < 2; j++)
  2458.         {
  2459.           j2=3-j;
  2460.           img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+JQQ2)/JQQ1));
  2461.           img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+JQQ2)/JQQ1));
  2462.         }
  2463.       }
  2464.     }
  2465.   }
  2467.   //  Decoded block moved to memory
  2468.   for (j=0; j < BLOCK_SIZE*2; j++)
  2469.     for (i=0; i < BLOCK_SIZE*2; i++)
  2470.     {
  2471.       imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
  2472.     }
  2474.   return cr_cbp;
  2475. }
  2478. #endif
  2480. /*!
  2481.  ************************************************************************
  2482.  * brief
  2483.  *    The routine performs transform,quantization,inverse transform, adds the diff.
  2484.  *    to the prediction and writes the result to the decoded luma frame. Includes the
  2485.  *    RD constrained quantization also.
  2486.  *
  2487.  * para Input:
  2488.  *    block_x,block_y: Block position inside a macro block (0,4,8,12).
  2489.  *
  2490.  * para Output:
  2491.  *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels.            n
  2492.  *    coeff_cost: Counter for nonzero coefficients, used to discard expencive levels.
  2493.  ************************************************************************
  2494.  */
  2495. int copyblock_sp(int block_x,int block_y)
  2496. {
  2497.   int sign(int a,int b);
  2499.   int i,j,i1,j1,m5[4],m6[4],coeff_ctr;
  2501.   int predicted_block[BLOCK_SIZE][BLOCK_SIZE],quant_set1;
  2503.   //  Horizontal transform
  2504.   for (j=0; j< BLOCK_SIZE; j++)
  2505.     for (i=0; i< BLOCK_SIZE; i++)
  2506.     {
  2507.       predicted_block[i][j]=img->mpr[i+block_x][j+block_y];
  2508.     }
  2510.   for (j=0; j < BLOCK_SIZE; j++)
  2511.   {
  2512.     for (i=0; i < 2; i++)
  2513.     {
  2514.       i1=3-i;
  2515.       m5[i]=predicted_block[i][j]+predicted_block[i1][j];
  2516.       m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
  2517.     }
  2518.     predicted_block[0][j]=(m5[0]+m5[1])*13;
  2519.     predicted_block[2][j]=(m5[0]-m5[1])*13;
  2520.     predicted_block[1][j]=m5[3]*17+m5[2]*7;
  2521.     predicted_block[3][j]=m5[3]*7-m5[2]*17;
  2522.   }
  2524.   //  Vertival transform
  2526.   for (i=0; i < BLOCK_SIZE; i++)
  2527.   {
  2528.     for (j=0; j < 2; j++)
  2529.     {
  2530.       j1=3-j;
  2531.       m5[j]=predicted_block[i][j]+predicted_block[i][j1];
  2532.       m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
  2533.     }
  2534.     predicted_block[i][0]=(m5[0]+m5[1])*13;
  2535.     predicted_block[i][2]=(m5[0]-m5[1])*13;
  2536.     predicted_block[i][1]=m5[3]*17+m5[2]*7;
  2537.     predicted_block[i][3]=m5[3]*7-m5[2]*17;
  2538.   }
  2540.   // Quant
  2541.   quant_set1=img->qpsp;
  2543.     for (coeff_ctr=0;coeff_ctr < 16;coeff_ctr++)     // 8 times if double scan, 16 normal scan
  2544.     {
  2545.         i=SNGL_SCAN[coeff_ctr][0];
  2546.         j=SNGL_SCAN[coeff_ctr][1];
  2547.         img->m7[i][j]=sign((abs(predicted_block[i][j])*JQ[quant_set1][0]+JQQ2)/ JQQ1,predicted_block[i][j])*JQ[quant_set1][1];
  2548.     }
  2550.   //     IDCT.
  2551.   //     horizontal
  2553.   for (j=0; j < BLOCK_SIZE; j++)
  2554.   {
  2555.     for (i=0; i < BLOCK_SIZE; i++)
  2556.     {
  2557.       m5[i]=img->m7[i][j];
  2558.     }
  2559.     m6[0]=(m5[0]+m5[2])*13;
  2560.     m6[1]=(m5[0]-m5[2])*13;
  2561.     m6[2]=m5[1]*7-m5[3]*17;
  2562.     m6[3]=m5[1]*17+m5[3]*7;
  2564.     for (i=0; i < 2; i++)
  2565.     {
  2566.       i1=3-i;
  2567.       img->m7[i][j]=m6[i]+m6[i1];
  2568.       img->m7[i1][j]=m6[i]-m6[i1];
  2569.     }
  2570.   }
  2572.   //  vertical
  2574.   for (i=0; i < BLOCK_SIZE; i++)
  2575.   {
  2576.     for (j=0; j < BLOCK_SIZE; j++)
  2577.     {
  2578.       m5[j]=img->m7[i][j];
  2579.     }
  2580.     m6[0]=(m5[0]+m5[2])*13;
  2581.     m6[1]=(m5[0]-m5[2])*13;
  2582.     m6[2]=m5[1]*7-m5[3]*17;
  2583.     m6[3]=m5[1]*17+m5[3]*7;
  2585.     for (j=0; j < 2; j++)
  2586.     {
  2587.       j1=3-j;
  2588.       img->m7[i][j] =min(255,max(0,(m6[j]+m6[j1]+JQQ2)/JQQ1));
  2589.       img->m7[i][j1]=min(255,max(0,(m6[j]-m6[j1]+JQQ2)/JQQ1));
  2590.     }
  2591.   }
  2593.   //  Decoded block moved to frame memory
  2595.   for (j=0; j < BLOCK_SIZE; j++)
  2596.     for (i=0; i < BLOCK_SIZE; i++)
  2597.       imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=img->m7[i][j];
  2600.   return 1;
  2601. }