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

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

Audio

开发平台：

Visual C++

macroblock.c：源码内容
  2. /*!
  3.  ***********************************************************************
  4.  * file macroblock.c
  5.  *
  6.  * brief
  7.  *     Decode a Macroblock
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Inge Lille-Lang鴜               <inge.lille-langoy@telenor.com>
  12.  *    - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  13.  *    - Jani Lainema                    <jani.lainema@nokia.com>
  14.  *    - Sebastian Purreiter             <sebastian.purreiter@mch.siemens.de>
  15.  *    - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  16.  *    - Detlev Marpe                    <marpe@hhi.de>
  17.  *    - Gabi Blaettermann
  18.  *    - Ye-Kui Wang                     <wyk@ieee.org>
  19.  *    - Lowell Winger                   <lwinger@lsil.com>
  20.  *    - Alexis Michael Tourapis         <alexismt@ieee.org>
  21.  ***********************************************************************
  22. */
  24. #include "contributors.h"
  26. #include <math.h>
  28. #include "global.h"
  29. #include "mbuffer.h"
  30. #include "elements.h"
  31. #include "errorconcealment.h"
  32. #include "macroblock.h"
  33. #include "fmo.h"
  34. #include "cabac.h"
  35. #include "vlc.h"
  36. #include "image.h"
  37. #include "mb_access.h"
  38. #include "biaridecod.h"
  39. #include "block.h"
  40. #include "transform8x8.h"
  41. #include "transform.h"
  42. #include "mc_prediction.h"
  43. #include "quant.h"
  45. #if TRACE
  46. #define TRACE_STRING(s) strncpy(currSE.tracestring, s, TRACESTRING_SIZE)
  47. #define TRACE_DECBITS(i) dectracebitcnt(1)
  48. #define TRACE_PRINTF(s) sprintf(type, "%s", s);
  49. #define TRACE_STRING_P(s) strncpy(currSE->tracestring, s, TRACESTRING_SIZE)
  50. #else
  51. #define TRACE_STRING(s)
  52. #define TRACE_DECBITS(i)
  53. #define TRACE_PRINTF(s) 
  54. #define TRACE_STRING_P(s)
  55. #endif
  57. //! single scan pattern
  58. static const byte SNGL_SCAN[16][2] =
  59. {
  60.   {0,0},{1,0},{0,1},{0,2},
  61.   {1,1},{2,0},{3,0},{2,1},
  62.   {1,2},{0,3},{1,3},{2,2},
  63.   {3,1},{3,2},{2,3},{3,3}
  64. };
  66. //! field scan pattern
  67. static const byte FIELD_SCAN[16][2] =
  68. {
  69.   {0,0},{0,1},{1,0},{0,2},
  70.   {0,3},{1,1},{1,2},{1,3},
  71.   {2,0},{2,1},{2,2},{2,3},
  72.   {3,0},{3,1},{3,2},{3,3}
  73. };
  75. //! used to control block sizes : Not used/16x16/16x8/8x16/8x8/8x4/4x8/4x4
  76. static const int BLOCK_STEP[8][2]=
  77. {
  78.   {0,0},{4,4},{4,2},{2,4},{2,2},{2,1},{1,2},{1,1}
  79. };
  81. const byte QP_SCALE_CR[52]=
  82. {
  83.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
  84.    12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
  85.    28,29,29,30,31,32,32,33,34,34,35,35,36,36,37,37,
  86.    37,38,38,38,39,39,39,39
  88. };
  90. //! single scan pattern
  91. const byte SNGL_SCAN8x8[64][2] = {
  92.   {0,0}, {1,0}, {0,1}, {0,2}, {1,1}, {2,0}, {3,0}, {2,1}, {1,2}, {0,3}, {0,4}, {1,3}, {2,2}, {3,1}, {4,0}, {5,0},
  93.   {4,1}, {3,2}, {2,3}, {1,4}, {0,5}, {0,6}, {1,5}, {2,4}, {3,3}, {4,2}, {5,1}, {6,0}, {7,0}, {6,1}, {5,2}, {4,3},
  94.   {3,4}, {2,5}, {1,6}, {0,7}, {1,7}, {2,6}, {3,5}, {4,4}, {5,3}, {6,2}, {7,1}, {7,2}, {6,3}, {5,4}, {4,5}, {3,6},
  95.   {2,7}, {3,7}, {4,6}, {5,5}, {6,4}, {7,3}, {7,4}, {6,5}, {5,6}, {4,7}, {5,7}, {6,6}, {7,5}, {7,6}, {6,7}, {7,7}
  96. };
  99. //! field scan pattern
  100. const byte FIELD_SCAN8x8[64][2] = {   // 8x8
  101.   {0,0}, {0,1}, {0,2}, {1,0}, {1,1}, {0,3}, {0,4}, {1,2}, {2,0}, {1,3}, {0,5}, {0,6}, {0,7}, {1,4}, {2,1}, {3,0},
  102.   {2,2}, {1,5}, {1,6}, {1,7}, {2,3}, {3,1}, {4,0}, {3,2}, {2,4}, {2,5}, {2,6}, {2,7}, {3,3}, {4,1}, {5,0}, {4,2},
  103.   {3,4}, {3,5}, {3,6}, {3,7}, {4,3}, {5,1}, {6,0}, {5,2}, {4,4}, {4,5}, {4,6}, {4,7}, {5,3}, {6,1}, {6,2}, {5,4},
  104.   {5,5}, {5,6}, {5,7}, {6,3}, {7,0}, {7,1}, {6,4}, {6,5}, {6,6}, {6,7}, {7,2}, {7,3}, {7,4}, {7,5}, {7,6}, {7,7}
  105. };
  107. //! single scan pattern
  108. const byte SCAN_YUV422[8][2] =
  109. {
  110.   {0,0},{0,1},
  111.   {1,0},{0,2},
  112.   {0,3},{1,1},
  113.   {1,2},{1,3}
  114. };
  116. static unsigned char cbp_blk_chroma[8][4] =
  117. { {16, 17, 18, 19},
  118.   {20, 21, 22, 23},
  119.   {24, 25, 26, 27},
  120.   {28, 29, 30, 31},
  121.   {32, 33, 34, 35},
  122.   {36, 37, 38, 39},
  123.   {40, 41, 42, 43},
  124.   {44, 45, 46, 47} };
  126. //! look up tables for FRExt_chroma support
  127. const unsigned char subblk_offset_x[3][8][4] =
  128. {
  129.   { {0, 4, 0, 4},
  130.     {0, 4, 0, 4},
  131.     {0, 0, 0, 0},
  132.     {0, 0, 0, 0},
  133.     {0, 0, 0, 0},
  134.     {0, 0, 0, 0},
  135.     {0, 0, 0, 0},
  136.     {0, 0, 0, 0}, },
  138.   { {0, 4, 0, 4},
  139.     {0, 4, 0, 4},
  140.     {0, 4, 0, 4},
  141.     {0, 4, 0, 4},
  142.     {0, 0, 0, 0},
  143.     {0, 0, 0, 0},
  144.     {0, 0, 0, 0},
  145.     {0, 0, 0, 0}, },
  147.   { {0, 4, 0, 4},
  148.     {8,12, 8,12},
  149.     {0, 4, 0, 4},
  150.     {8,12, 8,12},
  151.     {0, 4, 0, 4},
  152.     {8,12, 8,12},
  153.     {0, 4, 0, 4},
  154.     {8,12, 8,12}  }
  155. };
  157. const unsigned char subblk_offset_y[3][8][4] =
  158. { { {0, 0, 4, 4},
  159.     {0, 0, 4, 4},
  160.     {0, 0, 0, 0},
  161.     {0, 0, 0, 0},
  162.     {0, 0, 0, 0},
  163.     {0, 0, 0, 0},
  164.     {0, 0, 0, 0},
  165.     {0, 0, 0, 0}, },
  167.   { {0, 0, 4, 4},
  168.     {8, 8,12,12},
  169.     {0, 0, 4, 4},
  170.     {8, 8,12,12},
  171.     {0, 0, 0, 0},
  172.     {0, 0, 0, 0},
  173.     {0, 0, 0, 0},
  174.     {0, 0, 0, 0}  },
  176.   { {0, 0, 4, 4},
  177.     {0, 0, 4, 4},
  178.     {8, 8,12,12},
  179.     {8, 8,12,12},
  180.     {0, 0, 4, 4},
  181.     {0, 0, 4, 4},
  182.     {8, 8,12,12},
  183.     {8, 8,12,12} }
  184. };
  186. const unsigned char cofuv_blk_x[3][8][4] =
  187. { { {0, 1, 0, 1},
  188.     {0, 1, 0, 1},
  189.     {0, 0, 0, 0},
  190.     {0, 0, 0, 0},
  191.     {0, 0, 0, 0},
  192.     {0, 0, 0, 0},
  193.     {0, 0, 0, 0},
  194.     {0, 0, 0, 0} },
  196.   { {0, 1, 0, 1},
  197.     {0, 1, 0, 1},
  198.     {0, 1, 0, 1},
  199.     {0, 1, 0, 1},
  200.     {0, 0, 0, 0},
  201.     {0, 0, 0, 0},
  202.     {0, 0, 0, 0},
  203.     {0, 0, 0, 0} },
  205.   { {0, 1, 0, 1},
  206.     {2, 3, 2, 3},
  207.     {0, 1, 0, 1},
  208.     {2, 3, 2, 3},
  209.     {0, 1, 0, 1},
  210.     {2, 3, 2, 3},
  211.     {0, 1, 0, 1},
  212.     {2, 3, 2, 3} }
  213. };
  215. static const unsigned char cofuv_blk_y[3][8][4] =
  216. {
  217.   { { 0, 0, 1, 1},
  218.     { 0, 0, 1, 1},
  219.     { 0, 0, 0, 0},
  220.     { 0, 0, 0, 0},
  221.     { 0, 0, 0, 0},
  222.     { 0, 0, 0, 0},
  223.     { 0, 0, 0, 0},
  224.     { 0, 0, 0, 0} },
  226.   { { 0, 0, 1, 1},
  227.     { 2, 2, 3, 3},
  228.     { 0, 0, 1, 1},
  229.     { 2, 2, 3, 3},
  230.     { 0, 0, 0, 0},
  231.     { 0, 0, 0, 0},
  232.     { 0, 0, 0, 0},
  233.     { 0, 0, 0, 0} },
  235.   { { 0, 0, 1, 1},
  236.     { 0, 0, 1, 1},
  237.     { 2, 2, 3, 3},
  238.     { 2, 2, 3, 3},
  239.     { 0, 0, 1, 1},
  240.     { 0, 0, 1, 1},
  241.     { 2, 2, 3, 3},
  242.     { 2, 2, 3, 3}}
  243. };
  245. void dectracebitcnt(int count);
  247. extern int last_dquant;
  248. extern ColocatedParams *Co_located;
  249. extern ColocatedParams *Co_located_JV[MAX_PLANE];  //!< Co_located to be used during 4:4:4 independent mode decoding
  252. static void readMotionInfoFromNAL  (ImageParameters *img, Macroblock *currMB);
  253. static void read_ipred_modes       (ImageParameters *img, Macroblock *currMB);
  254. static void readCBPandCoeffsFromNAL(ImageParameters *img, Macroblock *currMB);
  255. static void readIPCMcoeffsFromNAL  (ImageParameters *img, struct datapartition *dP);
  257. // Interpret MB mode
  258. static void (*interpret_mb_mode)(Macroblock *currMB);
  260. /*!
  261.  ************************************************************************
  262.  * brief
  263.  *    Set context for reference frames
  264.  ************************************************************************
  265.  */
  266. int BType2CtxRef (int btype)
  267. {
  268.   return (btype >= 4);
  269. }
  271. /*!
  272.  ************************************************************************
  273.  * brief
  274.  *    Function pointer for reading the reference picture indices
  275.  ************************************************************************
  276.  */
  277. static char (*readRefPictureIdx)   (SyntaxElement *currSE, DataPartition *dP, char b8mode, int list);
  279. /*!
  280.  ************************************************************************
  281.  * brief
  282.  *    Function for reading the reference picture indices using VLC
  283.  ************************************************************************
  284.  */
  285. static char readRefPictureIdx_VLC(SyntaxElement *currSE, DataPartition *dP, char b8mode, int list)
  286. {
  287. #if TRACE
  288.   static char tstring[20];   
  289.   sprintf( tstring, "ref_idx_l%d", list); 
  290.   strncpy(currSE->tracestring, tstring, TRACESTRING_SIZE);
  291. #endif
  292.   currSE->context = BType2CtxRef (b8mode);
  293.   currSE->value2 = list;
  294.   dP->readSyntaxElement (currSE,img,dP);
  295.   return (char) currSE->value1;
  296. }
  298. /*!
  299.  ************************************************************************
  300.  * brief
  301.  *    Function for reading the reference picture indices using FLC
  302.  ************************************************************************
  303.  */
  304. static char readRefPictureIdx_FLC(SyntaxElement *currSE, DataPartition *dP, char b8mode, int list)
  305. {
  306. #if TRACE
  307.   static char tstring[20];   
  308.   sprintf( tstring, "ref_idx_l%d", list); 
  309.   strncpy(currSE->tracestring, tstring, TRACESTRING_SIZE);
  310. #endif
  312.   currSE->context = BType2CtxRef (b8mode);
  313.   currSE->len = 1;
  314.   readSyntaxElement_FLC(currSE, dP->bitstream);
  315.   currSE->value1 = 1 - currSE->value1;
  317.   return (char) currSE->value1;
  318. }
  320. /*!
  321.  ************************************************************************
  322.  * brief
  323.  *    Dummy Function for reading the reference picture indices
  324.  ************************************************************************
  325.  */
  326. static char readRefPictureIdx_Null(SyntaxElement *currSE, DataPartition *dP, char b8mode, int list)
  327. {
  328.   return 0;
  329. }
  331. /*!
  332.  ************************************************************************
  333.  * brief
  334.  *    Function to prepare reference picture indice function pointer
  335.  ************************************************************************
  336.  */
  337. static inline void prepareListforRefIdx ( SyntaxElement *currSE, DataPartition *dP, int num_ref_idx_active, int refidx_present)
  338. {
  339.   readRefPictureIdx = readRefPictureIdx_Null; // Initialize readRefPictureIdx
  340.   if(num_ref_idx_active > 1)
  341.   {
  342.     if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)
  343.     {
  344.       currSE->mapping = linfo_ue;
  345.       if (refidx_present)
  346.       {
  347.         if (num_ref_idx_active == 2)
  348.           readRefPictureIdx = readRefPictureIdx_FLC;        
  349.         else
  350.           readRefPictureIdx = readRefPictureIdx_VLC;
  351.       }
  352.     }
  353.     else
  354.     {
  355.       currSE->reading = readRefFrame_CABAC;
  356.       if (refidx_present)
  357.         readRefPictureIdx = readRefPictureIdx_VLC;
  358.     }
  359.   }    
  360. }
  362. void set_chroma_qp(ImageParameters *img, Macroblock* currMB)
  363. {
  364.   int i;
  365.   for (i=0; i<2; i++)
  366.   {
  367.     currMB->qpc[i] = iClip3 ( -img->bitdepth_chroma_qp_scale, 51, currMB->qp + dec_picture->chroma_qp_offset[i] );
  368.     currMB->qpc[i] = currMB->qpc[i] < 0 ? currMB->qpc[i] : QP_SCALE_CR[currMB->qpc[i]];
  369.     currMB->qp_scaled[i + 1] = currMB->qpc[i] + img->bitdepth_chroma_qp_scale;
  370.   }
  371. }
  373. /*!
  374. ************************************************************************
  375. * brief
  376. *    updates chroma QP according to luma QP and bit depth
  377. ************************************************************************
  378. */
  379. void update_qp(ImageParameters *img, Macroblock *currMB, int qp)
  380. {
  381.   currMB->qp = qp;
  382.   currMB->qp_scaled[0] = qp + img->bitdepth_luma_qp_scale;
  383.   set_chroma_qp(img, currMB);
  384. }
  386. static void read_delta_quant(SyntaxElement *currSE, DataPartition *dP, Slice *currSlice, ImageParameters *img, Macroblock *currMB, int *partMap, int type)
  387. {
  388.   currSE->type = type;
  390.   dP = &(currSlice->partArr[partMap[currSE->type]]);
  392.   if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)
  393.   {
  394.     currSE->mapping = linfo_se;
  395.   }
  396.   else
  397.     currSE->reading= readDquant_CABAC;
  399.   TRACE_STRING_P("mb_qp_delta");
  401.   dP->readSyntaxElement(currSE,img,dP);
  402.   currMB->delta_quant = currSE->value1;
  403.   if ((currMB->delta_quant < -(26 + img->bitdepth_luma_qp_scale/2)) || (currMB->delta_quant > (25 + img->bitdepth_luma_qp_scale/2)))
  404.     error ("mb_qp_delta is out of range", 500);
  406.   img->qp = ((img->qp + currMB->delta_quant + 52 + 2*img->bitdepth_luma_qp_scale)%(52+img->bitdepth_luma_qp_scale)) -
  407.     img->bitdepth_luma_qp_scale;
  408.   update_qp(img, currMB, img->qp);
  409. }
  411. /*!
  412.  ************************************************************************
  413.  * brief
  414.  *    Function to read reference picture indice values
  415.  ************************************************************************
  416.  */
  417. static inline void readMBRefPictureIdx (SyntaxElement *currSE, DataPartition *dP, Macroblock *currMB, ImageParameters *img, char  **cur_ref_idx, int list, int step_v0, int step_h0)
  418. {
  419.   static int k, j, j0, i0;
  420.   static char refframe;
  422.   for (j0 = 0; j0 < 4; j0 += step_v0)
  423.   {
  424.     img->subblock_y = j0;
  425.     for (i0 = 0; i0 < 4; i0 += step_h0)
  426.     {
  427.       img->subblock_x = i0;
  428.       k = 2 * (j0 >> 1) + (i0 >> 1);
  430.       if ((currMB->b8pdir[k] == list || currMB->b8pdir[k] == BI_PRED) && currMB->b8mode[k] != 0)
  431.       {
  432.         refframe = readRefPictureIdx(currSE, dP, currMB->b8mode[k], list);
  434.         for (j = j0; j < j0 + step_v0; j++)
  435.           memset(&cur_ref_idx[j][img->block_x + i0], refframe, step_h0 * sizeof(char));
  436.       }
  437.     }
  438.   }
  439. }
  441. /*!
  442.  ************************************************************************
  443.  * brief
  444.  *    Function to read reference picture indice values
  445.  ************************************************************************
  446.  */
  447. static inline void readMBMotionVectors (SyntaxElement *currSE, DataPartition *dP, Macroblock *currMB, ImageParameters *img, int list, int step_h0, int step_v0)
  448. {
  449.   static int i, j, k, i4, j4, ii, jj, kk, i0, j0;
  450.   static short curr_mvd[2], curr_mv[2], pred_mv[2];
  451.   static short (*mvd)[4][2];
  452.   static short ***mv;
  453.   static int mv_mode, step_h, step_v;
  454.   static char cur_ref_idx;
  456.   for (j0=0; j0<4; j0+=step_v0)
  457.   {
  458.     for (i0=0; i0<4; i0+=step_h0)
  459.     {       
  460.       kk = 2 * (j0 >> 1) + (i0 >> 1);
  461.       if ((currMB->b8pdir[kk]== list || currMB->b8pdir[kk]== BI_PRED) && (currMB->b8mode[kk] !=0))//has forward vector
  462.       {
  463.         cur_ref_idx = dec_picture->motion.ref_idx[list][img->block_y+j0][img->block_x+i0];
  464.         mv_mode  = currMB->b8mode[kk];
  465.         step_h = BLOCK_STEP [mv_mode][0];
  466.         step_v = BLOCK_STEP [mv_mode][1];
  468.         for (j = j0; j < j0 + step_v0; j += step_v)
  469.         {
  470.           img->subblock_y = j; // position used for context determination
  471.           j4 = img->block_y + j;
  472.           mv  = &dec_picture->motion.mv [list][j4];
  473.           mvd = &currMB->mvd     [list][j];
  474.           for (i = i0; i < i0 + step_h0; i += step_h)
  475.           {
  476.             img->subblock_x = i; // position used for context determination
  477.             i4 = img->block_x + i;
  479.             // first make mv-prediction
  480.             SetMotionVectorPredictor (img, currMB, pred_mv, cur_ref_idx, (byte) list, dec_picture->motion.ref_idx, dec_picture->motion.mv, BLOCK_SIZE * i, BLOCK_SIZE * j, 4*step_h, 4*step_v);
  482.             for (k=0; k < 2; k++)
  483.             {
  484. #if TRACE
  485.               static char tstring[20];   
  486.               sprintf( tstring, "mvd_l%d", list); 
  487.               strncpy(currSE->tracestring, tstring, TRACESTRING_SIZE);
  488. #endif
  489.               currSE->value2   = (k << 1) + list; // identifies the component; only used for context determination
  490.               dP->readSyntaxElement(currSE,img,dP);
  491.               curr_mvd[k] = (short) currSE->value1;
  492.               curr_mv [k] = (short)(curr_mvd[k] + pred_mv[k]);  // compute motion vector 
  493.             }
  495.             // Init first line (mv)
  496.             for(ii = i4; ii < i4 + step_h; ii++)
  497.             {
  498.               memcpy(&mv[0][ii][0], curr_mv,  2 * sizeof(short));
  499.             }              
  500.             // now copy all other lines
  501.             for(jj = 1; jj < step_v; jj++)
  502.             {
  503.               memcpy(&mv[jj][i4][0], &mv[0][i4][0],  2 * step_h * sizeof(short));
  504.             }
  506.             // Init first line (mvd)
  507.             for(ii = i; ii < i + step_h; ii++)
  508.             {
  509.               memcpy(&mvd[0][ii][0], curr_mvd,  2 * sizeof(short));
  510.             }              
  512.             // now copy all other lines
  513.             for(jj = 1; jj < step_v; jj++)
  514.             {
  515.               memcpy(&mvd[jj][i][0], &mvd[0][i][0],  2 * step_h * sizeof(short));
  516.             }
  517.           }
  518.         }
  519.       }
  520.     }
  521.   }
  522. }
  524. void invScaleCoeff(ImageParameters *img, Macroblock *currMB, int level, int run, int qp_per, int i, int j, int i0, int j0, int coef_ctr, const byte (*pos_scan4x4)[2], int (*InvLevelScale4x4)[4])
  525. {
  526.   if (level != 0)    /* leave if len=1 */
  527.   {
  528.     coef_ctr += run + 1;
  530.     i0=pos_scan4x4[coef_ctr][0];
  531.     j0=pos_scan4x4[coef_ctr][1];
  533.     currMB->cbp_blk |= (int64)1 << ((j << 2) + i) ;
  534.     img->cof[0][(j<<2) + j0][(i<<2) + i0]= rshift_rnd_sf((level * InvLevelScale4x4[j0][i0]) << qp_per, 4);
  535.   }
  536. }
  538. /*!
  539.  ************************************************************************
  540.  * brief
  541.  *    initializes the current macroblock
  542.  ************************************************************************
  543.  */
  544. void start_macroblock(ImageParameters *img, Macroblock **currMB)
  545. {
  546.   int mb_nr = img->current_mb_nr;
  547.   *currMB = &img->mb_data[mb_nr];   // intialization code deleted, see below, StW  
  548.   (*currMB)->mbAddrX = mb_nr;
  550.   assert (mb_nr < (int) img->PicSizeInMbs);
  552.   /* Update coordinates of the current macroblock */
  553.   if (img->MbaffFrameFlag)
  554.   {
  555.     img->mb_x =    (mb_nr) % ((2*img->width) / MB_BLOCK_SIZE);
  556.     img->mb_y = 2*((mb_nr) / ((2*img->width) / MB_BLOCK_SIZE));
  558.     img->mb_y += (img->mb_x & 0x01);
  559.     img->mb_x >>= 1;
  560.   }
  561.   else
  562.   {
  563.     img->mb_x = PicPos[mb_nr][0];
  564.     img->mb_y = PicPos[mb_nr][1];
  565.   }
  567.   /* Define vertical positions */
  568.   img->block_y = img->mb_y * BLOCK_SIZE;      /* luma block position */
  569.   img->block_y_aff = img->block_y;
  570.   img->pix_y   = img->mb_y * MB_BLOCK_SIZE;   /* luma macroblock position */
  571.   img->pix_c_y = img->mb_y * img->mb_cr_size_y; /* chroma macroblock position */
  573.   /* Define horizontal positions */
  574.   img->block_x = img->mb_x * BLOCK_SIZE;      /* luma block position */
  575.   img->pix_x   = img->mb_x * MB_BLOCK_SIZE;   /* luma pixel position */
  576.   img->pix_c_x = img->mb_x * img->mb_cr_size_x; /* chroma pixel position */
  578.   // Save the slice number of this macroblock. When the macroblock below
  579.   // is coded it will use this to decide if prediction for above is possible
  580.   (*currMB)->slice_nr = img->current_slice_nr;
  582.   if (img->current_slice_nr >= MAX_NUM_SLICES)
  583.   {
  584.     error ("Maximum number of supported slices exceeded. nPlease recompile with increased value for MAX_NUM_SLICES", 200);
  585.   }
  587.   dec_picture->slice_id[img->mb_y][img->mb_x] = (short) img->current_slice_nr;
  588.   dec_picture->max_slice_id = (short) imax(img->current_slice_nr, dec_picture->max_slice_id);
  590.   CheckAvailabilityOfNeighbors(*currMB);
  592.   // Reset syntax element entries in MB struct
  593.   (*currMB)->qp              = img->qp ;
  594.   (*currMB)->mb_type         = 0;
  595.   (*currMB)->delta_quant     = 0;
  596.   (*currMB)->cbp             = 0;
  597.   (*currMB)->cbp_blk         = 0;
  598.   (*currMB)->cbp_blk_CbCr[0] = 0;
  599.   (*currMB)->cbp_blk_CbCr[1] = 0;  
  600.   (*currMB)->c_ipred_mode    = DC_PRED_8; //GB
  602.   memset(&((*currMB)->mvd[0][0][0][0]),0, 2 * BLOCK_MULTIPLE * BLOCK_MULTIPLE * 2 * sizeof(short));
  603.   
  604.   memset((*currMB)->cbp_bits, 0, 3 * sizeof(int64));
  605.   memset((*currMB)->cbp_bits_8x8, 0, 3 * sizeof(int64));
  607.   // initialize img->mb_rres
  608.   memset(&(img->mb_rres[0][0][0]), 0, 3 * MB_PIXELS * sizeof(int));
  610.   // store filtering parameters for this MB
  611.   (*currMB)->DFDisableIdc = img->currentSlice->DFDisableIdc;
  612.   (*currMB)->DFAlphaC0Offset = img->currentSlice->DFAlphaC0Offset;
  613.   (*currMB)->DFBetaOffset = img->currentSlice->DFBetaOffset;
  614. }
  616. /*!
  617.  ************************************************************************
  618.  * brief
  619.  *    set coordinates of the next macroblock
  620.  *    check end_of_slice condition
  621.  ************************************************************************
  622.  */
  623. Boolean exit_macroblock(ImageParameters *img,int eos_bit)
  624. {
  625.  //! The if() statement below resembles the original code, which tested
  626.   //! img->current_mb_nr == img->PicSizeInMbs.  Both is, of course, nonsense
  627.   //! In an error prone environment, one can only be sure to have a new
  628.   //! picture by checking the tr of the next slice header!
  630. // printf ("exit_macroblock: FmoGetLastMBOfPicture %d, img->current_mb_nr %dn", FmoGetLastMBOfPicture(), img->current_mb_nr);
  631.   img->num_dec_mb++;
  633.   if (img->num_dec_mb == img->PicSizeInMbs)
  634.   {
  635.     return TRUE;
  636.   }
  637.   // ask for last mb in the slice  UVLC
  638.   else
  639.   {
  641.     img->current_mb_nr = FmoGetNextMBNr (img->current_mb_nr);
  643.     if (img->current_mb_nr == -1)     // End of Slice group, MUST be end of slice
  644.     {
  645.       assert (nal_startcode_follows (img->currentSlice, eos_bit) == TRUE);
  646.       return TRUE;
  647.     }
  649.     if(nal_startcode_follows(img->currentSlice, eos_bit) == FALSE)
  650.       return FALSE;
  652.     if(img->type == I_SLICE  || img->type == SI_SLICE || active_pps->entropy_coding_mode_flag == CABAC)
  653.       return TRUE;
  654.     if(img->cod_counter <= 0)
  655.       return TRUE;
  656.     return FALSE;
  657.   }
  658. }
  660. /*!
  661.  ************************************************************************
  662.  * brief
  663.  *    Interpret the mb mode for P-Frames
  664.  ************************************************************************
  665.  */
  666. static void interpret_mb_mode_P(Macroblock *currMB)
  667. {
  668.   const int ICBPTAB[6] = {0,16,32,15,31,47};
  669.   int         mbmode = currMB->mb_type;
  671. #define ZERO_P8x8     (mbmode==5)
  672. #define MODE_IS_P8x8  (mbmode==4 || mbmode==5)
  673. #define MODE_IS_I4x4  (mbmode==6)
  674. #define I16OFFSET     (mbmode-7)
  675. #define MODE_IS_IPCM  (mbmode==31)
  677.   if(mbmode <4)
  678.   {
  679.     currMB->mb_type = mbmode;
  680.     memset(&currMB->b8mode[0],mbmode,4 * sizeof(char));
  681.     memset(&currMB->b8pdir[0], 0, 4 * sizeof(char));
  682.   }
  683.   else if(MODE_IS_P8x8)
  684.   {
  685.     currMB->mb_type = P8x8;
  686.     img->allrefzero = ZERO_P8x8;
  687.   }
  688.   else if(MODE_IS_I4x4)
  689.   {
  690.     currMB->mb_type = I4MB;
  691.     memset(&currMB->b8mode[0],IBLOCK, 4 * sizeof(char));
  692.     memset(&currMB->b8pdir[0],    -1, 4 * sizeof(char));
  693.   }
  694.   else if(MODE_IS_IPCM)
  695.   {
  696.     currMB->mb_type = IPCM;
  697.     currMB->cbp = -1;
  698.     currMB->i16mode = 0;
  700.     memset(&currMB->b8mode[0], 0, 4 * sizeof(char));
  701.     memset(&currMB->b8pdir[0],-1, 4 * sizeof(char));
  702.   }
  703.   else
  704.   {
  705.     currMB->mb_type = I16MB;
  706.     currMB->cbp = ICBPTAB[(I16OFFSET)>>2];
  707.     currMB->i16mode = (I16OFFSET) & 0x03;
  708.     memset(&currMB->b8mode[0], 0, 4 * sizeof(char));
  709.     memset(&currMB->b8pdir[0],-1, 4 * sizeof(char));
  710.   }
  711. }
  713. /*!
  714.  ************************************************************************
  715.  * brief
  716.  *    Interpret the mb mode for I-Frames
  717.  ************************************************************************
  718.  */
  719. static void interpret_mb_mode_I(Macroblock *currMB)
  720. {
  721.   static const int ICBPTAB[6] = {0,16,32,15,31,47};
  722.   int         mbmode   = currMB->mb_type;
  724.   if (mbmode==0)
  725.   {
  726.     currMB->mb_type = I4MB;
  727.     memset(&currMB->b8mode[0],IBLOCK,4 * sizeof(char));
  728.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  729.   }
  730.   else if(mbmode==25)
  731.   {
  732.     currMB->mb_type=IPCM;
  733.     currMB->cbp= -1;
  734.     currMB->i16mode = 0;
  736.     memset(&currMB->b8mode[0],0,4 * sizeof(char));
  737.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  738.   }
  739.   else
  740.   {
  741.     currMB->mb_type = I16MB;
  742.     currMB->cbp= ICBPTAB[(mbmode-1)>>2];
  743.     currMB->i16mode = (mbmode-1) & 0x03;
  744.     memset(&currMB->b8mode[0], 0, 4 * sizeof(char));
  745.     memset(&currMB->b8pdir[0],-1, 4 * sizeof(char));
  746.   }
  747. }
  749. /*!
  750.  ************************************************************************
  751.  * brief
  752.  *    Interpret the mb mode for B-Frames
  753.  ************************************************************************
  754.  */
  755. static void interpret_mb_mode_B(Macroblock *currMB)
  756. {
  757.   static const int offset2pdir16x16[12]   = {0, 0, 1, 2, 0,0,0,0,0,0,0,0};
  758.   static const int offset2pdir16x8[22][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,1},{0,0},{0,1},{0,0},{1,0},
  759.                                              {0,0},{0,2},{0,0},{1,2},{0,0},{2,0},{0,0},{2,1},{0,0},{2,2},{0,0}};
  760.   static const int offset2pdir8x16[22][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{1,1},{0,0},{0,1},{0,0},
  761.                                              {1,0},{0,0},{0,2},{0,0},{1,2},{0,0},{2,0},{0,0},{2,1},{0,0},{2,2}};
  763.   const int ICBPTAB[6] = {0,16,32,15,31,47};
  765.   int i, mbmode;
  766.   int mbtype  = currMB->mb_type;
  768.   //--- set mbtype, b8type, and b8pdir ---
  769.   if (mbtype==0)       // direct
  770.   {
  771.     mbmode=0;
  772.     memset(&currMB->b8mode[0],0,4 * sizeof(char));
  773.     memset(&currMB->b8pdir[0],2,4 * sizeof(char));
  774.   }
  775.   else if (mbtype==23) // intra4x4
  776.   {
  777.     mbmode=I4MB;
  778.     memset(&currMB->b8mode[0],IBLOCK,4 * sizeof(char));
  779.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  780.   }
  781.   else if ((mbtype>23) && (mbtype<48) ) // intra16x16
  782.   {
  783.     mbmode=I16MB;
  784.     memset(&currMB->b8mode[0],0,4 * sizeof(char));
  785.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  787.     currMB->cbp     = ICBPTAB[(mbtype-24)>>2];
  788.     currMB->i16mode = (mbtype-24) & 0x03;
  789.   }
  790.   else if (mbtype==22) // 8x8(+split)
  791.   {
  792.     mbmode=P8x8;       // b8mode and pdir is transmitted in additional codewords
  793.   }
  794.   else if (mbtype<4)   // 16x16
  795.   {
  796.     mbmode=1;
  797.     memset(&currMB->b8mode[0], 1,4 * sizeof(char));
  798.     memset(&currMB->b8pdir[0],offset2pdir16x16[mbtype],4 * sizeof(char));
  799.   }
  800.   else if(mbtype==48)
  801.   {
  802.     mbmode=IPCM;
  803.     memset(&currMB->b8mode[0], 0,4 * sizeof(char));
  804.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  806.     currMB->cbp= -1;
  807.     currMB->i16mode = 0;
  808.   }
  810.   else if ((mbtype&0x01)==0) // 16x8
  811.   {
  812.     mbmode=2;
  813.     memset(&currMB->b8mode[0], 2,4 * sizeof(char));
  814.     for(i=0;i<4;i++)
  815.     {
  816.       currMB->b8pdir[i] = (char) offset2pdir16x8 [mbtype][i>>1];
  817.     }
  818.   }
  819.   else
  820.   {
  821.     mbmode=3;
  822.     memset(&currMB->b8mode[0], 3,4 * sizeof(char));
  823.     for(i=0;i<4;i++)
  824.     {
  825.       currMB->b8pdir[i] = (char) offset2pdir8x16 [mbtype][i&0x01];
  826.     }
  827.   }
  828.   currMB->mb_type = mbmode;
  829. }
  830. /*!
  831.  ************************************************************************
  832.  * brief
  833.  *    Interpret the mb mode for SI-Frames
  834.  ************************************************************************
  835.  */
  836. static void interpret_mb_mode_SI(Macroblock *currMB)
  837. {
  838.   const int ICBPTAB[6] = {0,16,32,15,31,47};
  839.   int         mbmode   = currMB->mb_type;
  841.   if (mbmode==0)
  842.   {
  843.     currMB->mb_type = SI4MB;
  844.     memset(&currMB->b8mode[0],IBLOCK,4 * sizeof(char));
  845.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  846.     img->siblock[img->mb_y][img->mb_x]=1;
  847.   }
  848.   else if (mbmode==1)
  849.   {
  850.     currMB->mb_type = I4MB;
  851.     memset(&currMB->b8mode[0],IBLOCK,4 * sizeof(char));
  852.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  853.   }
  854.   else if(mbmode==26)
  855.   {
  856.     currMB->mb_type=IPCM;
  857.     currMB->cbp= -1;
  858.     currMB->i16mode = 0;
  859.     memset(&currMB->b8mode[0],0,4 * sizeof(char));
  860.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  861.   }
  863.   else
  864.   {
  865.     currMB->mb_type = I16MB;
  866.     currMB->cbp= ICBPTAB[(mbmode-1)>>2];
  867.     currMB->i16mode = (mbmode-2) & 0x03;
  868.     memset(&currMB->b8mode[0],0,4 * sizeof(char));
  869.     memset(&currMB->b8pdir[0],-1,4 * sizeof(char));
  870.   }
  871. }
  873. /*!
  874.  ************************************************************************
  875.  * brief
  876.  *    Set mode interpretation based on slice type
  877.  ************************************************************************
  878.  */
  879. void set_interpret_mb_mode(int slice_type)
  880. {
  881.   switch (slice_type)
  882.   {
  883.   case P_SLICE: case SP_SLICE:
  884.     interpret_mb_mode = interpret_mb_mode_P;
  885.     break;
  886.   case B_SLICE:
  887.     interpret_mb_mode = interpret_mb_mode_B;
  888.     break;
  889.   case I_SLICE: 
  890.     interpret_mb_mode = interpret_mb_mode_I;
  891.     break;
  892.   case SI_SLICE: 
  893.     interpret_mb_mode = interpret_mb_mode_SI;
  894.     break;
  895.   default:
  896.     printf("Unsupported slice typen");
  897.     break;
  898.   }
  899. }
  900. /*!
  901.  ************************************************************************
  902.  * brief
  903.  *    init macroblock I and P frames
  904.  ************************************************************************
  905.  */
  906. static void init_macroblock(ImageParameters *img)
  907. {
  908.   int i, j, k;
  910.   for (k = LIST_0; k <= LIST_1; k++)
  911.   {
  912.     for(j = img->block_y; j < img->block_y + BLOCK_SIZE; j++)
  913.       memset(&img->ipredmode[j][img->block_x], DC_PRED, BLOCK_SIZE * sizeof(char));
  915.     for(j = img->block_y; j < img->block_y + BLOCK_SIZE; j++)
  916.     {                           // reset vectors and pred. modes
  917.       memset(&dec_picture->motion.mv[k][j][img->block_x][0], 0, 2 * BLOCK_SIZE * sizeof(short));
  918.       memset(&dec_picture->motion.ref_idx[k][j][img->block_x], -1, BLOCK_SIZE * sizeof(char));
  919.       for (i = img->block_x; i < img->block_x + BLOCK_SIZE;i++)
  920.       {
  921.         dec_picture->motion.ref_pic_id[k][j][i] = INT64_MIN;
  922.       }
  923.     }
  924.   }
  925. }
  928. /*!
  929.  ************************************************************************
  930.  * brief
  931.  *    Sets mode for 8x8 block
  932.  ************************************************************************
  933.  */
  934. void SetB8Mode (ImageParameters* img, Macroblock* currMB, int value, int i)
  935. {
  936.   static const int p_v2b8 [ 5] = {4, 5, 6, 7, IBLOCK};
  937.   static const int p_v2pd [ 5] = {0, 0, 0, 0, -1};
  938.   static const int b_v2b8 [14] = {0, 4, 4, 4, 5, 6, 5, 6, 5, 6, 7, 7, 7, IBLOCK};
  939.   static const int b_v2pd [14] = {2, 0, 1, 2, 0, 0, 1, 1, 2, 2, 0, 1, 2, -1};
  941.   if (img->type==B_SLICE)
  942.   {
  943.     currMB->b8mode[i] = (char) b_v2b8[value];
  944.     currMB->b8pdir[i] = (char) b_v2pd[value];
  945.   }
  946.   else
  947.   {
  948.     currMB->b8mode[i] = (char) p_v2b8[value];
  949.     currMB->b8pdir[i] = (char) p_v2pd[value];
  950.   }
  951. }
  954. void reset_coeffs(void)
  955. {
  956.   // reset all coeffs
  957.   memset(&img->fcf[0][0][0], 0, 3 * MB_PIXELS * sizeof(int));
  958.   memset(&img->cof[0][0][0], 0, 3 * MB_PIXELS * sizeof(int));
  960.   // CAVLC
  961.   if (active_pps->entropy_coding_mode_flag == UVLC)
  962.     memset(&img->nz_coeff[img->current_mb_nr][0][0][0], 0, 3 * BLOCK_SIZE * BLOCK_SIZE * sizeof(int));
  963. }
  965. void field_flag_inference(Macroblock *currMB)
  966. {
  967.   if (currMB->mbAvailA)
  968.   {
  969.     currMB->mb_field = img->mb_data[currMB->mbAddrA].mb_field;
  970.   }
  971.   else
  972.   {
  973.     // check top macroblock pair
  974.     currMB->mb_field = currMB->mbAvailB ? img->mb_data[currMB->mbAddrB].mb_field : 0;
  975.   }
  976. }
  979. void copy_macroblock(ImageParameters *img, Macroblock *currMB)
  980. {
  981.   short pred_mv[2];
  982.   int zeroMotionAbove;
  983.   int zeroMotionLeft;
  984.   PixelPos mb_a, mb_b;
  985.   int   i, j;
  986.   int   a_mv_y = 0;
  987.   int   a_ref_idx = 0;
  988.   int   b_mv_y = 0;
  989.   int   b_ref_idx = 0;
  990.   int   img_block_y   = img->block_y;
  991.   int   list_offset = ((img->MbaffFrameFlag)&&(currMB->mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  992.   short ***cur_mv = dec_picture->motion.mv[LIST_0];
  993.   get4x4Neighbour(currMB,-1, 0, img->mb_size[IS_LUMA], &mb_a);
  994.   get4x4Neighbour(currMB, 0,-1, img->mb_size[IS_LUMA], &mb_b);
  996.   if (mb_a.available)
  997.   {
  998.     a_mv_y    = cur_mv[mb_a.pos_y][mb_a.pos_x][1];
  999.     a_ref_idx = dec_picture->motion.ref_idx[LIST_0][mb_a.pos_y][mb_a.pos_x];
  1001.     if (currMB->mb_field && !img->mb_data[mb_a.mb_addr].mb_field)
  1002.     {
  1003.       a_mv_y    /=2;
  1004.       a_ref_idx *=2;
  1005.     }
  1006.     if (!currMB->mb_field && img->mb_data[mb_a.mb_addr].mb_field)
  1007.     {
  1008.       a_mv_y    *=2;
  1009.       a_ref_idx >>=1;
  1010.     }
  1011.   }
  1013.   if (mb_b.available)
  1014.   {
  1015.     b_mv_y    = cur_mv[mb_b.pos_y][mb_b.pos_x][1];
  1016.     b_ref_idx = dec_picture->motion.ref_idx[LIST_0][mb_b.pos_y][mb_b.pos_x];
  1018.     if (currMB->mb_field && !img->mb_data[mb_b.mb_addr].mb_field)
  1019.     {
  1020.       b_mv_y    /=2;
  1021.       b_ref_idx *=2;
  1022.     }
  1023.     if (!currMB->mb_field && img->mb_data[mb_b.mb_addr].mb_field)
  1024.     {
  1025.       b_mv_y    *=2;
  1026.       b_ref_idx >>=1;
  1027.     }
  1028.   }
  1030.   zeroMotionLeft  = !mb_a.available ? 1 : a_ref_idx==0 && cur_mv[mb_a.pos_y][mb_a.pos_x][0]==0 && a_mv_y==0 ? 1 : 0;
  1031.   zeroMotionAbove = !mb_b.available ? 1 : b_ref_idx==0 && cur_mv[mb_b.pos_y][mb_b.pos_x][0]==0 && b_mv_y==0 ? 1 : 0;
  1033.   currMB->cbp = 0;
  1034.   reset_coeffs();
  1036.   if (zeroMotionAbove || zeroMotionLeft)
  1037.   {
  1038.     for(j = img_block_y; j < img_block_y + BLOCK_SIZE;j++)
  1039.     {
  1040.       memset(&cur_mv[j][img->block_x][0], 0, 2 * BLOCK_SIZE * sizeof(short));
  1041.     }
  1042.   }
  1043.   else
  1044.   {
  1045.     SetMotionVectorPredictor (img, currMB, pred_mv, 0, LIST_0, dec_picture->motion.ref_idx, dec_picture->motion.mv, 0, 0, 16, 16);
  1047.     for(j=img_block_y;j<img_block_y + BLOCK_SIZE;j++)
  1048.     {        
  1049.       for(i=img->block_x;i<img->block_x + BLOCK_SIZE;i++)
  1050.         memcpy(&cur_mv[j][i][0], &pred_mv[0], 2 * sizeof(short));
  1051.     }
  1052.   }
  1053.   for(j=img_block_y;j< img_block_y + BLOCK_SIZE;j++)
  1054.   {
  1055.     memset(&dec_picture->motion.ref_idx[LIST_0][j][img->block_x], 0, BLOCK_SIZE * sizeof(char));
  1056.     for(i=img->block_x;i<img->block_x + BLOCK_SIZE;i++)
  1057.     {        
  1058.       dec_picture->motion.ref_pic_id[LIST_0][j][i] =
  1059.         dec_picture->ref_pic_num[img->current_slice_nr][LIST_0 + list_offset][(short)dec_picture->motion.ref_idx[LIST_0][j][i]];
  1060.     }
  1061.   }  
  1062. }
  1064. /*!
  1065.  ************************************************************************
  1066.  * brief
  1067.  *    Get the syntax elements from the NAL
  1068.  ************************************************************************
  1069.  */
  1070. void read_one_macroblock(ImageParameters *img, Macroblock *currMB)
  1071. {
  1072.   int i;
  1074.   SyntaxElement currSE;
  1075.   int mb_nr = img->current_mb_nr; 
  1077.   Slice *currSlice = img->currentSlice;
  1078.   DataPartition *dP;
  1079.   int *partMap = assignSE2partition[currSlice->dp_mode];
  1080.   Macroblock *topMB = NULL;
  1081.   int  prevMbSkipped = 0;
  1082.   int  check_bottom, read_bottom, read_top;  
  1084.   if (img->MbaffFrameFlag)
  1085.   {
  1086.     if (mb_nr&0x01)
  1087.     {
  1088.       topMB= &img->mb_data[mb_nr-1];
  1089.       if(!(img->type == B_SLICE))
  1090.         prevMbSkipped = (topMB->mb_type == 0);
  1091.       else
  1092.         prevMbSkipped = topMB->skip_flag;
  1093.     }
  1094.     else
  1095.       prevMbSkipped = 0;
  1096.   }
  1098.   currMB->mb_field = ((mb_nr&0x01) == 0)? 0 : img->mb_data[mb_nr-1].mb_field;
  1100.   update_qp(img, currMB, img->qp);
  1102.   currSE.type = SE_MBTYPE;
  1104.   //  read MB mode *****************************************************************
  1105.   dP = &(currSlice->partArr[partMap[currSE.type]]);
  1107.   if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)   
  1108.     currSE.mapping = linfo_ue;
  1110.   if(img->type == I_SLICE || img->type == SI_SLICE)
  1111.   {
  1112.     // read MB aff
  1113.     if (img->MbaffFrameFlag && (mb_nr&0x01)==0)
  1114.     {
  1115.       TRACE_STRING("mb_field_decoding_flag");
  1116.       if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)
  1117.       {
  1118.         currSE.len = (int64) 1;
  1119.         readSyntaxElement_FLC(&currSE, dP->bitstream);
  1120.       }
  1121.       else
  1122.       {
  1123.         currSE.reading = readFieldModeInfo_CABAC;
  1124.         dP->readSyntaxElement(&currSE,img,dP);
  1125.       }
  1126.       currMB->mb_field = currSE.value1;
  1127.     }
  1128.     
  1129.     if(active_pps->entropy_coding_mode_flag  == CABAC)
  1130.       CheckAvailabilityOfNeighborsCABAC(currMB);
  1132.     //  read MB type
  1133.     TRACE_STRING("mb_type");
  1134.     currSE.reading = readMB_typeInfo_CABAC;
  1135.     dP->readSyntaxElement(&currSE,img,dP);
  1137.     currMB->mb_type = currSE.value1;
  1138.     if(!dP->bitstream->ei_flag)
  1139.       currMB->ei_flag = 0;
  1140.   }
  1141.   // non I/SI-slice CABAC
  1142.   else if (active_pps->entropy_coding_mode_flag == CABAC)
  1143.   {
  1144.     // read MB skip_flag
  1145.     if (img->MbaffFrameFlag && ((mb_nr&0x01) == 0||prevMbSkipped))
  1146.       field_flag_inference(currMB);
  1148.     CheckAvailabilityOfNeighborsCABAC(currMB);
  1149.     TRACE_STRING("mb_skip_flag");
  1150.     currSE.reading = readMB_skip_flagInfo_CABAC;
  1151.     dP->readSyntaxElement(&currSE,img,dP);
  1153.     currMB->mb_type   = currSE.value1;
  1154.     currMB->skip_flag = !(currSE.value1);
  1156.     if (img->type==B_SLICE)
  1157.       currMB->cbp = currSE.value2;
  1159.     if (!dP->bitstream->ei_flag)
  1160.       currMB->ei_flag = 0;
  1162.     if ((img->type==B_SLICE) && currSE.value1==0 && currSE.value2==0)
  1163.       img->cod_counter=0;
  1165.     // read MB AFF
  1166.     if (img->MbaffFrameFlag)
  1167.     {
  1168.       check_bottom=read_bottom=read_top=0;
  1169.       if ((mb_nr&0x01)==0)
  1170.       {
  1171.         check_bottom =  currMB->skip_flag;
  1172.         read_top = !check_bottom;
  1173.       }
  1174.       else
  1175.       {
  1176.         read_bottom = (topMB->skip_flag && (!currMB->skip_flag));
  1177.        }
  1179.       if (read_bottom || read_top)
  1180.       {
  1181.         TRACE_STRING("mb_field_decoding_flag");
  1182.         currSE.reading = readFieldModeInfo_CABAC;
  1183.         dP->readSyntaxElement(&currSE,img,dP);
  1184.         currMB->mb_field = currSE.value1;
  1185.       }
  1186.       if (check_bottom)
  1187.         check_next_mb_and_get_field_mode_CABAC(&currSE,img,dP);
  1189.     }
  1191.     CheckAvailabilityOfNeighborsCABAC(currMB);
  1193.     // read MB type
  1194.     if (currMB->mb_type != 0 )
  1195.     {
  1196.       currSE.reading = readMB_typeInfo_CABAC;
  1197.       TRACE_STRING("mb_type");
  1198.       dP->readSyntaxElement(&currSE,img,dP);
  1199.       currMB->mb_type = currSE.value1;
  1200.       if(!dP->bitstream->ei_flag)
  1201.         currMB->ei_flag = 0;
  1202.     }
  1203.   }
  1204.   // VLC Non-Intra
  1205.   else
  1206.   {
  1207.     if(img->cod_counter == -1)
  1208.     {
  1209.       TRACE_STRING("mb_skip_run");
  1210.       dP->readSyntaxElement(&currSE,img,dP);
  1211.       img->cod_counter = currSE.value1;
  1212.     }
  1213.     if (img->cod_counter==0)
  1214.     {
  1215.       // read MB aff
  1216.       if ((img->MbaffFrameFlag) && (((mb_nr&0x01)==0) || ((mb_nr&0x01) && prevMbSkipped)))
  1217.       {
  1218.         TRACE_STRING("mb_field_decoding_flag");
  1219.         currSE.len = (int64) 1;
  1220.         readSyntaxElement_FLC(&currSE, dP->bitstream);
  1221.         currMB->mb_field = currSE.value1;
  1222.       }
  1224.       // read MB type
  1225.       TRACE_STRING("mb_type");
  1226.       dP->readSyntaxElement(&currSE,img,dP);
  1227.       if(img->type == P_SLICE || img->type == SP_SLICE)
  1228.         currSE.value1++;
  1229.       currMB->mb_type = currSE.value1;
  1230.       if(!dP->bitstream->ei_flag)
  1231.         currMB->ei_flag = 0;
  1232.       img->cod_counter--;
  1233.       currMB->skip_flag = 0;
  1234.     }
  1235.     else
  1236.     {
  1237.       img->cod_counter--;
  1238.       currMB->mb_type = 0;
  1239.       currMB->ei_flag = 0;
  1240.       currMB->skip_flag = 1;
  1242.       // read field flag of bottom block
  1243.       if(img->MbaffFrameFlag)
  1244.       {
  1245.         if(img->cod_counter == 0 && ((mb_nr&0x01) == 0))
  1246.         {
  1247.           TRACE_STRING("mb_field_decoding_flag (of coded bottom mb)");
  1248.           currSE.len = (int64) 1;
  1249.           readSyntaxElement_FLC(&currSE, dP->bitstream);
  1250.           dP->bitstream->frame_bitoffset--;
  1251.           TRACE_DECBITS(1);
  1252.           currMB->mb_field = currSE.value1;
  1253.         }
  1254.         else if(img->cod_counter > 0 && ((mb_nr&0x01) == 0))
  1255.         {
  1256.           // check left macroblock pair first
  1257.           if (mb_is_available(mb_nr-2, currMB)&&((mb_nr%(img->PicWidthInMbs*2))!=0))
  1258.           {
  1259.             currMB->mb_field = img->mb_data[mb_nr-2].mb_field;
  1260.           }
  1261.           else
  1262.           {
  1263.             // check top macroblock pair
  1264.             if (mb_is_available(mb_nr - 2*img->PicWidthInMbs, currMB))
  1265.             {
  1266.               currMB->mb_field = img->mb_data[mb_nr-2*img->PicWidthInMbs].mb_field;
  1267.             }
  1268.             else
  1269.               currMB->mb_field = 0;
  1270.           }
  1271.         }
  1272.       }
  1273.     }
  1274.   }
  1276.   dec_picture->motion.mb_field[mb_nr] = (byte) currMB->mb_field;
  1278.   img->block_y_aff = ((img->MbaffFrameFlag) && (currMB->mb_field)) ? (mb_nr&0x01) ? (img->block_y - 4)>>1 : img->block_y >> 1 : img->block_y;
  1279.   img->siblock[img->mb_y][img->mb_x]=0;
  1280.   interpret_mb_mode(currMB);
  1282.   if(img->MbaffFrameFlag)
  1283.   {
  1284.     if(currMB->mb_field)
  1285.     {
  1286.       img->num_ref_idx_l0_active <<=1;
  1287.       img->num_ref_idx_l1_active <<=1;
  1288.     }
  1289.   }
  1291.   //init NoMbPartLessThan8x8Flag
  1292.   currMB->NoMbPartLessThan8x8Flag = (IS_DIRECT(currMB) && !(active_sps->direct_8x8_inference_flag))? 0: 1;
  1294.   //====== READ 8x8 SUB-PARTITION MODES (modes of 8x8 blocks) and Intra VBST block modes ======
  1295.   if (IS_P8x8 (currMB))
  1296.   {
  1297.     currSE.type    = SE_MBTYPE;
  1298.     dP = &(currSlice->partArr[partMap[SE_MBTYPE]]);
  1300.     if (active_pps->entropy_coding_mode_flag ==UVLC || dP->bitstream->ei_flag) 
  1301.       currSE.mapping = linfo_ue;
  1302.     else
  1303.       currSE.reading = readB8_typeInfo_CABAC;
  1305.     for (i=0; i<4; i++)
  1306.     {
  1307.       TRACE_STRING("sub_mb_type");
  1308.       dP->readSyntaxElement (&currSE, img, dP);
  1309.       SetB8Mode (img, currMB, currSE.value1, i);
  1311.       //set NoMbPartLessThan8x8Flag for P8x8 mode
  1312.       currMB->NoMbPartLessThan8x8Flag &= (currMB->b8mode[i]==0 && active_sps->direct_8x8_inference_flag) ||
  1313.                                          (currMB->b8mode[i]==4);
  1314.     }
  1315.     //--- init macroblock data ---
  1316.     init_macroblock       (img);
  1317.     readMotionInfoFromNAL (img, currMB);
  1318.   }
  1321.   //============= Transform Size Flag for INTRA MBs =============
  1322.   //-------------------------------------------------------------
  1323.   //transform size flag for INTRA_4x4 and INTRA_8x8 modes
  1324.   if (currMB->mb_type == I4MB && img->Transform8x8Mode)
  1325.   {
  1326.     currSE.type   =  SE_HEADER;
  1327.     dP = &(currSlice->partArr[partMap[SE_HEADER]]);
  1328.     currSE.reading = readMB_transform_size_flag_CABAC;
  1329.     TRACE_STRING("transform_size_8x8_flag");
  1331.     // read UVLC transform_size_8x8_flag
  1332.     if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)
  1333.     {
  1334.       currSE.len = (int64) 1;
  1335.       readSyntaxElement_FLC(&currSE, dP->bitstream);
  1336.     }
  1337.     else
  1338.     {
  1339.       dP->readSyntaxElement(&currSE,img,dP);
  1340.     }
  1342.     currMB->luma_transform_size_8x8_flag = currSE.value1;
  1344.     if (currMB->luma_transform_size_8x8_flag)
  1345.     {
  1346.       currMB->mb_type = I8MB;
  1347.       for (i=0;i<4;i++)
  1348.       {
  1349.         currMB->b8mode[i]=I8MB;
  1350.         currMB->b8pdir[i]=-1;
  1351.       }
  1352.     }
  1353.   }
  1354.   else
  1355.   {
  1356.     currMB->luma_transform_size_8x8_flag = 0;
  1357.   }
  1359.   if(active_pps->constrained_intra_pred_flag && (img->type==P_SLICE|| img->type==B_SLICE))        // inter frame
  1360.   {
  1361.     if( !IS_INTRA(currMB) )
  1362.     {
  1363.       img->intra_block[mb_nr] = 0;
  1364.     }
  1365.   }
  1367.   //! TO for error concealment
  1368.   //! If we have an INTRA Macroblock and we lost the partition
  1369.   //! which contains the intra coefficients Copy MB would be better
  1370.   //! than just a gray block.
  1371.   //! Seems to be a bit at the wrong place to do this right here, but for this case
  1372.   //! up to now there is no other way.
  1373. /*
  1374.  !!!KS
  1375.   dP = &(currSlice->partArr[partMap[SE_CBP_INTRA]]);
  1376.   if(IS_INTRA (currMB) && dP->bitstream->ei_flag && img->number)
  1377.   {
  1378.     currMB->mb_type = 0;
  1379.     currMB->ei_flag = 1;
  1380.     for (i=0;i<4;i++) {currMB->b8mode[i]=currMB->b8pdir[i]=0; }
  1381.   }
  1382.   dP = &(currSlice->partArr[partMap[currSE.type]]);
  1383.   //! End TO
  1384. */
  1386.   //--- init macroblock data ---
  1387.   if (!IS_P8x8 (currMB))
  1388.     init_macroblock(img);
  1390.   if (IS_DIRECT (currMB) && img->cod_counter >= 0)
  1391.   {
  1392.     currMB->cbp = 0;
  1393.     reset_coeffs();
  1395.     if (active_pps->entropy_coding_mode_flag ==CABAC)
  1396.       img->cod_counter=-1;
  1397.   }
  1398.   else if (IS_COPY (currMB)) //keep last macroblock
  1399.   {
  1400.     copy_macroblock(img, currMB);
  1401.   }
  1402.   else if(currMB->mb_type != IPCM)
  1403.   {
  1404.     // intra prediction modes for a macroblock 4x4 **********************************************
  1405.     if (IS_INTRA(currMB))
  1406.       read_ipred_modes(img, currMB);
  1408.     // read inter frame vector data *********************************************************
  1409.     if (IS_INTERMV (currMB) && (!IS_P8x8(currMB)))
  1410.     {
  1411.       readMotionInfoFromNAL (img, currMB);
  1412.     }
  1413.     // read CBP and Coeffs  ***************************************************************
  1414.     readCBPandCoeffsFromNAL (img, currMB);
  1415.   }
  1416.   else
  1417.   {
  1418.     //read pcm_alignment_zero_bit and pcm_byte[i]
  1420.     // here dP is assigned with the same dP as SE_MBTYPE, because IPCM syntax is in the
  1421.     // same category as MBTYPE
  1422.     if ( currSlice->dp_mode && currSlice->dpB_NotPresent )
  1423.     {
  1424.       concealIPCMcoeffs(img);
  1425.     }
  1426.     else
  1427.     {
  1428.       dP = &(currSlice->partArr[partMap[SE_LUM_DC_INTRA]]);
  1429.       readIPCMcoeffsFromNAL(img, dP);
  1430.     }
  1431.   }
  1433.   return;
  1434. }
  1437. /*!
  1438.  ************************************************************************
  1439.  * brief
  1440.  *    Initialize decoding engine after decoding an IPCM macroblock
  1441.  *    (for IPCM CABAC  28/11/2003)
  1442.  *
  1443.  * author
  1444.  *    Dong Wang <Dong.Wang@bristol.ac.uk>
  1445.  ************************************************************************
  1446.  */
  1447. void init_decoding_engine_IPCM(ImageParameters *img)
  1448. {
  1449.   Slice *currSlice = img->currentSlice;
  1450.   Bitstream *currStream;
  1451.   int ByteStartPosition;
  1452.   int PartitionNumber;
  1453.   int i;
  1455.   if(currSlice->dp_mode==PAR_DP_1)
  1456.     PartitionNumber=1;
  1457.   else if(currSlice->dp_mode==PAR_DP_3)
  1458.     PartitionNumber=3;
  1459.   else
  1460.   {
  1461.     printf("Partition Mode is not supportedn");
  1462.     exit(1);
  1463.   }
  1465.   for(i=0;i<PartitionNumber;i++)
  1466.   {
  1467.     currStream = currSlice->partArr[i].bitstream;
  1468.     ByteStartPosition = currStream->read_len;
  1470.     arideco_start_decoding (&currSlice->partArr[i].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len);
  1471.   }
  1472. }
  1477. /*!
  1478.  ************************************************************************
  1479.  * brief
  1480.  *    Read IPCM pcm_alignment_zero_bit and pcm_byte[i] from stream to img->cof
  1481.  *    (for IPCM CABAC and IPCM CAVLC)
  1482.  *
  1483.  * author
  1484.  *    Dong Wang <Dong.Wang@bristol.ac.uk>
  1485.  ************************************************************************
  1486.  */
  1488. static void readIPCMcoeffsFromNAL(ImageParameters *img, struct datapartition *dP)
  1489. {
  1490.   SyntaxElement currSE;
  1491.   int i,j;
  1493.   //For CABAC, we don't need to read bits to let stream byte aligned
  1494.   //  because we have variable for integer bytes position
  1495.   if(active_pps->entropy_coding_mode_flag  == CABAC)
  1496.   {
  1497.     readIPCM_CABAC(dP);
  1498.     init_decoding_engine_IPCM(img);
  1499.   }
  1500.   else
  1501.   {
  1502.     //read bits to let stream byte aligned
  1504.     if(((dP->bitstream->frame_bitoffset) & 0x07) != 0)
  1505.     {
  1506.       TRACE_STRING("pcm_alignment_zero_bit");
  1507.       currSE.len = (8 - ((dP->bitstream->frame_bitoffset) & 0x07));
  1508.       readSyntaxElement_FLC(&currSE, dP->bitstream);
  1509.     }
  1511.     //read luma and chroma IPCM coefficients
  1512.     currSE.len=img->bitdepth_luma;
  1513.     TRACE_STRING("pcm_sample_luma");
  1515.     for(i=0;i<MB_BLOCK_SIZE;i++)
  1516.     {
  1517.       for(j=0;j<MB_BLOCK_SIZE;j++)
  1518.       {
  1519.         readSyntaxElement_FLC(&currSE, dP->bitstream);
  1520.         img->cof[0][i][j] = currSE.value1;
  1521.         img->fcf[0][i][j] = currSE.value1;
  1522.       }
  1523.     }
  1524.     currSE.len=img->bitdepth_chroma;
  1525.     if ((dec_picture->chroma_format_idc != YUV400) && !IS_INDEPENDENT(img))
  1526.     {
  1527.       TRACE_STRING("pcm_sample_chroma (u)");
  1528.       for(i=0;i<img->mb_cr_size_y;i++)
  1529.       {
  1530.         for(j=0;j<img->mb_cr_size_x;j++)
  1531.         {
  1532.           readSyntaxElement_FLC(&currSE, dP->bitstream);
  1533.           img->cof[1][i][j] = currSE.value1;
  1534.           img->fcf[1][i][j] = currSE.value1;
  1535.         }
  1536.       }
  1537.       TRACE_STRING("pcm_sample_chroma (v)");
  1538.       for(i=0;i<img->mb_cr_size_y;i++)
  1539.       {
  1540.         for(j=0;j<img->mb_cr_size_x;j++)
  1541.         {
  1542.           readSyntaxElement_FLC(&currSE, dP->bitstream);
  1543.           img->cof[2][i][j] = currSE.value1;
  1544.           img->fcf[2][i][j] = currSE.value1;
  1545.         }
  1546.       }
  1547.     }
  1548.   }
  1549. }
  1552. /*!
  1553.  ************************************************************************
  1554.  * brief
  1555.  *    If data partition B is lost, conceal PCM sample values with DC.
  1556.  *
  1557.  ************************************************************************
  1558.  */
  1560. void concealIPCMcoeffs(ImageParameters *img)
  1561. {
  1562.   int i, j, k;
  1564.   for(i=0;i<MB_BLOCK_SIZE;i++)
  1565.   {
  1566.     for(j=0;j<MB_BLOCK_SIZE;j++)
  1567.     {
  1568.       img->cof[0][i][j] = img->dc_pred_value_comp[0];
  1569.       img->fcf[0][i][j] = img->dc_pred_value_comp[0];
  1570.     }
  1571.   }
  1573.   if ((dec_picture->chroma_format_idc != YUV400) && !IS_INDEPENDENT(img))
  1574.   {
  1575.     for (k = 0; k < 2; k++)
  1576.     {
  1577.       for(i=0;i<img->mb_cr_size_y;i++)
  1578.       {
  1579.         for(j=0;j<img->mb_cr_size_x;j++)
  1580.         {
  1581.           img->cof[k][i][j] = img->dc_pred_value_comp[k];
  1582.           img->fcf[k][i][j] = img->dc_pred_value_comp[k];
  1583.         }
  1584.       }
  1585.     }
  1586.   }
  1587. }
  1591. static void read_ipred_modes(ImageParameters *img, Macroblock *currMB)
  1592. {
  1593.   int b8,i,j,bi,bj,bx,by,dec;
  1594.   SyntaxElement currSE;
  1595.   DataPartition *dP;
  1596.   Slice *currSlice = img->currentSlice;
  1597.   int *partMap = assignSE2partition[currSlice->dp_mode];
  1598.   int ts, ls;
  1599.   int mostProbableIntraPredMode;
  1600.   int upIntraPredMode;
  1601.   int leftIntraPredMode;
  1602.   char IntraChromaPredModeFlag = IS_INTRA(currMB);
  1603.   int bs_x, bs_y;
  1604.   int ii,jj;
  1605.   
  1606.   PixelPos left_block, top_block;
  1608.   currSE.type = SE_INTRAPREDMODE;
  1610.   TRACE_STRING("intra4x4_pred_mode");
  1611.   dP = &(currSlice->partArr[partMap[currSE.type]]);
  1613.   if (!(active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag))
  1614.     currSE.reading = readIntraPredMode_CABAC;
  1615.     
  1616.   for(b8 = 0; b8 < 4; b8++)  //loop 8x8 blocks
  1617.   {
  1618.     if((currMB->b8mode[b8]==IBLOCK )||(currMB->b8mode[b8]==I8MB))
  1619.     {
  1620.       bs_x = bs_y = (currMB->b8mode[b8] == I8MB)?8:4;
  1622.       IntraChromaPredModeFlag = 1;
  1624.       ii = (bs_x>>2);
  1625.       jj = (bs_y>>2);
  1627.       for(j=0;j<2;j+=jj)  //loop subblocks
  1628.       {
  1629.         by = (b8&2) + j;
  1630.         bj = img->block_y + by;
  1631.         for(i=0;i<2;i+=ii)
  1632.         {
  1633.           bx = ((b8&1)<<1) + i;
  1634.           bi = img->block_x + bx;
  1635.           //get from stream
  1636.           if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag)
  1637.             readSyntaxElement_Intra4x4PredictionMode(&currSE,img,dP->bitstream);
  1638.           else
  1639.           {
  1640.             currSE.context=(b8<<2)+(j<<1) +i;
  1641.             dP->readSyntaxElement(&currSE,img,dP);
  1642.           }
  1644.           get4x4Neighbour(currMB, (bx<<2) - 1, (by<<2),     img->mb_size[IS_LUMA], &left_block);
  1645.           get4x4Neighbour(currMB, (bx<<2),     (by<<2) - 1, img->mb_size[IS_LUMA], &top_block );
  1647.           //get from array and decode
  1649.           if (active_pps->constrained_intra_pred_flag)
  1650.           {
  1651.             left_block.available = left_block.available ? img->intra_block[left_block.mb_addr] : 0;
  1652.             top_block.available  = top_block.available  ? img->intra_block[top_block.mb_addr]  : 0;
  1653.           }
  1655.           // !! KS: not sure if the following is still correct...
  1656.           ts = ls = 0;   // Check to see if the neighboring block is SI
  1657.           if (IS_OLDINTRA(currMB) && img->type == SI_SLICE)           // need support for MBINTLC1
  1658.           {
  1659.             if (left_block.available)
  1660.               if (img->siblock [left_block.pos_y][left_block.pos_x])
  1661.                 ls=1;
  1663.             if (top_block.available)
  1664.               if (img->siblock [top_block.pos_y][top_block.pos_x])
  1665.                 ts=1;
  1666.           }
  1668.           upIntraPredMode            = (top_block.available  &&(ts == 0)) ? img->ipredmode[top_block.pos_y ][top_block.pos_x ] : -1;
  1669.           leftIntraPredMode          = (left_block.available &&(ls == 0)) ? img->ipredmode[left_block.pos_y][left_block.pos_x] : -1;
  1671.           mostProbableIntraPredMode  = (upIntraPredMode < 0 || leftIntraPredMode < 0) ? DC_PRED : upIntraPredMode < leftIntraPredMode ? upIntraPredMode : leftIntraPredMode;
  1673.           dec = (currSE.value1 == -1) ? mostProbableIntraPredMode : currSE.value1 + (currSE.value1 >= mostProbableIntraPredMode);
  1675.           //set
  1676.           for(jj = 0; jj < (bs_y >> 2); jj++)   //loop 4x4s in the subblock for 8x8 prediction setting
  1677.           {
  1678.             memset(&(img->ipredmode[bj + jj][bi]), dec, (bs_x>>2) * sizeof(char));
  1679.           }
  1680.         }
  1681.       }
  1682.     }
  1683.   }
  1685.   if (IntraChromaPredModeFlag && (dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
  1686.   {
  1687.     currSE.type = SE_INTRAPREDMODE;
  1688.     TRACE_STRING("intra_chroma_pred_mode");
  1689.     dP = &(currSlice->partArr[partMap[currSE.type]]);
  1691.     if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag) 
  1692.       currSE.mapping = linfo_ue;
  1693.     else
  1694.       currSE.reading = readCIPredMode_CABAC;
  1696.     dP->readSyntaxElement(&currSE,img,dP);
  1697.     currMB->c_ipred_mode = currSE.value1;
  1699.     if (currMB->c_ipred_mode < DC_PRED_8 || currMB->c_ipred_mode > PLANE_8)
  1700.     {
  1701.       error("illegal chroma intra pred mode!n", 600);
  1702.     }
  1703.   }
  1704. }
  1706. /*!
  1707.  ************************************************************************
  1708.  * brief
  1709.  *    Set motion vector predictor
  1710.  ************************************************************************
  1711.  */
  1712. void SetMotionVectorPredictor (ImageParameters  *img,
  1713.                                Macroblock *currMB,                               
  1714.                                short           pred_mv[2],
  1715.                                char            ref_frame,
  1716.                                byte            list,
  1717.                                char            ***refPic,
  1718.                                short           ****tmp_mv,
  1719.                                int             mb_x,
  1720.                                int             mb_y,
  1721.                                int             blockshape_x,
  1722.                                int             blockshape_y)
  1723. {
  1724.   int mv_a, mv_b, mv_c, pred_vec=0;
  1725.   int mvPredType, rFrameL, rFrameU, rFrameUR;
  1726.   int hv;
  1729.   PixelPos block_a, block_b, block_c, block_d;
  1731.   get4x4Neighbour(currMB, mb_x - 1,            mb_y,     img->mb_size[IS_LUMA], &block_a);
  1732.   get4x4Neighbour(currMB, mb_x,                mb_y - 1, img->mb_size[IS_LUMA], &block_b);
  1733.   get4x4Neighbour(currMB, mb_x + blockshape_x, mb_y - 1, img->mb_size[IS_LUMA], &block_c);
  1734.   get4x4Neighbour(currMB, mb_x - 1,            mb_y - 1, img->mb_size[IS_LUMA], &block_d);
  1736.   if (mb_y > 0)
  1737.   {
  1738.     if (mb_x < 8)  // first column of 8x8 blocks
  1739.     {
  1740.       if (mb_y==8)
  1741.       {
  1742.         if (blockshape_x == 16)      
  1743.           block_c.available  = 0;
  1744.       }
  1745.       else
  1746.       {
  1747.         if (mb_x + blockshape_x == 8)  
  1748.           block_c.available  = 0;
  1749.       }
  1750.     }
  1751.     else
  1752.     {
  1753.       if (mb_x + blockshape_x == 16)   
  1754.         block_c.available  = 0;
  1755.     }
  1756.   }
  1758.   if (!block_c.available)
  1759.   {
  1760.     block_c = block_d;
  1761.   }
  1763.   mvPredType = MVPRED_MEDIAN;
  1765.   if (!img->MbaffFrameFlag)
  1766.   {
  1767.     rFrameL  = block_a.available ? refPic[list][block_a.pos_y][block_a.pos_x] : -1;
  1768.     rFrameU  = block_b.available ? refPic[list][block_b.pos_y][block_b.pos_x] : -1;
  1769.     rFrameUR = block_c.available ? refPic[list][block_c.pos_y][block_c.pos_x] : -1;
  1770.   }
  1771.   else
  1772.   {
  1773.     if (img->mb_data[img->current_mb_nr].mb_field)
  1774.     {
  1775.       rFrameL    = block_a.available    ?
  1776.         img->mb_data[block_a.mb_addr].mb_field ?
  1777.         refPic[list][block_a.pos_y][block_a.pos_x]:
  1778.         refPic[list][block_a.pos_y][block_a.pos_x] * 2:
  1779.         -1;
  1780.       rFrameU    = block_b.available    ?
  1781.         img->mb_data[block_b.mb_addr].mb_field ?
  1782.         refPic[list][block_b.pos_y][block_b.pos_x]:
  1783.         refPic[list][block_b.pos_y][block_b.pos_x] * 2:
  1784.         -1;
  1785.       rFrameUR    = block_c.available    ?
  1786.         img->mb_data[block_c.mb_addr].mb_field ?
  1787.         refPic[list][block_c.pos_y][block_c.pos_x]:
  1788.         refPic[list][block_c.pos_y][block_c.pos_x] * 2:
  1789.         -1;
  1790.     }
  1791.     else
  1792.     {
  1793.       rFrameL    = block_a.available    ?
  1794.         img->mb_data[block_a.mb_addr].mb_field ?
  1795.         refPic[list][block_a.pos_y][block_a.pos_x] >>1:
  1796.         refPic[list][block_a.pos_y][block_a.pos_x] :
  1797.         -1;
  1798.       rFrameU    = block_b.available    ?
  1799.         img->mb_data[block_b.mb_addr].mb_field ?
  1800.         refPic[list][block_b.pos_y][block_b.pos_x] >>1:
  1801.         refPic[list][block_b.pos_y][block_b.pos_x] :
  1802.         -1;
  1803.       rFrameUR    = block_c.available    ?
  1804.         img->mb_data[block_c.mb_addr].mb_field ?
  1805.         refPic[list][block_c.pos_y][block_c.pos_x] >>1:
  1806.         refPic[list][block_c.pos_y][block_c.pos_x] :
  1807.         -1;
  1808.     }
  1809.   }
  1812.   /* Prediction if only one of the neighbors uses the reference frame
  1813.    * we are checking
  1814.    */
  1815.   if (rFrameL == ref_frame && rFrameU != ref_frame && rFrameUR != ref_frame)       
  1816.     mvPredType = MVPRED_L;
  1817.   else if(rFrameL != ref_frame && rFrameU == ref_frame && rFrameUR != ref_frame)  
  1818.     mvPredType = MVPRED_U;
  1819.   else if(rFrameL != ref_frame && rFrameU != ref_frame && rFrameUR == ref_frame)  
  1820.     mvPredType = MVPRED_UR;
  1821.   // Directional predictions
  1822.   if(blockshape_x == 8 && blockshape_y == 16)
  1823.   {
  1824.     if(mb_x == 0)
  1825.     {
  1826.       if(rFrameL == ref_frame)
  1827.         mvPredType = MVPRED_L;
  1828.     }
  1829.     else
  1830.     {
  1831.       if( rFrameUR == ref_frame)
  1832.         mvPredType = MVPRED_UR;
  1833.     }
  1834.   }
  1835.   else if(blockshape_x == 16 && blockshape_y == 8)
  1836.   {
  1837.     if(mb_y == 0)
  1838.     {
  1839.       if(rFrameU == ref_frame)
  1840.         mvPredType = MVPRED_U;
  1841.     }
  1842.     else
  1843.     {
  1844.       if(rFrameL == ref_frame)
  1845.         mvPredType = MVPRED_L;
  1846.     }
  1847.   }
  1849.   for (hv=0; hv < 2; hv++)
  1850.   {
  1851.     if (!img->MbaffFrameFlag || hv==0)
  1852.     {
  1853.       mv_a = block_a.available ? tmp_mv[list][block_a.pos_y][block_a.pos_x][hv] : 0;
  1854.       mv_b = block_b.available ? tmp_mv[list][block_b.pos_y][block_b.pos_x][hv] : 0;
  1855.       mv_c = block_c.available ? tmp_mv[list][block_c.pos_y][block_c.pos_x][hv] : 0;
  1856.     }
  1857.     else
  1858.     {
  1859.       if (img->mb_data[img->current_mb_nr].mb_field)
  1860.       {
  1861.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field?
  1862.           tmp_mv[list][block_a.pos_y][block_a.pos_x][hv]:
  1863.           tmp_mv[list][block_a.pos_y][block_a.pos_x][hv] / 2:
  1864.           0;
  1865.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field?
  1866.           tmp_mv[list][block_b.pos_y][block_b.pos_x][hv]:
  1867.           tmp_mv[list][block_b.pos_y][block_b.pos_x][hv] / 2:
  1868.           0;
  1869.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field?
  1870.           tmp_mv[list][block_c.pos_y][block_c.pos_x][hv]:
  1871.           tmp_mv[list][block_c.pos_y][block_c.pos_x][hv] / 2:
  1872.           0;
  1873.       }
  1874.       else
  1875.       {
  1876.         mv_a = block_a.available  ? img->mb_data[block_a.mb_addr].mb_field?
  1877.           tmp_mv[list][block_a.pos_y][block_a.pos_x][hv] * 2:
  1878.           tmp_mv[list][block_a.pos_y][block_a.pos_x][hv]:
  1879.           0;
  1880.         mv_b = block_b.available  ? img->mb_data[block_b.mb_addr].mb_field?
  1881.           tmp_mv[list][block_b.pos_y][block_b.pos_x][hv] * 2:
  1882.           tmp_mv[list][block_b.pos_y][block_b.pos_x][hv]:
  1883.           0;
  1884.         mv_c = block_c.available  ? img->mb_data[block_c.mb_addr].mb_field?
  1885.           tmp_mv[list][block_c.pos_y][block_c.pos_x][hv] * 2:
  1886.           tmp_mv[list][block_c.pos_y][block_c.pos_x][hv]:
  1887.           0;
  1888.       }
  1889.     }
  1891.     switch (mvPredType)
  1892.     {
  1893.     case MVPRED_MEDIAN:
  1894.       if(!(block_b.available || block_c.available))
  1895.         pred_vec = mv_a;
  1896.       else
  1897.         pred_vec = mv_a + mv_b + mv_c - imin(mv_a,imin(mv_b,mv_c))-imax(mv_a,imax(mv_b,mv_c));
  1898.       break;
  1899.     case MVPRED_L:
  1900.       pred_vec = mv_a;
  1901.       break;
  1902.     case MVPRED_U:
  1903.       pred_vec = mv_b;
  1904.       break;
  1905.     case MVPRED_UR:
  1906.       pred_vec = mv_c;
  1907.       break;
  1908.     default:
  1909.       break;
  1910.     }
  1912.     pred_mv[hv] = (short) pred_vec;
  1913.   }
  1914. }
  1916. /*!
  1917.  ************************************************************************
  1918.  * brief
  1919.  *    Read motion info
  1920.  ************************************************************************
  1921.  */
  1922. static void readMotionInfoFromNAL (ImageParameters *img, Macroblock *currMB)
  1923. {
  1924.   int i,j,k;
  1925.   int mb_nr = img->current_mb_nr;
  1926.   SyntaxElement currSE;
  1927.   Slice *currSlice    = img->currentSlice;
  1928.   DataPartition *dP = NULL;
  1929.   int *partMap        = assignSE2partition[currSlice->dp_mode];
  1930.   int bslice          = (img->type==B_SLICE);
  1931.   int partmode        = (IS_P8x8(currMB)?4:currMB->mb_type);
  1932.   int step_h0         = BLOCK_STEP [partmode][0];
  1933.   int step_v0         = BLOCK_STEP [partmode][1];
  1935.   int i0, j0, j6;
  1937.   int j4, i4, ii;
  1938.   MotionParams *colocated;
  1940.   int mv_scale = 0;
  1942.   int list_offset = ((img->MbaffFrameFlag)&&(currMB->mb_field))? (mb_nr&0x01) ? 4 : 2 : 0;
  1945.   if (bslice)
  1946.   {
  1947.     if ((img->MbaffFrameFlag) && (currMB->mb_field))
  1948.     {
  1949.       if(mb_nr&0x01)
  1950.       {
  1951.         colocated = &Co_located->bottom;
  1952.       }
  1953.       else
  1954.       {
  1955.         colocated = &Co_located->top;
  1956.       }
  1957.     }
  1958.     else
  1959.     {
  1960.       colocated = &Co_located->frame;
  1961.     }
  1963.     if (IS_P8x8 (currMB))
  1964.     {
  1965.       if (img->direct_spatial_mv_pred_flag)
  1966.       {
  1967.         char  l0_rFrame, l1_rFrame;
  1968.         short pmvl0[2]={0,0}, pmvl1[2]={0,0};
  1970.         prepare_direct_params(currMB, dec_picture, img, pmvl0, pmvl1, &l0_rFrame, &l1_rFrame);
  1972.         for (k = 0; k < 4; k++)
  1973.         {        
  1974.           if (currMB->b8mode[k] == 0)
  1975.           {
  1976.             i = img->block_x + 2 * (k & 0x01);
  1977.             for(j = 2 * (k >> 1); j < 2 * (k >> 1)+2;j++)
  1978.             {
  1979.               j6 = img->block_y_aff + j;
  1980.               j4 = img->block_y     + j;
  1981.               for(i4 = i; i4 < i + 2; i4++)
  1982.               {
  1983.                 if (l0_rFrame >= 0)
  1984.                 {
  1985.                   if  (!l0_rFrame  && ((!colocated->moving_block[j6][i4]) && (!listX[LIST_1 + list_offset][0]->is_long_term)))
  1986.                   {
  1987.                     dec_picture->motion.mv  [LIST_0][j4][i4][0] = 0;
  1988.                     dec_picture->motion.mv  [LIST_0][j4][i4][1] = 0;
  1989.                     dec_picture->motion.ref_idx[LIST_0][j4][i4] = 0;
  1990.                   }
  1991.                   else
  1992.                   {
  1993.                     dec_picture->motion.mv  [LIST_0][j4][i4][0] = pmvl0[0];
  1994.                     dec_picture->motion.mv  [LIST_0][j4][i4][1] = pmvl0[1];
  1995.                     dec_picture->motion.ref_idx[LIST_0][j4][i4] = l0_rFrame;
  1996.                   }
  1997.                 }
  1998.                 else
  1999.                 {
  2000.                   dec_picture->motion.mv  [LIST_0][j4][i4][0] = 0;
  2001.                   dec_picture->motion.mv  [LIST_0][j4][i4][1] = 0;
  2002.                   dec_picture->motion.ref_idx[LIST_0][j4][i4] = -1;
  2003.                 }
  2005.                 if (l1_rFrame >= 0)
  2006.                 {
  2007.                   if  (l1_rFrame==0 && ((!colocated->moving_block[j6][i4])&& (!listX[LIST_1 + list_offset][0]->is_long_term)))
  2008.                   {
  2009.                     dec_picture->motion.mv  [LIST_1][j4][i4][0] = 0;
  2010.                     dec_picture->motion.mv  [LIST_1][j4][i4][1] = 0;
  2011.                     dec_picture->motion.ref_idx[LIST_1][j4][i4] = 0;
  2012.                   }
  2013.                   else
  2014.                   {
  2015.                     dec_picture->motion.mv  [LIST_1][j4][i4][0] = pmvl1[0];
  2016.                     dec_picture->motion.mv  [LIST_1][j4][i4][1] = pmvl1[1];
  2017.                     dec_picture->motion.ref_idx[LIST_1][j4][i4] = l1_rFrame;
  2018.                   }
  2019.                 }
  2020.                 else
  2021.                 {
  2022.                   dec_picture->motion.mv  [LIST_1][j4][i4][0] = 0;
  2023.                   dec_picture->motion.mv  [LIST_1][j4][i4][1] = 0;
  2024.                   dec_picture->motion.ref_idx[LIST_1][j4][i4] = -1;
  2025.                 }
  2027.                 if (l0_rFrame <0 && l1_rFrame <0)
  2028.                 {
  2029.                   dec_picture->motion.ref_idx[LIST_0][j4][i4] = 0;
  2030.                   dec_picture->motion.ref_idx[LIST_1][j4][i4] = 0;
  2031.                 }
  2032.               }
  2033.             }
  2034.           }
  2035.         }
  2036.       }
  2037.       else
  2038.       {
  2039.         for (k = 0; k < 4; k++) // Scan all blocks
  2040.         {
  2041.           if (currMB->b8mode[k] == 0)
  2042.           {
  2043.             for(j0 = 2 * (k >> 1); j0 < 2 * (k >> 1) + 2; j0 += step_v0)
  2044.             {
  2045.               for(i0 = img->block_x + 2*(k & 0x01); i0 < img->block_x + 2 * (k & 0x01)+2; i0 += step_h0)
  2046.               {
  2047.                 int refList = colocated->ref_idx[LIST_0 ][img->block_y_aff + j0][i0]== -1 ? LIST_1 : LIST_0;
  2048.                 int ref_idx = colocated->ref_idx[refList][img->block_y_aff + j0][i0];
  2049.                 int mapped_idx = -1, iref;
  2051.                 if (ref_idx == -1)
  2052.                 {
  2053.                   for (j4 = img->block_y + j0; j4 < img->block_y + j0 + step_v0; j4++)
  2054.                   {
  2055.                     memset(&dec_picture->motion.ref_idx [LIST_0][j4][i0],    0,     step_h0 * sizeof(char));
  2056.                     memset(&dec_picture->motion.ref_idx [LIST_1][j4][i0],    0,     step_h0 * sizeof(char));
  2057.                     memset(&dec_picture->motion.mv      [LIST_0][j4][i0][0], 0, 2 * step_h0 * sizeof(short));
  2058.                     memset(&dec_picture->motion.mv      [LIST_1][j4][i0][0], 0, 2 * step_h0 * sizeof(short));
  2059.                   }
  2060.                 }
  2061.                 else
  2062.                 {
  2063.                   for (iref = 0; iref < imin(img->num_ref_idx_l0_active,listXsize[LIST_0 + list_offset]); iref++)
  2064.                   {
  2065.                     int curr_mb_field = ((img->MbaffFrameFlag)&&(currMB->mb_field));
  2067.                     if(img->structure==0 && curr_mb_field==0)
  2068.                     {
  2069.                       // If the current MB is a frame MB and the colocated is from a field picture,
  2070.                       // then the colocated->ref_pic_id may have been generated from the wrong value of
  2071.                       // frame_poc if it references it's complementary field, so test both POC values
  2072.                       if(listX[0][iref]->top_poc * 2    == colocated->ref_pic_id[refList][img->block_y_aff + j0][i0]
  2073.                       || listX[0][iref]->bottom_poc * 2 == colocated->ref_pic_id[refList][img->block_y_aff + j0][i0])
  2074.                       {
  2075.                         mapped_idx=iref;
  2076.                         break;
  2077.                       }
  2078.                       else //! invalid index. Default to zero even though this case should not happen
  2079.                         mapped_idx=INVALIDINDEX;
  2080.                       continue;
  2081.                     }
  2082.                     if (dec_picture->ref_pic_num[img->current_slice_nr][LIST_0 + list_offset][iref]==colocated->ref_pic_id[refList][img->block_y_aff + j0][i0])
  2083.                     {
  2084.                       mapped_idx=iref;
  2085.                       break;
  2086.                     }
  2087.                     else //! invalid index. Default to zero even though this case should not happen
  2088.                       mapped_idx=INVALIDINDEX;
  2089.                   }
  2091.                   if (INVALIDINDEX == mapped_idx)
  2092.                   {
  2093.                     error("temporal direct errorncolocated block has ref that is unavailable",-1111);
  2094.                   }
  2096.                   for (j = j0; j < j0 + step_v0; j++)
  2097.                   {
  2098.                     j4 = img->block_y + j;
  2099.                     j6 = img->block_y_aff + j;
  2101.                     for (i4 = i0; i4 < i0 + step_h0; i4++)
  2102.                     {
  2103.                       mv_scale = img->mvscale[LIST_0 + list_offset][mapped_idx];
  2105.                       dec_picture->motion.ref_idx [LIST_0][j4][i4] = (char) mapped_idx;
  2106.                       dec_picture->motion.ref_idx [LIST_1][j4][i4] = 0;
  2108.                       for (ii=0; ii < 2; ii++)
  2109.                       {
  2110.                         if (mv_scale == 9999 || listX[LIST_0+list_offset][mapped_idx]->is_long_term)
  2111.                         {
  2112.                           dec_picture->motion.mv  [LIST_0][j4][i4][ii] = colocated->mv[refList][j6][i4][ii];
  2113.                           dec_picture->motion.mv  [LIST_1][j4][i4][ii] = 0;
  2114.                         }
  2115.                         else
  2116.                         {
  2117.                           dec_picture->motion.mv  [LIST_0][j4][i4][ii] = (short) ((mv_scale * colocated->mv[refList][j6][i4][ii] + 128 ) >> 8);
  2118.                           dec_picture->motion.mv  [LIST_1][j4][i4][ii] = (short) (dec_picture->motion.mv[LIST_0][j4][i4][ii] - colocated->mv[refList][j6][i4][ii]);
  2119.                         }
  2120.                       }
  2121.                     }
  2122.                   }
  2123.                 }
  2124.               }
  2125.             }
  2126.           }
  2127.         }
  2128.       }
  2129.     }
  2130.   }
  2132.   //=====  READ REFERENCE PICTURE INDICES =====
  2133.   currSE.type = SE_REFFRAME;
  2134.   dP = &(currSlice->partArr[partMap[SE_REFFRAME]]);
  2135.   //  For LIST_0, if multiple ref. pictures, read LIST_0 reference picture indices for the MB ***********
  2136.   prepareListforRefIdx (&currSE, dP, img->num_ref_idx_l0_active, !IS_P8x8 (currMB) || bslice || (!img->allrefzero));
  2137.   readMBRefPictureIdx  (&currSE, dP, currMB, img, &dec_picture->motion.ref_idx[LIST_0][img->block_y], LIST_0, step_v0, step_h0);
  2139.   //  For LIST_1, if multiple ref. pictures, read LIST_1 reference picture indices for the MB ***********
  2140.   prepareListforRefIdx (&currSE, dP, img->num_ref_idx_l1_active, !IS_P8x8 (currMB) || bslice || (!img->allrefzero));
  2141.   readMBRefPictureIdx  (&currSE, dP, currMB, img, &dec_picture->motion.ref_idx[LIST_1][img->block_y], LIST_1, step_v0, step_h0);
  2143.   //=====  READ MOTION VECTORS =====
  2144.   currSE.type = SE_MVD;
  2145.   dP = &(currSlice->partArr[partMap[SE_MVD]]);
  2147.   if (active_pps->entropy_coding_mode_flag == UVLC || dP->bitstream->ei_flag) 
  2148.     currSE.mapping = linfo_se;
  2149.   else                                                  
  2150.     currSE.reading = readMVD_CABAC;
  2152.   // LIST_0 Motion vectors
  2153.   readMBMotionVectors (&currSE, dP, currMB, img, LIST_0, step_h0, step_v0);
  2154.   // LIST_1 Motion vectors
  2155.   if (bslice)
  2156.     readMBMotionVectors (&currSE, dP, currMB, img, LIST_1, step_h0, step_v0);
  2158.   // record reference picture Ids for deblocking decisions
  2160.   for (k = LIST_0; k <= (bslice ? LIST_1: LIST_0); k++)
  2161.   {
  2162.     for(j4 = img->block_y; j4 < (img->block_y +4);j4++)
  2163.     {
  2164.       for(i4 = img->block_x; i4 < (img->block_x + 4);i4++)
  2165.       {
  2166.         if (dec_picture->motion.ref_idx[k][j4][i4]>=0)
  2167.           dec_picture->motion.ref_pic_id[k][j4][i4] = dec_picture->ref_pic_num[img->current_slice_nr][k + list_offset][(short)dec_picture->motion.ref_idx[k][j4][i4]];
  2168.         else
  2169.           dec_picture->motion.ref_pic_id[k][j4][i4] = INT64_MIN;
  2170.       }
  2171.     }
  2172.   }
  2173. }
  2175. /*!
  2176.  ************************************************************************
  2177.  * brief
  2178.  *    Get the Prediction from the Neighboring Blocks for Number of 
  2179.  *    Nonzero Coefficients
  2180.  *
  2181.  *    Luma Blocks
  2182.  ************************************************************************
  2183.  */
  2184. int predict_nnz(Macroblock *currMB, int block_type, ImageParameters *img, int i,int j)
  2185. {
  2186.   PixelPos pix;
  2188.   int pred_nnz = 0;
  2189.   int cnt      = 0;
  2191.   // left block
  2192.   get4x4Neighbour(currMB, i - 1, j, img->mb_size[IS_LUMA], &pix);
  2194.   if (IS_INTRA(currMB) && pix.available && active_pps->constrained_intra_pred_flag && (img->currentSlice->dp_mode==PAR_DP_3))
  2195.   {
  2196.     pix.available &= img->intra_block[pix.mb_addr];
  2197.     if (!pix.available)
  2198.       cnt++;
  2199.   }
  2201.   if (pix.available)
  2202.   { 
  2203.     switch (block_type)
  2204.     {
  2205.     case LUMA:
  2206.       pred_nnz = img->nz_coeff [pix.mb_addr ][0][pix.y][pix.x];
  2207.       cnt++;
  2208.       break;
  2209.     case CB:
  2210.       pred_nnz = img->nz_coeff [pix.mb_addr ][1][pix.y][pix.x];
  2211.       cnt++;
  2212.       break;
  2213.     case CR:
  2214.       pred_nnz = img->nz_coeff [pix.mb_addr ][2][pix.y][pix.x];
  2215.       cnt++;
  2216.       break;
  2217.     default:
  2218.       error("writeCoeff4x4_CAVLC: Invalid block type", 600);
  2219.       break;
  2220.     }
  2221.   }
  2223.   // top block
  2224.   get4x4Neighbour(currMB, i, j - 1, img->mb_size[IS_LUMA], &pix);
  2226.   if (IS_INTRA(currMB) && pix.available && active_pps->constrained_intra_pred_flag && (img->currentSlice->dp_mode==PAR_DP_3))
  2227.   {
  2228.     pix.available &= img->intra_block[pix.mb_addr];
  2229.     if (!pix.available)
  2230.       cnt++;
  2231.   }
  2233.   if (pix.available)
  2234.   {
  2235.     switch (block_type)
  2236.     {
  2237.     case LUMA:
  2238.       pred_nnz += img->nz_coeff [pix.mb_addr ][0][pix.y][pix.x];
  2239.       cnt++;
  2240.       break;
  2241.     case CB:
  2242.       pred_nnz += img->nz_coeff [pix.mb_addr ][1][pix.y][pix.x];
  2243.       cnt++;
  2244.       break;
  2245.     case CR:
  2246.       pred_nnz += img->nz_coeff [pix.mb_addr ][2][pix.y][pix.x];
  2247.       cnt++;
  2248.       break;
  2249.     default:
  2250.       error("writeCoeff4x4_CAVLC: Invalid block type", 600);
  2251.       break;
  2252.     }
  2253.   }
  2255.   if (cnt==2)
  2256.   {
  2257.     pred_nnz++;
  2258.     pred_nnz>>=1;
  2259.   }
  2261.   return pred_nnz;
  2262. }
  2265. /*!
  2266.  ************************************************************************
  2267.  * brief
  2268.  *    Get the Prediction from the Neighboring Blocks for Number of 
  2269.  *    Nonzero Coefficients
  2270.  *
  2271.  *    Chroma Blocks
  2272.  ************************************************************************
  2273.  */
  2274. int predict_nnz_chroma(Macroblock *currMB, ImageParameters *img, int i,int j)
  2275. {
  2276.   PixelPos pix;
  2278.   int pred_nnz = 0;
  2279.   int cnt      = 0;
  2281.   if (dec_picture->chroma_format_idc != YUV444)
  2282.   {
  2283.     //YUV420 and YUV422
  2284.     // left block
  2285.     get4x4Neighbour(currMB, ((i&0x01)<<2) - 1, j, img->mb_size[IS_CHROMA], &pix);
  2287.     if (IS_INTRA(currMB) && pix.available && active_pps->constrained_intra_pred_flag && (img->currentSlice->dp_mode==PAR_DP_3))
  2288.     {
  2289.       pix.available &= img->intra_block[pix.mb_addr];
  2290.       if (!pix.available)
  2291.         cnt++;
  2292.     }
  2294.     if (pix.available)
  2295.     {
  2296.       pred_nnz = img->nz_coeff [pix.mb_addr ][1][pix.y][2 * (i>>1) + pix.x];
  2297.       cnt++;
  2298.     }
  2300.     // top block
  2301.     get4x4Neighbour(currMB, ((i&0x01)<<2), j - 1, img->mb_size[IS_CHROMA], &pix);
  2303.     if (IS_INTRA(currMB) && pix.available && active_pps->constrained_intra_pred_flag && (img->currentSlice->dp_mode==PAR_DP_3))
  2304.     {
  2305.       pix.available &= img->intra_block[pix.mb_addr];
  2306.       if (!pix.available)
  2307.         cnt++;
  2308.     }
  2310.     if (pix.available)
  2311.     {
  2312.       pred_nnz += img->nz_coeff [pix.mb_addr ][1][pix.y][2 * (i>>1) + pix.x];
  2313.       cnt++;
  2314.     }
  2316.     if (cnt==2)
  2317.     {
  2318.       pred_nnz++;
  2319.       pred_nnz >>= 1;
  2320.     }
  2321.   }
  2323.   return pred_nnz;
  2324. }
  2327. /*!
  2328.  ************************************************************************
  2329.  * brief
  2330.  *    Reads coeff of an 4x4 block (CAVLC)
  2331.  *
  2332.  * author
  2333.  *    Karl Lillevold <karll@real.com>
  2334.  *    contributions by James Au <james@ubvideo.com>
  2335.  ************************************************************************
  2336.  */
  2337. void readCoeff4x4_CAVLC (Macroblock *currMB, ImageParameters *img,
  2338.                          int block_type,
  2339.                          int i, int j, int levarr[16], int runarr[16],
  2340.                          int *number_coefficients)
  2341. {
  2342.   int mb_nr = img->current_mb_nr;
  2343.   SyntaxElement currSE;
  2344.   Slice *currSlice = img->currentSlice;
  2345.   DataPartition *dP;
  2346.   int *partMap = assignSE2partition[currSlice->dp_mode];
  2347.   static Bitstream *currStream;
  2349.   int k, code, vlcnum;
  2350.   static int numcoeff, numtrailingones, numcoeff_vlc;
  2351.   static int level_two_or_higher;
  2352.   int numones, totzeros, abslevel, cdc=0, cac=0;
  2353.   int zerosleft, ntr, dptype = 0;
  2354.   int max_coeff_num = 0, nnz;
  2355.   static char type[15];
  2356.   static int incVlc[] = {0,3,6,12,24,48,32768};    // maximum vlc = 6
  2358.   numcoeff = 0;
  2359.   
  2360.   switch (block_type)
  2361.   {
  2362.   case LUMA:
  2363.     max_coeff_num = 16;
  2364.     TRACE_PRINTF("Luma");
  2365.     dptype = IS_INTRA (currMB) ? SE_LUM_AC_INTRA : SE_LUM_AC_INTER;
  2366.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2367.     break;
  2368.   case LUMA_INTRA16x16DC:
  2369.     max_coeff_num = 16;
  2370.     TRACE_PRINTF("Lum16DC");
  2371.     dptype = SE_LUM_DC_INTRA;
  2372.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2373.     break;
  2374.   case LUMA_INTRA16x16AC:
  2375.     max_coeff_num = 15;
  2376.     TRACE_PRINTF("Lum16AC");
  2377.     dptype = SE_LUM_AC_INTRA;
  2378.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2379.     break;
  2380.   case CB:
  2381.     max_coeff_num = 16;
  2382.     TRACE_PRINTF("Luma_add1");
  2383.     dptype = (IS_INTRA (currMB)) ? SE_LUM_AC_INTRA : SE_LUM_AC_INTER;
  2384.     img->nz_coeff[mb_nr][1][j][i] = 0; 
  2385.     break;
  2386.   case CB_INTRA16x16DC:
  2387.     max_coeff_num = 16;
  2388.     TRACE_PRINTF("Luma_add1_16DC");
  2389.     dptype = SE_LUM_DC_INTRA;
  2390.     img->nz_coeff[mb_nr][1][j][i] = 0; 
  2391.     break;
  2392.   case CB_INTRA16x16AC:
  2393.     max_coeff_num = 15;
  2394.     TRACE_PRINTF("Luma_add1_16AC");
  2395.     dptype = SE_LUM_AC_INTRA;
  2396.     img->nz_coeff[mb_nr][1][j][i] = 0; 
  2397.     break;
  2398.   case CR:
  2399.     max_coeff_num = 16;
  2400.     TRACE_PRINTF("Luma_add2");
  2401.     dptype = (IS_INTRA (currMB)) ? SE_LUM_AC_INTRA : SE_LUM_AC_INTER;
  2402.     img->nz_coeff[mb_nr][2][j][i] = 0; 
  2403.     break;
  2404.   case CR_INTRA16x16DC:
  2405.     max_coeff_num = 16;
  2406.     TRACE_PRINTF("Luma_add2_16DC");
  2407.     dptype = SE_LUM_DC_INTRA;
  2408.     img->nz_coeff[mb_nr][2][j][i] = 0; 
  2409.     break;
  2410.   case CR_INTRA16x16AC:
  2411.     max_coeff_num = 15;
  2412.     TRACE_PRINTF("Luma_add1_16AC");
  2413.     dptype = SE_LUM_AC_INTRA;
  2414.     img->nz_coeff[mb_nr][2][j][i] = 0; 
  2415.     break;        
  2416.   case CHROMA_DC:
  2417.     max_coeff_num = img->num_cdc_coeff;
  2418.     cdc = 1;
  2419.     TRACE_PRINTF("ChrDC");
  2420.     dptype = IS_INTRA (currMB) ? SE_CHR_DC_INTRA : SE_CHR_DC_INTER;
  2421.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2422.     break;
  2423.   case CHROMA_AC:
  2424.     max_coeff_num = 15;
  2425.     cac = 1;
  2426.     TRACE_PRINTF("ChrDC");
  2427.     dptype = IS_INTRA (currMB) ? SE_CHR_AC_INTRA : SE_CHR_AC_INTER;
  2428.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2429.     break;
  2430.   default:
  2431.     error ("readCoeff4x4_CAVLC: invalid block type", 600);
  2432.     img->nz_coeff[mb_nr][0][j][i] = 0; 
  2433.     break;
  2434.   }
  2435.   
  2436.   currSE.type = dptype;
  2437.   dP = &(currSlice->partArr[partMap[dptype]]);
  2438.   currStream = dP->bitstream;  
  2439.   
  2440.   if (!cdc)
  2441.   {    
  2442.     // luma or chroma AC    
  2443.     if(block_type==LUMA || block_type==LUMA_INTRA16x16DC || block_type==LUMA_INTRA16x16AC ||block_type==CHROMA_AC)
  2444.     {
  2445.       nnz = (!cac) ? predict_nnz(currMB, LUMA, img, i<<2, j<<2) : predict_nnz_chroma(currMB, img, i, ((j-4)<<2));
  2446.     }
  2447.     else if (block_type==CB || block_type==CB_INTRA16x16DC || block_type==CB_INTRA16x16AC)
  2448.     {   
  2449.       nnz = predict_nnz(currMB, CB, img, i<<2, j<<2);
  2450.     }
  2451.     else
  2452.     { 
  2453.       nnz = predict_nnz(currMB, CR, img, i<<2, j<<2);
  2454.     }
  2455.     
  2456.     if (nnz < 2)
  2457.     {
  2458.       numcoeff_vlc = 0;
  2459.     }
  2460.     else if (nnz < 4)
  2461.     {
  2462.       numcoeff_vlc = 1;
  2463.     }
  2464.     else if (nnz < 8)
  2465.     {
  2466.       numcoeff_vlc = 2;
  2467.     }
  2468.     else //
  2469.     {
  2470.       numcoeff_vlc = 3;
  2471.     }
  2472.     
  2473.     currSE.value1 = numcoeff_vlc;
  2474.     
  2475.     readSyntaxElement_NumCoeffTrailingOnes(&currSE, currStream, type);
  2476.     
  2477.     numcoeff        =  currSE.value1;
  2478.     numtrailingones =  currSE.value2;
  2479.     
  2480.     if(block_type==LUMA || block_type==LUMA_INTRA16x16DC || block_type==LUMA_INTRA16x16AC ||block_type==CHROMA_AC)
  2481.       img->nz_coeff[mb_nr][0][j][i] = numcoeff;
  2482.     else if (block_type==CB || block_type==CB_INTRA16x16DC || block_type==CB_INTRA16x16AC)
  2483.       img->nz_coeff[mb_nr][1][j][i] = numcoeff;
  2484.     else
  2485.       img->nz_coeff[mb_nr][2][j][i] = numcoeff;        
  2486.   }
  2487.   else
  2488.   {
  2489.     // chroma DC
  2490.     readSyntaxElement_NumCoeffTrailingOnesChromaDC(&currSE, currStream);
  2491.     
  2492.     numcoeff        =  currSE.value1;
  2493.     numtrailingones =  currSE.value2;
  2494.   }
  2495.   
  2496.   memset(levarr, 0, max_coeff_num * sizeof(int));
  2497.   memset(runarr, 0, max_coeff_num * sizeof(int));
  2498.   
  2499.   numones = numtrailingones;
  2500.   *number_coefficients = numcoeff;
  2501.   
  2502.   if (numcoeff)
  2503.   {
  2504.     if (numtrailingones)
  2505.     {      
  2506.       currSE.len = numtrailingones;
  2507.       
  2508. #if TRACE
  2509.       snprintf(currSE.tracestring,
  2510.         TRACESTRING_SIZE, "%s trailing ones sign (%d,%d)", type, i, j);
  2511. #endif
  2512.       
  2513.       readSyntaxElement_FLC (&currSE, currStream);
  2514.       
  2515.       code = currSE.inf;
  2516.       ntr = numtrailingones;
  2517.       for (k = numcoeff - 1; k > numcoeff - 1 - numtrailingones; k--)
  2518.       {
  2519.         ntr --;
  2520.         levarr[k] = (code>>ntr)&1 ? -1 : 1;
  2521.       }
  2522.     }
  2523.     
  2524.     // decode levels
  2525.     level_two_or_higher = (numcoeff > 3 && numtrailingones == 3)? 0 : 1;
  2526.     vlcnum = (numcoeff > 10 && numtrailingones < 3) ? 1 : 0;
  2527.     
  2528.     for (k = numcoeff - 1 - numtrailingones; k >= 0; k--)
  2529.     {
  2530.       
  2531. #if TRACE
  2532.       snprintf(currSE.tracestring,
  2533.        TRACESTRING_SIZE, "%s lev (%d,%d) k=%d vlc=%d ", type, i, j, k, vlcnum);
  2534. #endif
  2535.       
  2536.       if (vlcnum == 0)
  2537.         readSyntaxElement_Level_VLC0(&currSE, currStream);
  2538.       else
  2539.         readSyntaxElement_Level_VLCN(&currSE, vlcnum, currStream);
  2540.       
  2541.       if (level_two_or_higher)
  2542.       {
  2543.         currSE.inf += (currSE.inf > 0) ? 1 : -1;
  2544.         level_two_or_higher = 0;
  2545.       }
  2546.       
  2547.       levarr[k] = currSE.inf;
  2548.       abslevel = iabs(levarr[k]);
  2549.       if (abslevel  == 1)
  2550.         numones ++;
  2551.       
  2552.       // update VLC table
  2553.       if (abslevel  > incVlc[vlcnum])
  2554.         vlcnum++;
  2555.       
  2556.       if (k == numcoeff - 1 - numtrailingones && abslevel >3)
  2557.         vlcnum = 2;      
  2558.     }
  2559.     
  2560.     if (numcoeff < max_coeff_num)
  2561.     {
  2562.       // decode total run
  2563.       vlcnum = numcoeff - 1;
  2564.       currSE.value1 = vlcnum;
  2565.       
  2566. #if TRACE
  2567.       snprintf(currSE.tracestring,
  2568.         TRACESTRING_SIZE, "%s totalrun (%d,%d) vlc=%d ", type, i,j, vlcnum);
  2569. #endif
  2570.       if (cdc)
  2571.         readSyntaxElement_TotalZerosChromaDC(&currSE, currStream);
  2572.       else
  2573.         readSyntaxElement_TotalZeros(&currSE, currStream);
  2574.       
  2575.       totzeros = currSE.value1;
  2576.     }
  2577.     else
  2578.     {
  2579.       totzeros = 0;
  2580.     }
  2581.     
  2582.     // decode run before each coefficient
  2583.     zerosleft = totzeros;
  2584.     i = numcoeff - 1;
  2586.     if (zerosleft > 0 && i > 0)
  2587.     {
  2588.       do
  2589.       {
  2590.         // select VLC for runbefore
  2591.         vlcnum = imin(zerosleft - 1, RUNBEFORE_NUM_M1);
  2593.         currSE.value1 = vlcnum;
  2594. #if TRACE
  2595.         snprintf(currSE.tracestring,
  2596.           TRACESTRING_SIZE, "%s run (%d,%d) k=%d vlc=%d ",
  2597.           type, i, j, i, vlcnum);
  2598. #endif
  2599.         
  2600.         readSyntaxElement_Run(&currSE, currStream);
  2601.         runarr[i] = currSE.value1;
  2602.         
  2603.         zerosleft -= runarr[i];
  2604.         i --;
  2605.       } while (zerosleft != 0 && i != 0);
  2606.     }
  2607.     runarr[i] = zerosleft;    
  2608.   } // if numcoeff
  2609. }
  2614. /*!
  2615. ************************************************************************
  2616. * brief
  2617. *    Get coefficients (run/level) of one 8x8 block
  2618. *    from the NAL (CABAC Mode)
  2619. ************************************************************************
  2620. */
  2621. static void readLumaCoeff8x8_CABAC (ImageParameters *img, Macroblock *currMB, ColorPlane pl, int b8)
  2622. {
  2623.   static int (*tcoeffs)[16];
  2624.   int i,j,k;