Ticket #44: fix_zeroout_clean.patch

File fix_zeroout_clean.patch, 61.3 KB (added by XiangLi, 7 years ago)

fix and cleanning

  • source/Lib/TLibCommon/CommonDef.h

     
    218218static const Int  LM_SYMBOL_NUM = (2 + JVET_E0077_MMLM + LM_FILTER_NUM);
    219219#endif
    220220
     221static const Int ZERO_OUT_TH =                                    32;  ///< threshold of zeor-out transform
    221222
    222223#if COM16_C806_T64
    223224#if JVET_C0024_QTBT
    224 static const Int MLS_GRP_NUM =                                    1024; ///< Max number of coefficient groups, max(16, 256)
     225static const Int MLS_GRP_NUM =                                   1024; ///< Max number of coefficient groups, max(16, 256)
    225226#else
    226227static const Int MLS_GRP_NUM =                                    256; ///< Max number of coefficient groups, max(16, 256)
    227228#endif
    … …  
    238239
    239240#if JVET_C0046_ZO_ASSERT
    240241static const Int TH_LOG2TBAREASIZE =                               10; ///< Threshold for zeroing out
    241 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    242 static const Int JVET_C0046_ZERO_OUT_TH =                          32;
    243242#endif
    244 #endif
    245243
    246244#if ADAPTIVE_QP_SELECTION
    247245static const Int ARL_C_PRECISION =                                  7; ///< G382: 7-bit arithmetic precision
    … …  
    474472static const Double PBINTRA_RATIO     =                             1.1;
    475473#endif
    476474
    477 #if JVET_C0024_ZERO_OUT_FIX
    478 static const Int    JVET_C0024_ZERO_OUT_TH =                        32;
    479 #endif
    480 
    481475//QTBT high level parameters
    482476//for I slice luma CTB configuration para.
    483477static const Int    MAX_BT_DEPTH  =                                 4;      ///<  <=7

  • source/Lib/TLibCommon/TComTrQuant.cpp

     
    21622162__attribute__((optimize("no-tree-vrp")))
    21632163#endif
    21642164#endif
    2165 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    21662165void fastForwardDCT2_B64(TCoeff *src, TCoeff *dst, Int shift, Int line, Int iSkipLine, Int iSkipLine2
    21672166#if JVET_D0077_TRANSFORM_OPT
    21682167                         , Int use
    21692168#endif
    21702169                         )
    2171 #else
    2172 void fastForwardDCT2_B64(TCoeff *src, TCoeff *dst, Int shift, Int line, Int zo, Int use)
    2173 #endif
    21742170{
    21752171  Int rnd_factor = 1<<(shift-1);
    21762172  const Int uiTrSize = 64;
    … …  
    21892185  Int EEEEE[2],EEEEO[2];
    21902186  TCoeff *tmp = dst;
    21912187
    2192 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    21932188  Bool zo = iSkipLine2 >= 32;
    21942189  for (j=0; j<line-iSkipLine; j++)
    2195 #else
    2196   for (j=0; j<(line>>(2==zo?1:0)); j++)
    2197 #endif
    21982190  {   
    21992191    /* E and O*/
    22002192    for (k=0;k<32;k++)
    … …  
    22652257    dst ++;
    22662258  }
    22672259
    2268 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    22692260  const Int  reducedLine = line - iSkipLine;
    22702261  const Int  cutoff = uiTrSize - iSkipLine2;
    22712262  if( iSkipLine )
    … …  
    22822273    dst = tmp + line*cutoff;
    22832274    memset( dst, 0, sizeof(TCoeff)*line*iSkipLine2 );
    22842275  }
    2285 #else
    2286   if( zo==2 )
    2287   {
    2288     for (j=0; j<uiTrSize/2; j++)
    2289     {
    2290       memset( dst, 0, sizeof(TCoeff)*uiTrSize/2 );
    2291       dst += uiTrSize;
    2292     }
    2293   }
    2294   dst = tmp + uiTrSize*uiTrSize/2;
    2295   memset( dst, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    2296 #endif
    22972276}
    22982277
    22992278
    … …  
    23032282__attribute__((optimize("no-tree-vrp")))
    23042283#endif
    23052284#endif
    2306 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    23072285void fastInverseDCT2_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, 
    23082286#if JVET_D0077_TRANSFORM_OPT
    23092287                         Int use,
    23102288#endif
    23112289                         const TCoeff outputMinimum, const TCoeff outputMaximum)
    2312 #else
    2313 void fastInverseDCT2_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)
    2314 #endif
    23152290{
    23162291  Int rnd_factor = 1<<(shift-1);
    23172292  const Int uiTrSize = 64;
    … …  
    23282303  Int EEE[8],EEO[8];
    23292304  Int EEEE[4],EEEO[4];
    23302305  Int EEEEE[2],EEEEO[2];
    2331 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    23322306  Bool zo = iSkipLine2 >= 32;
    23332307  for (j=0; j<line-iSkipLine; j++)
    2334 #else
    2335   for (j=0; j<(line>>(2==zo?1:0)); j++)
    2336 #endif
    23372308  {   
    23382309    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
    23392310    for (k=0;k<32;k++)
    … …  
    24002371    coeff ++;
    24012372    block += uiTrSize;
    24022373  }
    2403 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    24042374  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    2405 #endif
    24062375}
    24072376
    24082377
    24092378
    24102379#if JVET_C0024_QTBT
    2411 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    24122380void fastForwardDCT2_B128(TCoeff *src, TCoeff *dst, Int shift, Int line, Int iSkipLine, Int iSkipLine2
    24132381#if JVET_D0077_TRANSFORM_OPT
    24142382                          , Int use
    24152383#endif
    24162384                          )
    2417 #else
    2418 void fastForwardDCT2_B128(TCoeff *src, TCoeff *dst, Int shift, Int line, Int zo, Int use)
    2419 #endif
    24202385{
    24212386  Int j,k;
    24222387  Int E[64],O[64];
    … …  
    24282393  Int add = 1<<(shift-1);
    24292394  const TMatrixCoeff (*iT)[128] = g_aiTr128[DCT2];
    24302395
    2431 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    24322396  TCoeff* tmp = dst;
    24332397  for (j=0; j<line-iSkipLine; j++)
    2434 #else
    2435   for (j=0; j<line; j++)
    2436 #endif
    24372398  {   
    24382399    /* E and O*/
    24392400    for (k=0;k< 64;k++)
    … …  
    26482609    src += 128;
    26492610    dst ++;
    26502611  }
    2651 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    26522612  const UInt uiTrSize = 128;
    26532613  const Int  reducedLine = line - iSkipLine;
    26542614  const Int  cutoff = uiTrSize - iSkipLine2;
    … …  
    26662626    dst = tmp + line*cutoff;
    26672627    memset( dst, 0, sizeof(TCoeff)*line*iSkipLine2 );
    26682628  }
    2669 #endif
    26702629}
    2671 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    26722630void fastInverseDCT2_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, 
    26732631#if JVET_D0077_TRANSFORM_OPT
    26742632                          Int use,
    26752633#endif
    26762634                          const TCoeff outputMinimum, const TCoeff outputMaximum)
    2677 #else
    2678 void fastInverseDCT2_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)
    2679 #endif
    26802635{
    26812636  Int j,k;
    26822637  Int E[64],O[64];
    … …  
    26882643  Int add = 1<<(shift-1);
    26892644  const TMatrixCoeff (*iT)[128] = g_aiTr128[DCT2];
    26902645
    2691 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    26922646  Bool c1 = iSkipLine2 >= 96 ;
    26932647  Bool c2 = iSkipLine2 >= 64 ;
    26942648  Bool c3 = iSkipLine2 >= 32 ;
    26952649
    26962650  for (j=0; j<line - iSkipLine; j++)
    2697 #else
    2698   for (j=0; j<line; j++)
    2699 #endif
    27002651  {   
    27012652    /* Utilizing symmetry properties to the maximum to minimize the number of multiplications */
    2702 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    27032653    if (c1)
    27042654    {
    27052655      for (k=0;k<64;k++) //+2
    … …  
    28822832    }
    28832833    else
    28842834    {
    2885 #endif
    28862835      for (k=0;k<64;k++) //+2
    28872836      {
    28882837        O[k] = iT[ 1][k]*coeff[ line  ]
    … …  
    29882937        + iT[126][k]*coeff[ 126*line ]
    29892938        ;
    29902939      }
    2991 
    2992 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    29932940    }
    2994 #endif
    29952941
    29962942    for (k=0;k<16;k++) //+8
    29972943    {
    … …  
    30863032    coeff ++;
    30873033    block += 128;
    30883034  }
    3089 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    30903035  memset(block, 0, 128*iSkipLine*sizeof(TCoeff));
    3091 #endif
    30923036}
    30933037#endif
    30943038// Fast DST Algorithm. Full matrix multiplication for DST and Fast DST algorithm
    … …  
    36153559
    36163560
    36173561#if JVET_C0024_QTBT
    3618 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    36193562void fastForwardDST7_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    36203563#if JVET_D0077_TRANSFORM_OPT
    36213564                         , Int use
    36223565#endif
    36233566                         )  // input block, output coeff
    3624 #else
    3625 void fastForwardDST7_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    3626 #endif
    36273567{
    36283568  Int i, j, k, iSum;
    36293569  Int rnd_factor = 1<<(shift-1);
    … …  
    36323572  const TMatrixCoeff *iT;
    36333573  TCoeff *pCoef;
    36343574
    3635 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    36363575  const Int  reducedLine = line - iSkipLine;
    36373576  const Int  cutoff = uiTrSize - iSkipLine2;
    36383577  for (i=0; i<reducedLine; i++)
    … …  
    36673606    pCoef = coeff + line*cutoff;
    36683607    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    36693608  }
    3670 #else
    3671   if ( zo )
    3672   {
    3673     TCoeff *tmp = coeff;
    3674     for (i=0; i<(line>>(zo-1)); i++)
    3675     {
    3676       pCoef = coeff;
    3677       iT = g_aiTr64[DST7][0];
    3678       for (j=0; j<uiTrSize/2; j++)
    3679       {
    3680         iSum = 0;
    3681         for (k=0; k<uiTrSize; k++)
    3682         {
    3683           iSum += block[k]*iT[k];
    3684         }
    3685         pCoef[i] = (iSum + rnd_factor)>>shift;
    3686         iT += uiTrSize;
    3687         pCoef += line;
    3688       }
    3689       block+=uiTrSize;
    3690     }
    3691 
    3692     coeff += (line>>(zo-1));
    3693     if( zo==2 )
    3694     {
    3695       for (j=0; j<uiTrSize/2; j++)
    3696       {
    3697         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    3698         coeff += uiTrSize;
    3699       }
    3700     }
    3701     coeff = tmp + uiTrSize*uiTrSize/2;
    3702     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    3703   }
    3704   else
    3705   {
    3706     for (i=0; i<line; i++)
    3707     {
    3708       pCoef = coeff;
    3709       iT = g_aiTr64[DST7][0];
    3710       for (j=0; j<uiTrSize; j++)
    3711       {
    3712         iSum = 0;
    3713         for (k=0; k<uiTrSize; k++)
    3714         {
    3715           iSum += block[k]*iT[k];
    3716         }
    3717         pCoef[i] = (iSum + rnd_factor)>>shift;
    3718         pCoef += line;
    3719         iT += uiTrSize;
    3720       }
    3721       block += uiTrSize;
    3722     }
    3723   }
    3724 #endif
    37253609}
    37263610
    37273611#ifdef __GNUC__
    … …  
    37303614__attribute__((optimize("no-tree-vrp")))
    37313615#endif
    37323616#endif
    3733 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    37343617void fastInverseDST7_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    37353618#if JVET_D0077_TRANSFORM_OPT
    37363619                         Int use,
    37373620#endif
    37383621                         const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    3739 #else
    3740 void fastInverseDST7_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    3741 #endif
    37423622{
    37433623  Int i, j, k, iSum;
    37443624  Int rnd_factor = 1<<(shift-1);
    … …  
    37673647    memset(block, 0, (iSkipLine<<6)*sizeof(TCoeff));
    37683648  }
    37693649#else
    3770 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    37713650  Bool zo = iSkipLine2 >= 32;
    3772 #endif
    37733651
    37743652  if ( zo )
    37753653  {
    3776 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    37773654    for (i=0; i<line-iSkipLine; i++)
    3778 #else
    3779     for (i=0; i<(line>>(zo-1)); i++)
    3780 #endif
    37813655    {
    37823656      for (j=0; j<uiTrSize; j++)
    37833657      {
    … …  
    37943668  }
    37953669  else
    37963670  {
    3797 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    37983671    for (i=0; i<line-iSkipLine; i++)
    3799 #else
    3800     for (i=0; i<line; i++)
    3801 #endif
    38023672    {
    38033673      for (j=0; j<uiTrSize; j++)
    38043674      {
    … …  
    38143684    }
    38153685  }
    38163686
    3817 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    38183687  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    38193688#endif
    3820 #endif
    38213689}
    38223690
    3823 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    38243691void fastForwardDST7_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    38253692#if JVET_D0077_TRANSFORM_OPT
    38263693                          , Int use
    38273694#endif
    38283695                          )  // input block, output coeff
    3829 #else
    3830 void fastForwardDST7_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    3831 #endif
    38323696{
    38333697  Int i, j, k, iSum;
    38343698  Int rnd_factor = 1<<(shift-1);
    … …  
    38373701  const TMatrixCoeff *iT;
    38383702  TCoeff *pCoef;
    38393703
    3840 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    38413704  const Int  reducedLine = line - iSkipLine;
    38423705  const Int  cutoff = uiTrSize - iSkipLine2;
    38433706  for (i=0; i<reducedLine; i++)
    … …  
    38723735    pCoef = coeff + line*cutoff;
    38733736    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    38743737  }
    3875 #else
    3876   if ( zo )
    3877   {
    3878     TCoeff *tmp = coeff;
    3879     for (i=0; i<(line>>(zo-1)); i++)
    3880     {
    3881       pCoef = coeff;
    3882       iT = g_aiTr128[DST7][0];
    3883       for (j=0; j<uiTrSize/2; j++)
    3884       {
    3885         iSum = 0;
    3886         for (k=0; k<uiTrSize; k++)
    3887         {
    3888           iSum += block[k]*iT[k];
    3889         }
    3890         pCoef[i] = (iSum + rnd_factor)>>shift;
    3891         iT += uiTrSize;
    3892         pCoef += line;
    3893       }
    3894       block+=uiTrSize;
    3895     }
    3896 
    3897     coeff += (line>>(zo-1));
    3898     if( zo==2 )
    3899     {
    3900       for (j=0; j<uiTrSize/2; j++)
    3901       {
    3902         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    3903         coeff += uiTrSize;
    3904       }
    3905     }
    3906     coeff = tmp + uiTrSize*uiTrSize/2;
    3907     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    3908   }
    3909   else
    3910   {
    3911     for (i=0; i<line; i++)
    3912     {
    3913       pCoef = coeff;
    3914       iT = g_aiTr128[DST7][0];
    3915       for (j=0; j<uiTrSize; j++)
    3916       {
    3917         iSum = 0;
    3918         for (k=0; k<uiTrSize; k++)
    3919         {
    3920           iSum += block[k]*iT[k];
    3921         }
    3922         pCoef[i] = (iSum + rnd_factor)>>shift;
    3923         pCoef += line;
    3924         iT += uiTrSize;
    3925       }
    3926       block += uiTrSize;
    3927     }
    3928   }
    3929 #endif
    39303738}
    39313739
    39323740#ifdef __GNUC__
    … …  
    39353743__attribute__((optimize("no-tree-vrp")))
    39363744#endif
    39373745#endif
    3938 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    39393746void fastInverseDST7_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    39403747#if JVET_D0077_TRANSFORM_OPT
    39413748                          Int use,
    39423749#endif
    39433750                          const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    3944 #else
    3945 void fastInverseDST7_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    3946 #endif
    39473751{
    39483752  Int i, j, k, iSum;
    39493753  Int rnd_factor = 1<<(shift-1);
    … …  
    39733777    memset(block, 0, (iSkipLine<<7)*sizeof(TCoeff));
    39743778  }
    39753779#else
    3976 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    39773780  Bool zo = iSkipLine2 >= 64;
    3978 #endif
    39793781
    39803782  if ( zo )
    39813783  {
    3982 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    39833784    for (i=0; i<line-iSkipLine; i++)
    3984 #else
    3985     for (i=0; i<(line>>(zo-1)); i++)
    3986 #endif
    39873785    {
    39883786      for (j=0; j<uiTrSize; j++)
    39893787      {
    … …  
    40003798  }
    40013799  else
    40023800  {
    4003 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    40043801    for (i=0; i<line-iSkipLine; i++)
    4005 #else
    4006     for (i=0; i<line; i++)
    4007 #endif
    40083802    {
    40093803      for (j=0; j<uiTrSize; j++)
    40103804      {
    … …  
    40193813      coeff++;
    40203814    }
    40213815  }
    4022 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    40233816  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    40243817#endif
    4025 #endif
    40263818}
    40273819#endif
    40283820
    … …  
    45394331}
    45404332
    45414333#if JVET_C0024_QTBT
    4542 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    45434334void fastForwardDCT8_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    45444335#if JVET_D0077_TRANSFORM_OPT
    45454336                         , Int use
    45464337#endif
    45474338                         )  // input block, output coeff
    4548 #else
    4549 void fastForwardDCT8_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    4550 #endif
    45514339{
    45524340  Int i, j, k, iSum;
    45534341  Int rnd_factor = 1<<(shift-1);
    … …  
    45564344  const TMatrixCoeff *iT;
    45574345  TCoeff *pCoef;
    45584346
    4559 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    45604347  const Int  reducedLine = line - iSkipLine;
    45614348  const Int  cutoff = uiTrSize - iSkipLine2;
    45624349  for (i=0; i<reducedLine; i++)
    … …  
    45914378    pCoef = coeff + line*cutoff;
    45924379    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    45934380  }
    4594 #else
    4595   if ( zo )
    4596   {
    4597     TCoeff *tmp = coeff;
    4598     for (i=0; i<(line>>(zo-1)); i++)
    4599     {
    4600       pCoef = coeff;
    4601       iT = g_aiTr64[DCT8][0];
    4602       for (j=0; j<uiTrSize/2; j++)
    4603       {
    4604         iSum = 0;
    4605         for (k=0; k<uiTrSize; k++)
    4606         {
    4607           iSum += block[k]*iT[k];
    4608         }
    4609         pCoef[i] = (iSum + rnd_factor)>>shift;
    4610         iT += uiTrSize;
    4611         pCoef += line;
    4612       }
    4613       block+=uiTrSize;
    4614     }
    4615 
    4616     coeff += (line>>(zo-1));
    4617     if( zo==2 )
    4618     {
    4619       for (j=0; j<uiTrSize/2; j++)
    4620       {
    4621         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    4622         coeff += uiTrSize;
    4623       }
    4624     }
    4625     coeff = tmp + uiTrSize*uiTrSize/2;
    4626     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    4627   }
    4628   else
    4629   {
    4630     for (i=0; i<line; i++)
    4631     {
    4632       pCoef = coeff;
    4633       iT = g_aiTr64[DCT8][0];
    4634       for (j=0; j<uiTrSize; j++)
    4635       {
    4636         iSum = 0;
    4637         for (k=0; k<uiTrSize; k++)
    4638         {
    4639           iSum += block[k]*iT[k];
    4640         }
    4641         pCoef[i] = (iSum + rnd_factor)>>shift;
    4642         pCoef += line;
    4643         iT += uiTrSize;
    4644       }
    4645       block += uiTrSize;
    4646     }
    4647   }
    4648 #endif
    46494381}
    46504382
    46514383#ifdef __GNUC__
    … …  
    46544386__attribute__((optimize("no-tree-vrp")))
    46554387#endif
    46564388#endif
    4657 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    46584389void fastInverseDCT8_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    46594390#if JVET_D0077_TRANSFORM_OPT
    46604391                         Int use,
    46614392#endif
    46624393                         const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    4663 #else
    4664 void fastInverseDCT8_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    4665 #endif
    46664394{
    46674395  Int i, j, k, iSum;
    46684396  Int rnd_factor = 1<<(shift-1);
    … …  
    46924420    memset(block, 0, (iSkipLine<<6)*sizeof(TCoeff));
    46934421  }
    46944422#else
    4695 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    46964423  Bool zo = iSkipLine2 >= 32;
    4697 #endif
    46984424
    46994425  if ( zo )
    47004426  {
    4701 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    47024427    for (i=0; i<line-iSkipLine; i++)
    4703 #else
    4704     for (i=0; i<(line>>(zo-1)); i++)
    4705 #endif
    47064428    {
    47074429      for (j=0; j<uiTrSize; j++)
    47084430      {
    … …  
    47194441  }
    47204442  else
    47214443  {
    4722 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    47234444    for (i=0; i<line-iSkipLine; i++)
    4724 #else
    4725     for (i=0; i<line; i++)
    4726 #endif
    47274445    {
    47284446      for (j=0; j<uiTrSize; j++)
    47294447      {
    … …  
    47384456      coeff++;
    47394457    }
    47404458  }
    4741 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    47424459  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    47434460#endif
    4744 #endif
    47454461}
    47464462
    4747 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    47484463void fastForwardDCT8_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    47494464#if JVET_D0077_TRANSFORM_OPT
    47504465                          , Int use
    47514466#endif
    47524467                          )  // input block, output coeff
    4753 #else
    4754 void fastForwardDCT8_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    4755 #endif
    47564468{
    47574469  Int i, j, k, iSum;
    47584470  Int rnd_factor = 1<<(shift-1);
    … …  
    47614473  const TMatrixCoeff *iT;
    47624474  TCoeff *pCoef;
    47634475
    4764 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    47654476  const Int  reducedLine = line - iSkipLine;
    47664477  const Int  cutoff = uiTrSize - iSkipLine2;
    47674478  for (i=0; i<reducedLine; i++)
    … …  
    47964507    pCoef = coeff + line*cutoff;
    47974508    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    47984509  }
    4799 #else
    4800   if ( zo )
    4801   {
    4802     TCoeff *tmp = coeff;
    4803     for (i=0; i<(line>>(zo-1)); i++)
    4804     {
    4805       pCoef = coeff;
    4806       iT = g_aiTr128[DCT8][0];
    4807       for (j=0; j<uiTrSize/2; j++)
    4808       {
    4809         iSum = 0;
    4810         for (k=0; k<uiTrSize; k++)
    4811         {
    4812           iSum += block[k]*iT[k];
    4813         }
    4814         pCoef[i] = (iSum + rnd_factor)>>shift;
    4815         iT += uiTrSize;
    4816         pCoef += line;
    4817       }
    4818       block+=uiTrSize;
    4819     }
    4820 
    4821     coeff += (line>>(zo-1));
    4822     if( zo==2 )
    4823     {
    4824       for (j=0; j<uiTrSize/2; j++)
    4825       {
    4826         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    4827         coeff += uiTrSize;
    4828       }
    4829     }
    4830     coeff = tmp + uiTrSize*uiTrSize/2;
    4831     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    4832   }
    4833   else
    4834   {
    4835     for (i=0; i<line; i++)
    4836     {
    4837       pCoef = coeff;
    4838       iT = g_aiTr128[DCT8][0];
    4839       for (j=0; j<uiTrSize; j++)
    4840       {
    4841         iSum = 0;
    4842         for (k=0; k<uiTrSize; k++)
    4843         {
    4844           iSum += block[k]*iT[k];
    4845         }
    4846         pCoef[i] = (iSum + rnd_factor)>>shift;
    4847         pCoef += line;
    4848         iT += uiTrSize;
    4849       }
    4850       block += uiTrSize;
    4851     }
    4852   }
    4853 #endif
    48544510}
    48554511
    48564512#ifdef __GNUC__
    … …  
    48594515__attribute__((optimize("no-tree-vrp")))
    48604516#endif
    48614517#endif
    4862 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    48634518void fastInverseDCT8_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    48644519#if JVET_D0077_TRANSFORM_OPT
    48654520                          Int use,
    48664521#endif
    48674522                          const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    4868 #else
    4869 void fastInverseDCT8_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    4870 #endif
    48714523{
    48724524  Int i, j, k, iSum;
    48734525  Int rnd_factor = 1<<(shift-1);
    … …  
    48974549    memset(block, 0, (iSkipLine<<7)*sizeof(TCoeff));
    48984550  }
    48994551#else
    4900 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    49014552  Bool zo = iSkipLine2 >= 64;
    4902 #endif
    49034553
    49044554  if ( zo )
    49054555  {
    4906 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    49074556    for (i=0; i<line-iSkipLine; i++)
    4908 #else
    4909     for (i=0; i<(line>>(zo-1)); i++)
    4910 #endif
    49114557    {
    49124558      for (j=0; j<uiTrSize; j++)
    49134559      {
    … …  
    49244570  }
    49254571  else
    49264572  {
    4927 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    49284573    for (i=0; i<line-iSkipLine; i++)
    4929 #else
    4930     for (i=0; i<line; i++)
    4931 #endif
    49324574    {
    49334575      for (j=0; j<uiTrSize; j++)
    49344576      {
    … …  
    49444586    }
    49454587  }
    49464588
    4947 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    49484589  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    49494590#endif
    4950 #endif
    49514591}
    49524592#endif
    49534593
    … …  
    53835023}
    53845024
    53855025#if JVET_C0024_QTBT
    5386 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    53875026void fastForwardDCT5_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    53885027#if JVET_D0077_TRANSFORM_OPT
    53895028                         , Int use
    53905029#endif
    53915030                         )  // input block, output coeff
    5392 #else
    5393 void fastForwardDCT5_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    5394 #endif
    53955031{
    53965032  Int i, j, k, iSum;
    53975033  Int rnd_factor = 1<<(shift-1);
    … …  
    54005036  const TMatrixCoeff *iT;
    54015037  TCoeff *pCoef;
    54025038
    5403 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    54045039  const Int  reducedLine = line - iSkipLine;
    54055040  const Int  cutoff = uiTrSize - iSkipLine2;
    54065041  for (i=0; i<reducedLine; i++)
    … …  
    54355070    pCoef = coeff + line*cutoff;
    54365071    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    54375072  }
    5438 #else
    5439   if ( zo )
    5440   {
    5441     TCoeff *tmp = coeff;
    5442     for (i=0; i<(line>>(zo-1)); i++)
    5443     {
    5444       pCoef = coeff;
    5445       iT = g_aiTr64[DCT5][0];
    5446       for (j=0; j<uiTrSize/2; j++)
    5447       {
    5448         iSum = 0;
    5449         for (k=0; k<uiTrSize; k++)
    5450         {
    5451           iSum += block[k]*iT[k];
    5452         }
    5453         pCoef[i] = (iSum + rnd_factor)>>shift;
    5454         iT += uiTrSize;
    5455         pCoef += line;
    5456       }
    5457       block+=uiTrSize;
    5458     }
    5459 
    5460     coeff += (line>>(zo-1));
    5461     if( zo==2 )
    5462     {
    5463       for (j=0; j<uiTrSize/2; j++)
    5464       {
    5465         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    5466         coeff += uiTrSize;
    5467       }
    5468     }
    5469     coeff = tmp + uiTrSize*uiTrSize/2;
    5470     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    5471   }
    5472   else
    5473   {
    5474     for (i=0; i<line; i++)
    5475     {
    5476       pCoef = coeff;
    5477       iT = g_aiTr64[DCT5][0];
    5478       for (j=0; j<uiTrSize; j++)
    5479       {
    5480         iSum = 0;
    5481         for (k=0; k<uiTrSize; k++)
    5482         {
    5483           iSum += block[k]*iT[k];
    5484         }
    5485         pCoef[i] = (iSum + rnd_factor)>>shift;
    5486         pCoef += line;
    5487         iT += uiTrSize;
    5488       }
    5489       block += uiTrSize;
    5490     }
    5491   }
    5492 #endif
    54935073}
    54945074
    5495 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    54965075void fastInverseDCT5_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    54975076#if JVET_D0077_TRANSFORM_OPT
    54985077                         Int use,
    54995078#endif
    55005079                         const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    5501 #else
    5502 void fastInverseDCT5_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    5503 #endif
    55045080{
    55055081  Int i, j, k, iSum;
    55065082  Int rnd_factor = 1<<(shift-1);
    … …  
    55305106    memset(block, 0, (iSkipLine<<6)*sizeof(TCoeff));
    55315107  }
    55325108#else
    5533 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    55345109  Bool zo = iSkipLine2 >= 32;
    5535 #endif
    55365110
    55375111  if ( zo )
    55385112  {
    5539 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    55405113    for (i=0; i<line-iSkipLine; i++)
    5541 #else
    5542     for (i=0; i<(line>>(zo-1)); i++)
    5543 #endif
    55445114    {
    55455115      for (j=0; j<uiTrSize; j++)
    55465116      {
    … …  
    55575127  }
    55585128  else
    55595129  {
    5560 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    55615130    for (i=0; i<line-iSkipLine; i++)
    5562 #else
    5563     for (i=0; i<line; i++)
    5564 #endif
    55655131    {
    55665132      for (j=0; j<uiTrSize; j++)
    55675133      {
    … …  
    55775143    }
    55785144  }
    55795145
    5580 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    55815146  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    55825147#endif
    5583 #endif
    55845148}
    55855149
    5586 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    55875150void fastForwardDCT5_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    55885151#if JVET_D0077_TRANSFORM_OPT
    55895152                          , Int use
    55905153#endif
    55915154                          )  // input block, output coeff
    5592 #else
    5593 void fastForwardDCT5_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    5594 #endif
    55955155{
    55965156  Int i, j, k, iSum;
    55975157  Int rnd_factor = 1<<(shift-1);
    … …  
    56005160  const TMatrixCoeff *iT;
    56015161  TCoeff *pCoef;
    56025162
    5603 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    56045163  const Int  reducedLine = line - iSkipLine;
    56055164  const Int  cutoff = uiTrSize - iSkipLine2;
    56065165  for (i=0; i<reducedLine; i++)
    … …  
    56355194    pCoef = coeff + line*cutoff;
    56365195    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    56375196  }
    5638 #else
    5639   if ( zo )
    5640   {
    5641     TCoeff *tmp = coeff;
    5642     for (i=0; i<(line>>(zo-1)); i++)
    5643     {
    5644       pCoef = coeff;
    5645       iT = g_aiTr128[DCT5][0];
    5646       for (j=0; j<uiTrSize/2; j++)
    5647       {
    5648         iSum = 0;
    5649         for (k=0; k<uiTrSize; k++)
    5650         {
    5651           iSum += block[k]*iT[k];
    5652         }
    5653         pCoef[i] = (iSum + rnd_factor)>>shift;
    5654         iT += uiTrSize;
    5655         pCoef += line;
    5656       }
    5657       block+=uiTrSize;
    5658     }
    5659 
    5660     coeff += (line>>(zo-1));
    5661     if( zo==2 )
    5662     {
    5663       for (j=0; j<uiTrSize/2; j++)
    5664       {
    5665         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    5666         coeff += uiTrSize;
    5667       }
    5668     }
    5669     coeff = tmp + uiTrSize*uiTrSize/2;
    5670     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    5671   }
    5672   else
    5673   {
    5674     for (i=0; i<line; i++)
    5675     {
    5676       pCoef = coeff;
    5677       iT = g_aiTr128[DCT5][0];
    5678       for (j=0; j<uiTrSize; j++)
    5679       {
    5680         iSum = 0;
    5681         for (k=0; k<uiTrSize; k++)
    5682         {
    5683           iSum += block[k]*iT[k];
    5684         }
    5685         pCoef[i] = (iSum + rnd_factor)>>shift;
    5686         pCoef += line;
    5687         iT += uiTrSize;
    5688       }
    5689       block += uiTrSize;
    5690     }
    5691   }
    5692 #endif
    56935197}
    56945198
    5695 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    56965199void fastInverseDCT5_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    56975200#if JVET_D0077_TRANSFORM_OPT
    56985201                          Int use,
    56995202#endif
    57005203                          const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    5701 #else
    5702 void fastInverseDCT5_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    5703 #endif
    57045204{
    57055205  Int i, j, k, iSum;
    57065206  Int rnd_factor = 1<<(shift-1);
    … …  
    57305230    memset(block, 0, (iSkipLine<<7)*sizeof(TCoeff));
    57315231  }
    57325232#else
    5733 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    57345233  Bool zo = iSkipLine2 >= 64;
    5735 #endif
    57365234
    57375235  if ( zo )
    57385236  {
    5739 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    57405237    for (i=0; i<line-iSkipLine; i++)
    5741 #else
    5742     for (i=0; i<(line>>(zo-1)); i++)
    5743 #endif
    57445238    {
    57455239      for (j=0; j<uiTrSize; j++)
    57465240      {
    … …  
    57575251  }
    57585252  else
    57595253  {
    5760 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    57615254    for (i=0; i<line-iSkipLine; i++)
    5762 #else
    5763     for (i=0; i<line; i++)
    5764 #endif
    57655255    {
    57665256      for (j=0; j<uiTrSize; j++)
    57675257      {
    … …  
    57775267    }
    57785268  }
    57795269
    5780 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    57815270  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    57825271#endif
    5783 #endif
    57845272}
    57855273#endif
    57865274
    … …  
    61945682#endif
    61955683}
    61965684#if JVET_C0024_QTBT
    6197 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    61985685void fastForwardDST1_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    61995686#if JVET_D0077_TRANSFORM_OPT
    62005687                         , Int use
    62015688#endif
    62025689                         )  // input block, output coeff
    6203 #else
    6204 void fastForwardDST1_B64(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    6205 #endif
    62065690{
    62075691  Int i, j, k, iSum;
    62085692  Int rnd_factor = 1<<(shift-1);
    … …  
    62115695  const TMatrixCoeff *iT;
    62125696  TCoeff *pCoef;
    62135697
    6214 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    62155698  const Int  reducedLine = line - iSkipLine;
    62165699  const Int  cutoff = uiTrSize - iSkipLine2;
    62175700  for (i=0; i<reducedLine; i++)
    … …  
    62465729    pCoef = coeff + line*cutoff;
    62475730    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    62485731  }
    6249 #else
    6250   if ( zo )
    6251   {
    6252     TCoeff *tmp = coeff;
    6253     for (i=0; i<(line>>(zo-1)); i++)
    6254     {
    6255       pCoef = coeff;
    6256       iT = g_aiTr64[DST1][0];
    6257       for (j=0; j<uiTrSize/2; j++)
    6258       {
    6259         iSum = 0;
    6260         for (k=0; k<uiTrSize; k++)
    6261         {
    6262           iSum += block[k]*iT[k];
    6263         }
    6264         pCoef[i] = (iSum + rnd_factor)>>shift;
    6265         iT += uiTrSize;
    6266         pCoef += line;
    6267       }
    6268       block+=uiTrSize;
    6269     }
    6270 
    6271     coeff += (line>>(zo-1));
    6272     if( zo==2 )
    6273     {
    6274       for (j=0; j<uiTrSize/2; j++)
    6275       {
    6276         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    6277         coeff += uiTrSize;
    6278       }
    6279     }
    6280     coeff = tmp + uiTrSize*uiTrSize/2;
    6281     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    6282   }
    6283   else
    6284   {
    6285     for (i=0; i<line; i++)
    6286     {
    6287       pCoef = coeff;
    6288       iT = g_aiTr64[DST1][0];
    6289       for (j=0; j<uiTrSize; j++)
    6290       {
    6291         iSum = 0;
    6292         for (k=0; k<uiTrSize; k++)
    6293         {
    6294           iSum += block[k]*iT[k];
    6295         }
    6296         pCoef[i] = (iSum + rnd_factor)>>shift;
    6297         pCoef += line;
    6298         iT += uiTrSize;
    6299       }
    6300       block += uiTrSize;
    6301     }
    6302   }
    6303 #endif
    63045732}
    63055733
    6306 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    63075734void fastInverseDST1_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    63085735#if JVET_D0077_TRANSFORM_OPT
    63095736                         Int use,
    63105737#endif
    63115738                         const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    6312 #else
    6313 void fastInverseDST1_B64(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    6314 #endif
    63155739{
    63165740  Int i, j, k, iSum;
    63175741  Int rnd_factor = 1<<(shift-1);
    … …  
    63415765    memset(block, 0, (iSkipLine<<6)*sizeof(TCoeff));
    63425766  }
    63435767#else
    6344 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    63455768  Bool zo = iSkipLine2 >= 32;
    6346 #endif
    63475769
    63485770  if ( zo )
    63495771  {
    6350 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    63515772    for (i=0; i<line-iSkipLine; i++)
    6352 #else
    6353     for (i=0; i<(line>>(zo-1)); i++)
    6354 #endif
    63555773    {
    63565774      for (j=0; j<uiTrSize; j++)
    63575775      {
    … …  
    63685786  }
    63695787  else
    63705788  {
    6371 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    63725789    for (i=0; i<line-iSkipLine; i++)
    6373 #else
    6374     for (i=0; i<line; i++)
    6375 #endif
    63765790    {
    63775791      for (j=0; j<uiTrSize; j++)
    63785792      {
    … …  
    63885802    }
    63895803  }
    63905804
    6391 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    63925805  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    63935806#endif
    6394 #endif
    63955807}
    63965808
    6397 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    63985809void fastForwardDST1_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2
    63995810#if JVET_D0077_TRANSFORM_OPT
    64005811                          , Int use
    64015812#endif
    64025813                          )  // input block, output coeff
    6403 #else
    6404 void fastForwardDST1_B128(TCoeff *block, TCoeff *coeff,Int shift, Int line, Int zo, Int use)  // input block, output coeff
    6405 #endif
    64065814{
    64075815  Int i, j, k, iSum;
    64085816  Int rnd_factor = 1<<(shift-1);
    … …  
    64115819  const TMatrixCoeff *iT;
    64125820  TCoeff *pCoef;
    64135821
    6414 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    64155822  const Int  reducedLine = line - iSkipLine;
    64165823  const Int  cutoff = uiTrSize - iSkipLine2;
    64175824  for (i=0; i<reducedLine; i++)
    … …  
    64465853    pCoef = coeff + line*cutoff;
    64475854    memset( pCoef, 0, sizeof(TCoeff)*line*iSkipLine2 );
    64485855  }
    6449 #else
    6450   if ( zo )
    6451   {
    6452     TCoeff *tmp = coeff;
    6453     for (i=0; i<(line>>(zo-1)); i++)
    6454     {
    6455       pCoef = coeff;
    6456       iT = g_aiTr128[DST1][0];
    6457       for (j=0; j<uiTrSize/2; j++)
    6458       {
    6459         iSum = 0;
    6460         for (k=0; k<uiTrSize; k++)
    6461         {
    6462           iSum += block[k]*iT[k];
    6463         }
    6464         pCoef[i] = (iSum + rnd_factor)>>shift;
    6465         iT += uiTrSize;
    6466         pCoef += line;
    6467       }
    6468       block+=uiTrSize;
    6469     }
    6470 
    6471     coeff += (line>>(zo-1));
    6472     if( zo==2 )
    6473     {
    6474       for (j=0; j<uiTrSize/2; j++)
    6475       {
    6476         memset( coeff, 0, sizeof(TCoeff)*uiTrSize/2 );
    6477         coeff += uiTrSize;
    6478       }
    6479     }
    6480     coeff = tmp + uiTrSize*uiTrSize/2;
    6481     memset( coeff, 0, sizeof(TCoeff)*uiTrSize*uiTrSize/2 );
    6482   }
    6483   else
    6484   {
    6485     for (i=0; i<line; i++)
    6486     {
    6487       pCoef = coeff;
    6488       iT = g_aiTr128[DST1][0];
    6489       for (j=0; j<uiTrSize; j++)
    6490       {
    6491         iSum = 0;
    6492         for (k=0; k<uiTrSize; k++)
    6493         {
    6494           iSum += block[k]*iT[k];
    6495         }
    6496         pCoef[i] = (iSum + rnd_factor)>>shift;
    6497         pCoef += line;
    6498         iT += uiTrSize;
    6499       }
    6500       block += uiTrSize;
    6501     }
    6502   }
    6503 #endif
    65045856}
    65055857
    6506 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    65075858void fastInverseDST1_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2,
    65085859#if JVET_D0077_TRANSFORM_OPT
    65095860                          Int use,
    65105861#endif
    65115862                          const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    6512 #else
    6513 void fastInverseDST1_B128(TCoeff *coeff, TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum)  // input block, output coeff
    6514 #endif
    65155863{
    65165864  Int i, j, k, iSum;
    65175865  Int rnd_factor = 1<<(shift-1);
    … …  
    65415889    memset(block, 0, (iSkipLine<<7)*sizeof(TCoeff));
    65425890  }
    65435891#else
    6544 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    65455892  Bool zo = iSkipLine2 >= 64;
    6546 #endif
    65475893
    65485894  if ( zo )
    65495895  {
    6550 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    65515896    for (i=0; i<line-iSkipLine; i++)
    6552 #else
    6553     for (i=0; i<(line>>(zo-1)); i++)
    6554 #endif
    65555897    {
    65565898      for (j=0; j<uiTrSize; j++)
    65575899      {
    … …  
    65685910  }
    65695911  else
    65705912  {
    6571 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    65725913    for (i=0; i<line-iSkipLine; i++)
    6573 #else
    6574     for (i=0; i<line; i++)
    6575 #endif
    65765914    {
    65775915      for (j=0; j<uiTrSize; j++)
    65785916      {
    … …  
    65875925      coeff++;
    65885926    }
    65895927  }
    6590 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    65915928  memset(block, 0, uiTrSize*iSkipLine*sizeof(TCoeff));
    65925929#endif
    6593 #endif
    65945930}
    65955931#endif
    65965932
    … …  
    66175953  const Int shift_2nd        = (g_aucConvertToBit[iHeight] + MIN_CU_LOG2) + TRANSFORM_MATRIX_SHIFT + COM16_C806_TRANS_PREC;
    66185954  const UInt nLog2WidthMinus1 = g_aucConvertToBit[iWidth] + MIN_CU_LOG2 - 1;  //nLog2WidthMinus1, since transform start from 2-point
    66195955  const UInt nLog2HeightMinus1 = g_aucConvertToBit[iHeight] + MIN_CU_LOG2 - 1;  //nLog2HeightMinus1, since transform start from 2-point
    6620 #if JVET_C0024_ZERO_OUT_FIX
    6621   Int iSkipWidth = (iWidth > JVET_C0024_ZERO_OUT_TH ? iWidth-JVET_C0024_ZERO_OUT_TH : 0);
    6622   Int iSkipHeight = (iHeight > JVET_C0024_ZERO_OUT_TH ? iHeight-JVET_C0024_ZERO_OUT_TH : 0);
     5956  Int iSkipWidth = (iWidth > ZERO_OUT_TH ? iWidth-ZERO_OUT_TH : 0);
     5957  Int iSkipHeight = (iHeight > ZERO_OUT_TH ? iHeight-ZERO_OUT_TH : 0);
    66235958#else
    6624 #if JVET_D0077_TRANSFORM_OPT
    6625   Int iSkipWidth = 0;
    6626   Int iSkipHeight = 0;
    6627 #else
    6628   const Bool bZeroOut        = 0;
    6629 #endif
    6630 #endif
    6631 #else
    66325959  const Int shift_1st        = ((g_aucConvertToBit[iWidth] + 2) +  bitDepth + TRANSFORM_MATRIX_SHIFT) - maxLog2TrDynamicRange + COM16_C806_TRANS_PREC;
    66335960  const Int shift_2nd        = (g_aucConvertToBit[iHeight] + 2) + TRANSFORM_MATRIX_SHIFT + COM16_C806_TRANS_PREC;
    66345961  const UInt nLog2SizeMinus2 = g_aucConvertToBit[iWidth];
    … …  
    66575984  }
    66585985
    66595986#if JVET_C0024_QTBT
    6660 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    66615987#if JVET_D0077_TRANSFORM_OPT
    66625988  fastFwdTrans[nTrIdxHor][nLog2WidthMinus1]( block, tmp, shift_1st, iHeight, 0, iSkipWidth, 1 );
    66635989  fastFwdTrans[nTrIdxVer][nLog2HeightMinus1]( tmp, coeff, shift_2nd,  iWidth, iSkipWidth, iSkipHeight, 1 );
    … …  
    66816007  }
    66826008#endif
    66836009#else
    6684   fastFwdTrans[nTrIdxHor][nLog2WidthMinus1]( block, tmp, shift_1st, iHeight, bZeroOut?1:0, 1 );
    6685   fastFwdTrans[nTrIdxVer][nLog2HeightMinus1]( tmp, coeff, shift_2nd,  iWidth, bZeroOut?2:0, 1 );
    6686 #endif
    6687 #else
    66886010  fastFwdTrans[nTrIdxHor][nLog2SizeMinus2]( block, tmp, shift_1st, iHeight, bZeroOut?1:0, 1 );
    66896011  fastFwdTrans[nTrIdxVer][nLog2SizeMinus2]( tmp, coeff, shift_2nd,  iWidth, bZeroOut?2:0, 1 );
    66906012#endif
    … …  
    67466068  assert(shift_2nd >= 0);
    67476069
    67486070  TCoeff tmp[ MAX_TU_SIZE * MAX_TU_SIZE ];
    6749 #if JVET_C0024_ZERO_OUT_FIX
    6750   Int iSkipWidth = (iWidth > JVET_C0024_ZERO_OUT_TH ? iWidth-JVET_C0024_ZERO_OUT_TH : 0);
    6751   Int iSkipHeight = (iHeight > JVET_C0024_ZERO_OUT_TH ? iHeight-JVET_C0024_ZERO_OUT_TH : 0);
    6752 #endif
    6753 #if JVET_D0077_TRANSFORM_OPT && !JVET_C0024_ZERO_OUT_FIX
    6754   Int iSkipWidth = 0;
    6755   Int iSkipHeight = 0;
    6756 #endif
     6071  Int iSkipWidth = (iWidth > ZERO_OUT_TH ? iWidth-ZERO_OUT_TH : 0);
     6072  Int iSkipHeight = (iHeight > ZERO_OUT_TH ? iHeight-ZERO_OUT_TH : 0);
    67576073  switch (iWidth)   
    67586074  {
    67596075#if JVET_C0024_QTBT
    … …  
    67916107#endif
    67926108#if COM16_C806_T64
    67936109#if JVET_C0024_QTBT
    6794 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    67956110#if JVET_D0077_TRANSFORM_OPT
    67966111    case 64:    fastForwardDCT2_B64( block, tmp, shift_1st, iHeight, 0, iSkipWidth, 0 );  break;
    67976112    case 128:   fastForwardDCT2_B128( block, tmp, shift_1st, iHeight, 0, iSkipWidth, 0 );  break;
    … …  
    68006115    case 128:   fastForwardDCT2_B128( block, tmp, shift_1st, iHeight, 0, iSkipWidth );  break;
    68016116#endif
    68026117#else
    6803     case 64:    fastForwardDCT2_B64( block, tmp, shift_1st, iHeight, 0, 0 );  break;
    6804     case 128:   fastForwardDCT2_B128( block, tmp, shift_1st, iHeight, 0, 0 );  break;
    6805 #endif
    6806 #else
    68076118    case 64:    fastForwardDCT2_B64( block, tmp, shift_1st, iHeight, 1, 0 );  break;
    68086119#endif
    68096120#endif
    … …  
    68486159#endif
    68496160#if COM16_C806_T64
    68506161#if JVET_C0024_QTBT
    6851 #if JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    68526162#if JVET_D0077_TRANSFORM_OPT
    68536163    case 64:    fastForwardDCT2_B64( tmp, coeff, shift_2nd, iWidth, iSkipWidth, iSkipHeight, 0 );  break;
    68546164    case 128:   fastForwardDCT2_B128( tmp, coeff, shift_2nd, iWidth, iSkipWidth, iSkipHeight, 0 );  break;
    … …  
    68576167    case 128:   fastForwardDCT2_B128( tmp, coeff, shift_2nd, iWidth, iSkipWidth, iSkipHeight );  break;
    68586168#endif
    68596169#else
    6860     case 64:    fastForwardDCT2_B64( tmp, coeff, shift_2nd, iWidth, 0, 0 );  break;
    6861     case 128:   fastForwardDCT2_B128( tmp, coeff, shift_2nd, iWidth, 0, 0 );  break;
    6862 #endif
    6863 #else
    68646170    case 64:    fastForwardDCT2_B64( tmp, coeff, shift_2nd, iWidth, 2, 0 );  break;
    68656171#endif
    68666172#endif
    … …  
    68966202#if JVET_C0024_QTBT
    68976203  const UInt nLog2WidthMinus1 = g_aucConvertToBit[iWidth] + MIN_CU_LOG2 - 1;  //nLog2WidthMinus1, since transform start from 2-point
    68986204  const UInt nLog2HeightMinus1 = g_aucConvertToBit[iHeight] + MIN_CU_LOG2 - 1;  //nLog2HeightMinus1, since transform start from 2-point
    6899 #if !JVET_C0024_ITSKIP && !JVET_C0024_ZERO_OUT_FIX && !JVET_D0077_TRANSFORM_OPT
    6900   const Bool bZeroOut        = 0;
    6901 #endif
    69026205#else
    69036206  const UInt nLog2SizeMinus2 = g_aucConvertToBit[iWidth];
    69046207  const Bool bZeroOut        = ( ucMode == INTER_MODE_IDX
    … …  
    69256228  }
    69266229
    69276230#if JVET_C0024_QTBT
    6928 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    6929 #if JVET_C0024_ZERO_OUT_FIX
    69306231#if JVET_C0024_ITSKIP
    69316232  // uiSkipWidth and uiSkipHeight (initilized as 0) may not be set at encoder side, need to be calculated 
    6932   if( iWidth > JVET_C0024_ZERO_OUT_TH && uiSkipWidth == 0 )
     6233  if( iWidth > ZERO_OUT_TH && uiSkipWidth == 0 )
    69336234  {
    6934     uiSkipWidth = iWidth - JVET_C0024_ZERO_OUT_TH;
     6235    uiSkipWidth = iWidth - ZERO_OUT_TH;
    69356236  }
    6936   if( iHeight > JVET_C0024_ZERO_OUT_TH && uiSkipHeight == 0 )
     6237  if( iHeight > ZERO_OUT_TH && uiSkipHeight == 0 )
    69376238  {
    6938     uiSkipHeight = iHeight - JVET_C0024_ZERO_OUT_TH;
     6239    uiSkipHeight = iHeight - ZERO_OUT_TH;
    69396240  }
    69406241#else
    6941   UInt uiSkipWidth = (iWidth > JVET_C0024_ZERO_OUT_TH ? iWidth - JVET_C0024_ZERO_OUT_TH : 0);
    6942   UInt uiSkipHeight = (iHeight > JVET_C0024_ZERO_OUT_TH ? iHeight - JVET_C0024_ZERO_OUT_TH : 0);
     6242  UInt uiSkipWidth = (iWidth > ZERO_OUT_TH ? iWidth - ZERO_OUT_TH : 0);
     6243  UInt uiSkipHeight = (iHeight > ZERO_OUT_TH ? iHeight - ZERO_OUT_TH : 0);
    69436244#endif
    6944 #endif
    69456245
    69466246#if JVET_D0077_TRANSFORM_OPT
    69476247  fastInvTrans[nTrIdxVer][nLog2HeightMinus1]( coeff, tmp, shift_1st,  iWidth, uiSkipWidth, uiSkipHeight, 1, clipMinimum, clipMaximum );
    … …  
    69496249#else
    69506250  if (nLog2HeightMinus1 + 1 >= 6)
    69516251  {
    6952 #if JVET_C0024_ITSKIP && (JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT)
    6953     assert( uiSkipHeight >= iHeight - JVET_C0024_ZERO_OUT_TH );
     6252#if JVET_C0024_ITSKIP && (ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT)
     6253    assert( uiSkipHeight >= iHeight - ZERO_OUT_TH );
    69546254#endif
    69556255    fastInvTrans[nTrIdxVer][nLog2HeightMinus1]( coeff, tmp, shift_1st,  iWidth, uiSkipWidth, uiSkipHeight, clipMinimum, clipMaximum );
    69566256  }
    … …  
    69616261
    69626262  if (nLog2WidthMinus1 + 1>=6)
    69636263  {
    6964 #if JVET_C0024_ITSKIP && (JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT)
    6965     assert( uiSkipWidth >= iWidth - JVET_C0024_ZERO_OUT_TH );
     6264#if JVET_C0024_ITSKIP && JVET_D0077_TRANSFORM_OPT
     6265    assert( uiSkipWidth >= iWidth - ZERO_OUT_TH );
    69666266#endif
    69676267    fastInvTrans[nTrIdxHor][nLog2WidthMinus1]( tmp, block, shift_2nd, iHeight, 0, uiSkipWidth, clipMinimum, clipMaximum );
    69686268  }
    … …  
    69726272  }
    69736273#endif
    69746274#else
    6975   fastInvTrans[nTrIdxVer][nLog2HeightMinus1]( coeff, tmp, shift_1st,  iWidth, bZeroOut?2:0, 1, clipMinimum, clipMaximum );
    6976   fastInvTrans[nTrIdxHor][nLog2WidthMinus1]( tmp, block, shift_2nd, iHeight, bZeroOut?1:0, 1, clipMinimum, clipMaximum );
    6977 #endif
    6978 #else
    69796275  fastInvTrans[nTrIdxVer][nLog2SizeMinus2]( coeff, tmp, shift_1st,  iWidth, bZeroOut?2:0, 1, clipMinimum, clipMaximum );
    69806276  fastInvTrans[nTrIdxHor][nLog2SizeMinus2]( tmp, block, shift_2nd, iHeight, bZeroOut?1:0, 1, clipMinimum, clipMaximum );
    69816277#endif
    … …  
    70346330  assert(shift_2nd >= 0);
    70356331
    70366332  TCoeff tmp[MAX_TU_SIZE * MAX_TU_SIZE];
    7037 #if (JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT) && !JVET_C0024_ITSKIP
    7038   UInt uiSkipWidth = (iWidth > JVET_C0024_ZERO_OUT_TH ? iWidth - JVET_C0024_ZERO_OUT_TH : 0);
    7039   UInt uiSkipHeight = (iHeight > JVET_C0024_ZERO_OUT_TH ? iHeight - JVET_C0024_ZERO_OUT_TH : 0);
     6333#if JVET_D0077_TRANSFORM_OPT && !JVET_C0024_ITSKIP
     6334  UInt uiSkipWidth = (iWidth > ZERO_OUT_TH ? iWidth - ZERO_OUT_TH : 0);
     6335  UInt uiSkipHeight = (iHeight > ZERO_OUT_TH ? iHeight - ZERO_OUT_TH : 0);
    70406336#endif
    70416337
    70426338  switch (iHeight)
    … …  
    70776373#endif
    70786374#if COM16_C806_T64
    70796375#if JVET_C0024_QTBT
    7080 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    70816376#if JVET_D0077_TRANSFORM_OPT
    70826377    case 64: fastInverseDCT2_B64( coeff, tmp, shift_1st, iWidth, uiSkipWidth, uiSkipHeight, 0, clipMinimum, clipMaximum); break;
    70836378    case 128: fastInverseDCT2_B128( coeff, tmp, shift_1st, iWidth, uiSkipWidth, uiSkipHeight, 0, clipMinimum, clipMaximum); break;
    … …  
    70866381    case 128: fastInverseDCT2_B128( coeff, tmp, shift_1st, iWidth, uiSkipWidth, uiSkipHeight, clipMinimum, clipMaximum); break;
    70876382#endif
    70886383#else
    7089     case 64: fastInverseDCT2_B64( coeff, tmp, shift_1st, iWidth, 0, 0, clipMinimum, clipMaximum); break;
    7090     case 128: fastInverseDCT2_B128( coeff, tmp, shift_1st, iWidth, 0, 0, clipMinimum, clipMaximum); break;
    7091 #endif
    7092 #else
    70936384    case 64: fastInverseDCT2_B64( coeff, tmp, shift_1st, iWidth, 2, 0, clipMinimum, clipMaximum); break;
    70946385#endif
    70956386#endif
    … …  
    71356426#endif
    71366427#if COM16_C806_T64
    71376428#if JVET_C0024_QTBT
    7138 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX || JVET_D0077_TRANSFORM_OPT
    71396429#if JVET_D0077_TRANSFORM_OPT
    71406430    case 64: fastInverseDCT2_B64( tmp, block, shift_2nd, iHeight, 0, uiSkipWidth, 0, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    71416431    case 128: fastInverseDCT2_B128( tmp, block, shift_2nd, iHeight, 0, uiSkipWidth, 0, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    … …  
    71446434    case 128: fastInverseDCT2_B128( tmp, block, shift_2nd, iHeight, 0, uiSkipWidth, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    71456435#endif
    71466436#else
    7147     case 64: fastInverseDCT2_B64( tmp, block, shift_2nd, iHeight, 0, 0, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    7148     case 128: fastInverseDCT2_B128( tmp, block, shift_2nd, iHeight, 0, 0, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    7149 #endif
    7150 #else
    71516437    case 64: fastInverseDCT2_B64( tmp, block, shift_2nd, iHeight, 1, 0, std::numeric_limits<Pel>::min(), std::numeric_limits<Pel>::max()); break;
    71526438#endif
    71536439#endif

  • source/Lib/TLibCommon/TComTrQuant.h

     
    157157#if JVET_C0024_QTBT
    158158void fastForwardDCT2_B2 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    159159void fastInverseDCT2_B2 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    160 #if JVET_C0024_ZERO_OUT_FIX
    161160void fastForwardDCT2_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    162 #else
    163 void fastForwardDCT2_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    164 #endif
    165 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    166161void fastInverseDCT2_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    167 #else
    168 void fastInverseDCT2_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    169162#endif
    170 #endif
    171163void fastForwardDCT2_B4 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    172164void fastInverseDCT2_B4 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    173165void fastForwardDCT2_B8 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    … …  
    176168void fastInverseDCT2_B16(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    177169void fastForwardDCT2_B32(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    178170void fastInverseDCT2_B32(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    179 #if JVET_C0024_ZERO_OUT_FIX
    180171void fastForwardDCT2_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    181 #else
    182 void fastForwardDCT2_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    183 #endif
    184 #if JVET_C0024_ITSKIP || JVET_C0024_ZERO_OUT_FIX
    185172void fastInverseDCT2_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    186 #else
    187 void fastInverseDCT2_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    188 #endif
    189173
    190174void fastForwardDST7_B4 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    191175void fastInverseDST7_B4 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    … …  
    197181void fastForwardDST7_B32(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    198182void fastInverseDST7_B32(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    199183#if JVET_C0024_QTBT
    200 #if JVET_C0024_ZERO_OUT_FIX
    201184void fastForwardDST7_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    202185void fastInverseDST7_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    203186void fastForwardDST7_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    204187void fastInverseDST7_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    205 #else
    206 void fastForwardDST7_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    207 void fastInverseDST7_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    208 void fastForwardDST7_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    209 void fastInverseDST7_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    210188#endif
    211 #endif
    212189
    213190void fastForwardDCT5_B4 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    214191void fastInverseDCT5_B4 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    … …  
    219196void fastForwardDCT5_B32(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    220197void fastInverseDCT5_B32(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    221198#if JVET_C0024_QTBT
    222 #if JVET_C0024_ZERO_OUT_FIX
    223199void fastForwardDCT5_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    224200void fastInverseDCT5_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    225201void fastForwardDCT5_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    226202void fastInverseDCT5_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    227 #else
    228 void fastForwardDCT5_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    229 void fastInverseDCT5_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    230 void fastForwardDCT5_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    231 void fastInverseDCT5_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    232203#endif
    233 #endif
    234204
    235205void fastForwardDCT8_B4 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    236206void fastInverseDCT8_B4 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    … …  
    241211void fastForwardDCT8_B32(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    242212void fastInverseDCT8_B32(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    243213#if JVET_C0024_QTBT
    244 #if JVET_C0024_ZERO_OUT_FIX
    245214void fastForwardDCT8_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    246215void fastInverseDCT8_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    247216void fastForwardDCT8_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    248217void fastInverseDCT8_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    249 #else
    250 void fastForwardDCT8_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    251 void fastInverseDCT8_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    252 void fastForwardDCT8_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    253 void fastInverseDCT8_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    254218#endif
    255 #endif
    256219
    257220void fastForwardDST1_B4 (TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    258221void fastInverseDST1_B4 (TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    … …  
    263226void fastForwardDST1_B32(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    264227void fastInverseDST1_B32(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    265228#if JVET_C0024_QTBT
    266 #if JVET_C0024_ZERO_OUT_FIX
    267229void fastForwardDST1_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    268230void fastInverseDST1_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    269231void fastForwardDST1_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int iSkipLine, Int iSkipLine2);
    270232void fastInverseDST1_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int iSkipLine, Int iSkipLine2, const TCoeff outputMinimum, const TCoeff outputMaximum);
    271 #else
    272 void fastForwardDST1_B64(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    273 void fastInverseDST1_B64(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    274 void fastForwardDST1_B128(TCoeff *block,TCoeff *coeff,Int shift, Int line, Int zo, Int use);
    275 void fastInverseDST1_B128(TCoeff *coeff,TCoeff *block,Int shift, Int line, Int zo, Int use, const TCoeff outputMinimum, const TCoeff outputMaximum);
    276233#endif
    277 #endif
    278234
    279235typedef void FwdTrans (TCoeff *, TCoeff *, Int, Int, Int, Int);
    280236typedef void InvTrans (TCoeff *, TCoeff *, Int, Int, Int, Int, const TCoeff, const TCoeff);

  • source/Lib/TLibCommon/TypeDef.h

     
    9494#define JVET_C0024_CTU_256                                0  ///< support CTU 256 for QTBT, force QT split for CU 256x256
    9595#define JVET_C0024_ENCODER_OVERFLOW_FIX                   1  ///< fix the encoder overflow in the case of very high QP
    9696#define JVET_C0024_DELTA_QP_FIX                           1  ///< support delta QP signaling in QTBT
    97 #define JVET_C0024_ZERO_OUT_FIX                           1
    9897
    9998// for fast algorithms
    10099#define JVET_C0024_AMAX_BT                                1  ///< slice level adaptive maximum BT size (encoder only)
    … …  
    197196#if JVET_C0046_ZO_ASSERT
    198197#define JVET_C0046_ZO_ASSERT_CODED_SBK_FLAG               1  ///< if (iCGX > TH1 || iCGY > TH1) and (no TS && no TQBypass), then coded_sbk_flag(iCGX, iCGY) shall be 0.
    199198#define JVET_C0046_ZO_ASSERT_LAST_COEF                    1  ///< if (posLastX>TH2 || posLastY>TH2) and (no TS && no TQBypass), then last coef (x,y) shall be in the low frequency domain.
    200 #if !JVET_C0024_QTBT
    201 #define JVET_C0046_ZO_ASSERT_FIX_TICKET24                 1  ///< fixed ticket#24
    202199#endif
    203200#endif
    204 #endif
    205201
    206202#if COM16_C806_EMT || COM16_C806_T64
    207203#define COM16_C806_TRANS_PREC                             2  ///< Integer transform matrix precision

  • source/Lib/TLibDecoder/TDecSbac.cpp

     
    23672367#endif
    23682368  const UInt         uiMaxNumCoeff     = uiWidth * uiHeight;
    23692369  const UInt         uiMaxNumCoeffM1   = uiMaxNumCoeff - 1;
     2370  const Int          log2CoeffGroupSize = 2 - ((uiWidth & 0x03) != 0 || (uiHeight & 0x03) != 0);
    23702371
    23712372
    23722373  const ChannelType  channelType       = toChannelType(compID);
    … …  
    25052506  pcCoef[ uiBlkPosLast ] = 1;
    25062507
    25072508#if JVET_C0046_ZO_ASSERT && JVET_C0046_ZO_ASSERT_LAST_COEF
    2508 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2509   if ( ((uiWidth > JVET_C0046_ZERO_OUT_TH) || (uiHeight > JVET_C0046_ZERO_OUT_TH)) &&
    2510 #else
    2511   if ( ((uiWidth > JVET_C0024_ZERO_OUT_TH) || (uiHeight > JVET_C0024_ZERO_OUT_TH)) &&
    2512 #endif
     2509  if ( ((uiWidth > ZERO_OUT_TH) || (uiHeight > ZERO_OUT_TH)) &&
    25132510       (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)))
    25142511  {
    25152512     // last coeff shall be in the low freqecy domain
    2516 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2517      assert((uiPosLastX < JVET_C0046_ZERO_OUT_TH) && (uiPosLastY < JVET_C0046_ZERO_OUT_TH));
    2518 #else
    2519      assert((uiPosLastX < JVET_C0024_ZERO_OUT_TH) && (uiPosLastY < JVET_C0024_ZERO_OUT_TH));
    2520 #endif
     2513     assert((uiPosLastX < ZERO_OUT_TH) && (uiPosLastY < ZERO_OUT_TH));
    25212514  }
    25222515#endif
    25232516
    … …  
    26262619    {
    26272620      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
    26282621    }
    2629 #if COM16_C806_T64 && (!JVET_C0024_QTBT || JVET_C0024_ZERO_OUT_FIX ) && !JVET_C0046_ZO_ASSERT
    2630 #if JVET_C0024_ZERO_OUT_FIX
    2631     else if( iCGPosY>=(JVET_C0024_ZERO_OUT_TH>>2) || iCGPosX>=(JVET_C0024_ZERO_OUT_TH>>2) )
    2632 #else
    2633     else if( uiWidth>=64 && ( iCGPosY>=(codingParameters.heightInGroups/2) || iCGPosX>=(codingParameters.widthInGroups/2) ) )
    2634 #endif
     2622#if COM16_C806_T64 && !JVET_C0024_QTBT && !JVET_C0046_ZO_ASSERT
     2623    else if (iCGPosY >= (ZERO_OUT_TH >> log2CoeffGroupSize) || iCGPosX >= (ZERO_OUT_TH >> log2CoeffGroupSize))
    26352624    {
    26362625      uiSigCoeffGroupFlag[ iCGBlkPos ] = 0;
    26372626    }
    … …  
    26492638    }
    26502639
    26512640#if JVET_C0046_ZO_ASSERT && JVET_C0046_ZO_ASSERT_CODED_SBK_FLAG
    2652 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2653    if ( ((uiWidth > JVET_C0046_ZERO_OUT_TH) || (uiHeight > JVET_C0046_ZERO_OUT_TH)) &&
    2654 #else
    2655    if ( ((uiWidth > JVET_C0024_ZERO_OUT_TH) || (uiHeight > JVET_C0024_ZERO_OUT_TH)) &&
    2656 #endif
    2657        (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)) )
     2641   if ( ((uiWidth > ZERO_OUT_TH) || (uiHeight > ZERO_OUT_TH))
     2642     && (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)) )
    26582643   {
    2659 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2660       if (iCGPosY >= (JVET_C0046_ZERO_OUT_TH>>2) || iCGPosX >= (JVET_C0046_ZERO_OUT_TH>>2))
    2661 #else
    2662       if (iCGPosY >= (JVET_C0024_ZERO_OUT_TH>>2) || iCGPosX >= (JVET_C0024_ZERO_OUT_TH>>2))
    2663 #endif
     2644     if (iCGPosY >= (ZERO_OUT_TH >> log2CoeffGroupSize) || iCGPosX >= (ZERO_OUT_TH >> log2CoeffGroupSize))
    26642645      {
    26652646         //coded_sbk_flag(iCGX,iCGY) shall be equal to 0
    26662647         assert(0 == uiSigCoeffGroupFlag[iCGBlkPos]);

  • source/Lib/TLibEncoder/TEncSbac.cpp

     
    22842284  const Bool         alignCABACBeforeBypass = sps.getSpsRangeExtension().getCabacBypassAlignmentEnabledFlag();
    22852285  const Int          maxLog2TrDynamicRange  = sps.getMaxLog2TrDynamicRange(channelType);
    22862286
     2287  const Int          log2CoeffGroupSize = 2 - ((uiWidth & 0x03) != 0 || (uiHeight & 0x03) != 0);
     2288
    22872289  Bool beValid;
    22882290
    22892291  {
    … …  
    24562458
    24572459 
    24582460#if JVET_C0046_ZO_ASSERT && JVET_C0046_ZO_ASSERT_LAST_COEF
    2459 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2460   if ( ((uiWidth > JVET_C0046_ZERO_OUT_TH) || (uiHeight > JVET_C0046_ZERO_OUT_TH)) &&
    2461 #else
    2462   if ( ((uiWidth > JVET_C0024_ZERO_OUT_TH) || (uiHeight > JVET_C0024_ZERO_OUT_TH)) &&
    2463 #endif
    2464       (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)))
     2461  if ( ((uiWidth > ZERO_OUT_TH) || (uiHeight > ZERO_OUT_TH))
     2462    && (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)))
    24652463  {
    24662464     // last coeff shall be in the low freqecy domain
    2467 #if JVET_C0046_ZO_ASSERT_FIX_TICKET24
    2468      assert((posLastX < JVET_C0046_ZERO_OUT_TH) && (posLastY < JVET_C0046_ZERO_OUT_TH));
    2469 #else
    2470      assert((posLastX < JVET_C0024_ZERO_OUT_TH) && (posLastY < JVET_C0024_ZERO_OUT_TH));
    2471 #endif
     2465     assert((posLastX < ZERO_OUT_TH) && (posLastY < ZERO_OUT_TH));
    24722466  }
    24732467#endif
    24742468
    … …  
    25642558    {
    25652559      uiSigCoeffGroupFlag[ iCGBlkPos ] = 1;
    25662560    }
    2567 #if COM16_C806_T64  && (!JVET_C0024_QTBT || JVET_C0024_ZERO_OUT_FIX ) && !JVET_C0046_ZO_ASSERT
    2568 #if JVET_C0024_ZERO_OUT_FIX
    2569     else if( iCGPosY>=(JVET_C0024_ZERO_OUT_TH>>2) || iCGPosX>=(JVET_C0024_ZERO_OUT_TH>>2) )
    2570 #else
    2571     else if( uiWidth>=64 && ( iCGPosY>=(codingParameters.heightInGroups/2) || iCGPosX>=(codingParameters.widthInGroups/2) ) )
    2572 #endif
     2561#if COM16_C806_T64  && !JVET_C0024_QTBT && !JVET_C0046_ZO_ASSERT
     2562    else if( iCGPosY>=(ZERO_OUT_TH>>log2CoeffGroupSize) || iCGPosX>=(ZERO_OUT_TH>> log2CoeffGroupSize) )
    25732563    {
    25742564      assert( 0 == uiSigCoeffGroupFlag[ iCGBlkPos ] );
    25752565    }
    25762566#endif
    25772567#if JVET_C0046_ZO_ASSERT && JVET_C0046_ZO_ASSERT_CODED_SBK_FLAG
    2578     else if ( (uiLog2BlockWidth + uiLog2BlockHeight) > TH_LOG2TBAREASIZE &&
    2579               (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx) ))
     2568    else if ((iCGPosY >= (ZERO_OUT_TH >> log2CoeffGroupSize) || iCGPosX >= (ZERO_OUT_TH >> log2CoeffGroupSize))
     2569      && (!pcCU->getTransformSkip(compID) && !pcCU->getCUTransquantBypass(uiAbsPartIdx)))
    25802570    {
    2581         if ( iCGPosY >= (codingParameters.heightInGroups / 2) || iCGPosX >= (codingParameters.widthInGroups / 2) )
    2582         {
    2583             // coded_sbk_flag(iCGX,iCGY) shall be equal to 0
    2584             assert(0 == uiSigCoeffGroupFlag[iCGBlkPos]);
    2585         }
     2571      // coded_sbk_flag(iCGX,iCGY) shall be equal to 0
     2572      assert(0 == uiSigCoeffGroupFlag[iCGBlkPos]);
    25862573    }
    25872574#endif
    25882575    else