Changeset 367 in 3DVCSoftware for branches/HTM-DEV-0.1-dev


Ignore:
Timestamp:
3 May 2013, 17:09:57 (11 years ago)
Author:
tech
Message:

Further minor cleanups.

Location:
branches/HTM-DEV-0.1-dev/source
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-DEV-0.1-dev/source/App/TAppDecoder/TAppDecCfg.cpp

    r364 r367  
    4242#include "TAppCommon/program_options_lite.h"
    4343
    44 #if H_MV
    45 #include <cassert>
    46 #endif
    4744#ifdef WIN32
    4845#define strdup _strdup
     
    7875  ("OutputBitDepth,d", m_outputBitDepthY, 0, "bit depth of YUV output luma component (default: use 0 for native depth)")
    7976  ("OutputBitDepthC,d", m_outputBitDepthC, 0, "bit depth of YUV output chroma component (default: use 0 for native depth)")
    80 #if H_MV
    81   ("MaxLayerId,-ls", m_maxLayerId, MAX_NUM_LAYER_IDS-1, "Maximum LayerId to be decoded.")
    82 #endif
    8377  ("MaxTemporalLayer,t", m_iMaxTemporalLayer, -1, "Maximum Temporal Layer to be decoded. -1 to decode all layers")
    8478  ("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 1, "Control handling of decoded picture hash SEI messages\n"
     
    157151    }
    158152  }
    159 #if H_MV
    160   else
    161   {
    162     for ( Int curLayerId = 0; curLayerId <= m_maxLayerId; curLayerId++ )
    163     {
    164       m_targetDecLayerIdSet.push_back( curLayerId );
    165     }
    166   }
    167 #endif
    168153
    169154  return true;
    170155}
    171156
    172 #if H_MV
    173 Void TAppDecCfg::xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName)
    174 {
    175   size_t iInLength     = strlen(pchInputFileName);
    176   size_t iAppendLength = strlen(pchStringToAppend);
    177 
    178   rpchOutputFileName = (Char*) malloc(iInLength+iAppendLength+1);                       
    179   Char* pCDot = strrchr(pchInputFileName,'.');         
    180   pCDot = pCDot ? pCDot : pchInputFileName + iInLength;       
    181   size_t iCharsToDot = pCDot - pchInputFileName ;
    182   size_t iCharsToEnd = iInLength - iCharsToDot;         
    183   strncpy(rpchOutputFileName                            ,  pchInputFileName            , iCharsToDot  );
    184   strncpy(rpchOutputFileName+ iCharsToDot               ,  pchStringToAppend           , iAppendLength);
    185   strncpy(rpchOutputFileName+ iCharsToDot+iAppendLength ,  pchInputFileName+iCharsToDot, iCharsToEnd  );       
    186   rpchOutputFileName[iInLength+iAppendLength] = '\0';         
    187 }
    188 #endif
    189157//! \}
  • branches/HTM-DEV-0.1-dev/source/App/TAppDecoder/TAppDecCfg.h

    r365 r367  
    5858protected:
    5959  Char*         m_pchBitstreamFile;                   ///< input bitstream file name
    60 #if H_MV
    61   Int           m_maxLayerId;                         ///< maximum nuh_layer_id decoded
    62   std::vector<Char*> m_pchReconFiles;                 ///< array of output reconstruction file name create from output reconstruction file name
    63 #endif
    6460  Char*         m_pchReconFile;                       ///< output reconstruction file name
    6561  Int           m_iSkipFrame;                         ///< counter for frames prior to the random access point to skip
     
    7369  Int           m_respectDefDispWindow;               ///< Only output content inside the default display window
    7470
    75 #if H_MV
    76   Void xAppendToFileNameEnd( Char* pchInputFileName, const Char* pchStringToAppend, Char*& rpchOutputFileName); ///< create filenames
    77 #endif
    7871public:
    7972  TAppDecCfg()
    8073  : m_pchBitstreamFile(NULL)
    81 #if H_MV
    82   , m_maxLayerId(0)
    83   , m_pchReconFiles(NULL)
    84 #endif
    8574  , m_pchReconFile(NULL)
    8675  , m_iSkipFrame(0)
  • branches/HTM-DEV-0.1-dev/source/App/TAppDecoder/TAppDecTop.cpp

    r366 r367  
    5454
    5555TAppDecTop::TAppDecTop()
    56 #if !H_MV
    5756: m_iPOCLastDisplay(-MAX_INT)
    58 #else
    59 : m_numDecoders( 0 )
    60 #endif
    6157{
    6258  ::memset (m_abDecFlag, 0, sizeof (m_abDecFlag));
    63 #if H_MV
    64   for (Int i = 0; i < MAX_NUM_LAYER_IDS; i++) m_layerIdToDecIdx[i] = -1;
    65 #endif
    6659}
    6760
     
    7770    m_pchBitstreamFile = NULL;
    7871  }
    79 #if H_MV
    80   for (Int decIdx = 0; decIdx < m_numDecoders; decIdx++)
    81   {
    82     if (m_pchReconFiles[decIdx])
    83     {
    84       free (m_pchReconFiles[decIdx]);
    85       m_pchReconFiles[decIdx] = NULL;
    86     }
    87   }
    88 #endif
    8972  if (m_pchReconFile)
    9073  {
     
    10992{
    11093  Int                 poc;
    111 #if H_MV
    112   poc = -1;
    113 #endif
    11494  TComList<TComPic*>* pcListPic = NULL;
    11595
     
    126106  xCreateDecLib();
    127107  xInitDecLib  ();
    128 #if !H_MV
    129108  m_iPOCLastDisplay += m_iSkipFrame;      // set the last displayed POC correctly for skip forward.
    130109
    131110  // main decoder loop
    132111  Bool recon_opened = false; // reconstruction file not yet opened. (must be performed after SPS is seen)
    133 #else
    134   Int  pocCurrPic        = -MAX_INT;     
    135   Int  pocLastPic        = -MAX_INT;   
    136  
    137   Int  layerIdLastPic    = 0;
    138   Int  layerIdCurrPic    = 0;
    139 
    140   Int  decIdxLastPic     = 0;
    141   Int  decIdxCurrPic     = 0;
    142 
    143   Bool firstSlice        = true;
    144 #endif
    145112 
    146113  while (!!bitstreamFile)
     
    152119    streampos location = bitstreamFile.tellg();
    153120    AnnexBStats stats = AnnexBStats();
    154 #if !H_MV
    155121    Bool bPreviousPictureDecoded = false;
    156 #endif
    157122
    158123    vector<uint8_t> nalUnit;
     
    162127    // call actual decoding function
    163128    Bool bNewPicture = false;
    164 #if H_MV
    165     Bool newSliceDiffPoc   = false;
    166     Bool newSliceDiffLayer = false;
    167     Bool allLayersDecoded  = false;     
    168 #endif
    169129    if (nalUnit.empty())
    170130    {
     
    179139    {
    180140      read(nalu, nalUnit);
    181 #if H_MV     
    182       Int decIdx     = xGetDecoderIdx( nalu.m_layerId , true );
    183      
    184       if( (m_iMaxTemporalLayer >= 0 && nalu.m_temporalId > m_iMaxTemporalLayer) || !isNaluWithinTargetDecLayerIdSet(&nalu) )
    185       {
    186         bNewPicture = false;
    187       }
    188       else
    189       {
    190         newSliceDiffLayer = nalu.isSlice() && ( nalu.m_layerId != layerIdCurrPic ) && !firstSlice;
    191         newSliceDiffPoc   = m_tDecTop[decIdx]->decode(nalu, m_iSkipFrame, m_pocLastDisplay[decIdx], newSliceDiffLayer );
    192         // decode function only returns true when all of the following conditions are true
    193         // - poc in particular layer changes
    194         // - nalu does not belong to first slice in layer
    195         // - nalu.isSlice() == true     
    196 
    197         bNewPicture       = newSliceDiffLayer || newSliceDiffPoc;
    198 
    199         if ( nalu.isSlice() && firstSlice )
    200         {
    201           layerIdCurrPic = nalu.m_layerId;
    202           pocCurrPic     = m_tDecTop[decIdx]->getCurrPoc();
    203           decIdxCurrPic  = decIdx;
    204           firstSlice     = false;
    205         }
    206 
    207         if ( bNewPicture || !bitstreamFile )
    208         {
    209           layerIdLastPic    = layerIdCurrPic; 
    210           layerIdCurrPic    = nalu.m_layerId;
    211          
    212           pocLastPic        = pocCurrPic;
    213           pocCurrPic        = m_tDecTop[decIdx]->getCurrPoc();
    214          
    215           decIdxLastPic     = decIdxCurrPic;
    216           decIdxCurrPic     = decIdx;
    217 
    218           allLayersDecoded = ( pocCurrPic != pocLastPic );
    219         }
    220 
    221        
    222 #else
    223141      if( (m_iMaxTemporalLayer >= 0 && nalu.m_temporalId > m_iMaxTemporalLayer) || !isNaluWithinTargetDecLayerIdSet(&nalu)  )
    224142      {
     
    236154      {
    237155        bNewPicture = m_cTDecTop.decode(nalu, m_iSkipFrame, m_iPOCLastDisplay);
    238 #endif
    239156        if (bNewPicture)
    240157        {
     
    247164          bytestream.reset();
    248165        }
    249 #if !H_MV
    250166        bPreviousPictureDecoded = true;
    251 #endif
    252167      }
    253168    }
    254169    if (bNewPicture || !bitstreamFile)
    255170    {
    256 #if H_MV
    257       assert( decIdxLastPic != -1 );
    258       m_tDecTop[decIdxLastPic]->endPicDecoding(poc, pcListPic, m_targetDecLayerIdSet );
    259 #else
    260171      m_cTDecTop.executeLoopFilters(poc, pcListPic);
    261 #endif
    262     }
    263 #if H_3D
    264     if ( allLayersDecoded || !bitstreamFile )
    265     {
    266       for( Int dI = 0; dI < m_numDecoders; dI++ )
    267       {
    268         TComPic* picLastCoded = m_ivPicLists.getPic( m_tDecTop[dI]->getLayerId(), pocLastPic );
    269         assert( picLastCoded != NULL );       
    270         picLastCoded->compressMotion();         
    271       }
    272     }
    273 #endif
     172    }
    274173
    275174    if( pcListPic )
    276175    {
    277 #if H_MV
    278       if ( m_pchReconFiles[decIdxLastPic] && !m_reconOpen[decIdxLastPic] )
    279 #else
    280176      if ( m_pchReconFile && !recon_opened )
    281 #endif
    282177      {
    283178        if (!m_outputBitDepthY) { m_outputBitDepthY = g_bitDepthY; }
    284179        if (!m_outputBitDepthC) { m_outputBitDepthC = g_bitDepthC; }
    285180
    286 #if H_MV
    287         m_tVideoIOYuvReconFile[decIdxLastPic]->open( m_pchReconFiles[decIdxLastPic], true, m_outputBitDepthY, m_outputBitDepthC, g_bitDepthY, g_bitDepthC ); // write mode
    288         m_reconOpen[decIdxLastPic] = true;
    289       }
    290       if ( bNewPicture && newSliceDiffPoc &&
    291 #else
    292181        m_cTVideoIOYuvReconFile.open( m_pchReconFile, true, m_outputBitDepthY, m_outputBitDepthC, g_bitDepthY, g_bitDepthC ); // write mode
    293182        recon_opened = true;
    294183      }
    295184      if ( bNewPicture &&
    296 #endif
    297185           (   nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL
    298186            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_N_LP
     
    301189            || nalu.m_nalUnitType == NAL_UNIT_CODED_SLICE_BLA_W_LP ) )
    302190      {
    303 #if H_MV
    304         xFlushOutput( pcListPic, decIdxLastPic );
    305 #else
    306191        xFlushOutput( pcListPic );
    307 #endif
    308192      }
    309193      // write reconstruction to file
    310194      if(bNewPicture)
    311195      {
    312 #if H_MV
    313         xWriteOutput( pcListPic, decIdxLastPic, nalu.m_temporalId );
    314       }
    315     }
    316   }
    317 
    318   for(UInt decIdx = 0; decIdx < m_numDecoders; decIdx++)
    319   {
    320     xFlushOutput( m_tDecTop[decIdx]->getListPic(), decIdx );
    321   }
    322 #else
    323196        xWriteOutput( pcListPic, nalu.m_temporalId );
    324197      }
     
    329202  // delete buffers
    330203  m_cTDecTop.deletePicBuffer();
    331 #endif
    332204     
    333205  // destroy internal classes
     
    341213Void TAppDecTop::xCreateDecLib()
    342214{
    343 #if H_MV
    344   // initialize global variables
    345   initROM(); 
    346 #else
    347215  // create decoder class
    348216  m_cTDecTop.create();
    349 #endif
    350217}
    351218
    352219Void TAppDecTop::xDestroyDecLib()
    353220{
    354 #if H_MV
    355   // destroy ROM
    356   destroyROM();
    357 
    358   for(Int decIdx = 0; decIdx < m_numDecoders ; decIdx++)
    359   {
    360     if( m_tVideoIOYuvReconFile[decIdx] )
    361     {
    362       m_tVideoIOYuvReconFile[decIdx]->close();
    363       delete m_tVideoIOYuvReconFile[decIdx];
    364       m_tVideoIOYuvReconFile[decIdx] = NULL ;
    365     }
    366 
    367     if( m_tDecTop[decIdx] )
    368     {
    369       m_tDecTop[decIdx]->deletePicBuffer();
    370       m_tDecTop[decIdx]->destroy() ;
    371     }
    372     delete m_tDecTop[decIdx] ;
    373     m_tDecTop[decIdx] = NULL ;
    374   }
    375 #else
    376221  if ( m_pchReconFile )
    377222  {
     
    381226  // destroy decoder class
    382227  m_cTDecTop.destroy();
    383 #endif
    384228}
    385229
    386230Void TAppDecTop::xInitDecLib()
    387231{
    388 #if !H_MV
    389232  // initialize decoder class
    390233  m_cTDecTop.init();
    391234  m_cTDecTop.setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
    392 #endif
    393235}
    394236
     
    396238    \todo            DYN_REF_FREE should be revised
    397239 */
    398 #if H_MV
    399 Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, Int decIdx, Int tId )
    400 #else
    401240Void TAppDecTop::xWriteOutput( TComList<TComPic*>* pcListPic, UInt tId )
    402 #endif
    403241{
    404242  TComList<TComPic*>::iterator iterPic   = pcListPic->begin();
     
    408246  {
    409247    TComPic* pcPic = *(iterPic);
    410 #if H_MV
    411     if(pcPic->getOutputMark() && pcPic->getPOC() > m_pocLastDisplay[decIdx])
    412 #else
    413248    if(pcPic->getOutputMark() && pcPic->getPOC() > m_iPOCLastDisplay)
    414 #endif
    415249    {
    416250       not_displayed++;
     
    424258    TComPic* pcPic = *(iterPic);
    425259   
    426 #if H_MV
    427     if ( pcPic->getOutputMark() && (not_displayed >  pcPic->getNumReorderPics(tId) && pcPic->getPOC() > m_pocLastDisplay[decIdx]))
    428 #else
    429260    if ( pcPic->getOutputMark() && (not_displayed >  pcPic->getNumReorderPics(tId) && pcPic->getPOC() > m_iPOCLastDisplay))
    430 #endif
    431261    {
    432262      // write to file
    433263       not_displayed--;
    434 #if H_MV
    435       if ( m_pchReconFiles[decIdx] )
    436 #else
    437264      if ( m_pchReconFile )
    438 #endif
    439265      {
    440266        const Window &conf = pcPic->getConformanceWindow();
    441267        const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
    442 #if H_MV
    443         m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
    444 #else
    445268        m_cTVideoIOYuvReconFile.write( pcPic->getPicYuvRec(),
    446 #endif
    447269                                       conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
    448270                                       conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
     
    452274     
    453275      // update POC of display order
    454 #if H_MV
    455       m_pocLastDisplay[decIdx] = pcPic->getPOC();
    456 #else
    457276      m_iPOCLastDisplay = pcPic->getPOC();
    458 #endif
    459277     
    460278      // erase non-referenced picture in the reference picture list after display
     
    484302    \todo            DYN_REF_FREE should be revised
    485303 */
    486 #if H_MV
    487 Void TAppDecTop::xFlushOutput( TComList<TComPic*>* pcListPic, Int decIdx )
    488 #else
    489304Void TAppDecTop::xFlushOutput( TComList<TComPic*>* pcListPic )
    490 #endif
    491305{
    492306  if(!pcListPic)
     
    505319    {
    506320      // write to file
    507 #if H_MV
    508       if ( m_pchReconFiles[decIdx] )
    509 #else
    510321      if ( m_pchReconFile )
    511 #endif
    512322      {
    513323        const Window &conf = pcPic->getConformanceWindow();
    514324        const Window &defDisp = m_respectDefDispWindow ? pcPic->getDefDisplayWindow() : Window();
    515 #if H_MV
    516         m_tVideoIOYuvReconFile[decIdx]->write( pcPic->getPicYuvRec(),
    517 #else
    518325        m_cTVideoIOYuvReconFile.write( pcPic->getPicYuvRec(),
    519 #endif
    520326                                       conf.getWindowLeftOffset() + defDisp.getWindowLeftOffset(),
    521327                                       conf.getWindowRightOffset() + defDisp.getWindowRightOffset(),
     
    525331     
    526332      // update POC of display order
    527 #if H_MV
    528       m_pocLastDisplay[decIdx] = pcPic->getPOC();
    529 #else
    530333      m_iPOCLastDisplay = pcPic->getPOC();
    531 #endif
    532334     
    533335      // erase non-referenced picture in the reference picture list after display
     
    549351      pcPic->setOutputMark(false);
    550352    }
    551 #if !H_MV
    552353#if !DYN_REF_FREE
    553354    if(pcPic)
     
    558359    }
    559360#endif
    560 #endif
    561361    iterPic++;
    562362  }
    563 #if H_MV
    564   m_pocLastDisplay[decIdx] = -MAX_INT;
    565 #else
    566363  pcListPic->clear();
    567364  m_iPOCLastDisplay = -MAX_INT;
    568 #endif
    569365}
    570366
     
    579375  for (std::vector<Int>::iterator it = m_targetDecLayerIdSet.begin(); it != m_targetDecLayerIdSet.end(); it++)
    580376  {
    581 #if H_MV
    582     if ( nalu->m_layerId == (*it) )
    583 #else
    584377    if ( nalu->m_reservedZero6Bits == (*it) )
    585 #endif
    586378    {
    587379      return true;
  • branches/HTM-DEV-0.1-dev/source/App/TAppDecoder/TAppDecTop.h

    r365 r367  
    6161private:
    6262  // class interface
    63 #if H_MV
    64   TDecTop*                        m_tDecTop             [ MAX_NUM_LAYERS ];    ///< decoder classes
    65   TVideoIOYuv*                    m_tVideoIOYuvReconFile[ MAX_NUM_LAYERS ];    ///< reconstruction YUV class
    66   Int                             m_layerIdToDecIdx     [ MAX_NUM_LAYER_IDS ]; ///< maping from layer id to decoder index
    67   Int                             m_numDecoders;                               ///< number of decoder instances
    68   TComPicLists                    m_ivPicLists;                                ///< picture buffers of decoder instances
    69 #else
    7063  TDecTop                         m_cTDecTop;                     ///< decoder class
    7164  TVideoIOYuv                     m_cTVideoIOYuvReconFile;        ///< reconstruction YUV class
    72 #endif
    7365 
    7466  // for output control
    7567  Bool                            m_abDecFlag[ MAX_GOP ];         ///< decoded flag in one GOP
    76 #if H_MV
    77   Int                             m_pocLastDisplay      [ MAX_NUM_LAYERS ]; ///< last POC in display order
    78   Bool                            m_reconOpen           [ MAX_NUM_LAYERS ]; ///< reconstruction file opened
    79 #else
    8068  Int                             m_iPOCLastDisplay;              ///< last POC in display order
    81 #endif
    8269 
    8370public:
     
    9481  Void  xInitDecLib       (); ///< initialize decoder class
    9582 
    96 #if H_MV
    97   Void  xWriteOutput      ( TComList<TComPic*>* pcListPic, Int layerId, Int tId ); ///< write YUV to file
    98   Void  xFlushOutput      ( TComList<TComPic*>* pcListPic, Int layerId ); ///< flush all remaining decoded pictures to file
    99   Int   xGetDecoderIdx    ( Int layerId, Bool createFlag = false )
    100   {
    101     Int decIdx = -1;
    102     if ( m_layerIdToDecIdx[ layerId ] != -1 )
    103     {     
    104       decIdx = m_layerIdToDecIdx[ layerId ];
    105     }
    106     else
    107     {     
    108       assert ( createFlag );
    109       assert( m_numDecoders < MAX_NUM_LAYERS );
    110 
    111       decIdx = m_numDecoders;
    112      
    113       // Init decoder
    114       m_tDecTop[ decIdx ] =  new TDecTop;
    115       m_tDecTop[ decIdx ]->create();
    116       m_tDecTop[ decIdx ]->init( );
    117       m_tDecTop[ decIdx ]->setLayerId( layerId );
    118       m_tDecTop[ decIdx ]->setDecodedPictureHashSEIEnabled(m_decodedPictureHashSEIEnabled);
    119       m_tDecTop[ decIdx ]->setIvPicLists( &m_ivPicLists );
    120      
    121       // append pic list of new decoder to PicLists
    122       assert( m_ivPicLists.size() == m_numDecoders );
    123       m_ivPicLists.push_back( m_tDecTop[ decIdx ]->getListPic() );
    124 
    125       // create recon file related stuff     
    126       Char* pchTempFilename = NULL;
    127       if ( m_pchReconFile )
    128       {     
    129         Char buffer[4];     
    130         sprintf(buffer,"_%i", layerId );
    131         assert ( m_pchReconFile );
    132         xAppendToFileNameEnd( m_pchReconFile , buffer, pchTempFilename );
    133         assert( m_pchReconFiles.size() == m_numDecoders );
    134       }
    135 
    136       m_pchReconFiles.push_back( pchTempFilename );   
    137 
    138       m_tVideoIOYuvReconFile[ decIdx ] = new TVideoIOYuv;
    139       m_reconOpen           [ decIdx ] = false;
    140 
    141       // set others
    142       m_pocLastDisplay      [ decIdx ] = -MAX_INT;
    143       m_layerIdToDecIdx     [ layerId ] = decIdx;
    144 
    145       m_numDecoders++;
    146     };
    147     return decIdx;
    148   }
    149 #else
    15083  Void  xWriteOutput      ( TComList<TComPic*>* pcListPic , UInt tId); ///< write YUV to file
    15184  Void  xFlushOutput      ( TComList<TComPic*>* pcListPic ); ///< flush all remaining decoded pictures to file
    152 #endif
    15385  Bool  isNaluWithinTargetDecLayerIdSet ( InputNALUnit* nalu ); ///< check whether given Nalu is within targetDecLayerIdSet
    15486};
  • branches/HTM-DEV-0.1-dev/source/App/TAppDecoder/decmain.cpp

    r324 r367  
    5656  // print information
    5757  fprintf( stdout, "\n" );
    58 #if H_MV
    59   fprintf( stdout, "3D-HTM Software: Decoder Version [%s] based on HM Version [%s]", NV_VERSION, HM_VERSION ); 
    60 #else
    6158  fprintf( stdout, "HM software: Decoder Version [%s]", NV_VERSION );
    62 #endif
    6359  fprintf( stdout, NVM_ONOS );
    6460  fprintf( stdout, NVM_COMPILEDBY );
  • branches/HTM-DEV-0.1-dev/source/App/TAppEncoder/TAppEncCfg.cpp

    r366 r367  
    6464
    6565TAppEncCfg::TAppEncCfg()
    66 #if H_MV
    67 : m_pchBitstreamFile()
    68 #else
    6966: m_pchInputFile()
    7067, m_pchBitstreamFile()
    7168, m_pchReconFile()
    72 #endif
    7369, m_pchdQPFile()
    7470, m_pColumnWidth()
     
    7672, m_scalingListFile()
    7773{
    78 #if !H_MV
    7974  m_aidQP = NULL;
    80 #endif
    8175#if J0149_TONE_MAPPING_SEI
    8276  m_startOfCodedInterval = NULL;
     
    8882TAppEncCfg::~TAppEncCfg()
    8983{
    90 #if H_MV
    91   for( Int layer = 0; layer < m_aidQP.size(); layer++ )
    92   {
    93     if ( m_aidQP[layer] != NULL )
    94     {
    95       delete[] m_aidQP[layer];
    96       m_aidQP[layer] = NULL;
    97     }
    98   }
    99   for(Int i = 0; i< m_pchInputFileList.size(); i++ )
    100   {
    101     if ( m_pchInputFileList[i] != NULL )
    102       free (m_pchInputFileList[i]);
    103   }
    104 #else
    10584  if ( m_aidQP )
    10685  {
    10786    delete[] m_aidQP;
    10887  }
    109 #endif
    11088#if J0149_TONE_MAPPING_SEI
    11189  if ( m_startOfCodedInterval )
     
    125103  }
    126104#endif
    127 #if !H_MV
    128105  free(m_pchInputFile);
    129 #endif
    130106  free(m_pchBitstreamFile);
    131 #if H_MV
    132   for(Int i = 0; i< m_pchReconFileList.size(); i++ )
    133   {
    134     if ( m_pchReconFileList[i] != NULL )
    135       free (m_pchReconFileList[i]);
    136   }
    137 #else
    138107  free(m_pchReconFile);
    139 #endif
    140108  free(m_pchdQPFile);
    141109  free(m_pColumnWidth);
    142110  free(m_pRowHeight);
    143111  free(m_scalingListFile);
    144 #if H_MV
    145   for( Int i = 0; i < m_GOPListMvc.size(); i++ )
    146   {
    147     if( m_GOPListMvc[i] )
    148     {
    149       delete[] m_GOPListMvc[i];
    150       m_GOPListMvc[i] = NULL;
    151     }
    152   }
    153 #endif
    154112}
    155113
     
    203161  }
    204162#endif
    205 #if H_MV
    206   in>>entry.m_numInterViewRefPics;
    207   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    208   {
    209     in>>entry.m_interViewRefs[i];
    210   }
    211   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    212   {
    213     in>>entry.m_interViewRefPosL[0][i];
    214   }
    215   for( Int i = 0; i < entry.m_numInterViewRefPics; i++ )
    216   {
    217     in>>entry.m_interViewRefPosL[1][i];
    218   }
    219 #endif
    220163  return in;
    221164}
     
    229172  {"main10", Profile::MAIN10},
    230173  {"main-still-picture", Profile::MAINSTILLPICTURE},
    231 #if H_MV
    232   {"main-stereo",    Profile::MAINSTEREO},
    233   {"main-multiview", Profile::MAINMULTIVIEW},
    234 #if H_3D
    235   {"main-3d"    , Profile::MAIN3D},
    236 #endif
    237 #endif
    238174};
    239175
     
    317253  Bool do_help = false;
    318254 
    319 #if !H_MV
    320255  string cfg_InputFile;
    321 #endif
    322256  string cfg_BitstreamFile;
    323 #if !H_MV
    324257  string cfg_ReconFile;
    325 #endif
    326 #if H_MV
    327   vector<Int>   cfg_dimensionLength;
    328 #if H_3D
    329   cfg_dimensionLength.push_back( 2  );  // depth
    330   cfg_dimensionLength.push_back( 32 );  // texture
    331 #else
    332   cfg_dimensionLength.push_back( 64 );
    333 #endif
    334 #endif
    335258  string cfg_dQPFile;
    336259  string cfg_ColumnWidth;
     
    356279 
    357280  // File, I/O and source parameters
    358 #if H_MV
    359   ("InputFile_%d,i_%d",       m_pchInputFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d")
    360 #else
    361281  ("InputFile,i",           cfg_InputFile,     string(""), "Original YUV input file name")
    362 #endif
    363282  ("BitstreamFile,b",       cfg_BitstreamFile, string(""), "Bitstream output file name")
    364 #if H_MV
    365   ("ReconFile_%d,o_%d",       m_pchReconFileList,       (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d")
    366 #else
    367283  ("ReconFile,o",           cfg_ReconFile,     string(""), "Reconstructed YUV output file name")
    368 #endif
    369 #if H_MV
    370   ("NumberOfLayers",        m_numberOfLayers     , 1,                     "Number of layers")
    371 #if !H_3D
    372   ("ScalabilityMask",       m_scalabilityMask    , 1                    , "Scalability Mask")   
    373 #else
    374   ("ScalabilityMask",       m_scalabilityMask    , 3                    , "Scalability Mask, 1: Texture 3: Texture + Depth ")   
    375 #endif 
    376   ("DimensionIdLen",        m_dimensionIdLen     , cfg_dimensionLength  , "Number of bits used to store dimensions Id")
    377   ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id")
    378 #if H_3D
    379   ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
    380 #endif
    381   ("LayerIdInNuh",          m_layerIdInNuh       , std::vector<Int>(1,0), "LayerId in Nuh")
    382   ("SplittingFlag",         m_splittingFlag      , false                , "Splitting Flag")   
    383 #endif
    384284  ("SourceWidth,-wdt",      m_iSourceWidth,        0, "Source picture width")
    385285  ("SourceHeight,-hgt",     m_iSourceHeight,       0, "Source picture height")
     
    453353
    454354  /* Quantization parameters */
    455 #if H_MV
    456   ("QP,q",          m_fQP, std::vector<double>(1,30.0), "Qp values for each layer, if value is float, QP is switched once during encoding")
    457 #else
    458355  ("QP,q",          m_fQP,             30.0, "Qp value, if value is float, QP is switched once during encoding")
    459 #endif
    460356  ("DeltaQpRD,-dqr",m_uiDeltaQpRD,       0u, "max dQp offset for slice")
    461357  ("MaxDeltaQP,d",  m_iMaxDeltaQP,        0, "max dQp offset for block")
     
    481377 
    482378  // Deblocking filter parameters
    483 #if H_MV
    484   ("LoopFilterDisable",              m_bLoopFilterDisable,             std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )
    485 #else
    486379  ("LoopFilterDisable",              m_bLoopFilterDisable,             false )
    487 #endif
    488380  ("LoopFilterOffsetInPPS",          m_loopFilterOffsetInPPS,          false )
    489381  ("LoopFilterBetaOffset_div2",      m_loopFilterBetaOffsetDiv2,           0 )
     
    498390  ("TransformSkip",            m_useTransformSkip,          false, "Intra transform skipping")
    499391  ("TransformSkipFast",        m_useTransformSkipFast,      false, "Fast intra transform skipping")
    500 #if H_MV
    501   ("SAO",                      m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer")
    502 #else
    503392  ("SAO",                      m_bUseSAO,                   true,  "Enable Sample Adaptive Offset")
    504 #endif
    505393  ("MaxNumOffsetsPerPic",      m_maxNumOffsetsPerPic,       2048,  "Max number of SAO offset per picture (Default: 2048)")   
    506394  ("SAOLcuBoundary",           m_saoLcuBoundary,            false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas")
     
    684572  ;
    685573 
    686 #if H_MV
    687   // parse coding structure
    688   for( Int k = 0; k < MAX_NUM_LAYERS; k++ )
    689   {
    690     m_GOPListMvc.push_back( new GOPEntry[MAX_GOP + 1] );
    691     if( k == 0 )
    692     {
    693       for( Int i = 1; i < MAX_GOP + 1; i++ )
    694       {
    695         std::ostringstream cOSS;
    696         cOSS<<"Frame"<<i;
    697         opts.addOptions()( cOSS.str(), m_GOPListMvc[k][i-1], GOPEntry() );
    698       }
    699     }
    700     else
    701     {
    702       std::ostringstream cOSS1;
    703       cOSS1<<"FrameI"<<"_l"<<k;
    704       opts.addOptions()(cOSS1.str(), m_GOPListMvc[k][MAX_GOP], GOPEntry());
    705 
    706       for( Int i = 1; i < MAX_GOP + 1; i++ )
    707       {
    708         std::ostringstream cOSS2;
    709         cOSS2<<"Frame"<<i<<"_l"<<k;
    710         opts.addOptions()(cOSS2.str(), m_GOPListMvc[k][i-1], GOPEntry());
    711       }
    712     }
    713   }
    714 #else
    715574  for(Int i=1; i<MAX_GOP+1; i++) {
    716575    std::ostringstream cOSS;
     
    718577    opts.addOptions()(cOSS.str(), m_GOPList[i-1], GOPEntry());
    719578  }
    720 #endif
    721579  po::setDefaults(opts);
    722580  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
     
    738596   */
    739597  /* convert std::string to c string for compatability */
    740 #if !H_MV
    741598  m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());
    742 #endif
    743599  m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());
    744 #if !H_MV
    745600  m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());
    746 #endif
    747601  m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());
    748602 
     
    804658    m_pRowHeight = NULL;
    805659  }
    806 #if H_MV
    807   free ( pColumnWidth );
    808   free ( pRowHeight   );
    809 #endif
    810660#if SIGNAL_BITRATE_PICRATE_IN_VPS
    811661  readBoolString(cfg_bitRateInfoPresentFlag, m_bitRatePicRateMaxTLayers, m_bitRateInfoPresentFlag, "bit rate info. present flag" );
     
    887737 
    888738  // allocate slice-based dQP values
    889 #if H_MV
    890   xResizeVector( m_viewId    );
    891 #if H_3D
    892   xResizeVector( m_depthFlag );
    893 #endif
    894 
    895   xResizeVector( m_fQP );
    896 
    897   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    898   {
    899     m_aidQP.push_back( new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ] );
    900     ::memset( m_aidQP[layer], 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
    901 
    902     // handling of floating-point QP values
    903     // if QP is not integer, sequence is split into two sections having QP and QP+1
    904     m_iQP.push_back((Int)( m_fQP[layer] ));
    905     if ( m_iQP[layer] < m_fQP[layer] )
    906     {
    907       Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP[layer] - m_iQP[layer])*m_framesToBeEncoded + 0.5 );
    908 
    909       iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize;
    910       for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ )
    911       {
    912         m_aidQP[layer][i] = 1;
    913       }
    914     }
    915   }
    916 
    917   xResizeVector( m_bLoopFilterDisable );
    918   xResizeVector( m_bUseSAO );   
    919 
    920 #else
    921739  m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ];
    922740  ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) );
     
    935753    }
    936754  }
    937 #endif
    938755 
    939756  // reading external dQP description from file
     
    943760    if ( fpt )
    944761    {
    945 #if H_MV
    946       for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    947       {
    948 #endif
    949762      Int iValue;
    950763      Int iPOC = 0;
     
    952765      {
    953766        if ( fscanf(fpt, "%d", &iValue ) == EOF ) break;
    954 #if H_MV
    955         m_aidQP[layer][ iPOC ] = iValue;
    956         iPOC++;
    957       }
    958 #else
    959767        m_aidQP[ iPOC ] = iValue;
    960768        iPOC++;
    961 #endif
    962769      }
    963770      fclose(fpt);
     
    1125932  xConfirmPara( m_iFrameRate <= 0,                                                          "Frame rate must be more than 1" );
    1126933  xConfirmPara( m_framesToBeEncoded <= 0,                                                   "Total Number Of Frames encoded must be more than 0" );
    1127 #if H_MV
    1128   xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS ,                                      "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS");
    1129 
    1130 
    1131   xConfirmPara( m_layerIdInNuh[0] != 0      , "LayerIdInNuh must be 0 for the first layer. ");
    1132   xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
    1133  
    1134 #if H_3D
    1135   xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
    1136 #else
    1137   xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
    1138 #endif
    1139  
    1140   m_dimIds.push_back( m_viewId );
    1141 #if H_3D
    1142   if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
    1143     m_dimIds.push_back( m_depthFlag );
    1144 #endif
    1145 
    1146   xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );
    1147 
    1148  for( Int dim = 0; dim < m_dimIds.size(); dim++ )
    1149  {
    1150    xConfirmPara( m_dimIds[dim].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");
    1151    xConfirmPara( m_dimIds[dim][0] != 0,                    "DimensionId of layer 0 must be 0 in all dimensions. " );
    1152    xConfirmPara( m_dimensionIdLen[dim] < 1 || m_dimensionIdLen[dim] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
    1153    for( Int i = 1; i < m_numberOfLayers; i++ )
    1154    {     
    1155      xConfirmPara(  ( m_dimIds[dim][i] < 0 ) || ( m_dimIds[dim][i] > ( ( 1 << m_dimensionIdLen[dim] ) - 1 ) )   , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " );
    1156    }
    1157  }
    1158 
    1159  for( Int i = 0; i < m_numberOfLayers; i++ )
    1160  {
    1161    for( Int j = 0; j < i; j++ )
    1162    {     
    1163      Int numDiff  = 0;
    1164      Int lastDiff = -1;
    1165      for( Int dim = 0; dim < m_dimIds.size(); dim++ )
    1166      {
    1167        if ( m_dimIds[dim][i] != m_dimIds[dim][j] )
    1168        {
    1169          numDiff ++;
    1170          lastDiff = dim;
    1171        }
    1172      }
    1173 
    1174      Bool allEqual = ( numDiff == 0 );
    1175 
    1176      if ( allEqual )
    1177      {
    1178        printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);
    1179      }
    1180 
    1181      xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
    1182 
    1183      if ( numDiff  == 1 )
    1184      {
    1185        Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
    1186        if ( !inc )
    1187        {       
    1188          printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
    1189        }
    1190        xConfirmPara( !inc,  "DimensionIds shall be increasing within one dimension. " );
    1191      }
    1192    }
    1193  }
    1194 
    1195 #endif
    1196934  xConfirmPara( m_iGOPSize < 1 ,                                                            "GOP Size must be greater or equal to 1" );
    1197935  xConfirmPara( m_iGOPSize > 1 &&  m_iGOPSize % 2,                                          "GOP Size must be a multiple of 2, if GOP Size is greater than 1" );
    1198936  xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" );
    1199937  xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2,                   "Decoding Refresh Type must be equal to 0, 1 or 2" );
    1200 #if H_MV
    1201   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    1202   {
    1203     xConfirmPara( m_iQP[layer] <  -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51,      "QP exceeds supported range (-QpBDOffsety to 51)" );
    1204   }
    1205 #else
    1206938  xConfirmPara( m_iQP <  -6 * (m_internalBitDepthY - 8) || m_iQP > 51,                    "QP exceeds supported range (-QpBDOffsety to 51)" );
    1207 #endif
    1208939  xConfirmPara( m_loopFilterBetaOffsetDiv2 < -13 || m_loopFilterBetaOffsetDiv2 > 13,          "Loop Filter Beta Offset div. 2 exceeds supported range (-13 to 13)");
    1209940  xConfirmPara( m_loopFilterTcOffsetDiv2 < -13 || m_loopFilterTcOffsetDiv2 > 13,              "Loop Filter Tc Offset div. 2 exceeds supported range (-13 to 13)");
     
    1249980
    1250981#if ADAPTIVE_QP_SELECTION
    1251 #if H_MV
    1252   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    1253   {
    1254     xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP[layer] < 0,                                     "AdaptiveQpSelection must be disabled when QP < 0.");
    1255   }
    1256 #else
    1257982  xConfirmPara( m_bUseAdaptQpSelect == true && m_iQP < 0,                                              "AdaptiveQpSelection must be disabled when QP < 0.");
    1258 #endif
    1259983  xConfirmPara( m_bUseAdaptQpSelect == true && (m_cbQpOffset !=0 || m_crQpOffset != 0 ),               "AdaptiveQpSelection must be disabled when ChromaQpOffset is not equal to 0.");
    1260984#endif
     
    13101034  }
    13111035
    1312 #if H_MV
    1313   // validate that POC of same frame is identical across multiple layers
    1314   Bool bErrorMvePoc = false;
    1315   if( m_numberOfLayers > 1 )
    1316   {
    1317     for( Int k = 1; k < m_numberOfLayers; k++ )
    1318     {
    1319       for( Int i = 0; i < MAX_GOP; i++ )
    1320       {
    1321         if( m_GOPListMvc[k][i].m_POC != m_GOPListMvc[0][i].m_POC )
    1322         {
    1323           printf( "\nError: Frame%d_l%d POC %d is not identical to Frame%d POC\n", i, k, m_GOPListMvc[k][i].m_POC, i );
    1324           bErrorMvePoc = true;
    1325         }
    1326       }
    1327     }
    1328   }
    1329   xConfirmPara( bErrorMvePoc,  "Invalid inter-layer POC structure given" );
    1330 
    1331   // validate that baseview has no inter-view refs
    1332   Bool bErrorIvpBase = false;
    1333   for( Int i = 0; i < MAX_GOP; i++ )
    1334   {
    1335     if( m_GOPListMvc[0][i].m_numInterViewRefPics != 0 )
    1336     {
    1337       printf( "\nError: Frame%d inter_layer refs not available in layer 0\n", i );
    1338       bErrorIvpBase = true;
    1339     }
    1340   }
    1341   xConfirmPara( bErrorIvpBase, "Inter-layer refs not possible in base layer" );
    1342 
    1343   // validate inter-view refs
    1344   Bool bErrorIvpEnhV = false;
    1345   if( m_numberOfLayers > 1 )
    1346   {
    1347     for( Int k = 1; k < m_numberOfLayers; k++ )
    1348     {
    1349       for( Int i = 0; i < MAX_GOP+1; i++ )
    1350       {
    1351         for( Int j = 0; j < m_GOPListMvc[k][i].m_numInterViewRefPics; j++ )
    1352         {
    1353           Int iAbsViewId = m_GOPListMvc[k][i].m_interViewRefs[j] + k;
    1354           if( iAbsViewId < 0 || iAbsViewId >= k )
    1355           {
    1356             printf( "\nError: inter-layer ref pic %d is not available for Frame%d_l%d\n", m_GOPListMvc[k][i].m_interViewRefs[j], i, k );
    1357             bErrorIvpEnhV = true;
    1358           }
    1359           if( m_GOPListMvc[k][i].m_interViewRefPosL[0][j] < -1 || m_GOPListMvc[k][i].m_interViewRefPosL[0][j] > m_GOPListMvc[k][i].m_numRefPicsActive )
    1360           {
    1361             printf( "\nError: inter-layer ref pos %d on L0 is not available for Frame%d_l%d\n", m_GOPListMvc[k][i].m_interViewRefPosL[0][j], i, k );
    1362             bErrorIvpEnhV = true;
    1363           }
    1364           if( m_GOPListMvc[k][i].m_interViewRefPosL[1][j] < -1  || m_GOPListMvc[k][i].m_interViewRefPosL[1][j] > m_GOPListMvc[k][i].m_numRefPicsActive )
    1365           {
    1366             printf( "\nError: inter-layer ref pos %d on L1 is not available for Frame%d_l%d\n", m_GOPListMvc[k][i].m_interViewRefPosL[1][j], i, k );
    1367             bErrorIvpEnhV = true;
    1368           }
    1369         }
    1370         if( i == MAX_GOP ) // inter-view refs at I pic position in base view
    1371         {
    1372           if( m_GOPListMvc[k][MAX_GOP].m_sliceType != 'B' && m_GOPListMvc[k][MAX_GOP].m_sliceType != 'P' && m_GOPListMvc[k][MAX_GOP].m_sliceType != 'I' )
    1373           {
    1374             printf( "\nError: slice type of FrameI_l%d must be equal to B or P or I\n", k );
    1375             bErrorIvpEnhV = true;
    1376           }
    1377 
    1378           if( m_GOPListMvc[k][MAX_GOP].m_POC != 0 )
    1379           {
    1380             printf( "\nError: POC %d not possible for FrameI_l%d, must be 0\n", m_GOPListMvc[k][MAX_GOP].m_POC, k );
    1381             bErrorIvpEnhV = true;
    1382           }
    1383 
    1384           if( m_GOPListMvc[k][MAX_GOP].m_temporalId != 0 )
    1385           {
    1386             printf( "\nWarning: Temporal id of FrameI_l%d must be 0 (cp. I-frame in base layer)\n", k );
    1387             m_GOPListMvc[k][MAX_GOP].m_temporalId = 0;
    1388           }
    1389 
    1390           if( m_GOPListMvc[k][MAX_GOP].m_numRefPics != 0 )
    1391           {
    1392             printf( "\nWarning: temporal references not possible for FrameI_l%d\n", k );
    1393             for( Int j = 0; j < m_GOPListMvc[k][MAX_GOP].m_numRefPics; j++ )
    1394             {
    1395               m_GOPListMvc[k][MAX_GOP].m_referencePics[j] = 0;
    1396             }
    1397             m_GOPListMvc[k][MAX_GOP].m_numRefPics = 0;
    1398           }
    1399 
    1400           if( m_GOPListMvc[k][MAX_GOP].m_interRPSPrediction )
    1401           {
    1402             printf( "\nError: inter RPS prediction not possible for FrameI_l%d, must be 0\n", k );
    1403             bErrorIvpEnhV = true;
    1404           }
    1405 
    1406           if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'I' && m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics != 0 )
    1407           {
    1408             printf( "\nError: inter-layer prediction not possible for FrameI_l%d with slice type I, #IL_ref_pics must be 0\n", k );
    1409             bErrorIvpEnhV = true;
    1410           }
    1411 
    1412           if( m_GOPListMvc[k][MAX_GOP].m_numRefPicsActive > m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics )
    1413           {
    1414             m_GOPListMvc[k][MAX_GOP].m_numRefPicsActive = m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics;
    1415           }
    1416 
    1417           if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'P' )
    1418           {
    1419             if( m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
    1420             {
    1421               printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type P\n", k );
    1422               bErrorIvpEnhV = true;
    1423             }
    1424             else
    1425             {
    1426               for( Int j = 0; j < m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics; j++ )
    1427               {
    1428                 if( m_GOPListMvc[k][MAX_GOP].m_interViewRefPosL[1][j] != -1 )
    1429                 {
    1430                   printf( "\nError: inter-layer ref pos %d on L1 not possible for FrameI_l%d with slice type P\n", m_GOPListMvc[k][MAX_GOP].m_interViewRefPosL[1][j], k );
    1431                   bErrorIvpEnhV = true;
    1432                 }
    1433               }
    1434             }
    1435           }
    1436 
    1437           if( m_GOPListMvc[k][MAX_GOP].m_sliceType == 'B' && m_GOPListMvc[k][MAX_GOP].m_numInterViewRefPics < 1 )
    1438           {
    1439             printf( "\nError: #IL_ref_pics must be at least one for FrameI_l%d with slice type B\n", k );
    1440             bErrorIvpEnhV = true;
    1441           }
    1442         }
    1443       }
    1444     }
    1445   }
    1446   xConfirmPara( bErrorIvpEnhV, "Invalid inter-layer coding structure for enhancement layers given" );
    1447 
    1448   // validate temporal coding structure
    1449   if( !bErrorMvePoc && !bErrorIvpBase && !bErrorIvpEnhV )
    1450   {
    1451     for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    1452     {
    1453       GOPEntry* m_GOPList            = m_GOPListMvc           [layer]; // It is not a member, but this name helps avoiding code duplication !!!
    1454       Int&      m_extraRPSs          = m_extraRPSsMvc         [layer]; // It is not a member, but this name helps avoiding code duplication !!!
    1455       Int&      m_maxTempLayer       = m_maxTempLayerMvc      [layer]; // It is not a member, but this name helps avoiding code duplication !!!
    1456       Int*      m_maxDecPicBuffering = m_maxDecPicBufferingMvc[layer]; // It is not a member, but this name helps avoiding code duplication !!!
    1457       Int*      m_numReorderPics     = m_numReorderPicsMvc    [layer]; // It is not a member, but this name helps avoiding code duplication !!!
    1458 #endif
    14591036  /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure
    14601037   * This permits the ability to omit a GOP structure specification */
     
    14901067  }
    14911068 
    1492 #if H_MV
    1493   if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable[layer]) )
    1494 #else
    14951069  if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent && (!m_bLoopFilterDisable) )
    1496 #endif
    14971070  {
    14981071    for(Int i=0; i<m_iGOPSize; i++)
     
    15101083    if(m_GOPList[curGOP].m_POC<0)
    15111084    {
    1512 #if H_MV
    1513       printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer );
    1514 #else
    15151085      printf("\nError: found fewer Reference Picture Sets than GOPSize\n");
    1516 #endif
    15171086      errorGOP=true;
    15181087    }
     
    15511120          if(!found)
    15521121          {
    1553 #if H_MV
    1554             printf("\nError: ref pic %d is not available for GOP frame %d of layer %d\n", m_GOPList[curGOP].m_referencePics[i], curGOP+1, layer);
    1555 #else
    15561122            printf("\nError: ref pic %d is not available for GOP frame %d\n",m_GOPList[curGOP].m_referencePics[i],curGOP+1);
    1557 #endif
    15581123            errorGOP=true;
    15591124          }
     
    19321497  }
    19331498#endif
    1934 #if H_MV
    1935   }
    1936   }
    1937 #endif
    19381499
    19391500#undef xConfirmPara
     
    19711532{
    19721533  printf("\n");
    1973 #if H_MV
    1974   for( Int layer = 0; layer < m_numberOfLayers; layer++)
    1975   {
    1976     printf("Input File %i                 : %s\n", layer, m_pchInputFileList[layer]);
    1977   }
    1978 #else
    19791534  printf("Input          File          : %s\n", m_pchInputFile          );
    1980 #endif
    19811535  printf("Bitstream      File          : %s\n", m_pchBitstreamFile      );
    1982 #if H_MV
    1983   for( Int layer = 0; layer < m_numberOfLayers; layer++)
    1984   {
    1985     printf("Reconstruction File %i        : %s\n", layer, m_pchReconFileList[layer]);
    1986   }
    1987 #else
    19881536  printf("Reconstruction File          : %s\n", m_pchReconFile          );
    1989 #endif
    1990 #if H_MV
    1991  xPrintParaVector( "ViewId", m_viewId );
    1992 #endif
    1993 #if H_3D
    1994  xPrintParaVector( "DepthFlag", m_depthFlag );
    1995 #endif
    1996 #if H_MV 
    1997   xPrintParaVector( "QP"               , m_fQP                );
    1998   xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable );
    1999   xPrintParaVector( "SAO"              , m_bUseSAO            );
    2000 #endif
    20011537  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
    20021538  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
     
    20101546  printf("Intra period                 : %d\n", m_iIntraPeriod );
    20111547  printf("Decoding refresh type        : %d\n", m_iDecodingRefreshType );
    2012 #if !H_MV
    20131548  printf("QP                           : %5.2f\n", m_fQP );
    2014 #endif
    20151549  printf("Max dQP signaling depth      : %d\n", m_iMaxCuDQPDepth);
    20161550
     
    20771611  }
    20781612  printf("CIP:%d ", m_bUseConstrainedIntraPred);
    2079 #if !H_MV
    20801613  printf("SAO:%d ", (m_bUseSAO)?(1):(0));
    2081 #endif
    20821614  printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0);
    20831615  printf("SAOLcuBasedOptimization:%d ", (m_saoLcuBasedOptimization)?(1):(0));
  • branches/HTM-DEV-0.1-dev/source/App/TAppEncoder/TAppEncCfg.h

    r363 r367  
    5555protected:
    5656  // file I/O
    57 #if H_MV
    58   std::vector<char*>     m_pchInputFileList;                  ///< source file names
    59 #else
    6057  Char*     m_pchInputFile;                                   ///< source file name
    61 #endif
    6258  Char*     m_pchBitstreamFile;                               ///< output bitstream file
    63 #if H_MV
    64   std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
    65   Int                    m_numberOfLayers;                    ///< number of Layers to Encode
    66 #else
    6759  Char*     m_pchReconFile;                                   ///< output reconstruction file
    68 #endif
    6960  // VPS specification
    70 #if H_MV
    71   std::vector< std::vector<Int> > m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
    72   std::vector<Int>       m_viewId;                            ///< view id
    73 #if H_3D
    74   std::vector<Int>       m_depthFlag;                         ///< depth flag
    75 #endif
    76   std::vector<Int>       m_layerIdInNuh;                      ///< layer Id in Nuh for each layer
    77   Bool                   m_splittingFlag;                     ///< Splitting Flag
    78   Int                    m_scalabilityMask;                   ///< Mask indicating scalabilities, 1: texture; 3: texture + depth                                                               
    79   std::vector<Int>       m_dimensionIdLen;                   ///< Length of scalability dimension s
    80 #endif
    8161  Double    m_adLambdaModifier[ MAX_TLAYER ];                 ///< Lambda modifier array for each temporal layer
    8262  // source specification
     
    10888  Int       m_iDecodingRefreshType;                           ///< random access type
    10989  Int       m_iGOPSize;                                       ///< GOP size of hierarchical structure
    110 #if H_MV
    111   Int       m_extraRPSsMvc[MAX_NUM_LAYERS];                       ///< extra RPSs added to handle CRA for each layer
    112   std::vector< GOPEntry* >  m_GOPListMvc;                            ///< the coding structure entries from the config file for each layer
    113   Int       m_numReorderPicsMvc[MAX_NUM_LAYERS][MAX_TLAYER];      ///< total number of reorder pictures for each layer
    114   Int       m_maxDecPicBufferingMvc[MAX_NUM_LAYERS][MAX_TLAYER];  ///< total number of reference pictures needed for decoding for each layer
    115 #else
    11690  Int       m_extraRPSs;                                      ///< extra RPSs added to handle CRA
    11791  GOPEntry  m_GOPList[MAX_GOP];                               ///< the coding structure entries from the config file
     
    12296  Int       m_maxDecPicBuffering[MAX_TLAYER];                 ///< total number of reference pictures needed for decoding
    12397#endif
    124 #endif
    12598#if !L0034_COMBINED_LIST_CLEANUP
    12699  Bool      m_bUseLComb;                                      ///< flag for using combined reference list for uni-prediction in B-slices (JCTVC-D421)
     
    130103  Bool      m_enableAMP;
    131104  // coding quality
    132 #if H_MV
    133   std::vector<Double>  m_fQP;                                 ///< QP value of key-picture (floating point) for each layer
    134   std::vector<Int>     m_iQP;                                 ///< QP value of key-picture (integer) for each layer
    135 #else
    136105  Double    m_fQP;                                            ///< QP value of key-picture (floating point)
    137106  Int       m_iQP;                                            ///< QP value of key-picture (integer)
    138 #endif
    139107  Char*     m_pchdQPFile;                                     ///< QP offset for each slice (initialized from external file)
    140 #if H_MV
    141   std::vector<Int*> m_aidQP;                                    ///< array of slice QP values for each layer
    142 #else
    143108  Int*      m_aidQP;                                          ///< array of slice QP values
    144 #endif
    145109  Int       m_iMaxDeltaQP;                                    ///< max. |delta QP|
    146110  UInt      m_uiDeltaQpRD;                                    ///< dQP range for multi-pass slice QP optimization
     
    157121  Int       m_iQPAdaptationRange;                             ///< dQP range by QP adaptation
    158122 
    159 #if H_MV
    160   Int       m_maxTempLayerMvc[MAX_NUM_LAYER_IDS];             ///< Max temporal layer for each layer
    161 #else
    162123  Int       m_maxTempLayer;                                  ///< Max temporal layer
    163 #endif
    164124
    165125  // coding unit (CU) definition
     
    188148  // coding tool (lossless)
    189149  Bool      m_useLossless;                                    ///< flag for using lossless coding
    190 #if H_MV
    191   std::vector<Bool> m_bUseSAO;
    192 #else
    193150  Bool      m_bUseSAO;
    194 #endif
    195151  Int       m_maxNumOffsetsPerPic;                            ///< SAO maximun number of offset per picture
    196152  Bool      m_saoLcuBoundary;                                 ///< SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
    197153  Bool      m_saoLcuBasedOptimization;                        ///< SAO LCU-based optimization
    198154  // coding tools (loop filter)
    199 #if H_MV
    200   std::vector<Bool> m_bLoopFilterDisable;                     ///< flag for using deblocking filter for each layer
    201 #else
    202155  Bool      m_bLoopFilterDisable;                             ///< flag for using deblocking filter
    203 #endif
    204156  Bool      m_loopFilterOffsetInPPS;                         ///< offset for deblocking filter in 0 = slice header, 1 = PPS
    205157  Int       m_loopFilterBetaOffsetDiv2;                     ///< beta offset for deblocking filter
     
    372324  Void  xPrintParameter ();                                   ///< print configuration values
    373325  Void  xPrintUsage     ();                                   ///< print usage
    374 #if H_MV
    375   template <typename T>
    376   Void xResizeVector(  std::vector<T> & rpcVector )
    377   {
    378     for( Int layer = 0; rpcVector.size() < m_numberOfLayers; layer++ )
    379     {
    380       assert( rpcVector.size() > 0 );
    381       rpcVector.push_back( rpcVector[layer] );     
    382     }
    383 
    384 
    385     for( ; rpcVector.size() > m_numberOfLayers; )
    386     {     
    387       rpcVector.pop_back( );     
    388     }
    389 
    390   }
    391 
    392   template <typename T>
    393   Void xPrintParaVector( std::string description, std::vector<T> & rpcVector )
    394   {
    395     Int iSpace = max(1, ENC_CFG_CONSOUT_SPACE - (Int) description.length() );
    396    
    397     for ( Int i = 0; i < iSpace; i++ )
    398       description.append( " " );
    399      
    400     description.append( ":" );
    401     printf( "%s", description.c_str() );
    402 
    403     for(Int i=0;i<rpcVector.size();i++)               
    404       xPrintVectorElem( rpcVector[i] );
    405 
    406     printf("\n");
    407   }
    408  
    409   Void xPrintVectorElem( UInt   elem ) { printf(" %d"   , elem            );};
    410   Void xPrintVectorElem( Int    elem ) { printf(" %d"   , elem            );};
    411  
    412   Void xPrintVectorElem( Double elem ) { printf(" %5.2f", elem            );}; 
    413   Void xPrintVectorElem( Bool   elem ) { printf(" %d"   , ( elem ? 1 : 0 ));};
    414 #endif
    415326#if SIGNAL_BITRATE_PICRATE_IN_VPS
    416327  Int       m_bitRatePicRateMaxTLayers;                       ///< Indicates max. number of sub-layers for which bit rate is signalled.
     
    422333  Int*      m_constantPicRateIdc;                                ///< Indicates constant picture rate idc for various sub-layers
    423334#endif
    424 #if H_MV
    425   Int   getGOPSize() { return m_iGOPSize; }
    426 #endif
    427335public:
    428336  TAppEncCfg();
  • branches/HTM-DEV-0.1-dev/source/App/TAppEncoder/TAppEncTop.cpp

    r366 r367  
    5757TAppEncTop::TAppEncTop()
    5858{
    59 #if !H_MV
    6059  m_iFrameRcvd = 0;
    61 #endif
    6260  m_totalBytes = 0;
    6361  m_essentialBytes = 0;
     
    7270  TComVPS vps;
    7371 
    74 #if H_MV
    75   Int maxTempLayer = -1;
    76   for (Int j = 0; j < m_numberOfLayers; j++)
    77   {
    78     maxTempLayer = max( m_maxTempLayerMvc[ j ], maxTempLayer );
    79   }
    80 
    81   vps.setMaxTLayers                       ( maxTempLayer );
    82   if ( maxTempLayer )
    83   {
    84     vps.setTemporalNestingFlag(true);
    85   }
    86   vps.setMaxLayers( m_numberOfLayers );
    87   for(Int i = 0; i < MAX_TLAYER; i++)
    88   {
    89     Int maxNumReOrderPics  = 0;
    90     Int maxDecPicBuffering = 0;
    91     for (Int j = 0; j < m_numberOfLayers; j++)
    92     {
    93       maxNumReOrderPics  = max( maxNumReOrderPics,  m_numReorderPicsMvc    [ j ][ i ] );     
    94       maxDecPicBuffering = max( maxDecPicBuffering, m_maxDecPicBufferingMvc[ j ][ i ] );     
    95     }
    96 
    97     vps.setNumReorderPics                 ( maxNumReOrderPics  ,i );
    98     vps.setMaxDecPicBuffering             ( maxDecPicBuffering ,i );
    99   }
    100 #else
    10172  vps.setMaxTLayers                       ( m_maxTempLayer );
    10273  if (m_maxTempLayer == 1)
     
    11081    vps.setMaxDecPicBuffering             ( m_maxDecPicBuffering[i], i );
    11182  }
    112 #endif
    113 #if H_MV
    114   xSetLayerIds             ( vps );   
    115   xSetDimensionIdAndLength ( vps );
    116   xSetDirectDependencyFlags( vps );
    117 
    118   for(Int layer = 0; layer < m_numberOfLayers; layer++)
    119   {
    120     m_frameRcvd                 .push_back(0);
    121     m_acTEncTopList             .push_back(new TEncTop);
    122     m_acTVideoIOYuvInputFileList.push_back(new TVideoIOYuv);
    123     m_acTVideoIOYuvReconFileList.push_back(new TVideoIOYuv);
    124     m_picYuvRec                 .push_back(new TComList<TComPicYuv*>) ;
    125 
    126     m_ivPicLists.push_back( m_acTEncTopList[ layer ]->getListPic()  );
    127     TEncTop& m_cTEncTop = *m_acTEncTopList[ layer ];  // It is not a member, but this name helps avoiding code duplication !!!
    128    
    129     m_cTEncTop.setLayerIdInVps( layer );
    130     m_cTEncTop.setLayerId     ( vps.getLayerIdInNuh( layer ) );   
    131     m_cTEncTop.setViewId      ( vps.getViewId      ( layer ) );
    132 #if H_3D
    133     m_cTEncTop.setIsDepth     ( vps.getDepthId     ( layer ) != 0 );
    134 #endif
    135     m_cTEncTop.setIvPicLists  ( &m_ivPicLists );
    136 #endif
    13783  m_cTEncTop.setVPS(&vps);
    13884
     
    157103  m_cTEncTop.setDecodingRefreshType          ( m_iDecodingRefreshType );
    158104  m_cTEncTop.setGOPSize                      ( m_iGOPSize );
    159 #if H_MV
    160   m_cTEncTop.setGopList                      ( m_GOPListMvc[layer] );
    161   m_cTEncTop.setExtraRPSs                    ( m_extraRPSsMvc[layer] );
    162   for(Int i = 0; i < MAX_TLAYER; i++)
    163   {
    164     m_cTEncTop.setNumReorderPics             ( m_numReorderPicsMvc[layer][i], i );
    165     m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBufferingMvc[layer][i], i );
    166   }
    167 #else
    168105  m_cTEncTop.setGopList                      ( m_GOPList );
    169106  m_cTEncTop.setExtraRPSs                    ( m_extraRPSs );
     
    173110    m_cTEncTop.setMaxDecPicBuffering         ( m_maxDecPicBuffering[i], i );
    174111  }
    175 #endif
    176112  for( UInt uiLoop = 0; uiLoop < MAX_TLAYER; ++uiLoop )
    177113  {
    178114    m_cTEncTop.setLambdaModifier( uiLoop, m_adLambdaModifier[ uiLoop ] );
    179115  }
    180 #if H_MV
    181   m_cTEncTop.setQP                           ( m_iQP[layer] );
    182 #else
    183116  m_cTEncTop.setQP                           ( m_iQP );
    184 #endif
    185117
    186118  m_cTEncTop.setPad                          ( m_aiPad );
    187119
    188 #if H_MV
    189   m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayerMvc[layer] );
    190 #else
    191120  m_cTEncTop.setMaxTempLayer                 ( m_maxTempLayer );
    192 #endif
    193121  m_cTEncTop.setUseAMP( m_enableAMP );
    194122 
     
    196124 
    197125  //====== Loop/Deblock Filter ========
    198 #if H_MV
    199   m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable[layer]);
    200 #else
    201126  m_cTEncTop.setLoopFilterDisable            ( m_bLoopFilterDisable       );
    202 #endif
    203127  m_cTEncTop.setLoopFilterOffsetInPPS        ( m_loopFilterOffsetInPPS );
    204128  m_cTEncTop.setLoopFilterBetaOffset         ( m_loopFilterBetaOffsetDiv2  );
     
    227151  Int lowestQP;
    228152  lowestQP =  - 6*(g_bitDepthY - 8); // XXX: check
    229 #if H_MV
    230   if ((m_iMaxDeltaQP == 0 ) && (m_iQP[layer] == lowestQP) && (m_useLossless == true))
    231 #else
    232153  if ((m_iMaxDeltaQP == 0 ) && (m_iQP == lowestQP) && (m_useLossless == true))
    233 #endif
    234154  {
    235155    m_bUseAdaptiveQP = false;
     
    247167  m_cTEncTop.setUseLComb                     ( m_bUseLComb    );
    248168#endif
    249 #if H_MV
    250   m_cTEncTop.setdQPs                         ( m_aidQP[layer]   );
    251 #else
    252169  m_cTEncTop.setdQPs                         ( m_aidQP        );
    253 #endif
    254170  m_cTEncTop.setUseRDOQ                      ( m_useRDOQ     );
    255171  m_cTEncTop.setUseRDOQTS                    ( m_useRDOQTS   );
     
    308224  }
    309225  m_cTEncTop.setLFCrossSliceBoundaryFlag( m_bLFCrossSliceBoundaryFlag );
    310 #if H_MV
    311   m_cTEncTop.setUseSAO ( m_bUseSAO[layer] );
    312 #else
    313226  m_cTEncTop.setUseSAO ( m_bUseSAO );
    314 #endif
    315227  m_cTEncTop.setMaxNumOffsetsPerPic (m_maxNumOffsetsPerPic);
    316228
     
    460372  }
    461373#endif
    462 #if H_MV
    463   }
    464 #endif
    465374}
    466375
    467376Void TAppEncTop::xCreateLib()
    468377{
    469 #if H_MV
    470   // initialize global variables
    471   initROM();
    472 
    473   for( Int layer=0; layer < m_numberOfLayers; layer++)
    474   {
    475     m_acTVideoIOYuvInputFileList[layer]->open( m_pchInputFileList[layer],     false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
    476     m_acTVideoIOYuvInputFileList[layer]->skipFrames( m_FrameSkip, m_iSourceWidth - m_aiPad[0], m_iSourceHeight - m_aiPad[1]);
    477 
    478     if (m_pchReconFileList[layer])
    479     {
    480       m_acTVideoIOYuvReconFileList[layer]->open( m_pchReconFileList[layer], true, m_outputBitDepthY, m_outputBitDepthC, m_internalBitDepthY, m_internalBitDepthC);  // write mode
    481     }
    482     m_acTEncTopList[layer]->create();
    483   }
    484 #else
    485378  // Video I/O
    486379  m_cTVideoIOYuvInputFile.open( m_pchInputFile,     false, m_inputBitDepthY, m_inputBitDepthC, m_internalBitDepthY, m_internalBitDepthC );  // read  mode
     
    492385  // Neo Decoder
    493386  m_cTEncTop.create();
    494 #endif
    495387}
    496388
    497389Void TAppEncTop::xDestroyLib()
    498390{
    499 #if H_MV
    500   // destroy ROM
    501   destroyROM();
    502 
    503   for(Int layer=0; layer<m_numberOfLayers; layer++)
    504   {
    505     m_acTVideoIOYuvInputFileList[layer]->close();
    506     m_acTVideoIOYuvReconFileList[layer]->close();
    507     delete m_acTVideoIOYuvInputFileList[layer] ;
    508     m_acTVideoIOYuvInputFileList[layer] = NULL;
    509     delete m_acTVideoIOYuvReconFileList[layer] ;
    510     m_acTVideoIOYuvReconFileList[layer] = NULL;
    511     m_acTEncTopList[layer]->deletePicBuffer();
    512     m_acTEncTopList[layer]->destroy();
    513     delete m_acTEncTopList[layer] ;
    514     m_acTEncTopList[layer] = NULL;
    515     delete m_picYuvRec[layer] ;
    516     m_picYuvRec[layer] = NULL;
    517   }
    518 #else
    519391  // Video I/O
    520392  m_cTVideoIOYuvInputFile.close();
     
    523395  // Neo Decoder
    524396  m_cTEncTop.destroy();
    525 #endif
    526397}
    527398
    528399Void TAppEncTop::xInitLib()
    529400{
    530 #if H_MV
    531   for(Int layer=0; layer<m_numberOfLayers; layer++)
    532   {
    533     m_acTEncTopList[layer]->init( );
    534   }
    535 #else
    536401  m_cTEncTop.init();
    537 #endif
    538402}
    539403
     
    568432 
    569433  // main encoder loop
    570 #if H_MV
    571   Bool  allEos = false;
    572   std::vector<Bool>  eos ;
    573   std::vector<Bool>  flush ; 
    574  
    575   Int gopSize    = 1;
    576   Int maxGopSize = 0;
    577   maxGopSize = (std::max)(maxGopSize, m_acTEncTopList[0]->getGOPSize()); 
    578  
    579   for(Int layer=0; layer < m_numberOfLayers; layer++ )
    580   {
    581     eos  .push_back( false );
    582     flush.push_back( false );
    583   }
    584 #else
    585434  Int   iNumEncoded = 0;
    586435  Bool  bEos = false;
    587 #endif
    588436 
    589437  list<AccessUnit> outputAccessUnits; ///< list of access units to write out.  is populated by the encoding process
     
    592440  pcPicYuvOrg->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
    593441 
    594 #if H_MV
    595   while ( !allEos )
    596   {
    597     for(Int layer=0; layer < m_numberOfLayers; layer++ )
    598     {
    599       Int frmCnt = 0;
    600       while ( !eos[layer] && !(frmCnt == gopSize))
    601       {
    602         // get buffers
    603         xGetBuffer(pcPicYuvRec, layer);
    604 
    605         // read input YUV file
    606         m_acTVideoIOYuvInputFileList[layer]->read      ( pcPicYuvOrg, m_aiPad );
    607         m_acTEncTopList             [layer]->initNewPic( pcPicYuvOrg );
    608 
    609         // increase number of received frames
    610         m_frameRcvd[layer]++;
    611        
    612         frmCnt++;
    613 
    614         eos[layer] = (m_frameRcvd[layer] == m_framesToBeEncoded);
    615         allEos = allEos|eos[layer];
    616 
    617         // if end of file (which is only detected on a read failure) flush the encoder of any queued pictures
    618         if (m_acTVideoIOYuvInputFileList[layer]->isEof())
    619         {
    620           flush          [layer] = true;
    621           eos            [layer]   = true;
    622           m_frameRcvd    [layer]--;
    623           m_acTEncTopList[layer]->setFramesToBeEncoded(m_frameRcvd[layer]);
    624         }
    625       }
    626     }
    627     for ( Int gopId=0; gopId < gopSize; gopId++ )
    628     {
    629       for(Int layer=0; layer < m_numberOfLayers; layer++ )
    630       {
    631         Int   iNumEncoded = 0;
    632 
    633         // call encoding function for one frame         
    634         m_acTEncTopList[layer]->encode( eos[layer], flush[layer] ? 0 : pcPicYuvOrg, *m_picYuvRec[layer], outputAccessUnits, iNumEncoded, gopId );       
    635         xWriteOutput(bitstreamFile, iNumEncoded, outputAccessUnits, layer);
    636         outputAccessUnits.clear();
    637       }
    638 
    639     }
    640     gopSize = maxGopSize;
    641   }
    642   for(Int layer=0; layer < m_numberOfLayers; layer++ )
    643   {
    644     m_acTEncTopList[layer]->printSummary( m_acTEncTopList[layer]->getNumAllPicCoded() );
    645   }
    646 #else
    647442  while ( !bEos )
    648443  {
     
    680475
    681476  m_cTEncTop.printSummary();
    682 #endif
    683477
    684478  // delete original YUV buffer
     
    687481  pcPicYuvOrg = NULL;
    688482 
    689 #if !H_MV
    690483  // delete used buffers in encoder class
    691484  m_cTEncTop.deletePicBuffer();
    692 #endif
    693485
    694486  // delete buffers & classes
     
    701493}
    702494
    703 #if H_3D
    704 TEncTop* TAppEncTop::getTEncTopView( Int viewId, Bool isDepth )
    705 {
    706   TEncTop* encoder = NULL;
    707   for( Int layer = 0; layer < m_acTEncTopList.size(); layer++ )
    708   {
    709     if( m_acTEncTopList[layer]->getViewId()  == viewId &&
    710         m_acTEncTopList[layer]->getIsDepth() == isDepth )
    711     {
    712       encoder = m_acTEncTopList[layer];
    713       break;
    714     }
    715   }
    716   return encoder;
    717 }
    718 #endif
    719495// ====================================================================================================================
    720496// Protected member functions
     
    727503 .
    728504 */
    729 #if H_MV
    730 Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec, UInt layer)
    731 #else
    732505Void TAppEncTop::xGetBuffer( TComPicYuv*& rpcPicYuvRec)
    733 #endif
    734506{
    735507  assert( m_iGOPSize > 0 );
    736508 
    737509  // org. buffer
    738 #if H_MV
    739   if ( m_picYuvRec[layer]->size() == (UInt)m_iGOPSize )
    740   {
    741     rpcPicYuvRec = m_picYuvRec[layer]->popFront();
    742 #else
    743510  if ( m_cListPicYuvRec.size() == (UInt)m_iGOPSize )
    744511  {
    745512    rpcPicYuvRec = m_cListPicYuvRec.popFront();
    746 #endif
    747513
    748514  }
     
    754520
    755521  }
    756 #if H_MV
    757   m_picYuvRec[layer]->pushBack( rpcPicYuvRec );
    758 #else
    759522  m_cListPicYuvRec.pushBack( rpcPicYuvRec );
    760 #endif
    761523}
    762524
    763525Void TAppEncTop::xDeleteBuffer( )
    764526{
    765 #if H_MV
    766   for(Int layer=0; layer<m_picYuvRec.size(); layer++)
    767   {
    768     if(m_picYuvRec[layer])
    769     {
    770       TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_picYuvRec[layer]->begin();
    771       Int iSize = Int( m_picYuvRec[layer]->size() );
    772 #else
    773527  TComList<TComPicYuv*>::iterator iterPicYuvRec  = m_cListPicYuvRec.begin();
    774528 
    775529  Int iSize = Int( m_cListPicYuvRec.size() );
    776 #endif
    777530
    778531  for ( Int i = 0; i < iSize; i++ )
     
    783536  }
    784537
    785 #if H_MV
    786     }
    787   }
    788 #endif 
    789538}
    790539
    791540/** \param iNumEncoded  number of encoded frames
    792541 */
    793 #if H_MV
    794 Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, std::list<AccessUnit>& accessUnits, UInt layerId)
    795 #else
    796542Void TAppEncTop::xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits)
    797 #endif
    798543{
    799544  Int i;
    800545 
    801 #if H_MV
    802   if( iNumEncoded > 0 )
    803   {
    804     TComList<TComPicYuv*>::iterator iterPicYuvRec = m_picYuvRec[layerId]->end();
    805 #else
    806546  TComList<TComPicYuv*>::iterator iterPicYuvRec = m_cListPicYuvRec.end();
    807547  list<AccessUnit>::const_iterator iterBitstream = accessUnits.begin();
    808 #endif
    809548
    810549  for ( i = 0; i < iNumEncoded; i++ )
     
    816555  {
    817556    TComPicYuv*  pcPicYuvRec  = *(iterPicYuvRec++);
    818 #if H_MV
    819       if (m_pchReconFileList[layerId])
    820       {
    821         m_acTVideoIOYuvReconFileList[layerId]->write( pcPicYuvRec, m_confLeft, m_confRight, m_confTop, m_confBottom );
    822       }
    823     }
    824   }
    825   if( ! accessUnits.empty() )
    826   {
    827     list<AccessUnit>::iterator aUIter;
    828     for( aUIter = accessUnits.begin(); aUIter != accessUnits.end(); aUIter++ )
    829     {
    830       const vector<unsigned>& stats = writeAnnexB(bitstreamFile, *aUIter);
    831       rateStatsAccum(*aUIter, stats);
    832     }
    833   }
    834 #else
    835557    if (m_pchReconFile)
    836558    {
     
    842564    rateStatsAccum(au, stats);
    843565  }
    844 #endif
    845566}
    846567
     
    888609void TAppEncTop::printRateSummary()
    889610{
    890 #if H_MV
    891   Double time = (Double) m_frameRcvd[0] / m_iFrameRate;
    892   printf("\n");
    893 #else
    894611  Double time = (Double) m_iFrameRcvd / m_iFrameRate;
    895 #endif
    896612  printf("Bytes written to file: %u (%.3f kbps)\n", m_totalBytes, 0.008 * m_totalBytes / time);
    897613#if VERBOSE_RATE
     
    900616}
    901617
    902 #if H_MV
    903 Void TAppEncTop::xSetDimensionIdAndLength( TComVPS& vps )
    904 {   
    905   vps.setScalabilityMask( m_scalabilityMask );
    906   for( Int dim = 0; dim < m_dimIds.size(); dim++ )
    907   {
    908       vps.setDimensionIdLen( dim, m_dimensionIdLen[ dim ] );
    909       for( Int layer = 1; layer < vps.getMaxLayers(); layer++ )
    910       {       
    911         vps.setDimensionId( layer, dim, m_dimIds[ dim ][ layer ] );       
    912       } 
    913   }
    914 }
    915 
    916 Void TAppEncTop::xSetDirectDependencyFlags( TComVPS& vps )
    917 {
    918   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    919   {
    920     if( m_GOPListMvc[layer][MAX_GOP].m_POC == -1 )
    921     {
    922       continue;
    923     }
    924     for( Int i = 0; i < getGOPSize()+1; i++ )
    925     {
    926       GOPEntry ge = ( i < getGOPSize() ) ? m_GOPListMvc[layer][i] : m_GOPListMvc[layer][MAX_GOP];
    927       for( Int j = 0; j < ge.m_numInterViewRefPics; j++ )
    928       {
    929         Int interLayerRef = layer + ge.m_interViewRefs[j];
    930         vps.setDirectDependencyFlag( layer, interLayerRef, true );
    931       }
    932     }
    933   }
    934 
    935   vps.checkVPSExtensionSyntax();
    936   vps.calcIvRefLayers();
    937 }
    938 
    939 Void TAppEncTop::xSetLayerIds( TComVPS& vps )
    940 {
    941   vps.setSplittingFlag     ( m_splittingFlag );
    942 
    943   Bool nuhLayerIdPresentFlag = !( m_layerIdInNuh.size() == 1 );
    944   Int  maxNuhLayerId = nuhLayerIdPresentFlag ? xGetMax( m_layerIdInNuh ) : ( m_numberOfLayers - 1 ) ;
    945 
    946   vps.setMaxNuhLayerId( maxNuhLayerId );
    947   vps.setVpsNuhLayerIdPresentFlag( nuhLayerIdPresentFlag );
    948 
    949   for (Int layer = 0; layer < m_numberOfLayers; layer++ )
    950   {
    951     vps.setLayerIdInNuh( layer, nuhLayerIdPresentFlag ? m_layerIdInNuh[ layer ] : layer );
    952     vps.setLayerIdInVps( vps.getLayerIdInNuh( layer ), layer );
    953   }
    954 }
    955 
    956 Int TAppEncTop::xGetMax( std::vector<Int>& vec )
    957 {
    958   Int maxVec = 0;
    959   for ( Int i = 0; i < vec.size(); i++)   
    960     maxVec = max( vec[i], maxVec );
    961   return maxVec;
    962 }
    963 #endif
    964618
    965619//! \}
  • branches/HTM-DEV-0.1-dev/source/App/TAppEncoder/TAppEncTop.h

    r364 r367  
    5959private:
    6060  // class interface
    61 #if H_MV
    62   std::vector<TEncTop*>      m_acTEncTopList ;              ///< encoder class per layer
    63   std::vector<TVideoIOYuv*>  m_acTVideoIOYuvInputFileList;  ///< input YUV file
    64   std::vector<TVideoIOYuv*>  m_acTVideoIOYuvReconFileList;  ///< output reconstruction file
    65  
    66   std::vector<TComList<TComPicYuv*>*>  m_picYuvRec;         ///< list of reconstruction YUV files
    67 
    68   std::vector<Int>           m_frameRcvd;                   ///< number of received frames
    69 
    70   TComPicLists               m_ivPicLists;                  ///< picture buffers of encoder instances
    71 #else
    7261  TEncTop                    m_cTEncTop;                    ///< encoder class
    7362  TVideoIOYuv                m_cTVideoIOYuvInputFile;       ///< input YUV file
     
    7766 
    7867  Int                        m_iFrameRcvd;                  ///< number of received frames
    79 #endif
    8068
    8169  UInt m_essentialBytes;
     
    8977 
    9078  /// obtain required buffers
    91 #if H_MV
    92   Void xGetBuffer(TComPicYuv*& rpcPicYuvRec, UInt layer);
    93 #else
    9479  Void xGetBuffer(TComPicYuv*& rpcPicYuvRec);
    95 #endif
    9680
    9781  /// delete allocated buffers
     
    9983 
    10084  // file I/O
    101 #if H_MV
    102   Void xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, std::list<AccessUnit>& accessUnits, UInt layerId); ///< write bitstream to file
    103 #else
    10485  Void xWriteOutput(std::ostream& bitstreamFile, Int iNumEncoded, const std::list<AccessUnit>& accessUnits); ///< write bitstream to file
    105 #endif
    10686  void rateStatsAccum(const AccessUnit& au, const std::vector<UInt>& stats);
    10787  void printRateSummary();
    10888 
    109 #if H_MV
    110   Void xSetLayerIds               ( TComVPS& vps ); 
    111   Void xSetDimensionIdAndLength   ( TComVPS& vps );
    112   Void xSetDirectDependencyFlags  ( TComVPS& vps );
    113   Int  xGetMax( std::vector<Int>& vec);
    114 #endif
    11589public:
    11690  TAppEncTop();
     
    11892 
    11993  Void        encode      ();                               ///< main encoding function
    120 #if H_MV
    121   TEncTop*    getTEncTopLayer(UInt layer) { return  m_acTEncTopList[layer]; }  ///< return pointer to encoder class for specific layer
    122 #if H_3D
    123   TEncTop*    getTEncTopView( Int viewId, Bool isDepth );                      ///< return pointer to encoder class for specific view Id and texture or depth
    124 #endif
    125 #else
    12694  TEncTop&    getTEncTop  ()   { return  m_cTEncTop; }      ///< return encoder class pointer reference
    127 #endif
    12895};// END CLASS DEFINITION TAppEncTop
    12996
  • branches/HTM-DEV-0.1-dev/source/App/TAppEncoder/encmain.cpp

    r364 r367  
    5757  // print information
    5858  fprintf( stdout, "\n" );
    59 #if H_MV
    60   fprintf( stdout, "3D-HTM Software: Encoder Version [%s] based on HM Version [%s]", NV_VERSION, HM_VERSION ); 
    61 #else
    6259  fprintf( stdout, "HM software: Encoder Version [%s]", NV_VERSION );
    63 #endif
    6460  fprintf( stdout, NVM_ONOS );
    6561  fprintf( stdout, NVM_COMPILEDBY );
  • branches/HTM-DEV-0.1-dev/source/Lib/TAppCommon/program_options_lite.h

    r365 r367  
    3737#include <map>
    3838
    39 #if H_MV
    40 #include <vector>
    41 #include <errno.h>
    42 #include <cstring>
    43 
    44 #ifdef WIN32
    45 #define strdup _strdup
    46 #endif
    47 #endif
    4839//! \ingroup TAppCommon
    4940//! \{
     
    145136    }
    146137
    147 #if H_MV   
    148     template<>
    149     inline void
    150       Option<char*>::parse(const std::string& arg)
    151     {
    152       opt_storage = arg.empty() ? NULL : strdup(arg.c_str()) ;
    153     }
    154 
    155     template<>
    156     inline void
    157       Option< std::vector<char*> >::parse(const std::string& arg)
    158     {
    159       opt_storage.clear();
    160 
    161       char* pcStart = (char*) arg.data();     
    162       char* pcEnd = strtok (pcStart," ");
    163 
    164       while (pcEnd != NULL)
    165       {
    166         size_t uiStringLength = pcEnd - pcStart;
    167         char* pcNewStr = (char*) malloc( uiStringLength + 1 );
    168         strncpy( pcNewStr, pcStart, uiStringLength);
    169         pcNewStr[uiStringLength] = '\0';
    170         pcStart = pcEnd+1;
    171         pcEnd = strtok (NULL, " ,.-");
    172         opt_storage.push_back( pcNewStr );
    173       }     
    174     }
    175 
    176 
    177     template<>   
    178     inline void
    179       Option< std::vector<double> >::parse(const std::string& arg)
    180     {
    181       char* pcNextStart = (char*) arg.data();
    182       char* pcEnd = pcNextStart + arg.length();
    183 
    184       char* pcOldStart = 0;
    185 
    186       size_t iIdx = 0;
    187 
    188       while (pcNextStart < pcEnd)
    189       {
    190         errno = 0;
    191 
    192         if ( iIdx < opt_storage.size() )
    193         {
    194           opt_storage[iIdx] = strtod(pcNextStart, &pcNextStart);
    195         }
    196         else
    197         {
    198           opt_storage.push_back( strtod(pcNextStart, &pcNextStart)) ;
    199         }
    200         iIdx++;
    201 
    202         if ( errno == ERANGE || (pcNextStart == pcOldStart) )
    203         {
    204           std::cerr << "Error Parsing Doubles: `" << arg << "'" << std::endl;
    205           exit(EXIT_FAILURE);   
    206         };   
    207         while( (pcNextStart < pcEnd) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++; 
    208         pcOldStart = pcNextStart;
    209 
    210       }
    211     }
    212 
    213     template<>
    214     inline void
    215       Option< std::vector<int> >::parse(const std::string& arg)
    216     {
    217       opt_storage.clear();
    218 
    219 
    220       char* pcNextStart = (char*) arg.data();
    221       char* pcEnd = pcNextStart + arg.length();
    222 
    223       char* pcOldStart = 0;
    224 
    225       size_t iIdx = 0;
    226 
    227 
    228       while (pcNextStart < pcEnd)
    229       {
    230 
    231         if ( iIdx < opt_storage.size() )
    232         {
    233           opt_storage[iIdx] = (int) strtol(pcNextStart, &pcNextStart,10);
    234         }
    235         else
    236         {
    237           opt_storage.push_back( (int) strtol(pcNextStart, &pcNextStart,10)) ;
    238         }
    239         iIdx++;
    240         if ( errno == ERANGE || (pcNextStart == pcOldStart) )
    241         {
    242           std::cerr << "Error Parsing Integers: `" << arg << "'" << std::endl;
    243           exit(EXIT_FAILURE);
    244         };   
    245         while( (pcNextStart < pcEnd) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++; 
    246         pcOldStart = pcNextStart;
    247       }
    248     }
    249 
    250 
    251     template<>
    252     inline void
    253       Option< std::vector<bool> >::parse(const std::string& arg)
    254     {
    255       char* pcNextStart = (char*) arg.data();
    256       char* pcEnd = pcNextStart + arg.length();
    257 
    258       char* pcOldStart = 0;
    259 
    260       size_t iIdx = 0;
    261 
    262       while (pcNextStart < pcEnd)
    263       {
    264         if ( iIdx < opt_storage.size() )
    265         {
    266           opt_storage[iIdx] = (strtol(pcNextStart, &pcNextStart,10) != 0);
    267         }
    268         else
    269         {
    270           opt_storage.push_back(strtol(pcNextStart, &pcNextStart,10) != 0) ;
    271         }
    272         iIdx++;
    273 
    274         if ( errno == ERANGE || (pcNextStart == pcOldStart) )
    275         {
    276           std::cerr << "Error Parsing Bools: `" << arg << "'" << std::endl;
    277           exit(EXIT_FAILURE);
    278         };   
    279         while( (pcNextStart < pcEnd) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++; 
    280         pcOldStart = pcNextStart;
    281       }
    282     }
    283 #endif
    284138    /** Option class for argument handling using a user provided function */
    285139    struct OptionFunc : public OptionBase
     
    356210      }
    357211     
    358 #if H_MV
    359       template<typename T>
    360       OptionSpecific&
    361         operator()(const std::string& name, std::vector<T>& storage, T default_val, unsigned uiMaxNum, const std::string& desc = "" )
    362       {
    363         std::string cNameBuffer;
    364         std::string cDescriptionBuffer;
    365 
    366         cNameBuffer       .resize( name.size() + 10 );
    367         cDescriptionBuffer.resize( desc.size() + 10 );
    368 
    369         storage.resize(uiMaxNum);
    370         for ( unsigned int uiK = 0; uiK < uiMaxNum; uiK++ )
    371         {
    372           // isn't there are sprintf function for string??
    373           sprintf((char*) cNameBuffer.c_str()       ,name.c_str(),uiK,uiK);
    374           sprintf((char*) cDescriptionBuffer.c_str(),desc.c_str(),uiK,uiK);
    375 
    376           parent.addOption(new Option<T>( cNameBuffer, (storage[uiK]), default_val, cDescriptionBuffer ));
    377         }
    378 
    379         return *this;
    380       }
    381 #endif
    382212      /**
    383213       * Add option described by name to the parent Options list,
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/CommonDef.h

    r364 r367  
    5656// ====================================================================================================================
    5757
    58 #if H_MV
    59 #define NV_VERSION        "0.1"                 ///< Current software version
    60 #define HM_VERSION        "10.1"                ///<
    61 #else
    6258#define NV_VERSION        "10.1"                 ///< Current software version
    63 #endif
    6459
    6560// ====================================================================================================================
     
    157152}
    158153
    159 #if H_MV
    160 
    161 #define AOF( exp )                  \
    162 {                                   \
    163   if( !( exp ) )                    \
    164 {                                 \
    165   assert( 0 );                    \
    166 }                                 \
    167 }
    168 
    169 #endif
    170154
    171155// ====================================================================================================================
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/NAL.h

    r364 r367  
    4747  NalUnitType m_nalUnitType; ///< nal_unit_type
    4848  UInt        m_temporalId;  ///< temporal_id
    49 #if H_MV
    50   Int         m_layerId;     ///< layer id
    51 #else
    5249  UInt        m_reservedZero6Bits; ///< reserved_zero_6bits
    53 #endif
    5450
    5551  /** construct an NALunit structure with given header values. */
     
    5753    NalUnitType nalUnitType,
    5854    Int         temporalId = 0,
    59 #if H_MV
    60     Int         layerId = 0)
    61 #else
    6255    Int         reservedZero6Bits = 0)
    63 #endif
    6456    :m_nalUnitType (nalUnitType)
    6557    ,m_temporalId  (temporalId)
    66 #if H_MV
    67     ,m_layerId     (layerId)
    68 #else
    6958    ,m_reservedZero6Bits(reservedZero6Bits)
    70 #endif
    7159  {}
    7260
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/TComPic.cpp

    r365 r367  
    6464, m_pNDBFilterYuvTmp                      (NULL)
    6565, m_bCheckLTMSB                           (false)
    66 #if H_MV
    67 , m_layerId                               (0)
    68 , m_viewId                                (0)
    69 #if H_3D
    70 , m_isDepth                               (false)
    71 #endif
    72 #endif
    7366{
    7467  m_apcPicYuv[0]      = NULL;
     
    471464
    472465}
    473 #if H_MV
    474 Void TComPic::print( Bool legend )
    475 {
    476   if ( legend )
    477     std::cout  << "LId"        << "\t" << "POC"   << "\t" << "Rec"          << "\t" << "Ref"                       << "\t" << "LT"            << std::endl;
    478   else
    479     std::cout  << getLayerId() << "\t" << getPOC()<< "\t" << getReconMark() << "\t" << getSlice(0)->isReferenced() << "\t" << getIsLongTerm() << std::endl;
    480 }
    481 #endif
    482466
    483467
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/TComPic.h

    r364 r367  
    8686  SEIMessages  m_SEIs; ///< Any SEI messages that have been received.  If !NULL we own the object.
    8787
    88 #if H_MV
    89   Int                   m_layerId;
    90   Int                   m_viewId;
    91 #if H_3D
    92   Bool                  m_isDepth;
    93 #endif
    94 #endif
    9588public:
    9689  TComPic();
     
    10598  Void          setTLayer( UInt uiTLayer ) { m_uiTLayer = uiTLayer; }
    10699
    107 #if H_MV
    108   Void          setLayerId            ( Int layerId )    { m_layerId      = layerId; }
    109   Int           getLayerId            ()                 { return m_layerId;    }
    110   Void          setViewId             ( Int viewId )     { m_viewId = viewId;   }
    111   Int           getViewId             ()                 { return m_viewId;     }
    112 #if H_3D
    113   Void          setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
    114   Bool          getIsDepth            ()                 { return m_isDepth; }
    115 #endif
    116 #endif
    117100  Bool          getUsedByCurr()             { return m_bUsedByCurr; }
    118101  Void          setUsedByCurr( Bool bUsed ) { m_bUsedByCurr = bUsed; }
     
    181164  std::vector<TComDataCU*>& getOneSliceCUDataForNDBFilter      (Int sliceID) { return m_vSliceCUDataLink[sliceID];}
    182165
    183 #if H_MV
    184   Void          print( Bool legend );
    185 #endif
    186166  /** transfer ownership of seis to this picture */
    187167  void setSEIs(SEIMessages& seis) { m_SEIs = seis; }
     
    199179};// END CLASS DEFINITION TComPic
    200180
    201 #if H_MV
    202 class TComPicLists
    203 {
    204 private:
    205   TComList<TComList<TComPic*>*> m_lists;
    206 public:
    207  
    208   Void push_back( TComList<TComPic*>* list ) { m_lists.push_back( list ); }
    209   Int  size     ()                           { return (Int) m_lists.size    (); }
    210 
    211   TComPic* getPic( Int layerIdInNuh, Int poc )
    212   {
    213     TComPic* pcPic = NULL;
    214     for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() && pcPic == NULL ); itL++)
    215     {   
    216       for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() && pcPic == NULL ); itP++)
    217       {
    218         if ( ( (*itP)->getPOC() == poc ) && ( (*itP)->getLayerId() == layerIdInNuh ) )
    219         {
    220           pcPic = *itP ;     
    221         }
    222       }
    223     }
    224     return pcPic;
    225   }
    226 
    227   Void print( )
    228   {
    229     Bool first = true;     
    230     for(TComList<TComList<TComPic*>*>::iterator itL = m_lists.begin(); ( itL != m_lists.end() ); itL++)
    231     {   
    232       for(TComList<TComPic*>::iterator itP=(*itL)->begin(); ( itP!=(*itL)->end() ); itP++)
    233       {
    234         if ( first )
    235         {
    236           (*itP)->print( true );       
    237           first = false;
    238         }
    239         (*itP)->print( false );       
    240       }
    241     }
    242   }
    243 
    244 
    245 }; // END CLASS DEFINITION TComPicLists
    246 
    247 #endif
    248181//! \}
    249182
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/TComSlice.cpp

    r366 r367  
    107107, m_temporalLayerNonReferenceFlag ( false )
    108108, m_enableTMVPFlag                ( true )
    109 #if H_MV
    110 , m_layerId                       (0)
    111 , m_viewId                        (0)
    112 #if H_3D
    113 , m_isDepth                       (false)
    114 #endif
    115 #endif
    116109{
    117110#if L0034_COMBINED_LIST_CLEANUP
     
    145138    m_aiRefPOCList  [0][iNumCount] = 0;
    146139    m_aiRefPOCList  [1][iNumCount] = 0;
    147 #if H_MV
    148     m_aiRefLayerIdList[0][iNumCount] = 0;
    149     m_aiRefLayerIdList[1][iNumCount] = 0;
    150 #endif
    151140  }
    152141  resetWpScaling();
     
    320309    {
    321310      m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
    322 #if H_MV
    323       m_aiRefLayerIdList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getLayerId();
    324 #endif
    325311    }
    326312  }
     
    368354        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
    369355        {
    370 #if H_MV
    371           if ( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() &&
    372                m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getLayerId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getLayerId() )
    373 #else
    374356          if ( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() )
    375 #endif
    376357          {
    377358            m_iRefIdxOfL1FromRefIdxOfL0[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
     
    395376        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
    396377        {
    397 #if H_MV
    398           if ( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() &&
    399                m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getLayerId() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getLayerId() )
    400 #else
    401378          if ( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() )
    402 #endif
    403379          {
    404380            m_iRefIdxOfL0FromRefIdxOfL1[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
     
    420396#endif
    421397
    422 #if H_MV
    423 Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& refPicSetInterLayer , Bool checkNumPocTotalCurr)
    424 #else
    425398#if FIX1071
    426399Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr )
     
    428401Void TComSlice::setRefPicList( TComList<TComPic*>& rcListPic )
    429402#endif
    430 #endif
    431403{
    432404#if FIX1071
     
    442414    }
    443415   
    444 #if !H_MV
    445416    m_aiNumRefIdx[0] = getNumRefIdx(REF_PIC_LIST_0);
    446417    m_aiNumRefIdx[1] = getNumRefIdx(REF_PIC_LIST_1);
    447 #endif
    448418  }
    449419
     
    455425  UInt NumPocStCurr1 = 0;
    456426  UInt NumPocLtCurr = 0;
    457 #if H_MV
    458   Int numDirectRefLayers  = getVPS()->getNumDirectRefLayers( getLayerIdInVps() );
    459   assert( numDirectRefLayers == refPicSetInterLayer.size() );
    460 #endif
    461427  Int i;
    462428
     
    507473  TComPic*  rpsCurrList0[MAX_NUM_REF+1];
    508474  TComPic*  rpsCurrList1[MAX_NUM_REF+1];
    509 #if H_MV
    510   Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr + numDirectRefLayers;
    511   assert( numPocTotalCurr == getNumRpsCurrTempList() );
    512 #else
    513475  Int numPocTotalCurr = NumPocStCurr0 + NumPocStCurr1 + NumPocLtCurr;
    514 #endif
    515476#if FIX1071
    516477  if (checkNumPocTotalCurr)
     
    552513    rpsCurrList0[cIdx] = RefPicSetLtCurr[i];
    553514  }
    554 #if H_MV
    555   for ( i=0; i<numDirectRefLayers;  i++, cIdx++)
    556   {
    557     if( cIdx <= MAX_NUM_REF )
    558     {
    559       rpsCurrList0[cIdx] = refPicSetInterLayer[i];
    560     }
    561   }
    562 #endif
    563515
    564516  if (m_eSliceType==B_SLICE)
     
    577529      rpsCurrList1[cIdx] = RefPicSetLtCurr[i];
    578530    }
    579 #if H_MV
    580     for ( i=0; i<numDirectRefLayers;  i++, cIdx++)
    581     {
    582       if( cIdx <= MAX_NUM_REF )
    583       {
    584         rpsCurrList1[cIdx] = refPicSetInterLayer[i];
    585       }
    586     }
    587 #endif
    588531  }
    589532
     
    627570    }
    628571  }
    629 #if H_MV
    630   numRpsCurrTempList = numRpsCurrTempList + getVPS()->getNumDirectRefLayers( getLayerIdInVps() );
    631 #endif
    632572  return numRpsCurrTempList;
    633573}
     
    792732  m_iPOC                 = pSrc->m_iPOC;
    793733  m_eNalUnitType         = pSrc->m_eNalUnitType;
    794 #if H_MV
    795   m_layerId              = pSrc->m_layerId;
    796 #endif
    797734  m_eSliceType           = pSrc->m_eSliceType;
    798735  m_iSliceQp             = pSrc->m_iSliceQp;
     
    847784      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
    848785      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
    849 #if H_MV
    850       m_aiRefLayerIdList[i][j] = pSrc->m_aiRefLayerIdList[i][j];
    851 #endif
    852786    }
    853787  }
     
    865799
    866800  // access channel
    867 #if H_MV
    868   m_pcVPS                = pSrc->m_pcVPS;
    869 #endif
    870801  m_pcSPS                = pSrc->m_pcSPS;
    871802  m_pcPPS                = pSrc->m_pcPPS;
     
    13811312, m_bTemporalIdNestingFlag    (false)
    13821313, m_numHrdParameters          (  0)
    1383 #if H_MV
    1384 , m_maxNuhLayerId             (  0)
    1385 #else
    13861314, m_maxNuhReservedZeroLayerId (  0)
    1387 #endif
    13881315, m_hrdParameters             (NULL)
    13891316, m_hrdOpSetIdx               (NULL)
     
    14001327    m_uiMaxLatencyIncrease[i] = 0;
    14011328  }
    1402 #if H_MV
    1403   m_avcBaseLayerFlag = false;
    1404   m_splittingFlag    = false;
    1405  
    1406   for( Int i = 0; i < MAX_NUM_SCALABILITY_TYPES; i++ )
    1407   {
    1408     m_scalabilityMask[i] = false;
    1409     m_dimensionIdLen [i]  = -1;
    1410   }
    1411 
    1412   m_vpsNuhLayerIdPresentFlag = false;
    1413   m_numOutputLayerSets       = 0;
    1414 
    1415   for( Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ )
    1416   {
    1417     m_vpsProfilePresentFlag   [i] = false;
    1418     m_profileLayerSetRefMinus1[i] = 0;
    1419     m_outputLayerSetIdx       [i] = 0;
    1420     for( Int j = 0; j < MAX_VPS_NUH_LAYER_ID_PLUS1; j++ )
    1421     {
    1422       m_outputLayerFlag[i][j] = false;
    1423     }
    1424   }
    1425 
    1426   for( Int i = 0; i < MAX_NUM_LAYER_IDS; i++ )
    1427   {
    1428     m_layerIdInVps[i] =  (i == 0 ) ? 0 : -1;         
    1429   }
    1430 
    1431   for( Int i = 0; i < MAX_NUM_LAYERS; i++ )
    1432   {
    1433     m_layerIdInNuh      [i] = ( i == 0 ) ? 0 : -1;
    1434     m_numDirectRefLayers[i] = 0;
    1435 
    1436     for( Int j = 0; j < MAX_NUM_LAYERS; j++ )
    1437     {
    1438       m_directDependencyFlag[i][j] = false;
    1439       m_refLayerId[i][j]           = -1;
    1440     }
    1441 
    1442     for( Int j = 0; j < MAX_NUM_SCALABILITY_TYPES; j++ )
    1443     {
    1444       m_dimensionId[i][j] = 0;
    1445     }
    1446 
    1447   }
    1448 #endif
    14491329}
    14501330
     
    14561336}
    14571337
    1458 #if H_MV
    1459 
    1460 Bool TComVPS::checkVPSExtensionSyntax()
    1461 {
    1462   // check splitting flag constraint
    1463   if ( getSplittingFlag() )
    1464   {
    1465     // Derive dimBitOffset[j]
    1466     Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
    1467     Int numScalabilityTypes = getNumScalabilityTypes();
    1468     dimBitOffset[0] = 0;
    1469 
    1470     for (Int type = 1; type <= numScalabilityTypes; type++ )
    1471     {
    1472       dimBitOffset[ type ] = 0;
    1473       for (Int dimIdx = 0; dimIdx <= type - 1; dimIdx++)
    1474         dimBitOffset[ type ] += ( getDimensionIdLen( dimIdx ) );
    1475     }
    1476 
    1477     for (Int type = 0; type < getNumScalabilityTypes(); type++ )
    1478     {
    1479       for( Int layer = 1; layer < getMaxLayers(); layer++ )
    1480       {
    1481         assert( getDimensionId( layer, type ) == ( ( getLayerIdInNuh( layer ) & ( (1 << dimBitOffset[ type + 1 ] ) - 1) ) >> dimBitOffset[ type ] ) );
    1482       };
    1483   };
    1484   }
    1485 
    1486   for( Int layer = 1; layer < getMaxLayers(); layer++ )
    1487   {
    1488     // check layer_id_in_nuh constraint
    1489     assert( getLayerIdInNuh( layer ) > getLayerIdInNuh( layer -1 ) );
    1490   }
    1491   return true;
    1492 }
    1493 
    1494 Int TComVPS::getNumScalabilityTypes()
    1495 {
    1496   return scalTypeToScalIdx( ScalabilityType(MAX_NUM_SCALABILITY_TYPES) );
    1497 }
    1498 
    1499 Int TComVPS::scalTypeToScalIdx( ScalabilityType scalType )
    1500 {
    1501   assert( scalType >= 0 && scalType <= MAX_NUM_SCALABILITY_TYPES );
    1502   assert( scalType == MAX_NUM_SCALABILITY_TYPES || getScalabilityMask( scalType ) );
    1503 
    1504   Int scalIdx = 0;
    1505   for( Int curScalType = 0; curScalType < scalType; curScalType++ )
    1506   {
    1507     scalIdx += ( getScalabilityMask( curScalType ) ? 1 : 0 );
    1508   }
    1509 
    1510   return scalIdx;
    1511 }
    1512 
    1513 
    1514 
    1515 Void TComVPS::setScalabilityMask( UInt val )
    1516 {
    1517   for ( Int scalType = 0; scalType < MAX_NUM_SCALABILITY_TYPES; scalType++ )
    1518     setScalabilityMask( scalType, ( val & (1 << scalType ) ) == 1 );
    1519 }
    1520 
    1521 Void TComVPS::calcIvRefLayers()
    1522 {
    1523   for( Int i = 1; i <= getMaxLayers(); i++ )
    1524   {
    1525     m_numDirectRefLayers[ i ] = 0;
    1526     for( Int j = 0 ; j < i; j++ )
    1527       if( m_directDependencyFlag[ i ][ j ])
    1528         m_refLayerId[ i ][ m_numDirectRefLayers[ i ]++ ] = m_layerIdInNuh[ j ];   
    1529   }
    1530 }
    1531 
    1532 Int TComVPS::getRefLayerId( Int layerIdInVps, Int idx )
    1533 {
    1534   assert( idx >= 0 && idx < m_numDirectRefLayers[layerIdInVps] );     
    1535   Int layerIdInNuh = m_refLayerId[ layerIdInVps ][ idx ];   
    1536   assert ( layerIdInNuh >= 0 );
    1537   return layerIdInNuh;
    1538 }
    1539 
    1540 Int TComVPS::getScalabilityId( Int layerIdInVps, ScalabilityType scalType )
    1541 {
    1542   return ( ( layerIdInVps != 0 )&& getScalabilityMask( scalType ) ) ? getDimensionId( layerIdInVps, scalTypeToScalIdx( scalType ) ) : 0;
    1543 }
    1544 #endif
    15451338// ------------------------------------------------------------------------------------------------
    15461339// Sequence parameter set (SPS)
     
    15891382, m_vuiParametersPresentFlag  (false)
    15901383, m_vuiParameters             ()
    1591 #if H_MV
    1592 , m_interViewMvVertConstraintFlag (false)
    1593 #endif
    15941384{
    15951385  for ( Int i = 0; i < MAX_TLAYER; i++ )
     
    20551845}
    20561846
    2057 #if H_MV
    2058 Void TComSlice::createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer )
    2059 {
    2060   refPicSetInterLayer.clear();
    2061 
    2062   for( Int i = 0; i < getVPS()->getNumDirectRefLayers( getLayerIdInVps() ); i++ )
    2063   {
    2064     Int layerIdRef = getVPS()->getRefLayerId( getLayerIdInVps(), i );
    2065     TComPic* picRef = ivPicLists->getPic( layerIdRef, getPOC() ) ;
    2066     assert ( picRef != 0 );
    2067 
    2068     picRef->getPicYuvRec()->extendPicBorder();
    2069     picRef->setIsLongTerm( true );       
    2070     picRef->getSlice(0)->setReferenced( true );       
    2071 
    2072     refPicSetInterLayer.push_back( picRef );
    2073   }
    2074 }
    2075 
    2076 Void TComSlice::markIvRefPicsAsShortTerm( std::vector<TComPic*> refPicSetInterLayer )
    2077 {
    2078   // Mark as shortterm
    2079   for ( Int i = 0; i < refPicSetInterLayer.size(); i++ )
    2080   {
    2081     refPicSetInterLayer[i]->setIsLongTerm( false );
    2082   }
    2083 }
    2084 
    2085 Void TComSlice::markIvRefPicsAsUnused( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc )
    2086 {
    2087   // Fill targetDecLayerIdSet with all layers if empty.
    2088   if (targetDecLayerIdSet.size() == 0 )   
    2089   {
    2090     for ( Int layerIdInVps = 0; layerIdInVps < vps->getMaxLayers(); layerIdInVps++ )
    2091     {
    2092       targetDecLayerIdSet.push_back( vps->getLayerIdInNuh( layerIdInVps ) );
    2093     }
    2094   }     
    2095 
    2096   Int numTargetDecLayers = (Int) targetDecLayerIdSet.size();
    2097   Int latestDecIdx;
    2098   for ( latestDecIdx = 0; latestDecIdx < numTargetDecLayers; latestDecIdx++)
    2099   {
    2100     if ( targetDecLayerIdSet[ latestDecIdx ] == curLayerId )
    2101       break;
    2102   }       
    2103 
    2104   for( Int i = 0; i <= latestDecIdx; i++ )
    2105   {
    2106     if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ i ] ) )
    2107     {
    2108       TComPic* pcPic = ivPicLists->getPic( targetDecLayerIdSet[ i ], curPoc );
    2109       if( pcPic->getSlice(0)->isReferenced() && pcPic->getSlice(0)->getTemporalLayerNonReferenceFlag() )
    2110       {
    2111         Bool remainingInterLayerReferencesFlag = false;
    2112         for( Int j = latestDecIdx + 1; j < numTargetDecLayers; j++ )
    2113         {
    2114           TComVPS* vpsSlice = pcPic->getSlice(0)->getVPS();
    2115           if ( vps->nuhLayerIdIncluded( targetDecLayerIdSet[ j ] ) )
    2116           {
    2117             Int targetDecLayerIdinVPS = vpsSlice->getLayerIdInVps( targetDecLayerIdSet[ j ] );
    2118             for( Int k = 0; k < vpsSlice->getNumDirectRefLayers( targetDecLayerIdinVPS ); k++ )
    2119               if ( targetDecLayerIdSet[ i ] == vpsSlice->getRefLayerId( targetDecLayerIdinVPS,  k  ) )
    2120                 remainingInterLayerReferencesFlag = true;
    2121           }
    2122         }
    2123         if( !remainingInterLayerReferencesFlag )
    2124           pcPic->getSlice(0)->setReferenced( false );                   
    2125       }
    2126     }
    2127   }
    2128 }
    2129 
    2130 Void TComSlice::xPrintRefPicList()
    2131 
    2132   for ( Int li = 0; li < 2; li++)
    2133   {   
    2134     std::cout << std::endl << "RefPicListL" <<  li << ":" << std::endl;
    2135     for (Int rIdx = 0; rIdx <= (m_aiNumRefIdx[li]-1); rIdx ++)
    2136     {     
    2137       if (rIdx == 0 && li == 0) m_apcRefPicList[li][rIdx]->print( true );
    2138        
    2139       m_apcRefPicList[li][rIdx]->print( false );
    2140     }
    2141   }
    2142 }
    2143 #endif
    21441847/** get scaling matrix from RefMatrixID
    21451848 * \param sizeId size index
     
    23642067  {
    23652068    Int spsId = pps->getSPSId();
    2366 #if H_MV
    2367     // active parameter sets per layer should be used here
    2368 #else
    23692069    if (!isIRAP && (spsId != m_activeSPSId))
    23702070    {
     
    23722072      return false;
    23732073    }
    2374 #endif
    23752074    TComSPS *sps = m_spsMap.getPS(spsId);
    23762075    if (sps)
     
    24272126}
    24282127
    2429 #if H_MV
    2430 Void TComPTL::copyLevelFrom( TComPTL* source )
    2431 {
    2432   getGeneralPTL()->setLevelIdc( source->getGeneralPTL()->getLevelIdc() );
    2433   for( Int subLayer = 0; subLayer < 6; subLayer++ )
    2434   {
    2435     setSubLayerLevelPresentFlag( subLayer, source->getSubLayerLevelPresentFlag( subLayer ) );
    2436     getSubLayerPTL( subLayer )->setLevelIdc( source->getSubLayerPTL( subLayer )->getLevelIdc() );
    2437   }
    2438 }
    2439 #endif
    24402128#if SIGNAL_BITRATE_PICRATE_IN_VPS
    24412129TComBitRatePicRateInfo::TComBitRatePicRateInfo()
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/TComSlice.h

    r366 r367  
    5151class TComPic;
    5252class TComTrQuant;
    53 #if H_MV
    54 class TComPicLists;
    55 #endif
    5653// ====================================================================================================================
    5754// Constants
     
    248245  ProfileTierLevel* getGeneralPTL()  { return &m_generalPTL; }
    249246  ProfileTierLevel* getSubLayerPTL(Int i)  { return &m_subLayerPTL[i]; }
    250 #if H_MV
    251   Void copyLevelFrom( TComPTL* source );
    252 #endif
    253247};
    254248/// VPS class
     
    486480
    487481  UInt        m_numHrdParameters;
    488 #if H_MV
    489   UInt        m_maxNuhLayerId;
    490 #else
    491482  UInt        m_maxNuhReservedZeroLayerId;
    492 #endif
    493483  TComHRD*    m_hrdParameters;
    494484  UInt*       m_hrdOpSetIdx;
    495485  Bool*       m_cprmsPresentFlag;
    496486  UInt        m_numOpSets;
    497 #if H_MV
    498   Bool        m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_LAYER_ID_PLUS1];
    499 #else
    500487  Bool        m_layerIdIncludedFlag[MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1];
    501 #endif
    502 
    503 #if H_MV
    504   TComPTL     m_pcPTL[MAX_VPS_OP_SETS_PLUS1];
    505 #else
     488
    506489  TComPTL     m_pcPTL;
    507 #endif
    508490#if SIGNAL_BITRATE_PICRATE_IN_VPS
    509491  TComBitRatePicRateInfo    m_bitRatePicRateInfo;
     
    513495#endif
    514496
    515 #if H_MV
    516   Bool        m_avcBaseLayerFlag;
    517   Bool        m_splittingFlag;
    518   Bool        m_scalabilityMask          [MAX_NUM_SCALABILITY_TYPES];
    519   Int         m_dimensionIdLen           [MAX_NUM_SCALABILITY_TYPES];
    520   Bool        m_vpsNuhLayerIdPresentFlag;
    521   Int         m_layerIdInNuh             [MAX_NUM_LAYER_IDS];
    522   Int         m_layerIdInVps             [MAX_NUM_LAYERS   ];
    523   Int         m_dimensionId              [MAX_NUM_LAYER_IDS][MAX_NUM_SCALABILITY_TYPES]; 
    524 
    525  
    526   Bool        m_vpsProfilePresentFlag    [MAX_VPS_OP_SETS_PLUS1];
    527   Int         m_profileLayerSetRefMinus1 [MAX_VPS_OP_SETS_PLUS1];
    528   Int         m_numOutputLayerSets;
    529   Int         m_outputLayerSetIdx        [MAX_VPS_OP_SETS_PLUS1];
    530   Bool        m_outputLayerFlag          [MAX_VPS_OP_SETS_PLUS1][MAX_VPS_NUH_LAYER_ID_PLUS1];
    531   Bool        m_directDependencyFlag     [MAX_NUM_LAYER_IDS][MAX_NUM_LAYER_IDS];
    532 
    533   Int         m_numDirectRefLayers       [ MAX_NUM_LAYERS ];
    534   Int         m_refLayerId               [ MAX_NUM_LAYERS ][MAX_NUM_LAYERS]; 
    535 
    536 #endif
    537497public:
    538498  TComVPS();
     
    576536  Void    setNumHrdParameters(UInt v)                           { m_numHrdParameters = v;    }
    577537
    578 #if H_MV
    579   UInt    getMaxNuhLayerId()                                    { return m_maxNuhLayerId; }
    580   Void    setMaxNuhLayerId(UInt v)                              { m_maxNuhLayerId = v;    }
    581 #else
    582538  UInt    getMaxNuhReservedZeroLayerId()                        { return m_maxNuhReservedZeroLayerId; }
    583539  Void    setMaxNuhReservedZeroLayerId(UInt v)                  { m_maxNuhReservedZeroLayerId = v;    }
    584 #endif
    585540
    586541  UInt    getMaxOpSets()                                        { return m_numOpSets; }
     
    589544  Void    setLayerIdIncludedFlag(Bool v, UInt opsIdx, UInt id)  { m_layerIdIncludedFlag[opsIdx][id] = v;    }
    590545
    591 #if H_MV
    592   TComPTL* getPTL( Int layerSet = 0 ) { return &m_pcPTL[layerSet]; }
    593 #else
    594546  TComPTL* getPTL() { return &m_pcPTL; }
    595 #endif
    596547#if SIGNAL_BITRATE_PICRATE_IN_VPS
    597548  TComBitRatePicRateInfo *getBitratePicrateInfo() { return &m_bitRatePicRateInfo; }
     
    599550#if L0043_TIMING_INFO
    600551  TimingInfo* getTimingInfo() { return &m_timingInfo; }
    601 #endif
    602 #if H_MV
    603   Void    setAvcBaseLayerFlag( Bool val )                                  { m_avcBaseLayerFlag = val;  }
    604   Bool    getAvcBaseLayerFlag()                                            { return m_avcBaseLayerFlag; }
    605 
    606   Void    setSplittingFlag( Bool val )                                     { m_splittingFlag = val;  }
    607   Bool    getSplittingFlag()                                               { return m_splittingFlag; }
    608 
    609   Void    setScalabilityMask( UInt val );
    610 
    611   Void    setScalabilityMask( Int scalType, Bool val )              { m_scalabilityMask[scalType] = val;  }
    612   Bool    getScalabilityMask( Int scalType )                        { return m_scalabilityMask[scalType]; }
    613 
    614   Int     getNumScalabilityTypes( );
    615 
    616   Void    setDimensionIdLen( Int sIdx, Int val )                           { m_dimensionIdLen[sIdx] = val;  }
    617   Int     getDimensionIdLen( Int sIdx )                                    { assert( m_dimensionIdLen[sIdx] > 0) ; return m_dimensionIdLen[sIdx]; } 
    618 
    619   Void    setVpsNuhLayerIdPresentFlag( Bool val )                          { m_vpsNuhLayerIdPresentFlag = val; }
    620   Bool    getVpsNuhLayerIdPresentFlag()                                    { return m_vpsNuhLayerIdPresentFlag; }
    621 
    622   Void    setLayerIdInNuh( Int layerIdInVps, Int val )                     { m_layerIdInNuh[layerIdInVps] = val;  }
    623   Int     getLayerIdInNuh( Int layerIdInVps )                              { assert( m_layerIdInNuh[layerIdInVps] >= 0 ); return m_layerIdInNuh[layerIdInVps]; }
    624 
    625   Void    setLayerIdInVps( Int layerIdInNuh, Int val )                     { m_layerIdInVps[layerIdInNuh] = val;  }
    626   Int     getLayerIdInVps( Int layerIdInNuh )                              { assert( m_layerIdInVps[layerIdInNuh] >= 0 ); return m_layerIdInVps[layerIdInNuh]; }
    627 
    628   Bool    nuhLayerIdIncluded( Int layerIdinNuh )                           { return ( m_layerIdInVps[ layerIdinNuh ] > 0 );  }
    629 
    630   Void    setDimensionId( Int layerIdInVps, Int scalIdx, Int val )         { m_dimensionId[layerIdInVps][scalIdx] = val;  }
    631   Int     getDimensionId( Int layerIdInVps, Int scalIdx )                  { return m_dimensionId[layerIdInVps][scalIdx]; }
    632 
    633   Int     getScalabilityId ( Int layerIdInVps, ScalabilityType scalType );
    634 
    635   Int     getViewId  ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, VIEW_ID  ); }
    636 #if H_3D 
    637   Int     getDepthId ( Int layerIdInVps )                                  { return getScalabilityId( layerIdInVps, DEPTH_ID ); }
    638 #endif
    639 
    640 
    641   Void    setVpsProfilePresentFlag( Int layerSet, Bool val )               { m_vpsProfilePresentFlag[layerSet] = val;  }
    642   Bool    getVpsProfilePresentFlag( Int layerSet )                         { return m_vpsProfilePresentFlag[layerSet]; }
    643 
    644   Void    setProfileLayerSetRefMinus1( Int layerSet, Int val )             { m_profileLayerSetRefMinus1[layerSet] = val;  }
    645   Bool    getProfileLayerSetRefMinus1( Int layerSet )                      { return m_profileLayerSetRefMinus1[layerSet]; }
    646 
    647   Void    setNumOutputLayerSets( Int val )                                 { m_numOutputLayerSets = val;  }
    648   Int     getNumOutputLayerSets()                                          { return m_numOutputLayerSets; }
    649 
    650   Void    setOutputLayerSetIdx( Int layerSet, Int val )                    { m_outputLayerSetIdx[layerSet] = val;  }
    651   Int     getOutputLayerSetIdx( Int layerSet )                             { return m_outputLayerSetIdx[layerSet]; }
    652 
    653   Void    setOutputLayerFlag( Int layerSet, Int layer, Bool val )          { m_outputLayerFlag[layerSet][layer] = val;  }
    654   Bool    getOutputLayerFlag( Int layerSet, Int layer )                    { return m_outputLayerFlag[layerSet][layer]; }
    655 
    656   Void    setDirectDependencyFlag( Int layerHigh, Int layerLow, Bool val ) { m_directDependencyFlag[layerHigh][layerLow] = val;  }
    657   Bool    getDirectDependencyFlag( Int layerHigh, Int layerLow )           { return m_directDependencyFlag[layerHigh][layerLow]; }
    658 
    659   Void    calcIvRefLayers();
    660 
    661   Int     getNumDirectRefLayers( Int layerIdInVps )          { return m_numDirectRefLayers[ layerIdInVps ];  };                               
    662   Int     getRefLayerId        ( Int layerIdInVps, Int idx );;
    663  
    664   Bool    checkVPSExtensionSyntax();
    665   Int     scalTypeToScalIdx   ( ScalabilityType scalType );
    666552#endif
    667553};
     
    967853  static const Int   m_winUnitY[MAX_CHROMA_FORMAT_IDC+1];
    968854  TComPTL     m_pcPTL;
    969 #if H_MV
    970   Bool        m_interViewMvVertConstraintFlag;
    971 #endif
    972855public:
    973856  TComSPS();
     
    1100983
    1101984  TComPTL* getPTL()     { return &m_pcPTL; }
    1102 #if H_MV
    1103   Void setInterViewMvVertConstraintFlag(Bool val) { m_interViewMvVertConstraintFlag = val; }
    1104   Bool getInterViewMvVertConstraintFlag()         { return m_interViewMvVertConstraintFlag;}
    1105 #endif
    1106985};
    1107986
     
    11301009  Void       setRefPicSetIdxL1(UInt idx, UInt refPicSetIdx) { m_RefPicSetIdxL1[idx] = refPicSetIdx; }
    11311010  UInt       getRefPicSetIdxL1(UInt idx) { return m_RefPicSetIdxL1[idx]; }
    1132 #if H_MV
    1133   // Why not an listIdx for all members, would avoid code duplication??
    1134   Void       setRefPicSetIdxL(UInt li, UInt idx, UInt refPicSetIdx) {( li==0 ? m_RefPicSetIdxL0[idx] : m_RefPicSetIdxL1[idx] ) = refPicSetIdx; };
    1135   Void       setRefPicListModificationFlagL(UInt li, Bool flag) { ( li==0  ? m_bRefPicListModificationFlagL0 : m_bRefPicListModificationFlagL1 ) = flag;  }; 
    1136 #endif
    11371011};
    11381012
     
    13891263  TComPic*    m_apcRefPicList [2][MAX_NUM_REF+1];
    13901264  Int         m_aiRefPOCList  [2][MAX_NUM_REF+1];
    1391 #if H_MV
    1392   Int         m_aiRefLayerIdList[2][MAX_NUM_REF+1];
    1393 #endif
    13941265  Bool        m_bIsUsedAsLongTerm[2][MAX_NUM_REF+1];
    13951266  Int         m_iDepth;
     
    14571328
    14581329  Bool       m_enableTMVPFlag;
    1459 #if H_MV
    1460   Int        m_layerId;
    1461   Int        m_viewId;
    1462 #if H_3D
    1463   Bool       m_isDepth;
    1464 #endif
    1465 #endif
    14661330public:
    14671331  TComSlice();
     
    15701434  Void      setDepth            ( Int iDepth )                  { m_iDepth            = iDepth; }
    15711435 
    1572 #if H_MV
    1573   Int       getRefLayerId        ( RefPicList e, Int iRefIdx)    { return  m_aiRefLayerIdList[e][iRefIdx]; }
    1574   Void      setRefLayerId        ( Int i, RefPicList e, Int iRefIdx ) { m_aiRefLayerIdList[e][iRefIdx] = i; }
    1575 #endif
    1576 #if H_MV
    1577   Void      setRefPicList       ( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& interLayerRefPicSet , Bool checkNumPocTotalCurr = false );
    1578 #else
    15791436#if FIX1071
    15801437  Void      setRefPicList       ( TComList<TComPic*>& rcListPic, Bool checkNumPocTotalCurr = false );
    15811438#else
    15821439  Void      setRefPicList       ( TComList<TComPic*>& rcListPic );
    1583 #endif
    15841440#endif
    15851441  Void      setRefPOCList       ();
     
    16291485  Void decodingMarking( TComList<TComPic*>& rcListPic, Int iGOPSIze, Int& iMaxRefPicNum );
    16301486  Void applyReferencePictureSet( TComList<TComPic*>& rcListPic, TComReferencePictureSet *RPSList);
    1631 #if H_MV
    1632   Void createAndApplyIvReferencePictureSet( TComPicLists* ivPicLists, std::vector<TComPic*>& refPicSetInterLayer );
    1633   static Void markIvRefPicsAsShortTerm    ( std::vector<TComPic*> refPicSetInterLayer );
    1634   static Void markIvRefPicsAsUnused       ( TComPicLists* ivPicLists, std::vector<Int> targetDecLayerIdSet, TComVPS* vps, Int curLayerId, Int curPoc  );
    1635 
    1636 
    1637   Void xPrintRefPicList();
    1638 #endif
    16391487  Bool isTemporalLayerSwitchingPoint( TComList<TComPic*>& rcListPic );
    16401488  Bool isStepwiseTemporalLayerSwitchingPointCandidate( TComList<TComPic*>& rcListPic );
     
    17121560  Bool      getEnableTMVPFlag     ()              { return m_enableTMVPFlag;}
    17131561
    1714 #if H_MV
    1715   Void      setLayerId            ( Int layerId )    { m_layerId      = layerId; }
    1716   Int       getLayerId            ()                 { return m_layerId;    }
    1717   Int       getLayerIdInVps       ()                 { return getVPS()->getLayerIdInVps( m_layerId ); };
    1718   Void      setViewId             ( Int viewId )     { m_viewId = viewId;   }
    1719   Int       getViewId             ()                 { return m_viewId;     }
    1720 #if H_3D
    1721   Void      setIsDepth            ( Bool isDepth )   { m_isDepth = isDepth; }
    1722   Bool      getIsDepth            ()                 { return m_isDepth; }
    1723 #endif
    1724 #endif
    17251562protected:
    17261563  TComPic*  xGetRefPic  (TComList<TComPic*>& rcListPic,
    17271564                         Int                 poc);
    17281565TComPic*  xGetLongTermRefPic(TComList<TComPic*>& rcListPic, Int poc, Bool pocHasMsb);
    1729 #if H_MV
    1730   TComPic*  xGetInterLayerRefPic( std::vector<TComPic*>& rcListIlPic, Int layerId );
    1731 #endif
    17321566};// END CLASS DEFINITION TComSlice
    17331567
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibCommon/TypeDef.h

    r364 r367  
    4545
    4646
    47 #if H_MV
    48 #define H_3D                        0
    49 #endif
    5047
    5148///// ***** HM 10.1 *********
     
    9188#define MAX_VPS_NUM_HRD_PARAMETERS                1
    9289#define MAX_VPS_OP_SETS_PLUS1                     1024
    93 #if H_MV
    94 #define MAX_VPS_NUH_LAYER_ID_PLUS1  64
    95 #define MAX_NUM_SCALABILITY_TYPES   16
    96 #define ENC_CFG_CONSOUT_SPACE       29           
    97 #else
    9890#define MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1  1
    99 #endif
    10091
    10192#define RATE_CONTROL_LAMBDA_DOMAIN                  1  ///< JCTVC-K0103, rate control by R-lambda model
     
    10495#define MAX_CPB_CNT                     32  ///< Upper bound of (cpb_cnt_minus1 + 1)
    10596#define MAX_NUM_LAYER_IDS               64
    106 #if H_MV
    107 #define MAX_NUM_LAYERS                  64
    108 #endif
    10997
    11098#define COEF_REMAIN_BIN_REDUCTION        3 ///< indicates the level at which the VLC
     
    521509    MAIN10 = 2,
    522510    MAINSTILLPICTURE = 3,
    523 #if H_MV
    524     MAINSTEREO = 4,
    525     MAINMULTIVIEW = 5,
    526 #if H_3D
    527     MAIN3D = 6,
    528 #endif
    529 #endif
    530511  };
    531512}
     
    559540//! \}
    560541
    561 #if H_MV
    562 /// scalability types
    563   enum ScalabilityType
    564   {
    565     VIEW_ID  = 0,
    566 #if H_3D
    567     DEPTH_ID = 1,
    568 #endif   
    569   };
    570 #endif
    571 #endif
     542#endif
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibDecoder/NALread.cpp

    r362 r367  
    103103  assert(forbidden_zero_bit == 0);
    104104  nalu.m_nalUnitType = (NalUnitType) bs.read(6);  // nal_unit_type
    105 #if H_MV
    106   nalu.m_layerId = bs.read(6);                 // layerId
    107 #else
    108105  nalu.m_reservedZero6Bits = bs.read(6);       // nuh_reserved_zero_6bits
    109106  assert(nalu.m_reservedZero6Bits == 0);
    110 #endif
    111107  nalu.m_temporalId = bs.read(3) - 1;             // nuh_temporal_id_plus1
    112108
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibDecoder/TDecCAVLC.cpp

    r362 r367  
    680680  if (uiCode)
    681681  {
    682 #if H_MV
    683     READ_FLAG( uiCode, "inter_view_mv_vert_constraint_flag" );    pcSPS->setInterViewMvVertConstraintFlag(uiCode == 1 ? true : false);
    684 #else
    685682    while ( xMoreRbspData() )
    686683    {
    687684      READ_FLAG( uiCode, "sps_extension_data_flag");
    688685    }
    689 #endif
    690686  }
    691687}
     
    697693  READ_CODE( 4,  uiCode,  "vps_video_parameter_set_id" );         pcVPS->setVPSId( uiCode );
    698694  READ_CODE( 2,  uiCode,  "vps_reserved_three_2bits" );           assert(uiCode == 3);
    699 #if H_MV
    700   READ_CODE( 6,  uiCode,  "vps_max_layers_minus1" );              pcVPS->setMaxLayers( uiCode + 1 );
    701 #else
    702695  READ_CODE( 6,  uiCode,  "vps_reserved_zero_6bits" );            assert(uiCode == 0);
    703 #endif
    704696  READ_CODE( 3,  uiCode,  "vps_max_sub_layers_minus1" );          pcVPS->setMaxTLayers( uiCode + 1 );
    705697  READ_FLAG(     uiCode,  "vps_temporal_id_nesting_flag" );       pcVPS->setTemporalNestingFlag( uiCode ? true:false );
    706698  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
    707 #if H_MV
    708   READ_CODE( 16, uiCode,  "vps_extension_offset" );               
    709 #else
    710699  READ_CODE( 16, uiCode,  "vps_reserved_ffff_16bits" );           assert(uiCode == 0xffff);
    711 #endif
    712700  parsePTL ( pcVPS->getPTL(), true, pcVPS->getMaxTLayers()-1);
    713701#if SIGNAL_BITRATE_PICRATE_IN_VPS
     
    739727
    740728  assert( pcVPS->getNumHrdParameters() < MAX_VPS_OP_SETS_PLUS1 );
    741 #if H_MV
    742   assert( pcVPS->getMaxNuhLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
    743   READ_CODE( 6, uiCode, "vps_max_nuh_layer_id" );   pcVPS->setMaxNuhLayerId( uiCode );
    744 #else
    745729  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
    746730  READ_CODE( 6, uiCode, "vps_max_nuh_reserved_zero_layer_id" );   pcVPS->setMaxNuhReservedZeroLayerId( uiCode );
    747 #endif
    748731  READ_UVLC(    uiCode, "vps_max_op_sets_minus1" );               pcVPS->setMaxOpSets( uiCode + 1 );
    749732  for( UInt opsIdx = 1; opsIdx <= ( pcVPS->getMaxOpSets() - 1 ); opsIdx ++ )
    750733  {
    751734    // Operation point set
    752 #if H_MV
    753     for( UInt i = 0; i <= pcVPS->getMaxNuhLayerId(); i ++ )
    754 #else
    755735    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
    756 #endif
    757736    {
    758737      READ_FLAG( uiCode, "layer_id_included_flag[opsIdx][i]" );     pcVPS->setLayerIdIncludedFlag( uiCode == 1 ? true : false, opsIdx, i );
     
    793772  if (uiCode)
    794773  {
    795 #if H_MV
    796     m_pcBitstream->readOutTrailingBits();
    797 
    798     READ_FLAG( uiCode, "avc_base_layer_flag" );                     pcVPS->setAvcBaseLayerFlag( uiCode == 1 ? true : false );
    799     READ_FLAG( uiCode, "splitting_flag" );                          pcVPS->setSplittingFlag( uiCode == 1 ? true : false );
    800 
    801     // Parse scalability_mask[i]   
    802     for( Int sIdx = 0; sIdx < MAX_NUM_SCALABILITY_TYPES; sIdx++ )
    803     {
    804       READ_FLAG( uiCode,  "scalability_mask[i]" );                  pcVPS->setScalabilityMask( sIdx, uiCode == 1 ? true : false );     
    805     }
    806 
    807     Int numScalabilityTypes = pcVPS->getNumScalabilityTypes();
    808 
    809     // Parse dimension_id_len_minus1[j]   
    810     for( Int sIdx = 0; sIdx < numScalabilityTypes; sIdx++ )
    811     {
    812         READ_CODE( 3, uiCode, "dimension_id_len_minus1[j]" );       pcVPS->setDimensionIdLen( sIdx, uiCode + 1 );
    813     }
    814 
    815     // vps_nuh_layer_id_present_flag
    816     READ_FLAG( uiCode, "vps_nuh_layer_id_present_flag" );           pcVPS->setVpsNuhLayerIdPresentFlag( uiCode == 1 ? true : false );
    817 
    818     // parse layer_id_in_nuh[i] and derive LayerIdInVps
    819     pcVPS->setLayerIdInNuh( 0, 0 ); pcVPS->setLayerIdInVps( 0, 0 );
    820    
    821     for( Int layer = 1; layer <= pcVPS->getMaxLayers() - 1; layer++ )
    822     {
    823       UInt layerIdInNuh;
    824       if ( pcVPS->getVpsNuhLayerIdPresentFlag() )
    825       {
    826         READ_CODE( 6, uiCode, "layer_id_in_nuh[i]" );                layerIdInNuh = uiCode;
    827       }
    828       else
    829       {
    830         layerIdInNuh = layer;
    831       }     
    832 
    833       pcVPS->setLayerIdInNuh( layer, layerIdInNuh );
    834       pcVPS->setLayerIdInVps( layerIdInNuh, layer );
    835 
    836       // parse dimension_id[i][j]
    837       for( Int sIdx = 0; sIdx < numScalabilityTypes; sIdx++ )
    838       {
    839           READ_CODE( pcVPS->getDimensionIdLen( sIdx ), uiCode, "dimension_id[i][j]" );  pcVPS->setDimensionId( layer, sIdx, uiCode );
    840       }
    841     }
    842 
    843     for( Int layerSet = 1; layerSet <= pcVPS->getMaxOpSets() - 1; layerSet++ )
    844     {
    845       READ_FLAG(  uiCode, "vps_profile_present_flag[lsIdx]" );    pcVPS->setVpsProfilePresentFlag( layerSet, uiCode == 1 ? true : false );
    846       if( pcVPS->getVpsProfilePresentFlag( layerSet ) == false )
    847       {
    848         READ_UVLC( uiCode, "profile_layer_set_ref_minus1[lsIdx]" ); pcVPS->setProfileLayerSetRefMinus1( layerSet, uiCode );
    849       }
    850 
    851       parsePTL ( pcVPS->getPTL( layerSet ), pcVPS->getVpsProfilePresentFlag( layerSet ), pcVPS->getMaxTLayers()-1);
    852       if( pcVPS->getVpsProfilePresentFlag( layerSet ) == false )
    853       {
    854         TComPTL temp = *pcVPS->getPTL( layerSet );
    855         *pcVPS->getPTL( layerSet ) = *pcVPS->getPTL( pcVPS->getProfileLayerSetRefMinus1( layerSet ) + 1 );
    856         pcVPS->getPTL( layerSet )->copyLevelFrom( &temp );
    857       }
    858     }
    859 
    860     READ_UVLC( uiCode, "num_output_layer_sets" );                  pcVPS->setNumOutputLayerSets( uiCode );
    861    
    862     for( Int layerSet = 0; layerSet < pcVPS->getNumOutputLayerSets(); layerSet++ )
    863     {
    864       READ_UVLC( uiCode, "output_layer_set_idx[i]" );              pcVPS->setOutputLayerSetIdx( layerSet, uiCode );
    865       for( Int layer = 0; layer <= pcVPS->getMaxNuhLayerId(); layer++ )
    866       {
    867         if( pcVPS->getLayerIdIncludedFlag( pcVPS->getOutputLayerSetIdx( layerSet ), layer ) == true )
    868         {
    869           READ_FLAG( uiCode, "output_layer_flag" );                 pcVPS->setOutputLayerFlag( layerSet, layer, uiCode == 1 ? true : false );
    870         }
    871       }
    872     }
    873 
    874     for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    875     {
    876       for( Int j = 0; j < i; j++ )
    877       {
    878         READ_FLAG( uiCode, "direct_dependency_flag[i][j]" );             pcVPS->setDirectDependencyFlag( i, j, uiCode );
    879       }
    880     }
    881    
    882     READ_FLAG( uiCode,  "vps_extension2_flag" );
    883     if (uiCode)
    884     {
    885       while ( xMoreRbspData() )
    886       {
    887         READ_FLAG( uiCode, "vps_extension2_data_flag");
    888       }
    889     }
    890 
    891     pcVPS->checkVPSExtensionSyntax();
    892 
    893     pcVPS->calcIvRefLayers();
    894 
    895 #else
    896774    while ( xMoreRbspData() )
    897775    {
    898776      READ_FLAG( uiCode, "vps_extension_data_flag");
    899777    }
    900 #endif   
    901778  }
    902779 
     
    914791  TComPPS* pps = NULL;
    915792  TComSPS* sps = NULL;
    916 #if H_MV
    917   TComVPS* vps = NULL;
    918 #endif
    919793
    920794  UInt firstSliceSegmentInPic;
     
    931805  //!KS: need to add error handling code here, if SPS is not available
    932806  assert(sps!=0);
    933 #if H_MV
    934   vps = parameterSetManager->getPrefetchedVPS(sps->getVPSId());
    935   assert(vps!=0);
    936   rpcSlice->setVPS(vps);
    937 #endif
    938807  rpcSlice->setSPS(sps);
    939808  rpcSlice->setPPS(pps);
     
    15231392  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
    15241393  {
    1525 #if !H_MV
    15261394    if(profilePresentFlag)
    15271395    {
    1528 #endif
    15291396      READ_FLAG( uiCode, "sub_layer_profile_present_flag[i]" ); rpcPTL->setSubLayerProfilePresentFlag(i, uiCode);
    1530 #if H_MV
    1531     rpcPTL->setSubLayerProfilePresentFlag( i, profilePresentFlag && rpcPTL->getSubLayerProfilePresentFlag(i) );
    1532 #else
    1533     }
    1534 #endif
     1397    }
    15351398    READ_FLAG( uiCode, "sub_layer_level_present_flag[i]"   ); rpcPTL->setSubLayerLevelPresentFlag  (i, uiCode);
    15361399  }
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibDecoder/TDecGop.cpp

    r364 r367  
    205205  }
    206206
    207 #if !H_3D
    208207  rpcPic->compressMotion();
    209 #endif
    210208  Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
    211209  if (!pcSlice->isReferenced()) c += 32;
    212210
    213211  //-- For time output for each slice
    214 #if H_MV
    215   printf("\nLayer %2d   POC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getLayerId(),
    216                                                               pcSlice->getPOC(),
    217                                                               pcSlice->getTLayer(),
    218                                                               c,
    219                                                               pcSlice->getSliceQp() );
    220 #else
    221212  printf("\nPOC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getPOC(),
    222213                                                    pcSlice->getTLayer(),
    223214                                                    c,
    224215                                                    pcSlice->getSliceQp() );
    225 #endif
    226216
    227217  m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
     
    234224    for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
    235225    {
    236 #if H_MV
    237       if( pcSlice->getLayerId() != pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) )
    238       {
    239         printf( "V%d ", pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) );
    240       }
    241       else
    242       {
    243 #endif
    244226      printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex));
    245 #if H_MV
    246       }
    247 #endif
    248227    }
    249228    printf ("] ");
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibDecoder/TDecTop.cpp

    r364 r367  
    3939#include "TDecTop.h"
    4040
    41 #if H_MV
    42 ParameterSetManagerDecoder TDecTop::m_parameterSetManagerDecoder;
    43 #endif
    4441//! \ingroup TLibDecoder
    4542//! \{
     
    6057  m_bFirstSliceInPicture    = true;
    6158  m_bFirstSliceInSequence   = true;
    62 #if H_MV
    63   m_layerId = 0;
    64   m_viewId = 0;
    65 #if H_3D
    66   m_isDepth = false;
    67 #endif
    68 #endif
    6959}
    7060
     
    9686{
    9787  // initialize ROM
    98 #if !H_MV
    9988  initROM();
    100 #endif
    10189  m_cGopDecoder.init( &m_cEntropyDecoder, &m_cSbacDecoder, &m_cBinCABAC, &m_cCavlcDecoder, &m_cSliceDecoder, &m_cLoopFilter, &m_cSAO);
    10290  m_cSliceDecoder.init( &m_cEntropyDecoder, &m_cCuDecoder );
     
    112100  {
    113101    TComPic* pcPic = *(iterPic++);
    114 #if H_MV
    115     if( pcPic )
    116     {
    117 #endif
    118102    pcPic->destroy();
    119103   
    120104    delete pcPic;
    121105    pcPic = NULL;
    122 #if H_MV
    123     }
    124 #endif
    125106  }
    126107 
     
    129110  m_cLoopFilter.        destroy();
    130111 
    131 #if !H_MV
    132112  // destroy ROM
    133113  destroyROM();
    134 #endif
    135114}
    136115
     
    198177}
    199178
    200 #if H_MV
    201 Void TDecTop::endPicDecoding(Int& poc, TComList<TComPic*>*& rpcListPic, std::vector<Int>& targetDecLayerIdSet )
    202 #else
    203179Void TDecTop::executeLoopFilters(Int& poc, TComList<TComPic*>*& rpcListPic)
    204 #endif
    205180{
    206181  if (!m_pcPic)
     
    220195  rpcListPic          = &m_cListPic; 
    221196  m_cCuDecoder.destroy();       
    222 #if H_MV
    223   TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer ); 
    224   TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, targetDecLayerIdSet, m_parameterSetManagerDecoder.getActiveVPS(), m_layerId, poc );
    225 #endif
    226197  m_bFirstSliceInPicture  = true;
    227198
     
    340311}
    341312
    342 #if H_MV
    343 Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag )
    344 {
    345   assert( nalu.m_layerId == m_layerId );
    346 
    347 #else
    348313Bool TDecTop::xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay )
    349314{
    350 #endif
    351315  TComPic*&   pcPic         = m_pcPic;
    352316  m_apcSlicePilot->initSlice();
     
    373337  m_apcSlicePilot->setTLayerInfo(nalu.m_temporalId);
    374338
    375 #if H_MV
    376   m_apcSlicePilot->setLayerId( nalu.m_layerId );
    377 #endif
    378339  m_cEntropyDecoder.decodeSliceHeader (m_apcSlicePilot, &m_parameterSetManagerDecoder);
    379340
    380 #if H_MV 
    381   TComVPS* vps     = m_apcSlicePilot->getVPS();
    382   Int layerIdInVps = vps->getLayerIdInVps( nalu.m_layerId );
    383  
    384   setViewId(  vps->getViewId( layerIdInVps  ) );
    385   m_apcSlicePilot->setViewId( getViewId() );
    386 #if H_3D
    387   setIsDepth( vps->getDepthId( layerIdInVps ) == 1 );
    388   m_apcSlicePilot->setIsDepth( getIsDepth() );
    389 #endif
    390 #endif
    391341    // Skip pictures due to random access
    392342    if (isRandomAccessSkipPicture(iSkipFrame, iPOCLastDisplay))
     
    415365    m_prevPOC = m_apcSlicePilot->getPOC();
    416366  }
    417 #if H_MV
    418   if ( newLayerFlag )
    419   {
    420     return false;
    421   }
    422 #endif
    423367  // actual decoding starts here
    424368  xActivateParameterSets();
     
    440384    m_cPrediction.initTempBuff();
    441385    m_apcSlicePilot->applyReferencePictureSet(m_cListPic, m_apcSlicePilot->getRPS());
    442 #if H_MV
    443     m_apcSlicePilot->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer );
    444 #endif
    445386    //  Get a new picture buffer
    446387    xGetNewPicBuffer (m_apcSlicePilot, pcPic);
     
    574515  pcPic->setTLayer(nalu.m_temporalId);
    575516
    576 #if H_MV
    577   pcPic->setLayerId( nalu.m_layerId );
    578   pcPic->setViewId ( getViewId() );
    579 #if H_3D
    580   pcPic->setIsDepth( getIsDepth() );
    581 #endif
    582 #endif
    583517  if (bNextSlice)
    584518  {
    585519    pcSlice->checkCRA(pcSlice->getRPS(), m_pocCRA, m_prevRAPisBLA, m_cListPic );
    586520    // Set reference list
    587 #if H_MV   
    588     pcSlice->setRefPicList( m_cListPic, m_refPicSetInterLayer, true );   
    589 #else
    590521#if FIX1071
    591522    pcSlice->setRefPicList( m_cListPic, true );
     
    594525#endif
    595526
    596 #endif
    597527    // For generalized B
    598528    // note: maybe not existed case (always L0 is copied to L1 if L1 is empty)
     
    732662}
    733663
    734 #if H_MV
    735 Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayerFlag)
    736 #else
    737664Bool TDecTop::decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay)
    738 #endif
    739665{
    740666  // Initialize entropy decoder
     
    777703    case NAL_UNIT_CODED_SLICE_RASL_N:
    778704    case NAL_UNIT_CODED_SLICE_RASL_R:
    779 #if H_MV
    780       return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay, newLayerFlag);
    781 #else
    782705      return xDecodeSlice(nalu, iSkipFrame, iPOCLastDisplay);
    783 #endif
    784706      break;
    785707    default:
     
    861783}
    862784
    863 #if H_MV
    864 TComPic* TDecTop::getPic( Int poc )
    865 {
    866   xGetPic( m_layerId, poc );
    867   TComList<TComPic*>* listPic = getListPic();
    868   TComPic* pcPic = NULL;
    869   for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
    870   {
    871     if( (*it)->getPOC() == poc )
    872     {
    873       pcPic = *it ;
    874       break ;
    875     }
    876   }
    877   return pcPic;
    878 }
    879 
    880 TComPic* TDecTop::xGetPic( Int layerId, Int poc )
    881 {
    882   return m_ivPicLists->getPic( layerId, poc ) ;
    883 }
    884 
    885 #endif
    886785//! \}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibDecoder/TDecTop.h

    r366 r367  
    6161// ====================================================================================================================
    6262
    63 #if H_MV
    64 class TAppDecTop;
    65 #endif
    6663/// decoder class
    6764class TDecTop
     
    7572
    7673  TComList<TComPic*>      m_cListPic;         //  Dynamic buffer
    77 #if H_MV
    78   static ParameterSetManagerDecoder m_parameterSetManagerDecoder;  // storage for parameter sets
    79 #else
    8074  ParameterSetManagerDecoder m_parameterSetManagerDecoder;  // storage for parameter sets
    81 #endif
    8275  TComSlice*              m_apcSlicePilot;
    8376 
     
    10598  Bool                    m_bFirstSliceInPicture;
    10699  Bool                    m_bFirstSliceInSequence;
    107 #if H_MV
    108   // For H_MV m_bFirstSliceInSequence indicates first slice in sequence of the particular layer 
    109   Int                     m_layerId;
    110   Int                     m_viewId;
    111   TComPicLists*           m_ivPicLists;
    112   std::vector<TComPic*>   m_refPicSetInterLayer;
    113 #if H_3D
    114   Bool                    m_isDepth;
    115 #endif
    116 #endif
    117100
    118101public:
     
    126109
    127110  Void  init();
    128 #if H_MV 
    129   Bool  decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay, Bool newLayer );
    130 #else 
    131111  Bool  decode(InputNALUnit& nalu, Int& iSkipFrame, Int& iPOCLastDisplay);
    132 #endif
    133112 
    134113  Void  deletePicBuffer();
    135114
    136 #if H_MV
    137   Void endPicDecoding(Int& poc, TComList<TComPic*>*& rpcListPic,  std::vector<Int>& targetDecLayerIdSet); 
    138 #else
    139115  Void executeLoopFilters(Int& poc, TComList<TComPic*>*& rpcListPic);
    140 #endif
    141116 
    142 #if H_MV   
    143   TComPic*                getPic                ( Int poc );
    144   TComList<TComPic*>*     getListPic            ()               { return &m_cListPic;  } 
    145   Void                    setIvPicLists         ( TComPicLists* picLists) { m_ivPicLists = picLists; }
    146  
    147   Int                     getCurrPoc            ()               { return m_apcSlicePilot->getPOC(); }
    148   Void                    setLayerId            ( Int layer)     { m_layerId = layer;   }
    149   Int                     getLayerId            ()               { return m_layerId;    }
    150   Void                    setViewId             ( Int viewId  )  { m_viewId  = viewId;  }
    151   Int                     getViewId             ()               { return m_viewId;     } 
    152 #if H_3D   
    153   Void                    setIsDepth            ( Bool isDepth ) { m_isDepth = isDepth; }
    154   Bool                    getIsDepth            ()               { return m_isDepth;    }
    155 #endif
    156 #endif
    157117protected:
    158118  Void  xGetNewPicBuffer  (TComSlice* pcSlice, TComPic*& rpcPic);
     
    160120
    161121  Void      xActivateParameterSets();
    162 #if H_MV 
    163   TComPic*  xGetPic( Int layerId, Int poc );
    164   Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay, Bool newLayerFlag ); 
    165 #else
    166122  Bool      xDecodeSlice(InputNALUnit &nalu, Int &iSkipFrame, Int iPOCLastDisplay);
    167 #endif
    168123  Void      xDecodeVPS();
    169124  Void      xDecodeSPS();
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/NALwrite.cpp

    r324 r367  
    5353  bsNALUHeader.write(0,1);                    // forbidden_zero_bit
    5454  bsNALUHeader.write(nalu.m_nalUnitType, 6);  // nal_unit_type
    55 #if H_MV
    56   bsNALUHeader.write(nalu.m_layerId, 6);      // layerId       
    57 #else
    5855  bsNALUHeader.write(nalu.m_reservedZero6Bits, 6);                   // nuh_reserved_zero_6bits
    59 #endif
    6056  bsNALUHeader.write(nalu.m_temporalId+1, 3); // nuh_temporal_id_plus1
    6157
     
    146142{
    147143  naluDest.m_nalUnitType = naluSrc.m_nalUnitType;
    148 #if H_MV
    149   naluDest.m_layerId  = naluSrc.m_layerId;
    150 #else
    151144  naluDest.m_reservedZero6Bits  = naluSrc.m_reservedZero6Bits;
    152 #endif
    153145  naluDest.m_temporalId  = naluSrc.m_temporalId;
    154146  naluDest.m_Bitstream   = naluSrc.m_Bitstream;
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/NALwrite.h

    r324 r367  
    5757    NalUnitType nalUnitType,
    5858    UInt temporalID = 0,
    59 #if H_MV
    60     Int layerId = 0)
    61 #else
    6259    UInt reserved_zero_6bits = 0)
    63 #endif
    64 #if H_MV
    65   : NALUnit(nalUnitType, temporalID, layerId)
    66 #else
    6760  : NALUnit(nalUnitType, temporalID, reserved_zero_6bits)
    68 #endif
    6961  , m_Bitstream()
    7062  {}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncAnalyze.cpp

    r324 r367  
    3636*/
    3737
    38 #if !H_MV
    3938#include "TEncAnalyze.h"
    40 #endif
    4139
    4240//! \ingroup TLibEncoder
     
    4745//////////////////////////////////////////////////////////////////////
    4846
    49 #if !H_MV
    5047TEncAnalyze             m_gcAnalyzeAll;
    5148TEncAnalyze             m_gcAnalyzeI;
    5249TEncAnalyze             m_gcAnalyzeP;
    5350TEncAnalyze             m_gcAnalyzeB;
    54 #endif
    5551
    5652//! \}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncAnalyze.h

    r324 r367  
    150150};
    151151
    152 #if !H_MV
    153152extern TEncAnalyze             m_gcAnalyzeAll;
    154153extern TEncAnalyze             m_gcAnalyzeI;
    155154extern TEncAnalyze             m_gcAnalyzeP;
    156155extern TEncAnalyze             m_gcAnalyzeB;
    157 #endif
    158156
    159157//! \}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncCavlc.cpp

    r366 r367  
    549549  }
    550550
    551 #if H_MV
    552   WRITE_FLAG( 1, "sps_extension_flag" );
    553 
    554   WRITE_FLAG( pcSPS->getInterViewMvVertConstraintFlag() ? 1 : 0, "inter_view_mv_vert_constraint_flag" );
    555 #else
    556551  WRITE_FLAG( 0, "sps_extension_flag" );
    557 #endif
    558552}
    559553
     
    562556  WRITE_CODE( pcVPS->getVPSId(),                    4,        "vps_video_parameter_set_id" );
    563557  WRITE_CODE( 3,                                    2,        "vps_reserved_three_2bits" );
    564 #if H_MV
    565   WRITE_CODE( pcVPS->getMaxLayers() - 1,            6,        "vps_max_layers_minus1" );
    566 #else
    567558  WRITE_CODE( 0,                                    6,        "vps_reserved_zero_6bits" );
    568 #endif
    569559  WRITE_CODE( pcVPS->getMaxTLayers() - 1,           3,        "vps_max_sub_layers_minus1" );
    570560  WRITE_FLAG( pcVPS->getTemporalNestingFlag(),                "vps_temporal_id_nesting_flag" );
    571561  assert (pcVPS->getMaxTLayers()>1||pcVPS->getTemporalNestingFlag());
    572 #if H_MV
    573   WRITE_CODE( 0xffff,                              16,        "vps_extension_offset" );
    574 #else
    575562  WRITE_CODE( 0xffff,                              16,        "vps_reserved_ffff_16bits" );
    576 #endif
    577563  codePTL( pcVPS->getPTL(), true, pcVPS->getMaxTLayers() - 1 );
    578564#if SIGNAL_BITRATE_PICRATE_IN_VPS
     
    597583
    598584  assert( pcVPS->getNumHrdParameters() <= MAX_VPS_NUM_HRD_PARAMETERS );
    599 #if H_MV
    600   assert( pcVPS->getMaxNuhLayerId() < MAX_VPS_NUH_LAYER_ID_PLUS1 );
    601   WRITE_CODE( pcVPS->getMaxNuhLayerId(), 6,                 "vps_max_nuh_layer_id" );
    602 #else
    603585  assert( pcVPS->getMaxNuhReservedZeroLayerId() < MAX_VPS_NUH_RESERVED_ZERO_LAYER_ID_PLUS1 );
    604586  WRITE_CODE( pcVPS->getMaxNuhReservedZeroLayerId(), 6,     "vps_max_nuh_reserved_zero_layer_id" );
    605 #endif
    606587  pcVPS->setMaxOpSets(1);
    607588  WRITE_UVLC( pcVPS->getMaxOpSets() - 1,                    "vps_max_op_sets_minus1" );
     
    609590  {
    610591    // Operation point set
    611 #if H_MV
    612     for( UInt i = 0; i <= pcVPS->getMaxNuhLayerId(); i ++ )
    613 #else
    614592    for( UInt i = 0; i <= pcVPS->getMaxNuhReservedZeroLayerId(); i ++ )
    615 #endif
    616593    {
    617594      // Only applicable for version 1
     
    654631  }
    655632#endif
    656 #if H_MV
    657   WRITE_FLAG( 1,                                             "vps_extension_flag" );
    658 
    659   m_pcBitIf->writeAlignOne();                       
    660 
    661   WRITE_FLAG( pcVPS->getAvcBaseLayerFlag() ? 1 : 0,          "avc_base_layer_flag" );
    662   WRITE_FLAG( pcVPS->getSplittingFlag() ? 1 : 0,             "splitting_flag" );
    663  
    664   for( Int type = 0; type < MAX_NUM_SCALABILITY_TYPES; type++ )
    665   {
    666     WRITE_FLAG( pcVPS->getScalabilityMask( type ) ? 1 : 0,   "scalability_mask[i]" );
    667   }
    668 
    669   for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes( ); sIdx++ )
    670   {
    671     WRITE_CODE( pcVPS->getDimensionIdLen( sIdx ) - 1 , 3,    "dimension_id_len_minus1[j]");   
    672   }
    673 
    674   WRITE_FLAG( pcVPS->getVpsNuhLayerIdPresentFlag() ? 1 : 0,  "vps_nuh_layer_id_present_flag");
    675 
    676   for( Int layer = 1; layer <= pcVPS->getMaxLayers() - 1; layer++ )
    677   {
    678     if (pcVPS->getVpsNuhLayerIdPresentFlag() )
    679       WRITE_CODE( pcVPS->getLayerIdInNuh( layer ), 6,          "layer_id_in_nuh[i]");
    680     for( Int sIdx = 0; sIdx < pcVPS->getNumScalabilityTypes() ; sIdx++ )
    681     {     
    682       WRITE_CODE( pcVPS->getDimensionId( layer, sIdx ), pcVPS->getDimensionIdLen( sIdx ), "dimension_id[i][j]");     
    683     }
    684   }
    685 
    686   for( Int layerSet = 1; layerSet <= pcVPS->getMaxOpSets() - 1; layerSet++ )
    687   {
    688     WRITE_FLAG( pcVPS->getVpsProfilePresentFlag( layerSet ) ? 1 : 0, "vps_profile_present_flag[lsIdx]" );
    689     if( pcVPS->getVpsProfilePresentFlag( layerSet ) == false )
    690     {
    691       WRITE_UVLC( pcVPS->getProfileLayerSetRefMinus1( layerSet ), "profile_layer_set_ref_minus1[lsIdx]" );
    692     }
    693     codePTL( pcVPS->getPTL( layerSet ), pcVPS->getVpsProfilePresentFlag( layerSet ), pcVPS->getMaxTLayers() - 1 );
    694   }
    695 
    696   WRITE_UVLC( pcVPS->getNumOutputLayerSets(),                "num_output_layer_sets" );
    697 
    698   for( Int layerSet = 0; layerSet < pcVPS->getNumOutputLayerSets(); layerSet++ )
    699   {
    700     WRITE_UVLC( pcVPS->getOutputLayerSetIdx( layerSet ),      "output_layer_set_idx[i]" );
    701     for( Int layer = 0; layer <= pcVPS->getMaxNuhLayerId(); layer++ )
    702     {
    703       if( pcVPS->getLayerIdIncludedFlag( pcVPS->getOutputLayerSetIdx( layerSet ), layer ) == true )
    704       {
    705         WRITE_FLAG( pcVPS->getOutputLayerFlag( layerSet, layer ) ? 1 : 0, "output_layer_flag" );
    706       }
    707     }
    708   }
    709 
    710   for( Int i = 1; i <= pcVPS->getMaxLayers() - 1; i++ )
    711   {
    712     for( Int j = 0; j < i; j++ )
    713     {
    714       WRITE_FLAG( pcVPS->getDirectDependencyFlag( i, j ),    "direct_dependency_flag[i][j]" );
    715     }
    716   }
    717   WRITE_FLAG( 0,                                             "vps_extension2_flag" );
    718 #else
    719633  WRITE_FLAG( 0,                     "vps_extension_flag" );
    720 #endif
    721634 
    722635  //future extensions here..
     
    10911004  for (Int i = 0; i < maxNumSubLayersMinus1; i++)
    10921005  {
    1093 #if !H_MV
    10941006    if(profilePresentFlag)
    10951007    {
    1096 #endif
    10971008      WRITE_FLAG( pcPTL->getSubLayerProfilePresentFlag(i), "sub_layer_profile_present_flag[i]" );
    1098 #if !H_MV
    1099     }
    1100 #endif
     1009    }
    11011010   
    11021011    WRITE_FLAG( pcPTL->getSubLayerLevelPresentFlag(i),   "sub_layer_level_present_flag[i]" );
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncCfg.h

    r364 r367  
    6969  Int m_numRefIdc;
    7070  Int m_refIdc[MAX_NUM_REF_PICS+1];
    71 #if H_MV
    72   Int m_numInterViewRefPics;
    73   Int m_interViewRefs    [MAX_NUM_REF_PICS];
    74   Int m_interViewRefPosL[2][MAX_NUM_REF_PICS]; 
    75 #endif
    7671  GOPEntry()
    7772  : m_POC(-1)
     
    8883  , m_deltaRPS(0)
    8984  , m_numRefIdc(0)
    90 #if H_MV
    91   , m_numInterViewRefPics(0)
    92 #endif
    9385  {
    9486    ::memset( m_referencePics, 0, sizeof(m_referencePics) );
    9587    ::memset( m_usedByCurrPic, 0, sizeof(m_usedByCurrPic) );
    9688    ::memset( m_refIdc,        0, sizeof(m_refIdc) );
    97 #if H_MV
    98     ::memset( m_interViewRefs,   0, sizeof(m_interViewRefs) );
    99     ::memset( m_interViewRefPosL[0], -1, sizeof(m_interViewRefPosL[0]) );    ::memset( m_interViewRefPosL[1], -1, sizeof(m_interViewRefPosL[1]) );
    100 #endif
    10189  }
    10290};
     
    139127  UInt      m_uiDecodingRefreshType;            ///< the type of decoding refresh employed for the random access.
    140128  Int       m_iGOPSize;
    141 #if H_MV
    142   GOPEntry  m_GOPList[MAX_GOP+1];
    143 #else
    144129  GOPEntry  m_GOPList[MAX_GOP];
    145 #endif
    146130  Int       m_extraRPSs;
    147131  Int       m_maxDecPicBuffering[MAX_TLAYER];
     
    353337  Bool      m_useStrongIntraSmoothing;                        ///< enable the use of strong intra smoothing (bi_linear interpolation) for 32x32 blocks when reference samples are flat.
    354338
    355 #if H_MV
    356   Int       m_layerId;
    357   Int       m_layerIdInVps;
    358   Int       m_viewId;
    359 #if H_3D
    360   Bool      m_isDepth;
    361 #endif
    362 #endif
    363339public:
    364340  TEncCfg()
    365341  : m_puiColumnWidth()
    366342  , m_puiRowHeight()
    367 #if H_MV
    368   , m_layerId(-1)
    369   , m_layerIdInVps(-1)
    370   , m_viewId(-1)
    371 #if H_3D
    372   , m_isDepth(false)
    373 #endif
    374 #endif
    375343  {}
    376344
     
    394362  Void      setFramesToBeEncoded            ( Int   i )      { m_framesToBeEncoded = i; }
    395363 
    396 #if H_MV
    397   Void      setLayerId                       ( Int layerId )      { m_layerId = layerId; }
    398   Int       getLayerId                       ()                   { return m_layerId;    }
    399   Int       getLayerIdInVps                  ()                   { return m_layerIdInVps; }
    400   Void      setLayerIdInVps                  ( Int layerIdInVps)  { m_layerIdInVps = layerIdInVps; }
    401   Void      setViewId                        ( Int viewId  )      { m_viewId  = viewId;  }
    402   Int       getViewId                        ()                   { return m_viewId;    }
    403 #if H_3D
    404   Void      setIsDepth                       ( Bool isDepth )   { m_isDepth = isDepth; }
    405   Bool      getIsDepth                       ()                 { return m_isDepth; }
    406 #endif
    407 #endif
    408364  //====== Coding Structure ========
    409365  Void      setIntraPeriod                  ( Int   i )      { m_uiIntraPeriod = (UInt)i; }
    410366  Void      setDecodingRefreshType          ( Int   i )      { m_uiDecodingRefreshType = (UInt)i; }
    411367  Void      setGOPSize                      ( Int   i )      { m_iGOPSize = i; }
    412 #if H_MV
    413   Void      setGopList                      ( GOPEntry*  GOPList ) {  for ( Int i = 0; i < MAX_GOP+1; i++ ) m_GOPList[i] = GOPList[i]; }
    414 #else
    415368  Void      setGopList                      ( GOPEntry*  GOPList ) {  for ( Int i = 0; i < MAX_GOP; i++ ) m_GOPList[i] = GOPList[i]; }
    416 #endif
    417369  Void      setExtraRPSs                    ( Int   i )      { m_extraRPSs = i; }
    418370  GOPEntry  getGOPEntry                     ( Int   i )      { return m_GOPList[i]; }
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncGOP.cpp

    r366 r367  
    100100#endif
    101101#endif
    102 #if H_MV
    103   m_layerId      = 0;
    104   m_viewId       = 0;
    105   m_pocLastCoded = -1;
    106 #if H_3D
    107   m_isDepth = false;
    108 #endif
    109 #endif
    110102  return;
    111103}
     
    147139  m_totalCoded         = 0;
    148140
    149 #if H_MV
    150   m_ivPicLists           = pcTEncTop->getIvPicLists();
    151   m_layerId              = pcTEncTop->getLayerId();
    152   m_viewId               = pcTEncTop->getViewId();
    153 #if H_3D
    154   m_isDepth              = pcTEncTop->getIsDepth();
    155 #endif
    156 #endif
    157141}
    158142
     
    358342// Public member functions
    359343// ====================================================================================================================
    360 #if H_MV
    361 Void TEncGOP::initGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
    362 {
    363   xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
    364   m_iNumPicCoded = 0;
    365 }
    366 #endif
    367 #if H_MV
    368 Void TEncGOP::compressPicInGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Int iGOPid)
    369 #else
    370344Void TEncGOP::compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP)
    371 #endif
    372345{
    373346  TComPic*        pcPic;
     
    381354  TComOutputBitstream* pcSubstreamsOut = NULL;
    382355
    383 #if !H_MV
    384356  xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
    385357 
    386358  m_iNumPicCoded = 0;
    387 #endif
    388359  SEIPictureTiming pictureTimingSEI;
    389360#if L0208_SOP_DESCRIPTION_SEI
     
    408379  UInt *accumNalsDU = NULL;
    409380  SEIDecodingUnitInfo decodingUnitInfoSEI;
    410 #if !H_MV
    411381  for ( Int iGOPid=0; iGOPid < m_iGopSize; iGOPid++ )
    412 #endif
    413382  {
    414383    UInt uiColDir = 1;
     
    469438    if(pocCurr>=m_pcCfg->getFramesToBeEncoded())
    470439    {
    471 #if H_MV
    472       delete pcBitstreamRedirect;
    473       return;
    474 #else
    475440      continue;
    476 #endif
    477441    }
    478442
     
    495459    pcSlice->setLastIDR(m_iLastIDR);
    496460    pcSlice->setSliceIdx(0);
    497 #if H_MV
    498     pcPic  ->setLayerId     ( getLayerId() );
    499     pcPic  ->setViewId      ( getViewId()  );
    500     pcSlice->setLayerId     ( getLayerId() );
    501     pcSlice->setViewId      ( getViewId()  );
    502     pcSlice->setVPS         ( m_pcEncTop->getVPS() );
    503 #if H_3D
    504     pcPic  ->setIsDepth( getIsDepth() );
    505     pcSlice->setIsDepth( getIsDepth() );
    506 #endif
    507 #endif
    508461    //set default slice level flag to the same as SPS level flag
    509462    pcSlice->setLFCrossSliceBoundaryFlag(  pcSlice->getPPS()->getLoopFilterAcrossSlicesEnabledFlag()  );
     
    543496    }
    544497
    545 #if H_MV
     498    if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
     499    {
     500      pcSlice->setSliceType(P_SLICE);
     501    }
    546502    // Set the nal unit type
    547503    pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
    548     if( pcSlice->getSliceType() == B_SLICE )
    549     {
    550       if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' )
    551       {
    552         pcSlice->setSliceType( P_SLICE );
    553       }
    554     }
    555 #else
    556     if(pcSlice->getSliceType()==B_SLICE&&m_pcCfg->getGOPEntry(iGOPid).m_sliceType=='P')
    557     {
    558       pcSlice->setSliceType(P_SLICE);
    559     }
    560     // Set the nal unit type
    561     pcSlice->setNalUnitType(getNalUnitType(pocCurr, m_iLastIDR));
    562 #endif
    563504    if(pcSlice->getTemporalLayerNonReferenceFlag())
    564505    {
     
    648589    refPicListModification->setRefPicListModificationFlagL0(0);
    649590    refPicListModification->setRefPicListModificationFlagL1(0);
    650 #if H_MV
    651     pcSlice->createAndApplyIvReferencePictureSet( m_ivPicLists, m_refPicSetInterLayer );
    652     pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid ).m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer.size() ) ) );
    653     pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && getLayerId() > 0) ? MAX_GOP : iGOPid ).m_numRefPicsActive,( pcSlice->getRPS()->getNumberOfPictures() + (Int) m_refPicSetInterLayer.size() ) ) );
    654     xSetRefPicListModificationsMvc( pcSlice, pocCurr, iGOPid );   
    655 #else
    656591    pcSlice->setNumRefIdx(REF_PIC_LIST_0,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
    657592    pcSlice->setNumRefIdx(REF_PIC_LIST_1,min(m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive,pcSlice->getRPS()->getNumberOfPictures()));
    658 #endif
    659593
    660594#if ADAPTIVE_QP_SELECTION
     
    663597
    664598    //  Set reference list
    665 #if H_MV   
    666     pcSlice->setRefPicList( rcListPic, m_refPicSetInterLayer );
    667 #else
    668599    pcSlice->setRefPicList ( rcListPic );
    669 #endif
    670600
    671601    //  Slice info. refinement
    672 #if H_MV
    673     if ( pcSlice->getSliceType() == B_SLICE )
    674     {
    675       if( m_pcCfg->getGOPEntry( ( pcSlice->getRapPicFlag() == true && getLayerId() > 0 ) ? MAX_GOP : iGOPid ).m_sliceType == 'P' )
    676       {
    677         pcSlice->setSliceType( P_SLICE );
    678       }
    679     }
    680 #else
    681602    if ( (pcSlice->getSliceType() == B_SLICE) && (pcSlice->getNumRefIdx(REF_PIC_LIST_1) == 0) )
    682603    {
    683604      pcSlice->setSliceType ( P_SLICE );
    684605    }
    685 #endif
    686606#if !L0034_COMBINED_LIST_CLEANUP
    687607    if (pcSlice->getSliceType() != B_SLICE || !pcSlice->getSPS()->getUseLComb())
     
    11001020    {
    11011021      OutputNALUnit nalu(NAL_UNIT_VPS);
    1102 #if H_MV
    1103       if( getLayerId() == 0 )
    1104       {
    1105 #endif
    11061022      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    11071023      m_pcEntropyCoder->encodeVPS(m_pcEncTop->getVPS());
     
    11121028#endif
    11131029
    1114 #if H_MV
    1115       }
    1116       nalu = NALUnit(NAL_UNIT_SPS, 0, getLayerId());
    1117 #else
    11181030      nalu = NALUnit(NAL_UNIT_SPS);
    1119 #endif
    11201031      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    11211032      if (m_bSeqFirst)
     
    11501061#endif
    11511062
    1152 #if H_MV
    1153       nalu = NALUnit(NAL_UNIT_PPS, 0, getLayerId());
    1154 #else
    11551063      nalu = NALUnit(NAL_UNIT_PPS);
    1156 #endif
    11571064      m_pcEntropyCoder->setBitstream(&nalu.m_Bitstream);
    11581065      m_pcEntropyCoder->encodePPS(pcSlice->getPPS());
     
    14761383          m_pcEntropyCoder->resetEntropy      ();
    14771384          /* start slice NALunit */
    1478 #if H_MV
    1479           OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer(), getLayerId() );
    1480 #else
    14811385          OutputNALUnit nalu( pcSlice->getNalUnitType(), pcSlice->getTLayer() );
    1482 #endif
    14831386          Bool sliceSegment = (!pcSlice->isNextSlice());
    14841387          if (!sliceSegment)
     
    17071610      }
    17081611
    1709 #if !H_3D
    17101612      pcPic->compressMotion();
    1711 #endif
    1712 #if H_MV
    1713       m_pocLastCoded = pcPic->getPOC();
    1714 #endif
    17151613      //-- For time output for each slice
    17161614      Double dEncTime = (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
     
    20231921
    20241922      pcPic->setReconMark   ( true );
    2025 #if H_MV
    2026       TComSlice::markIvRefPicsAsShortTerm( m_refPicSetInterLayer ); 
    2027       std::vector<Int> temp;
    2028       TComSlice::markIvRefPicsAsUnused   ( m_ivPicLists, temp, pcPic->getSlice(0)->getVPS(), m_layerId, pcPic->getPOC() );
    2029 #endif
    20301923      m_bFirst = false;
    20311924      m_iNumPicCoded++;
     
    20481941  if( accumNalsDU != NULL) delete accumNalsDU;
    20491942
    2050 #if !H_MV
    20511943  assert ( m_iNumPicCoded == iNumPicRcvd );
    2052 #endif
    20531944}
    20541945
    2055 #if !H_MV
    20561946Void TEncGOP::printOutSummary(UInt uiNumAllPicCoded)
    20571947{
     
    20891979  printf("\nRVM: %.3lf\n" , xCalculateRVM());
    20901980}
    2091 #endif
    20921981
    20931982Void TEncGOP::preLoopFilterPicAll( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits )
     
    23652254
    23662255  //===== add PSNR =====
    2367 #if H_MV
    2368   m_pcEncTop->getAnalyzeAll()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2369 #else
    23702256  m_gcAnalyzeAll.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2371 #endif
    23722257  TComSlice*  pcSlice = pcPic->getSlice(0);
    23732258  if (pcSlice->isIntra())
    23742259  {
    2375 #if H_MV
    2376     m_pcEncTop->getAnalyzeI()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2377 #else
    23782260    m_gcAnalyzeI.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2379 #endif
    23802261  }
    23812262  if (pcSlice->isInterP())
    23822263  {
    2383 #if H_MV
    2384     m_pcEncTop->getAnalyzeP()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2385 #else
    23862264    m_gcAnalyzeP.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2387 #endif
    23882265  }
    23892266  if (pcSlice->isInterB())
    23902267  {
    2391 #if H_MV
    2392     m_pcEncTop->getAnalyzeB()->addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2393 #else
    23942268    m_gcAnalyzeB.addResult (dYPSNR, dUPSNR, dVPSNR, (Double)uibits);
    2395 #endif
    23962269  }
    23972270
     
    24002273
    24012274#if ADAPTIVE_QP_SELECTION
    2402 #if H_MV
    2403   printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
    2404     pcSlice->getLayerId(),
    2405     pcSlice->getPOC(),
    2406     pcSlice->getTLayer(),
    2407     c,
    2408     pcSlice->getSliceQpBase(),
    2409     pcSlice->getSliceQp(),
    2410     uibits );
    2411 #else
    24122275  printf("POC %4d TId: %1d ( %c-SLICE, nQP %d QP %d ) %10d bits",
    24132276         pcSlice->getPOC(),
     
    24172280         pcSlice->getSliceQp(),
    24182281         uibits );
    2419 #endif
    2420 #else
    2421 #if H_MV
    2422   printf("Layer %3d   POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
    2423     pcSlice->getLayerId(),
    2424     pcSlice->getPOC()-pcSlice->getLastIDR(),
    2425     pcSlice->getTLayer(),
    2426     c,
    2427     pcSlice->getSliceQp(),
    2428     uibits );
    24292282#else
    24302283  printf("POC %4d TId: %1d ( %c-SLICE, QP %d ) %10d bits",
     
    24342287         pcSlice->getSliceQp(),
    24352288         uibits );
    2436 #endif
    24372289
    24382290#endif
     
    24452297    for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
    24462298    {
    2447 #if H_MV
    2448       if( pcSlice->getLayerId() != pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) )
    2449       {
    2450         printf( "V%d ", pcSlice->getRefLayerId( RefPicList(iRefList), iRefIndex ) );
    2451       }
    2452       else
    2453       {
    2454 #endif
    24552299      printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex)-pcSlice->getLastIDR());
    2456 #if H_MV
    2457       }
    2458 #endif
    24592300    }
    24602301    printf("]");
     
    28222663}
    28232664#endif
    2824 #if H_MV
    2825 Void TEncGOP::xSetRefPicListModificationsMvc( TComSlice* pcSlice, UInt uiPOCCurr, UInt iGOPid )
    2826 {
    2827   TComVPS* vps = pcSlice->getVPS();
    2828   Int layer    = pcSlice->getLayerIdInVps( );
    2829  
    2830   if( pcSlice->getSliceType() == I_SLICE || !(pcSlice->getPPS()->getListsModificationPresentFlag()) || vps->getNumDirectRefLayers( layer ) == 0 )
    2831   {
    2832     return;
    2833   }
    2834 
    2835   // analyze inter-view modifications
    2836   GOPEntry ge = m_pcCfg->getGOPEntry( (pcSlice->getRapPicFlag() && ( layer > 0) ) ? MAX_GOP : iGOPid );
    2837 
    2838   TComRefPicListModification* refPicListModification = pcSlice->getRefPicListModification();
    2839  
    2840   Int maxRefListSize  = pcSlice->getNumRpsCurrTempList();
    2841   Int numTemporalRefs = maxRefListSize - vps->getNumDirectRefLayers( layer );
    2842 
    2843 
    2844   for (Int li = 0; li < 2; li ++) // Loop over lists L0 and L1
    2845   {
    2846     Int numModifications = 0;
    2847    
    2848     for( Int k = 0; k < ge.m_numInterViewRefPics; k++ )
    2849     {
    2850       numModifications +=  ( ge.m_interViewRefPosL[li][k] >= 0 ) ? 1 : 0;
    2851     }
    2852 
    2853     // set inter-view modifications
    2854     if( (maxRefListSize > 1) && (numModifications > 0) )
    2855     {
    2856       refPicListModification->setRefPicListModificationFlagL( li, true );
    2857       Int tempList[16];
    2858       for( Int k = 0; k < 16; k++ ) { tempList[k] = -1; }
    2859 
    2860       Bool isModified = false;
    2861       for( Int k = 0; k < ge.m_numInterViewRefPics; k++ )
    2862       {
    2863         if( ge.m_interViewRefPosL[li][k] >= 0 )
    2864         {
    2865           Int orgIdx    = numTemporalRefs;
    2866           Int targetIdx = ge.m_interViewRefPosL[ li ][ k ];
    2867           for( Int idx = 0; idx < vps->getNumDirectRefLayers( layer ); idx++ )
    2868           {           
    2869             Int refLayer  = vps->getLayerIdInVps( vps->getRefLayerId( layer, idx ) );         
    2870             if( ( layer + ge.m_interViewRefs[ k ]) == refLayer )
    2871             {
    2872               tempList[ targetIdx ] = orgIdx;             
    2873               isModified = ( targetIdx != orgIdx  );
    2874             }
    2875             orgIdx++;
    2876           }
    2877         }
    2878       }
    2879       if( isModified )
    2880       {
    2881         Int temporalRefIdx = 0;
    2882         for( Int i = 0; i < pcSlice->getNumRefIdx( ( li == 0 ) ? REF_PIC_LIST_0 : REF_PIC_LIST_1 ); i++ )
    2883         {
    2884           if( tempList[i] >= 0 )
    2885           {
    2886             refPicListModification->setRefPicSetIdxL( li, i, tempList[i] );
    2887           }
    2888           else
    2889           {
    2890             refPicListModification->setRefPicSetIdxL( li, i, temporalRefIdx );
    2891             temporalRefIdx++;
    2892           }
    2893         }
    2894       }
    2895       else
    2896       {
    2897         refPicListModification->setRefPicListModificationFlagL( li, false );
    2898       }
    2899     }
    2900   }
    2901 }
    2902 #endif
    29032665//! \}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncGOP.h

    r364 r367  
    9797  SEIWriter               m_seiWriter;
    9898 
    99 #if H_MV
    100   TComPicLists*           m_ivPicLists;
    101   std::vector<TComPic*>   m_refPicSetInterLayer;
    102 
    103   Int                     m_pocLastCoded;
    104   Int                     m_layerId; 
    105   Int                     m_viewId;
    106 #if H_3D
    107   Bool                    m_isDepth;
    108 #endif
    109 #endif
    11099  //--Adaptive Loop filter
    111100  TEncSampleAdaptiveOffset*  m_pcSAO;
     
    144133 
    145134  Void  init        ( TEncTop* pcTEncTop );
    146 #if H_MV
    147   Void  initGOP     ( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP);
    148   Void  compressPicInGOP ( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsInGOP, Int iGOPid );
    149 #else
    150135  Void  compressGOP( Int iPOCLast, Int iNumPicRcvd, TComList<TComPic*>& rcListPic, TComList<TComPicYuv*>& rcListPicYuvRec, std::list<AccessUnit>& accessUnitsInGOP );
    151 #endif
    152136  Void  xAttachSliceDataToNalUnit (OutputNALUnit& rNalu, TComOutputBitstream*& rpcBitstreamRedirect);
    153137
    154 #if H_MV
    155   Int       getPocLastCoded  ()                 { return m_pocLastCoded; } 
    156   Int       getLayerId       ()                 { return m_layerId;    } 
    157   Int       getViewId        ()                 { return m_viewId;    }
    158 #if H_3D
    159   Bool      getIsDepth       ()                 { return m_isDepth; }
    160 #endif
    161 #endif
    162138
    163139  Int   getGOPSize()          { return  m_iGopSize;  }
     
    165141  TComList<TComPic*>*   getListPic()      { return m_pcListPic; }
    166142 
    167 #if !H_MV
    168143  Void  printOutSummary      ( UInt uiNumAllPicCoded );
    169 #endif
    170144  Void  preLoopFilterPicAll  ( TComPic* pcPic, UInt64& ruiDist, UInt64& ruiBits );
    171145 
     
    211185#endif
    212186#endif
    213 #if H_MV
    214    Void  xSetRefPicListModificationsMvc( TComSlice* pcSlice, UInt uiPOCCurr, UInt iGOPid );
    215 #endif
    216187#if L0386_DB_METRIC
    217188  Void dblMetric( TComPic* pcPic, UInt uiNumSlices );
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncSlice.cpp

    r365 r367  
    219219 
    220220  // slice type
    221 #if H_MV
    222   SliceType eSliceTypeBaseView;
    223   if( pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0 )
    224   {
    225     eSliceTypeBaseView = I_SLICE;
    226   }
    227   else
    228   {
    229     eSliceTypeBaseView = B_SLICE;
    230   }
    231   SliceType eSliceType = eSliceTypeBaseView;
    232   if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
    233   {
    234     eSliceType = B_SLICE;
    235   }
    236 #else
    237221  SliceType eSliceType;
    238222 
     
    241225 
    242226  rpcSlice->setSliceType    ( eSliceType );
    243 #endif
    244227
    245228  // ------------------------------------------------------------------------------------------------------------------
     
    270253    if (!(( m_pcCfg->getMaxDeltaQP() == 0 ) && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() ) && (rpcSlice->getSPS()->getUseLossless())))
    271254    {
    272 #if H_MV
    273       dQP += m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPOffset;
    274 #else
    275255      dQP += m_pcCfg->getGOPEntry(iGOPid).m_QPOffset;
    276 #endif
    277256    }
    278257  }
     
    317296#endif
    318297    // Case #1: I or P-slices (key-frame)
    319 #if H_MV
    320     Double dQPFactor;
    321     if( eSliceType != I_SLICE )
    322     {
    323       dQPFactor = m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPFactor;
    324     }
    325     else
    326 #else
    327298    Double dQPFactor = m_pcCfg->getGOPEntry(iGOPid).m_QPFactor;
    328299    if ( eSliceType==I_SLICE )
    329 #endif
    330300    {
    331301      dQPFactor=0.57*dLambda_scale;
     
    362332  if( rpcSlice->getSliceType( ) != I_SLICE )
    363333  {
    364 #if H_MV
    365     dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_temporalId );
    366 #else
    367334    dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
    368 #endif
    369335  }
    370336
     
    405371#if HB_LAMBDA_FOR_LDC
    406372  // restore original slice type
    407 #if H_MV
    408   eSliceType = eSliceTypeBaseView;
    409   if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
    410   {
    411     eSliceType = B_SLICE;
    412   }
    413 #else
    414373  eSliceType = (pocLast == 0 || pocCurr % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
    415 #endif
    416374
    417375  rpcSlice->setSliceType        ( eSliceType );
     
    431389  rpcSlice->setSliceQpDeltaCb   ( 0 );
    432390  rpcSlice->setSliceQpDeltaCr   ( 0 );
    433 #if H_MV
    434   rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
    435   rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
    436 #else
    437391  rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
    438392  rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
    439 #endif
    440393
    441394#if L0386_DB_METRIC
     
    458411      if ( !m_pcCfg->getLoopFilterOffsetInPPS() && eSliceType!=I_SLICE)
    459412      {
    460 #if H_MV
    461         rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
    462         rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
    463         rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset()  );
    464         rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
    465 #else
    466413        rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
    467414        rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
    468415        rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset()  );
    469416        rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
    470 #endif
    471417      }
    472418      else
     
    489435  rpcSlice->setDepth            ( depth );
    490436 
    491 #if H_MV
    492   pcPic->setTLayer( m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_temporalId );
    493 #else
    494437  pcPic->setTLayer( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
    495 #endif
    496438  if(eSliceType==I_SLICE)
    497439  {
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncTop.cpp

    r366 r367  
    4242#include "TLibCommon/ContextModel.h"
    4343#endif
    44 #if H_MV
    45 #include "../../App/TAppEncoder/TAppEncTop.h"
    46 #endif
    4744
    4845//! \ingroup TLibEncoder
     
    8178  m_pcBitCounters          = NULL;
    8279  m_pcRdCosts              = NULL;
    83 #if H_MV
    84   m_ivPicLists = NULL;
    85 #endif
    8680}
    8781
     
    9589Void TEncTop::create ()
    9690{
    97 #if !H_MV
    9891  // initialize global variables
    9992  initROM();
    100 #endif
    10193 
    10294  // create processing unit classes
     
    276268  delete[] m_pcRdCosts;
    277269 
    278 #if !H_MV
    279270    // destroy ROM
    280271  destroyROM();
    281 #endif
    282272
    283273  return;
     
    329319// ====================================================================================================================
    330320
    331 #if H_MV
    332 Void TEncTop::initNewPic( TComPicYuv* pcPicYuvOrg )
    333 {
    334   TComPic* pcPicCurr = NULL;
    335 
    336   // get original YUV
    337   xGetNewPicBuffer( pcPicCurr );
    338   pcPicYuvOrg->copyToPic( pcPicCurr->getPicYuvOrg() );
    339 
    340   // compute image characteristics
    341   if ( getUseAdaptiveQP() )
    342   {
    343     m_cPreanalyzer.xPreanalyze( dynamic_cast<TEncPic*>( pcPicCurr ) );
    344   }
    345 }
    346 #endif
    347321Void TEncTop::deletePicBuffer()
    348322{
     
    371345 \retval  iNumEncoded         number of encoded pictures
    372346 */
    373 #if H_MV
    374 Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded , Int gopId )
    375 {
    376 #else
    377347Void TEncTop::encode(Bool flush, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded )
    378348{
    379 #endif
    380 #if H_3D
    381   TComPic* picLastCoded = getPic( getGOPEncoder()->getPocLastCoded() );
    382   if( picLastCoded )
    383   {
    384     picLastCoded->compressMotion();
    385   }
    386 #endif
    387 #if H_MV
    388   if( gopId == 0)
    389   {
    390     m_cGOPEncoder.initGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut); 
    391 #else
    392349  if (pcPicYuvOrg) {
    393350    // get original YUV
     
    408365    return;
    409366  }
    410 #endif
    411367 
    412368#if RATE_CONTROL_LAMBDA_DOMAIN
     
    417373#endif
    418374
    419 #if H_MV
    420   }
    421   m_cGOPEncoder.compressPicInGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut, gopId );
    422 
    423   if( gopId + 1 == m_cGOPEncoder.getGOPSize() )
    424   {
    425 #else
    426375  // compress GOP
    427376  m_cGOPEncoder.compressGOP(m_iPOCLast, m_iNumPicRcvd, m_cListPic, rcListPicYuvRecOut, accessUnitsOut);
    428 #endif
    429377
    430378#if RATE_CONTROL_LAMBDA_DOMAIN
     
    438386  m_iNumPicRcvd       = 0;
    439387  m_uiNumAllPicCoded += iNumEncoded;
    440 #if H_MV
    441 }
    442 #endif
    443388}
    444389
     
    505450Void TEncTop::xInitSPS()
    506451{
    507 #if H_MV
    508   m_cSPS.setSPSId( getLayerIdInVps() );
    509 #endif
    510452  ProfileTierLevel& profileTierLevel = *m_cSPS.getPTL()->getGeneralPTL();
    511453  profileTierLevel.setLevelIdc(m_level);
     
    652594Void TEncTop::xInitPPS()
    653595{
    654 #if H_MV
    655   if( m_cVPS.getNumDirectRefLayers( getLayerIdInVps() ) > 0 )
    656   {
    657     m_cPPS.setListsModificationPresentFlag( true );
    658   }
    659   m_cPPS.setPPSId( getLayerIdInVps() );
    660   m_cPPS.setSPSId( getLayerIdInVps() );
    661 #endif
    662596  m_cPPS.setConstrainedIntraPred( m_bUseConstrainedIntraPred );
    663597  Bool bUseDQP = (getMaxCuDQPDepth() > 0)? true : false;
     
    963897Void TEncTop::selectReferencePictureSet(TComSlice* slice, Int POCCurr, Int GOPid )
    964898{
    965 #if H_MV
    966   if( slice->getRapPicFlag() == true && getLayerId() > 0 && POCCurr == 0 )
    967   {
    968     TComReferencePictureSet* rps = slice->getLocalRPS();
    969     rps->setNumberOfNegativePictures(0);
    970     rps->setNumberOfPositivePictures(0);
    971     rps->setNumberOfLongtermPictures(0);
    972     rps->setNumberOfPictures(0);
    973     slice->setRPS(rps);
    974   }
    975   else
    976   {
    977 #endif
    978899  slice->setRPSidx(GOPid);
    979900
     
    1003924  slice->setRPS(getSPS()->getRPSList()->getReferencePictureSet(slice->getRPSidx()));
    1004925  slice->getRPS()->setNumberOfPictures(slice->getRPS()->getNumberOfNegativePictures()+slice->getRPS()->getNumberOfPositivePictures());
    1005 #if H_MV
    1006   }
    1007 #endif
    1008926
    1009927}
     
    11201038  }
    11211039}
    1122 #if H_MV
    1123 Void TEncTop::printSummary( Int numAllPicCoded )
    1124 {
    1125   assert (numAllPicCoded == m_cAnalyzeAll.getNumPic());
    1126 
    1127   //--CFG_KDY
    1128   m_cAnalyzeAll.setFrmRate( getFrameRate() );
    1129   m_cAnalyzeI.setFrmRate( getFrameRate() );
    1130   m_cAnalyzeP.setFrmRate( getFrameRate() );
    1131   m_cAnalyzeB.setFrmRate( getFrameRate() );
    1132 
    1133   //-- all
    1134   printf( "\n\nSUMMARY ------------------------------------------- LayerId %2d\n", m_layerId );
    1135 
    1136   m_cAnalyzeAll.printOut('a');
    1137 
    1138   printf( "\n\nI Slices--------------------------------------------------------\n" );
    1139   m_cAnalyzeI.printOut('i');
    1140 
    1141   printf( "\n\nP Slices--------------------------------------------------------\n" );
    1142   m_cAnalyzeP.printOut('p');
    1143 
    1144   printf( "\n\nB Slices--------------------------------------------------------\n" );
    1145   m_cAnalyzeB.printOut('b');
    1146 
    1147 #if _SUMMARY_OUT_
    1148   m_cAnalyzeAll.printSummaryOut();
    1149 #endif
    1150 #if _SUMMARY_PIC_
    1151   m_cAnalyzeI.printSummary('I');
    1152   m_cAnalyzeP.printSummary('P');
    1153   m_cAnalyzeB.printSummary('B');
    1154 #endif
    1155 }
    1156 
    1157 Int TEncTop::getFrameId(Int iGOPid) 
    1158 {
    1159   if(m_iPOCLast == 0)
    1160   {
    1161     return(0 );
    1162   }
    1163   else
    1164   {
    1165     return m_iPOCLast -m_iNumPicRcvd+ getGOPEntry(iGOPid).m_POC ;
    1166   }
    1167 }
    1168 
    1169 TComPic* TEncTop::getPic( Int poc )
    1170 {
    1171   TComList<TComPic*>* listPic = getListPic();
    1172   TComPic* pcPic = NULL;
    1173   for(TComList<TComPic*>::iterator it=listPic->begin(); it!=listPic->end(); it++)
    1174   {
    1175     if( (*it)->getPOC() == poc )
    1176     {
    1177       pcPic = *it ;
    1178       break ;
    1179     }
    1180   }
    1181   return pcPic;
    1182 }
    1183 #endif
    11841040//! \}
  • branches/HTM-DEV-0.1-dev/source/Lib/TLibEncoder/TEncTop.h

    r364 r367  
    7474  TComList<TComPic*>      m_cListPic;                     ///< dynamic list of pictures
    7575 
    76 #if H_MV
    77   TComPicLists*           m_ivPicLists;                   ///< access to picture lists of other layers
    78 #endif
    7976  // encoder search
    8077  TEncSearch              m_cSearch;                      ///< encoder search class
     
    125122  TEncRateCtrl            m_cRateCtrl;                    ///< Rate control class
    126123 
    127 #if H_MV
    128   TEncAnalyze             m_cAnalyzeAll;
    129   TEncAnalyze             m_cAnalyzeI;
    130   TEncAnalyze             m_cAnalyzeP;
    131   TEncAnalyze             m_cAnalyzeB; 
    132 #endif
    133124protected:
    134125  Void  xGetNewPicBuffer  ( TComPic*& rpcPic );           ///< get picture buffer which will be processed
     
    146137  Void      destroy         ();
    147138  Void      init            ();
    148 #if H_MV 
    149   TComPicLists* getIvPicLists() { return m_ivPicLists; }
    150 #endif
    151139  Void      deletePicBuffer ();
    152140
    153141  Void      createWPPCoders(Int iNumSubstreams);
    154142 
    155 #if H_MV
    156   Void      initNewPic(TComPicYuv* pcPicYuvOrg);
    157 #endif
    158143  // -------------------------------------------------------------------------------------------------------------------
    159144  // member access functions
     
    192177#endif
    193178  TComScalingList*        getScalingList        () { return  &m_scalingList;         }
    194 #if H_MV
    195   TEncAnalyze*            getAnalyzeAll         () { return &m_cAnalyzeAll; }
    196   TEncAnalyze*            getAnalyzeI           () { return &m_cAnalyzeI;   }
    197   TEncAnalyze*            getAnalyzeP           () { return &m_cAnalyzeP;   }
    198   TEncAnalyze*            getAnalyzeB           () { return &m_cAnalyzeB;   }
    199 
    200   Int                     getNumAllPicCoded     () { return m_uiNumAllPicCoded; }
    201  
    202   Int                     getFrameId            (Int iGOPid);
    203  
    204   TComPic*                getPic                ( Int poc );
    205   Void                    setIvPicLists         ( TComPicLists* picLists) { m_ivPicLists = picLists; }
    206 #endif
    207179  // -------------------------------------------------------------------------------------------------------------------
    208180  // encoder function
     
    210182
    211183  /// encode several number of pictures until end-of-sequence
    212 #if H_MV
    213   Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut, std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded  , Int gopId  ); 
    214 #else
    215184  Void encode( Bool bEos, TComPicYuv* pcPicYuvOrg, TComList<TComPicYuv*>& rcListPicYuvRecOut,
    216185              std::list<AccessUnit>& accessUnitsOut, Int& iNumEncoded ); 
    217 #endif
    218186
    219 #if H_MV
    220   Void printSummary      ( Int numAllPicCoded );
    221 #else
    222187  void printSummary() { m_cGOPEncoder.printOutSummary (m_uiNumAllPicCoded); }
    223 #endif
    224188};
    225189
Note: See TracChangeset for help on using the changeset viewer.