Changeset 655 in 3DVCSoftware for trunk/source/App/TAppEncoder/TAppEncTop.cpp


Ignore:
Timestamp:
23 Oct 2013, 23:01:30 (10 years ago)
Author:
tech
Message:

Merged 8.1-Cleanup@654

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

    r622 r655  
    8888    vps.setTemporalNestingFlag(true);
    8989  }
    90 #if H_MV5
    9190  vps.setMaxLayersMinus1( m_numberOfLayers - 1);
    92 #else
    93   vps.setMaxLayers( m_numberOfLayers );
    94 #endif
    9591  for(Int i = 0; i < MAX_TLAYER; i++)
    9692  {
     
    124120  xSetDependencies( vps );
    125121  xSetProfileTierLevel     ( vps );
    126 #if H_MV5
    127122  xSetRepFormat            ( vps );
    128 #endif
    129123  xSetLayerSets            ( vps );
    130 #if H_MV5
    131124  xSetVPSVUI               ( vps );
    132 #endif
    133125#if H_3D
    134 #if !H_MV5
    135   vps.initViewIndex();
    136 #endif
    137126  xSetVPSExtension2        ( vps );
    138127  m_ivPicLists.setVPS      ( &vps );
     
    140129
    141130
    142 #if H_MV5
    143131  for(Int layerIdInVps = 0; layerIdInVps < m_numberOfLayers; layerIdInVps++)
    144 #else
    145   for(Int layer = 0; layer < m_numberOfLayers; layer++)
    146 #endif
    147132  {
    148133    m_frameRcvd                 .push_back(0);
     
    151136    m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
    152137    m_picYuvRec                 .push_back(new TComList<TComPicYuv*>) ;
    153 #if H_MV5   
    154138    m_ivPicLists.push_back( m_acTEncTopList[ layerIdInVps ]->getListPic()  );
    155139    TEncTop& m_cTEncTop = *m_acTEncTopList[ layerIdInVps ];  // It is not a member, but this name helps avoiding code duplication !!!
     
    160144    m_cTEncTop.setViewId                       ( vps.getViewId      (  layerId ) );
    161145    m_cTEncTop.setViewIndex                    ( vps.getViewIndex   (  layerId ) );
    162 #else
    163     m_ivPicLists.push_back( m_acTEncTopList[ layer ]->getListPic()  );
    164     TEncTop& m_cTEncTop = *m_acTEncTopList[ layer ];  // It is not a member, but this name helps avoiding code duplication !!!
    165    
    166     m_cTEncTop.setLayerIdInVps                 ( layer );
    167     m_cTEncTop.setLayerId                      ( vps.getLayerIdInNuh( layer ) );   
    168     m_cTEncTop.setViewId                       ( vps.getViewId      ( layer ) );
    169 
    170 #endif
    171146#if H_3D
    172 #if H_MV5
    173147    Bool isDepth = ( vps.getDepthId     ( layerId ) != 0 ) ;
    174 #else
    175     Bool isDepth = ( vps.getDepthId     ( layer ) != 0 ) ;
    176     m_cTEncTop.setViewIndex                    ( vps.getViewIndex   ( layer ) );
    177 #endif
    178148    m_cTEncTop.setIsDepth                      ( isDepth );
    179149    //====== Camera Parameters =========
     
    201171    m_cTEncTop.setDWeight                      ( isDepth ? m_iDWeight             : 0     );
    202172#endif // H_3D_VSO
    203 #if H_MV5
    204173#if H_3D_ARP
    205174    //====== Advanced Inter-view Residual Prediction =========
     
    209178#if H_3D_IC
    210179    m_cTEncTop.setUseIC                        ( vps.getViewIndex( layerId ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
    211 #endif
    212 #else
    213 #if H_3D_ARP
    214     //====== Advanced Inter-view Residual Prediction =========
    215     m_cTEncTop.setUseAdvRP                     ( ( isDepth || 0==layer ) ? 0 : m_uiUseAdvResPred );
    216     m_cTEncTop.setARPStepNum                   ( ( isDepth || 0==layer ) ? 1 : H_3D_ARP_WFNR     );
    217 #endif
    218 #if H_3D_IC
    219     m_cTEncTop.setUseIC                        ( vps.getViewIndex( layer ) == 0 ? false : m_abUseIC[isDepth ? 1 : 0] );
    220 #endif
    221180#endif
    222181  //========== Depth intra modes ==========
     
    232191#endif
    233192    //====== Depth Inter SDC =========
    234 #if LGE_INTER_SDC_E0156
     193#if H_3D_INTER_SDC
    235194    m_cTEncTop.setInterSDCEnable               ( isDepth ? m_bDepthInterSDCFlag    : false );
    236195#endif
     
    260219  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
    261220#if H_MV
    262 #if H_MV5
    263221m_cTEncTop.setGopList                      ( m_GOPListMvc[layerIdInVps] );
    264222  m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layerIdInVps] );
     
    269227  }
    270228#else
    271   m_cTEncTop.setGopList                      ( m_GOPListMvc[layer] );
    272   m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layer] );
    273   for(Int i = 0; i < MAX_TLAYER; i++)
    274   {
    275     m_cTEncTop.setNumReorderPics             ( m_numReorderPicsMvc[layer][i], i );
    276     m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBufferingMvc[layer][i], i );
    277   }
    278 #endif
    279 #else
    280229  m_cTEncTop.setGopList                      ( m_GOPList );
    281230  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
     
    291240  }
    292241#if H_MV
    293 #if H_MV5
    294242  m_cTEncTop.setQP                           ( m_iQP[layerIdInVps] );
    295243#else
    296   m_cTEncTop.setQP                           ( m_iQP[layer] );
    297 #endif
    298 #else
    299244  m_cTEncTop.setQP                           ( m_iQP );
    300245#endif
     
    303248
    304249#if H_MV
    305 #if H_MV5
    306250  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layerIdInVps] );
    307251#else
    308   m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layer] );
    309 #endif
    310 #else
    311252  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
    312253#endif
     
    317258  //====== Loop/Deblock Filter ========
    318259#if H_MV
    319 #if H_MV5
    320260  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layerIdInVps]);
    321 #else
    322   m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layer]);
    323 #endif
    324261#else
    325262  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
     
    351288
    352289#if H_MV
    353 #if H_MV5
    354290  if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layerIdInVps] == lowestQP) && (m_useLossless == true))
    355 #else
    356   if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layer] == lowestQP) && (m_useLossless == true))
    357 #endif
    358291#else
    359292  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
     
    372305  m_cTEncTop.setUseLossless                  ( m_useLossless );
    373306#if H_MV
    374 #if H_MV5
    375307  m_cTEncTop.setdQPs                         ( m_aidQP[layerIdInVps]   );
    376 #else
    377   m_cTEncTop.setdQPs                         ( m_aidQP[layer]   );
    378 #endif
    379308#else
    380309  m_cTEncTop.setdQPs                         ( m_aidQP        );
     
    435364  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
    436365#if H_MV
    437 #if H_MV5
    438366  m_cTEncTop.setUseSAO ( m_bUseSAO[layerIdInVps] );
    439 #else
    440   m_cTEncTop.setUseSAO ( m_bUseSAO[layer] );
    441 #endif
    442367#else
    443368  m_cTEncTop.setUseSAO ( m_bUseSAO );
     
    512437  m_cTEncTop.setSignHideFlag(m_signHideFlag);
    513438#if RATE_CONTROL_LAMBDA_DOMAIN
    514   m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
     439#if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
     440  if(!m_cTEncTop.getIsDepth())    //only for texture
     441  {
     442    m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
     443  }
     444  else
     445  {
     446    m_cTEncTop.setUseRateCtrl         ( 0 );
     447  }
     448#else
     449    m_cTEncTop.setUseRateCtrl         ( m_RCEnableRateControl );
     450#endif
     451#if !KWU_RC_VIEWRC_E0227
    515452  m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
     453#endif
    516454  m_cTEncTop.setKeepHierBit         ( m_RCKeepHierarchicalBit );
    517455  m_cTEncTop.setLCULevelRC          ( m_RCLCULevelRC );
     
    519457  m_cTEncTop.setInitialQP           ( m_RCInitialQP );
    520458  m_cTEncTop.setForceIntraQP        ( m_RCForceIntraQP );
    521 #else
    522   m_cTEncTop.setUseRateCtrl     ( m_enableRateCtrl);
    523   m_cTEncTop.setTargetBitrate   ( m_targetBitrate);
    524   m_cTEncTop.setNumLCUInUnit    ( m_numLCUInUnit);
     459
     460#if KWU_RC_MADPRED_E0227
     461  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
     462  {
     463    m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred       : 0);
     464
     465    if(m_cTEncTop.getUseDepthMADPred())
     466    {
     467      m_cTEncTop.setCamParam(&m_cCameraData);
     468    }
     469  }
     470#endif
     471#if KWU_RC_VIEWRC_E0227
     472  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
     473  {
     474    m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
     475
     476    if(m_iNumberOfViews == 1)
     477    {
     478      if(m_viewWiseRateCtrl)
     479      {
     480        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
     481      }
     482      else
     483      {
     484        m_cTEncTop.setTargetBitrate       ( m_RCTargetBitrate );
     485      }
     486    }
     487    else
     488    {
     489      if(m_viewWiseRateCtrl)
     490      {
     491        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
     492      }
     493      else
     494      {
     495        if(m_iNumberOfViews == 2)
     496        {
     497          if(m_cTEncTop.getViewId() == 0)
     498          {
     499            m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*80)/100 );
     500          }
     501          else if(m_cTEncTop.getViewId() == 1)
     502          {
     503            m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*20)/100 );
     504          }
     505        }
     506        else if(m_iNumberOfViews == 3)
     507        {
     508          if(m_cTEncTop.getViewId() == 0)
     509          {
     510            m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*66)/100 );
     511          }
     512          else if(m_cTEncTop.getViewId() == 1)
     513          {
     514            m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*17)/100 );
     515          }
     516          else if(m_cTEncTop.getViewId() == 2)
     517          {
     518            m_cTEncTop.setTargetBitrate              ( (m_RCTargetBitrate*17)/100 );
     519          }
     520        }
     521        else
     522        {
     523          m_cTEncTop.setTargetBitrate              ( m_RCTargetBitrate );
     524        }
     525      }
     526    }
     527  }
     528#endif
     529#else
     530#if KWU_RC_VIEWRC_E0227 || KWU_RC_MADPRED_E0227
     531  if(!m_cTEncTop.getIsDepth())    //only for texture
     532  {
     533    m_cTEncTop.setUseRateCtrl         ( m_enableRateCtrl );
     534    m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
     535    m_cTEncTop.setNumLCUInUnit        ( m_numLCUInUnit);
     536  }
     537  else
     538  {
     539    m_cTEncTop.setUseRateCtrl         ( 0 );
     540  }
     541#else
     542  m_cTEncTop.setUseRateCtrl         ( m_enableRateCtrl );
     543  m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
     544  m_cTEncTop.setNumLCUInUnit        ( m_numLCUInUnit);
     545#endif
     546
     547 
     548#if KWU_RC_MADPRED_E0227
     549  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
     550  {
     551    m_cTEncTop.setUseDepthMADPred(layerIdInVps ? m_depthMADPred       : 0);
     552
     553    if(m_cTEncTop.getUseDepthMADPred())
     554    {
     555      m_cTEncTop.setCamParam(&m_cCameraData);
     556    }
     557  }
     558#endif
     559
     560#if KWU_RC_VIEWRC_E0227
     561  if(m_cTEncTop.getUseRateCtrl() && !m_cTEncTop.getIsDepth())
     562  {
     563    m_cTEncTop.setUseViewWiseRateCtrl(m_viewWiseRateCtrl);
     564    if(m_iNumberOfViews == 1)
     565    {
     566      if(m_viewWiseRateCtrl)
     567      {
     568        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
     569      }
     570      else
     571      {
     572        m_cTEncTop.setTargetBitrate       ( m_targetBitrate );
     573      }
     574    }
     575    else
     576    {
     577      if(m_viewWiseRateCtrl)
     578      {
     579        m_cTEncTop.setTargetBitrate(m_viewTargetBits[layerIdInVps>>1]);
     580      }
     581      else
     582      {
     583        if(m_iNumberOfViews == 2)
     584        {
     585          if(m_cTEncTop.getViewId() == 0)
     586          {
     587            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*80)/100 );
     588          }
     589          else if(m_cTEncTop.getViewId() == 1)
     590          {
     591            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*20)/100 );
     592          }
     593        }
     594        else if(m_iNumberOfViews == 3)
     595        {
     596          if(m_cTEncTop.getViewId() == 0)
     597          {
     598            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*66)/100 );
     599          }
     600          else if(m_cTEncTop.getViewId() == 1)
     601          {
     602            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*17)/100 );
     603          }
     604          else if(m_cTEncTop.getViewId() == 2)
     605          {
     606            m_cTEncTop.setTargetBitrate              ( (m_targetBitrate*17)/100 );
     607          }
     608        }
     609        else
     610        {
     611          m_cTEncTop.setTargetBitrate              ( m_targetBitrate );
     612        }
     613      }
     614    }
     615  }
     616#endif
    525617#endif
    526618  m_cTEncTop.setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
     
    664756}
    665757
    666 Void TAppEncTop::xInitLib()
     758Void TAppEncTop::xInitLib(Bool isFieldCoding)
    667759{
    668760#if H_MV
    669761  for(Int layer=0; layer<m_numberOfLayers; layer++)
    670762  {
    671     m_acTEncTopList[layer]->init( );
    672   }
    673 #else
    674   m_cTEncTop.init();
     763#if KWU_RC_MADPRED_E0227
     764    m_acTEncTopList[layer]->init( isFieldCoding, this );
     765#else
     766    m_acTEncTopList[layer]->init( isFieldCoding );
     767#endif
     768  }
     769#else
     770  m_cTEncTop.init( isFieldCoding );
    675771#endif
    676772}
     
    703799  xInitLibCfg();
    704800  xCreateLib();
    705   xInitLib();
     801  xInitLib(m_isField);
    706802 
    707803  // main encoder loop
     
    728824
    729825  // allocate original YUV buffer
     826  if( m_isField )
     827  {
     828    pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeightOrg, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
     829  }
     830  else
     831  {
    730832  pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
     833  }
    731834 
    732835#if H_MV
     
    789892      }
    790893    }
     894
     895#if !RATE_CONTROL_LAMBDA_DOMAIN && KWU_FIX_URQ
     896    for(Int layer=0; layer < m_numberOfLayers; layer++ )
     897    {
     898      if(m_acTEncTopList[layer]->getUseRateCtrl()  && !m_acTEncTopList[layer]->getIsDepth())
     899      {
     900        m_acTEncTopList[layer]->getRateCtrl()->updateRCGOPStatus();
     901      }
     902    }
     903#endif
     904
    791905    gopSize = maxGopSize;
    792906  }
    793907  for(Int layer=0; layer < m_numberOfLayers; layer++ )
    794908  {
    795     m_acTEncTopList[layer]->printSummary( m_acTEncTopList[layer]->getNumAllPicCoded() );
     909    m_acTEncTopList[layer]->printSummary( m_acTEncTopList[layer]->getNumAllPicCoded(), m_isField );
    796910  }
    797911#else
     
    807921    m_iFrameRcvd++;
    808922
    809     bEos = (m_iFrameRcvd == m_framesToBeEncoded);
     923    bEos = (m_isField && (m_iFrameRcvd == (m_framesToBeEncoded >> 1) )) || ( !m_isField && (m_iFrameRcvd == m_framesToBeEncoded) );
    810924
    811925    Bool flush = 0;
     
    820934
    821935    // call encoding function for one frame
     936    if ( m_isField )
     937    {
     938      m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded, m_isTopFieldFirst);
     939    }
     940    else
     941    {
    822942    m_cTEncTop.encode( bEos, flush ? 0 : pcPicYuvOrg, m_cListPicYuvRec, outputAccessUnits, iNumEncoded );
     943    }
    823944   
    824945    // write bistream to file if necessary
     
    830951  }
    831952
    832   m_cTEncTop.printSummary();
     953  m_cTEncTop.printSummary(m_isField);
    833954#endif
    834955
     
    9411062#endif
    9421063{
    943   Int i;
    944  
    945 #if H_MV
    946   if( iNumEncoded > 0 )
    947   {
    948     TComList<TComPicYuv*>::iterator iterPicYuvRec = m_picYuvRec[layerId]->end();
    949 #else
    950   TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
    951   list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
    952 #endif
    953 
    954   for ( i = 0; i < iNumEncoded; i++ )
    955   {
    956     --iterPicYuvRec;
    957   }
    958  
    959   for ( i = 0; i < iNumEncoded; i++ )
    960   {
    961     TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
     1064  if (m_isField)
     1065  {
     1066    //Reinterlace fields
     1067    Int i;
     1068#if H_MV
     1069    if( iNumEncoded > 0 )
     1070    {
     1071      TComList<TComPicYuv*>::iterator iterPicYuvRec = m_picYuvRec[layerId]->end();
     1072#else
     1073    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
     1074    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
     1075#endif
     1076
     1077    for ( i = 0; i < iNumEncoded; i++ )
     1078    {
     1079      --iterPicYuvRec;
     1080    }
     1081
     1082    for ( i = 0; i < iNumEncoded/2; i++ )
     1083    {
     1084      TComPicYuv*  pcPicYuvRecTop  = *(iterPicYuvRec++);
     1085      TComPicYuv*  pcPicYuvRecBottom  = *(iterPicYuvRec++);
     1086
    9621087#if H_MV
    9631088      if (m_pchReconFileList[layerId])
    9641089      {
    965         m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
    966       }
    967     }
    968   }
     1090        m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRecTop, pcPicYuvRecBottom, m_confLeft, m_confRight, m_confTop, m_confBottom, m_isTopFieldFirst );
     1091      }
     1092    }
     1093  }
     1094
    9691095  if( ! accessUnits.empty() )
    9701096  {
     
    9721098    for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
    9731099    {
     1100      const vector<UInt>& stats = writeAnnexB(bitstreamFile, *aUIter);
     1101      rateStatsAccum(*aUIter, stats);
     1102    }
     1103  }
     1104#else
     1105      if (m_pchReconFile)
     1106      {
     1107        m_cTVideoIOYuvReconFile.write( pcPicYuvRecTop, pcPicYuvRecBottom, m_confLeft, m_confRight, m_confTop, m_confBottom, m_isTopFieldFirst );
     1108      }
     1109
     1110      const AccessUnit& auTop = *(iterBitstream++);
     1111      const vector<UInt>& statsTop = writeAnnexB(bitstreamFile, auTop);
     1112      rateStatsAccum(auTop, statsTop);
     1113
     1114      const AccessUnit& auBottom = *(iterBitstream++);
     1115      const vector<UInt>& statsBottom = writeAnnexB(bitstreamFile, auBottom);
     1116      rateStatsAccum(auBottom, statsBottom);
     1117    }
     1118#endif
     1119  }
     1120  else
     1121  {
     1122    Int i;
     1123#if H_MV
     1124    if( iNumEncoded > 0 )
     1125    {
     1126      TComList<TComPicYuv*>::iterator iterPicYuvRec = m_picYuvRec[layerId]->end();
     1127#else
     1128    TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
     1129    list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
     1130#endif
     1131
     1132    for ( i = 0; i < iNumEncoded; i++ )
     1133    {
     1134      --iterPicYuvRec;
     1135    }
     1136
     1137    for ( i = 0; i < iNumEncoded; i++ )
     1138    {
     1139      TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
     1140#if H_MV
     1141      if (m_pchReconFileList[layerId])
     1142      {
     1143        m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
     1144      }   
     1145    }
     1146  }
     1147  if( ! accessUnits.empty() )
     1148  {
     1149    list<AccessUnit>::iterator aUIter;
     1150    for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
     1151    {
    9741152      const vector<unsigned>& stats = writeAnnexB(bitstreamFile, *aUIter);
    9751153      rateStatsAccum(*aUIter, stats);
     
    9771155  }
    9781156#else
    979     if (m_pchReconFile)
    980     {
    981       m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
    982     }
    983 
    984     const AccessUnit& au = *(iterBitstream++);
    985     const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
    986     rateStatsAccum(au, stats);
    987   }
    988 #endif
    989 }
    990 
     1157      if (m_pchReconFile)
     1158      {
     1159        m_cTVideoIOYuvReconFile.write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
     1160      }
     1161
     1162      const AccessUnit& au = *(iterBitstream++);
     1163      const vector<UInt>& stats = writeAnnexB(bitstreamFile, au);
     1164      rateStatsAccum(au, stats);   
     1165    }
     1166#endif   
     1167  }
     1168}
     1169 
    9911170/**
    9921171 *
     
    11211300Void TAppEncTop::xSetDimensionIdAndLength( TComVPS& vps )
    11221301{   
    1123 #if H_MV5
    11241302  vps.setScalabilityMaskFlag( m_scalabilityMask );
    1125 #else
    1126   vps.setScalabilityMask( m_scalabilityMask );
    1127 #endif
    11281303  for( Int dim = 0; dim < m_dimIds.size(); dim++ )
    11291304  {
    11301305    vps.setDimensionIdLen( dim, m_dimensionIdLen[ dim ] );
    1131 #if H_MV5
    11321306    for( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
    1133 #else
    1134     for( Int layer = 0; layer < vps.getMaxLayers(); layer++ )
    1135 #endif
    11361307
    11371308    {       
     
    11401311  }
    11411312
    1142 #if H_MV5
    11431313  Int maxViewId = xGetMax( m_viewId );
    11441314
     
    11531323
    11541324  assert( m_iNumberOfViews == vps.getNumViews() );
    1155 #endif
    11561325}
    11571326
     
    11801349
    11811350  // Max temporal id for inter layer reference pictures + presence flag
    1182 #if H_MV5
    11831351  Bool maxTidRefPresentFlag = false;
    1184 #endif
    11851352  for ( Int refLayerIdInVps = 0; refLayerIdInVps < m_numberOfLayers; refLayerIdInVps++)
    11861353    {
     
    12031370    }
    12041371    vps.setMaxTidIlRefPicPlus1( refLayerIdInVps, maxTid + 1 );
    1205 #if H_MV5
    12061372    maxTidRefPresentFlag = maxTidRefPresentFlag || ( maxTid != 6 );   
    1207 #endif
    1208   }
    1209 
    1210 #if H_MV5
     1373  }
     1374
    12111375  vps.setMaxTidRefPresentFlag( maxTidRefPresentFlag );
    1212 #endif
    12131376  // Max one active ref layer flag
    12141377  Bool maxOneActiveRefLayerFlag = true; 
    1215 #if H_MV5
    12161378  for ( Int layerIdInVps = 1; layerIdInVps < m_numberOfLayers && maxOneActiveRefLayerFlag; layerIdInVps++)
    1217 #else
    1218   for ( Int currLayerIdInVps = 1; currLayerIdInVps < m_numberOfLayers && maxOneActiveRefLayerFlag; currLayerIdInVps++)
    1219 #endif
    12201379  {
    12211380    for( Int i = 0; i < ( getGOPSize() + 1) && maxOneActiveRefLayerFlag; i++ )
    12221381    {       
    1223 #if H_MV5
    12241382      GOPEntry ge =  m_GOPListMvc[layerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    1225 #else
    1226       GOPEntry ge =  m_GOPListMvc[currLayerIdInVps][ ( i < getGOPSize()  ? i : MAX_GOP ) ];
    1227 #endif
    12281383      maxOneActiveRefLayerFlag =  maxOneActiveRefLayerFlag && (ge.m_numActiveRefLayerPics <= 1);
    12291384    }           
     
    12331388 
    12341389 
    1235 #if H_MV5
    12361390  // All Ref layers active flag
    12371391  Bool allRefLayersActiveFlag = true;
     
    12491403  // Currently cross layer irap aligned is always true.   
    12501404  vps.setCrossLayerIrapAlignedFlag( true );
    1251 #endif
    12521405  vps.setRefLayers();
    12531406};
    12541407
    1255 #if H_MV5
    12561408GOPEntry* TAppEncTop::xGetGopEntry( Int layerIdInVps, Int poc )
    12571409{
     
    12681420  return geFound;
    12691421}
    1270 #endif
    12711422
    12721423Void TAppEncTop::xSetLayerIds( TComVPS& vps )
     
    13081459}
    13091460
    1310 #if H_MV5
    13111461
    13121462Void TAppEncTop::xSetRepFormat( TComVPS& vps )
     
    13331483  }
    13341484}
    1335 #endif
    13361485
    13371486Void TAppEncTop::xSetLayerSets( TComVPS& vps )
     
    13861535  }
    13871536}
    1388 #if H_MV5
    13891537
    13901538Void TAppEncTop::xSetVPSVUI( TComVPS& vps )
     
    14781626}
    14791627#endif
    1480 #endif
    14811628#if H_3D
    14821629Void TAppEncTop::xSetVPSExtension2( TComVPS& vps )
    14831630{
    1484 #if H_MV5
    14851631
    14861632  for ( Int layer = 0; layer <= vps.getMaxLayersMinus1(); layer++ )
    1487 #else
    1488   for ( Int layer = 0; layer < vps.getMaxLayers(); layer++ )
    1489 #endif
    14901633  {
    14911634    Bool isDepth      = ( vps.getDepthId( layer ) == 1 ) ;
     
    15171660    vps.setViewSynthesisPredFlag( layer, !isLayerZero && !isDepth && m_viewSynthesisPredFlag );         
    15181661#endif     
    1519 #if LGE_INTER_SDC_E0156
     1662#if H_3D_INTER_SDC
    15201663    vps.setInterSDCFlag( layer, !isLayerZero && isDepth && m_bDepthInterSDCFlag );
    15211664#endif
Note: See TracChangeset for help on using the changeset viewer.