Changeset 1433 in SHVCSoftware


Ignore:
Timestamp:
11 Aug 2015, 20:22:28 (9 years ago)
Author:
seregin
Message:

port rev 4587 and fixes for the previous commit

Location:
branches/SHM-dev/source
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncCfg.cpp

    r1424 r1433  
    399399};
    400400
     401#if U0132_TARGET_BITS_SATURATION
     402UInt g_uiMaxCpbSize[2][21] =
     403{
     404  //         LEVEL1,        LEVEL2,LEVEL2_1,     LEVEL3, LEVEL3_1,      LEVEL4, LEVEL4_1,       LEVEL5,  LEVEL5_1,  LEVEL5_2,    LEVEL6,  LEVEL6_1,  LEVEL6_2
     405  { 0, 0, 0, 350000, 0, 0, 1500000, 3000000, 0, 6000000, 10000000, 0, 12000000, 20000000, 0,  25000000,  40000000,  60000000,  60000000, 120000000, 240000000 },
     406  { 0, 0, 0,      0, 0, 0,       0,       0, 0,       0,        0, 0, 30000000, 50000000, 0, 100000000, 160000000, 240000000, 240000000, 480000000, 800000000 }
     407};
     408#endif
     409
    401410static const struct MapStrToCostMode
    402411{
    … …  
    826835  Int*    cfg_RCInitialQP          [MAX_LAYERS];
    827836  Bool*   cfg_RCForceIntraQP       [MAX_LAYERS];
     837
     838#if U0132_TARGET_BITS_SATURATION
     839  Bool*   cfg_RCCpbSaturationEnabled[MAX_LAYERS];
     840  UInt*   cfg_RCCpbSize             [MAX_LAYERS];
     841  Double* cfg_RCInitialCpbFullness  [MAX_LAYERS];
     842#endif
    828843#endif
    829844
    … …  
    916931    cfg_RCInitialQP[layer]           = &m_apcLayerCfg[layer]->m_RCInitialQP;
    917932    cfg_RCForceIntraQP[layer]        = &m_apcLayerCfg[layer]->m_RCForceIntraQP;
     933
     934#if U0132_TARGET_BITS_SATURATION
     935    cfg_RCCpbSaturationEnabled[layer] = &m_apcLayerCfg[layer]->m_RCCpbSaturationEnabled;
     936    cfg_RCCpbSize[layer]              = &m_apcLayerCfg[layer]->m_RCCpbSize;
     937    cfg_RCInitialCpbFullness[layer]   = &m_apcLayerCfg[layer]->m_RCInitialCpbFullness;
     938#endif
    918939#endif
    919940
    … …  
    12481269  ("Profile",                                         extendedProfile,                                   NONE, "Profile name to use for encoding. Use main (for main), main10 (for main10), main-still-picture, main-RExt (for Range Extensions profile), any of the RExt specific profile names, or none")
    12491270  ("Level",                                           m_level,                                    Level::NONE, "Level limit to be used, eg 5.1, or none")
    1250   ("Tier",                                            m_levelTier,                                Level::MAIN, "Tier to use for interpretation of --Level (main or high only)") 
    1251 
     1271  ("Tier",                                            m_levelTier,                                Level::MAIN, "Tier to use for interpretation of --Level (main or high only)")
    12521272  ("MaxBitDepthConstraint",                           m_bitDepthConstraint,                                0u, "Bit depth to use for profile-constraint for RExt profiles. 0=automatically choose based upon other parameters")
    12531273  ("MaxChromaFormatConstraint",                       tmpConstraintChromaFormat,                            0, "Chroma-format to use for the profile-constraint for RExt profiles. 0=automatically choose based upon other parameters")
    … …  
    14491469  ("InitialQP%d",                                     cfg_RCInitialQP,                         0, m_numLayers, "Rate control: initial QP")
    14501470  ("RCForceIntraQP%d",                                cfg_RCForceIntraQP,                  false, m_numLayers, "Rate control: force intra QP to be equal to initial QP")
     1471#if U0132_TARGET_BITS_SATURATION
     1472  ( "RCCpbSaturation%d",                              cfg_RCCpbSaturationEnabled,          false, m_numLayers, "Rate control: enable target bits saturation to avoid CPB overflow and underflow" )
     1473  ( "RCCpbSize%d",                                    cfg_RCCpbSize,                          0u, m_numLayers, "Rate control: CPB size" )
     1474  ( "RCInitialCpbFullness%d",                         cfg_RCInitialCpbFullness,              0.9, m_numLayers, "Rate control: initial CPB fullness" )
     1475#endif
    14511476#else
    14521477  ( "RateControl",                                    m_RCEnableRateControl,                            false, "Rate control: enable rate control" )
    … …  
    14571482  ( "InitialQP",                                      m_RCInitialQP,                                        0, "Rate control: initial QP" )
    14581483  ( "RCForceIntraQP",                                 m_RCForceIntraQP,                                 false, "Rate control: force intra QP to be equal to initial QP" )
     1484#if U0132_TARGET_BITS_SATURATION
     1485  ( "RCCpbSaturation",                                m_RCCpbSaturationEnabled,                         false, "Rate control: enable target bits saturation to avoid CPB overflow and underflow" )
     1486  ( "RCCpbSize",                                      m_RCCpbSize,                                         0u, "Rate control: CPB size" )
     1487  ( "RCInitialCpbFullness",                           m_RCInitialCpbFullness,                             0.9, "Rate control: initial CPB fullness" )
     1488#endif
    14591489#endif
    14601490
    … …  
    41994229      }
    42004230    }
    4201   }
    4202   xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
     4231    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
     4232#if U0132_TARGET_BITS_SATURATION
     4233    Int layerPTLIdx = m_apcLayerCfg[layerIdx]->m_layerPTLIdx;
     4234
     4235    if( m_apcLayerCfg[layerIdx]->m_RCCpbSaturationEnabled && m_levelList[layerPTLIdx]!=Level::NONE && m_profileList[layerPTLIdx]!=Profile::NONE )
     4236    {
     4237      UInt uiLevelIdx = (m_levelList[layerPTLIdx] / 10) + (UInt)((m_levelList[layerPTLIdx] % 10) / 3);    // (m_level / 30)*3 + ((m_level % 10) / 3);
     4238      xConfirmPara( m_apcLayerCfg[layerIdx]->m_RCCpbSize > g_uiMaxCpbSize[m_levelTierList[layerPTLIdx]][uiLevelIdx], "RCCpbSize should be smaller than or equal to Max CPB size according to tier and level");
     4239      xConfirmPara( m_apcLayerCfg[layerIdx]->m_RCInitialCpbFullness > 1, "RCInitialCpbFullness should be smaller than or equal to 1");
     4240    }
     4241#endif
     4242  }
     4243#if U0132_TARGET_BITS_SATURATION
     4244  else
     4245  {
     4246    xConfirmPara( m_apcLayerCfg[layerIdx]->m_RCCpbSaturationEnabled != 0, "Target bits saturation cannot be processed without Rate control" );
     4247  }
     4248#endif
    42034249#else
    42044250  if ( m_RCEnableRateControl )
    … …  
    42134259    }
    42144260    xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" );
    4215   }
     4261#if U0132_TARGET_BITS_SATURATION
     4262    if ((m_RCCpbSaturationEnabled) && (m_level!=Level::NONE) && (m_profile!=Profile::NONE))
     4263    {
     4264      UInt uiLevelIdx = (m_level / 10) + (UInt)((m_level % 10) / 3);    // (m_level / 30)*3 + ((m_level % 10) / 3);
     4265      xConfirmPara(m_RCCpbSize > g_uiMaxCpbSize[m_levelTier][uiLevelIdx], "RCCpbSize should be smaller than or equal to Max CPB size according to tier and level");
     4266      xConfirmPara(m_RCInitialCpbFullness > 1, "RCInitialCpbFullness should be smaller than or equal to 1");
     4267    }
     4268#endif
     4269  }
     4270#if U0132_TARGET_BITS_SATURATION
     4271  else
     4272  {
     4273    xConfirmPara( m_RCCpbSaturationEnabled != 0, "Target bits saturation cannot be processed without Rate control" );
     4274  }
     4275#endif
    42164276#endif
    42174277
    … …  
    45044564    printf("InitialQP                              : %d\n", m_RCInitialQP );
    45054565    printf("ForceIntraQP                           : %d\n", m_RCForceIntraQP );
     4566#if U0132_TARGET_BITS_SATURATION
     4567    printf("CpbSaturation                          : %d\n", m_RCCpbSaturationEnabled );
     4568    if (m_RCCpbSaturationEnabled)
     4569    {
     4570      printf("CpbSize                                : %d\n", m_RCCpbSize);
     4571      printf("InitalCpbFullness                      : %.2f\n", m_RCInitialCpbFullness);
     4572    }
     4573#endif
    45064574  }
    45074575#endif
    … …  
    45714639
    45724640  printf(" SignBitHidingFlag:%d ", m_signHideFlag);
    4573   printf("RecalQP:%d ", m_recalculateQPAccordingToLambda ? 1 : 0 );
     4641  printf("RecalQP:%d", m_recalculateQPAccordingToLambda ? 1 : 0 );
    45744642
    45754643#if SVC_EXTENSION

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncCfg.h

    r1424 r1433  
    407407  Int       m_RCInitialQP;                        ///< inital QP for rate control
    408408  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
     409#if U0132_TARGET_BITS_SATURATION
     410  Bool      m_RCCpbSaturationEnabled;             ///< enable target bits saturation to avoid CPB overflow and underflow
     411  UInt      m_RCCpbSize;                          ///< CPB size
     412  Double    m_RCInitialCpbFullness;               ///< initial CPB fullness
     413#endif
    409414#endif
    410415#if !SVC_EXTENSION

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncLayerCfg.cpp

    r1381 r1433  
    266266    printf("InitialQP                         : %d\n", m_RCInitialQP );
    267267    printf("ForceIntraQP                      : %d\n", m_RCForceIntraQP );
     268#if U0132_TARGET_BITS_SATURATION
     269    printf("CpbSaturation                          : %d\n", m_RCCpbSaturationEnabled );
     270    if (m_RCCpbSaturationEnabled)
     271    {
     272      printf("CpbSize                                : %d\n", m_RCCpbSize);
     273      printf("InitalCpbFullness                      : %.2f\n", m_RCInitialCpbFullness);
     274    }
     275#endif
    268276  }
    269277#endif

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncLayerCfg.h

    r1381 r1433  
    8585  Int       m_RCInitialQP;                        ///< inital QP for rate control
    8686  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
     87#if U0132_TARGET_BITS_SATURATION
     88  Bool      m_RCCpbSaturationEnabled;             ///< enable target bits saturation to avoid CPB overflow and underflow
     89  UInt      m_RCCpbSize;                          ///< CPB size
     90  Double    m_RCInitialCpbFullness;               ///< initial CPB fullness
     91#endif
    8792#endif
    8893

  • branches/SHM-dev/source/App/TAppEncoder/TAppEncTop.cpp

    r1432 r1433  
    493493    Int           m_RCInitialQP                                = m_apcLayerCfg[layer]->getRCInitialQP();
    494494    Bool          m_RCForceIntraQP                             = m_apcLayerCfg[layer]->getRCForceIntraQP();
     495
     496#if U0132_TARGET_BITS_SATURATION
     497    Bool          m_RCCpbSaturationEnabled                     = m_apcLayerCfg[layer]->m_RCCpbSaturationEnabled;
     498    UInt          m_RCCpbSize                                  = m_apcLayerCfg[layer]->m_RCCpbSize;
     499    Double        m_RCInitialCpbFullness                       = m_apcLayerCfg[layer]->m_RCInitialCpbFullness;
     500#endif
    495501
    496502    ScalingListMode m_useScalingListId                         = m_apcLayerCfg[layer]->m_useScalingListId;
    … …  
    789795  m_cTEncTop.setInitialQP                                         ( m_RCInitialQP );
    790796  m_cTEncTop.setForceIntraQP                                      ( m_RCForceIntraQP );
     797#if U0132_TARGET_BITS_SATURATION
     798  m_cTEncTop.setCpbSaturationEnabled                              ( m_RCCpbSaturationEnabled );
     799  m_cTEncTop.setCpbSize                                           ( m_RCCpbSize );
     800  m_cTEncTop.setInitialCpbFullness                                ( m_RCInitialCpbFullness );
     801#endif
    791802  m_cTEncTop.setTransquantBypassEnableFlag                        ( m_TransquantBypassEnableFlag );
    792803  m_cTEncTop.setCUTransquantBypassFlagForceValue                  ( m_CUTransquantBypassFlagForce );

  • branches/SHM-dev/source/Lib/TLibCommon/TypeDef.h

    r1407 r1433  
    200200#endif
    201201
     202#define U0132_TARGET_BITS_SATURATION                      1 ///< Rate control with target bits saturation method
    202203
    203204// ====================================================================================================================

  • branches/SHM-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r1432 r1433  
    35753575  READ_UVLC( uiChromaInputBitDepthM8 , "cm_input_chroma_bit_depth_minus8" );
    35763576  READ_UVLC( uiOutputBitDepthM8, "cm_output_luma_bit_depth_minus8" );
    3577   READ_UVLC( uiChromaOutputBitDepthM8  "cm_output_chroma_bit_depth_minus8" );
     3577  READ_UVLC( uiChromaOutputBitDepthM8,  "cm_output_chroma_bit_depth_minus8" );
    35783578  READ_CODE( 2, uiResQaunBit, "cm_res_quant_bit" );
    35793579
    … …  
    36813681            for( Int nVertexIdx = 0; nVertexIdx < 4; nVertexIdx++ )
    36823682            {
    3683               pc3DAsymLUT->setCuboidVertexResTree( yIdx + y, uIdx +  , vIdx + v, nVertexIdx, 0, 0, 0 );
     3683              pc3DAsymLUT->setCuboidVertexResTree( yIdx + y, uIdx + u, vIdx + v, nVertexIdx, 0, 0, 0 );
    36843684#if R0164_CGS_LUT_BUGFIX_CHECK
    36853685              pc3DAsymLUT->xSetFilled( yIdx + y, uIdx + u, vIdx + v );

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncCfg.h

    r1432 r1433  
    339339  Int       m_RCInitialQP;
    340340  Bool      m_RCForceIntraQP;
     341#if U0132_TARGET_BITS_SATURATION
     342  Bool      m_RCCpbSaturationEnabled;
     343  UInt      m_RCCpbSize;
     344  Double    m_RCInitialCpbFullness;
     345#endif
    341346  Bool      m_TransquantBypassEnableFlag;                     ///< transquant_bypass_enable_flag setting in PPS.
    342347  Bool      m_CUTransquantBypassFlagForce;                    ///< if transquant_bypass_enable_flag, then, if true, all CU transquant bypass flags will be set to true.
    … …  
    936941  Bool         getForceIntraQP        ()                             { return m_RCForceIntraQP;        }
    937942  Void         setForceIntraQP        ( Bool b )                     { m_RCForceIntraQP = b;           }
     943#if U0132_TARGET_BITS_SATURATION
     944  Bool         getCpbSaturationEnabled()                             { return m_RCCpbSaturationEnabled;}
     945  Void         setCpbSaturationEnabled( Bool b )                     { m_RCCpbSaturationEnabled = b;   }
     946  UInt         getCpbSize             ()                             { return m_RCCpbSize;}
     947  Void         setCpbSize             ( UInt ui )                    { m_RCCpbSize = ui;   }
     948  Double       getInitialCpbFullness  ()                             { return m_RCInitialCpbFullness;  }
     949  Void         setInitialCpbFullness  (Double f)                     { m_RCInitialCpbFullness = f;     }
     950#endif
    938951  Bool         getTransquantBypassEnableFlag()                       { return m_TransquantBypassEnableFlag; }
    939952  Void         setTransquantBypassEnableFlag(Bool flag)              { m_TransquantBypassEnableFlag = flag; }

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r1432 r1433  
    24322432      estimatedBits = m_pcRateCtrl->getRCPic()->getTargetBits();
    24332433
     2434#if U0132_TARGET_BITS_SATURATION
     2435      if (m_pcRateCtrl->getCpbSaturationEnabled() && frameLevel != 0)
     2436      {
     2437        Int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
     2438
     2439        // prevent overflow
     2440        if (estimatedCpbFullness - estimatedBits > (Int)(m_pcRateCtrl->getCpbSize()*0.9f))
     2441        {
     2442          estimatedBits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.9f);
     2443        }
     2444
     2445        estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
     2446        // prevent underflow
     2447        if (estimatedCpbFullness - estimatedBits < (Int)(m_pcRateCtrl->getCpbSize()*0.1f))
     2448        {
     2449          estimatedBits = max(200, estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.1f));
     2450        }
     2451
     2452        m_pcRateCtrl->getRCPic()->setTargetBits(estimatedBits);
     2453      }
     2454#endif
     2455
    24342456      Int sliceQP = m_pcCfg->getInitialQP();
    24352457#if SVC_EXTENSION
    … …  
    24552477          Int bits = m_pcRateCtrl->getRCSeq()->getLeftAverageBits();
    24562478          bits = m_pcRateCtrl->getRCPic()->getRefineBitsForIntra( bits );
     2479
     2480#if U0132_TARGET_BITS_SATURATION
     2481          if (m_pcRateCtrl->getCpbSaturationEnabled() )
     2482          {
     2483            Int estimatedCpbFullness = m_pcRateCtrl->getCpbState() + m_pcRateCtrl->getBufferingRate();
     2484
     2485            // prevent overflow
     2486            if (estimatedCpbFullness - bits > (Int)(m_pcRateCtrl->getCpbSize()*0.9f))
     2487            {
     2488              bits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.9f);
     2489            }
     2490
     2491            estimatedCpbFullness -= m_pcRateCtrl->getBufferingRate();
     2492            // prevent underflow
     2493            if (estimatedCpbFullness - bits < (Int)(m_pcRateCtrl->getCpbSize()*0.1f))
     2494            {
     2495              bits = estimatedCpbFullness - (Int)(m_pcRateCtrl->getCpbSize()*0.1f);
     2496            }
     2497          }
     2498#endif
     2499
    24572500          if ( bits < 200 )
    24582501          {
    … …  
    28462889        m_pcRateCtrl->getRCGOP()->updateAfterPicture( estimatedBits );
    28472890      }
     2891#if U0132_TARGET_BITS_SATURATION
     2892      if (m_pcRateCtrl->getCpbSaturationEnabled())
     2893      {
     2894        m_pcRateCtrl->updateCpbState(actualTotalBits);
     2895        printf(" [CPB %6d bits]", m_pcRateCtrl->getCpbState());
     2896      }
     2897#endif
    28482898    }
    28492899
    … …  
    42564306#endif
    42574307#endif
    4258 Void TEncGOP::xFilterImg( Pel *src, Int iSrcStride, Pel *dst, Int iDstStride, Int height1, Int width1, BitDepths& bitDepth, ComponentID comp )
     4308Void TEncGOP::xFilterImg( Pel *src, Int iSrcStride, Pel *dst, Int iDstStride, Int height, Int width, BitDepths& bitDepth, ComponentID comp )
    42594309{
    42604310  Int height2, width2;
    … …  
    42644314  Int length = m_cgsFilterLength;
    42654315  Int shift  = bitDepth.recon[CHANNEL_TYPE_LUMA] - bitDepth.recon[CHANNEL_TYPE_CHROMA];
    4266   Int shift2 = 2*7+shift;
     4316  Int shift2 = 2*7 + shift;
    42674317  Int roundingOffset = (1 << (shift2 - 1));
    42684318  Int maxVal = (1<<(bitDepth.recon[toChannelType(comp)]-shift))-1;
    4269   height2 = (height1 * m_cgsFilterPhases) / m_iN;
    4270   width2  = (width1  * m_cgsFilterPhases) / m_iN;
     4319  height2 = (height * m_cgsFilterPhases) / m_iN;
     4320  width2  = (width  * m_cgsFilterPhases) / m_iN;
    42714321
    42724322  m_phaseFilter = comp == COMPONENT_Y ? m_phaseFilterLuma : m_phaseFilterChroma;
    42734323
    42744324  // horizontal filtering
    4275   for( Int j1 = 0; j1 < height1; j1++ )
     4325  for( Int j1 = 0; j1 < height; j1++ )
    42764326  {
    42774327    Int i0 = -m_iN;
    … …  
    43024352  }
    43034353
    4304   for( Int k = height1; k < (height1 + (length>>1)); k++)
     4354  for( Int k = height; k < (height + (length>>1)); k++)
    43054355  {
    43064356    memcpy(m_temp[k], m_temp[k-1], (width2) * sizeof(Int));

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncGOP.h

    r1432 r1433  
    292292  inline Short xClip( Short x, Int bitdepth );
    293293  Void xInitDs( const Int iWidth, const Int iHeight, const Bool allIntra, const Int posScalingFactorX);
    294   Void xFilterImg( Pel *src, Int iSrcStride, Pel *dst, Int iDstStride, Int height1, Int width1, BitDepths& bitDepth, ComponentID comp );
     294  Void xFilterImg( Pel *src, Int iSrcStride, Pel *dst, Int iDstStride, Int height, Int width, BitDepths& bitDepth, ComponentID comp );
    295295
    296296  Int  xCreate2DArray(Int ***array2D, Int dim0, Int dim1, Int iPadY, Int iPadX);

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncRateCtrl.cpp

    r1259 r1433  
    13791379    m_encRCSeq->initLCUPara();
    13801380  }
     1381#if U0132_TARGET_BITS_SATURATION
     1382  m_CpbSaturationEnabled = false;
     1383  m_cpbSize              = targetBitrate;
     1384  m_cpbState             = (UInt)(m_cpbSize*0.5f);
     1385  m_bufferingRate        = (Int)(targetBitrate / frameRate);
     1386#endif
    13811387
    13821388  delete[] bitsRatio;
    … …  
    13961402}
    13971403
     1404#if U0132_TARGET_BITS_SATURATION
     1405Int  TEncRateCtrl::updateCpbState(Int actualBits)
     1406{
     1407  Int cpbState = 1;
     1408
     1409  m_cpbState -= actualBits;
     1410  if (m_cpbState < 0)
     1411  {
     1412    cpbState = -1;
     1413  }
     1414
     1415  m_cpbState += m_bufferingRate;
     1416  if (m_cpbState > m_cpbSize)
     1417  {
     1418    cpbState = 0;
     1419  }
     1420
     1421  return cpbState;
     1422}
     1423
     1424Void TEncRateCtrl::initHrdParam(const TComHRD* pcHrd, Int iFrameRate, Double fInitialCpbFullness)
     1425{
     1426  m_CpbSaturationEnabled = true;
     1427  m_cpbSize = (pcHrd->getCpbSizeValueMinus1(0, 0, 0) + 1) << (4 + pcHrd->getCpbSizeScale());
     1428  m_cpbState = (UInt)(m_cpbSize*fInitialCpbFullness);
     1429  m_bufferingRate = (UInt)(((pcHrd->getBitRateValueMinus1(0, 0, 0) + 1) << (6 + pcHrd->getBitRateScale())) / iFrameRate);
     1430  printf("\nHRD - [Initial CPB state %6d] [CPB Size %6d] [Buffering Rate %6d]\n", m_cpbState, m_cpbSize, m_bufferingRate);
     1431}
     1432#endif
     1433
    13981434Void TEncRateCtrl::destroyRCGOP()
    13991435{

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncRateCtrl.h

    r1259 r1433  
    265265  TRCLCU& getLCU( Int LCUIdx )                            { return m_LCUs[LCUIdx]; }
    266266  Int  getPicActualHeaderBits()                           { return m_picActualHeaderBits; }
     267#if U0132_TARGET_BITS_SATURATION
     268  Void setBitLeft(Int bits)                               { m_bitsLeft = bits; }
     269#endif
    267270  Void setTargetBits( Int bits )                          { m_targetBits = bits; m_bitsLeft = bits;}
    268271  Void setTotalIntraCost(Double cost)                     { m_totalCostIntra = cost; }
    … …  
    322325  TEncRCPic* getRCPic()          { assert ( m_encRCPic != NULL ); return m_encRCPic; }
    323326  list<TEncRCPic*>& getPicList() { return m_listRCPictures; }
     327#if U0132_TARGET_BITS_SATURATION
     328  Bool       getCpbSaturationEnabled()  { return m_CpbSaturationEnabled;  }
     329  UInt       getCpbState()              { return m_cpbState;       }
     330  UInt       getCpbSize()               { return m_cpbSize;        }
     331  UInt       getBufferingRate()         { return m_bufferingRate;  }
     332  Int        updateCpbState(Int actualBits);
     333  Void       initHrdParam(const TComHRD* pcHrd, Int iFrameRate, Double fInitialCpbFullness);
     334#endif
    324335
    325336private:
    … …  
    329340  list<TEncRCPic*> m_listRCPictures;
    330341  Int        m_RCQP;
    331 };
    332 
     342#if U0132_TARGET_BITS_SATURATION
     343  Bool       m_CpbSaturationEnabled;    // Enable target bits saturation to avoid CPB overflow and underflow
     344  Int        m_cpbState;                // CPB State
     345  UInt       m_cpbSize;                 // CPB size
     346  UInt       m_bufferingRate;           // Buffering rate
    333347#endif
    334 
    335 
     348};
     349
     350#endif
     351
     352

  • branches/SHM-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r1406 r1433  
    228228  xInitVPS();
    229229
     230#if U0132_TARGET_BITS_SATURATION
     231  if (m_RCCpbSaturationEnabled)
     232  {
     233    m_cRateCtrl.initHrdParam(m_cSPS.getVuiParameters()->getHrdParameters(), m_iFrameRate, m_RCInitialCpbFullness);
     234  }
     235#endif
    230236  m_cRdCost.setCostMode(m_costMode);
    231237
    … …  
    10021008    m_cSPS.setUsedByCurrPicLtSPSFlag(k, 0);
    10031009  }
     1010
     1011#if U0132_TARGET_BITS_SATURATION
     1012  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() || getCpbSaturationEnabled() )
     1013#else
    10041014  if( getPictureTimingSEIEnabled() || getDecodingUnitInfoSEIEnabled() )
     1015#endif
    10051016  {
    10061017    xInitHrdParameters();
    … …  
    10251036}
    10261037
     1038#if U0132_TARGET_BITS_SATURATION
     1039// calculate scale value of bitrate and initial delay
     1040Int calcScale(Int x)
     1041{
     1042  UInt iMask = 0xffffffff;
     1043  Int ScaleValue = 32;
     1044
     1045  while ((x&iMask) != 0)
     1046  {
     1047    ScaleValue--;
     1048    iMask = (iMask >> 1);
     1049  }
     1050
     1051  return ScaleValue;
     1052}
     1053#endif
    10271054Void TEncTop::xInitHrdParameters()
    10281055{
    … …  
    10301057  Int  bitRate         = getTargetBitrate();
    10311058  Bool isRandomAccess  = getIntraPeriod() > 0;
    1032 
     1059# if U0132_TARGET_BITS_SATURATION
     1060  Int cpbSize          = getCpbSize();
     1061
     1062  if( !getVuiParametersPresentFlag() && !getCpbSaturationEnabled() )
     1063#else
    10331064  if( !getVuiParametersPresentFlag() )
     1065#endif
    10341066  {
    10351067    return;
    … …  
    10751107  hrd->setNalHrdParametersPresentFlag( rateCnt );
    10761108  hrd->setVclHrdParametersPresentFlag( rateCnt );
    1077 
    10781109  hrd->setSubPicCpbParamsPresentFlag( useSubCpbParams );
    10791110
    … …  
    10901121  }
    10911122
     1123#if U0132_TARGET_BITS_SATURATION
     1124  if (calcScale(bitRate) <= 6)
     1125  {
     1126    hrd->setBitRateScale(0);
     1127  }
     1128  else
     1129  {
     1130    hrd->setBitRateScale(calcScale(bitRate) - 6);
     1131  }
     1132
     1133  if (calcScale(cpbSize) <= 4)
     1134  {
     1135    hrd->setCpbSizeScale(0);
     1136  }
     1137  else
     1138  {
     1139    hrd->setCpbSizeScale(calcScale(cpbSize) - 4);
     1140  }
     1141#else
    10921142  hrd->setBitRateScale( 4 );                                       // in units of 2^( 6 + 4 ) = 1,024 bps
    10931143  hrd->setCpbSizeScale( 6 );                                       // in units of 2^( 4 + 6 ) = 1,024 bit
     1144#endif
     1145
    10941146  hrd->setDuCpbSizeScale( 6 );                                     // in units of 2^( 4 + 6 ) = 1,024 bit
    10951147
    … …  
    11231175    bitrateValue = bitRate / (1 << (6 + hrd->getBitRateScale()) );      // bitRate is in bits, so it needs to be scaled down
    11241176    // CpbSize[ i ] = ( cpb_size_value_minus1[ i ] + 1 ) * 2^( 4 + cpb_size_scale )
     1177#if U0132_TARGET_BITS_SATURATION
     1178    cpbSizeValue = cpbSize / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
     1179#else
    11251180    cpbSizeValue = bitRate / (1 << (4 + hrd->getCpbSizeScale()) );      // using bitRate results in 1 second CPB size
     1181#endif
     1182
    11261183
    11271184    // DU CPB size could be smaller (i.e. bitrateValue / number of DUs), but we don't know
Note: See TracChangeset for help on using the changeset viewer.