Changeset 655 in 3DVCSoftware for trunk/source/App/TAppEncoder


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

Merged 8.1-Cleanup@654

Location:
trunk/source/App/TAppEncoder
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/App/TAppEncoder/TAppEncCfg.cpp

    r622 r655  
    8282  m_codedPivotValue = NULL;
    8383  m_targetPivotValue = NULL;
     84
     85#if KWU_RC_MADPRED_E0227
     86  m_depthMADPred = 0;
     87#endif
    8488}
    8589
    … …  
    224228    in>>entry.m_interViewRefPosL[1][i];
    225229  }
    226 #if !H_MV5
    227   if (entry.m_numActiveRefLayerPics > 0 )
    228   {
    229     in>>entry.m_collocatedRefLayerIdx;
    230   }
    231 #endif
    232230#endif
    233231  return in;
    … …  
    369367  ("NumberOfLayers",        m_numberOfLayers     , 1,                     "Number of layers")
    370368#if !H_3D
    371 #if H_MV5
    372369  ("ScalabilityMask",       m_scalabilityMask    , 2                    , "Scalability Mask")   
    373 #else
    374   ("ScalabilityMask",       m_scalabilityMask    , 1                    , "Scalability Mask")   
    375 #endif
    376370#else
    377371  ("ScalabilityMask",       m_scalabilityMask    , 3                    , "Scalability Mask, 1: Texture 3: Texture + Depth ")   
    378372#endif 
    379373  ("DimensionIdLen",        m_dimensionIdLen     , cfg_dimensionLength  , "Number of bits used to store dimensions Id")
    380 #if H_MV5
    381374  ("ViewOrderIndex",        m_viewOrderIndex     , std::vector<Int>(1,0), "View Order Index per layer")
    382375  ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id per View Order Index")
    383 #else
    384   ("ViewId",                m_viewId             , std::vector<Int>(1,0), "View Id")
    385 #endif
    386376#if H_3D
    387377  ("DepthFlag",             m_depthFlag          , std::vector<Int>(1,0), "Depth Flag")
    … …  
    428418  ("FramesToBeEncoded,f",   m_framesToBeEncoded,   0, "Number of frames to be encoded (default=all)")
    429419
     420  //Field coding parameters
     421  ("FieldCoding", m_isField, false, "Signals if it's a field based coding")
     422  ("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not")
     423 
    430424  // Profile and level
    431425  ("Profile", m_profile,   Profile::NONE, "Profile to be used when encoding (Incomplete)")
    … …  
    517511  ("IlluCompEnable",           m_abUseIC, std::vector<Bool>(2, true), "Enable illumination compensation")
    518512#endif
    519 #if LGE_INTER_SDC_E0156
     513#if H_3D_INTER_SDC
    520514  ("InterSDC",                 m_bDepthInterSDCFlag,        true, "Enable depth inter SDC")
    521515#endif
    … …  
    594588  ( "InitialQP",           m_RCInitialQP,               0, "Rate control: initial QP" )
    595589  ( "RCForceIntraQP",      m_RCForceIntraQP,        false, "Rate control: force intra QP to be equal to initial QP" )
     590
     591#if KWU_RC_VIEWRC_E0227
     592  ("ViewWiseTargetBits, -vtbr" ,  m_viewTargetBits,  std::vector<Int>(1, 32), "View-wise target bit-rate setting")
     593  ("TargetBitAssign, -ta", m_viewWiseRateCtrl, false, "View-wise rate control on/off")
     594#endif
     595#if KWU_RC_MADPRED_E0227
     596  ("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
     597#endif
    596598#else
    597599  ("RateCtrl,-rc", m_enableRateCtrl, false, "Rate control on/off")
    598600  ("TargetBitrate,-tbr", m_targetBitrate, 0, "Input target bitrate")
    599601  ("NumLCUInUnit,-nu", m_numLCUInUnit, 0, "Number of LCUs in an Unit")
    600 #endif
    601 
    602 #if H_MV5
     602
     603#if KWU_RC_VIEWRC_E0227
     604  ("ViewWiseTargetBits, -vtbr" ,  m_viewTargetBits,  std::vector<Int>(1, 32), "View-wise target bit-rate setting")
     605  ("TargetBitAssign, -ta", m_viewWiseRateCtrl, false, "View-wise rate control on/off")
     606#endif
     607#if KWU_RC_MADPRED_E0227
     608  ("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off")
     609#endif
     610#endif
     611
    603612#if H_MV
    604613  // VPS VUI
    … …  
    617626  ("CtuBasedOffsetEnabledFlag"   , m_ctuBasedOffsetEnabledFlag   , std::vector< Bool >(1,0)  ,MAX_NUM_LAYERS       , "CtuBasedOffsetEnabledFlag    per direct reference for the N-th layer")
    618627  ("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int  >(1,0)  ,MAX_NUM_LAYERS       , "MinHorizontalCtuOffsetPlus1  per direct reference for the N-th layer")
    619 #endif
    620628#endif
    621629
    … …  
    762770    if( k == 0 )
    763771    {
    764 #if H_MV5
    765772      m_GOPListMvc[0][0].m_sliceType = 'I';
    766 #endif
    767773      for( Int i = 1; i < MAX_GOP + 1; i++ )
    768774      {
    … …  
    810816  const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv);
    811817
     818  if(m_isField)
     819  {
     820    //Frame height
     821    m_iSourceHeightOrg = m_iSourceHeight;
     822    //Field height
     823    m_iSourceHeight = m_iSourceHeight >> 1;
     824    //number of fields to encode
     825    m_framesToBeEncoded *= 2;
     826  }
     827 
    812828  for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)
    813829  {
    … …  
    928944        m_aiPad[1] = m_confBottom = ((m_iSourceHeight / minCuSize) + 1) * minCuSize - m_iSourceHeight;
    929945        m_iSourceHeight += m_confBottom;
     946        if ( m_isField )
     947        {
     948          m_iSourceHeightOrg += m_confBottom << 1;
     949          m_aiPad[1] = m_confBottom << 1;
     950        }
    930951      }
    931952      if (m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0)
    … …  
    968989  // allocate slice-based dQP values
    969990#if H_MV
    970 #if H_MV5
    971991  xResizeVector( m_viewOrderIndex    );
    972992
    … …  
    9881008#if H_3D
    9891009  xResizeVector( m_depthFlag );
    990 #endif
    991 #else
    992   xResizeVector( m_viewId    );
    993 #if H_3D
    994   xResizeVector( m_depthFlag );
    995 
    996   std::vector<Int> uniqueViewIds;
    997   for( Int layer = 0; layer < m_numberOfLayers; layer++ )
    998   {   
    999     Bool isIn = false;
    1000     for ( Int i = 0 ; i < uniqueViewIds.size(); i++ )
    1001     {
    1002       isIn = isIn || ( m_viewId[ layer ] == uniqueViewIds[ i ] );
    1003     }
    1004     if ( !isIn )
    1005     {
    1006       uniqueViewIds.push_back( m_viewId[ layer ] );
    1007     }
    1008   }
    1009   m_iNumberOfViews = (Int) uniqueViewIds.size();
    1010 #endif
    1011 
    10121010#endif
    10131011  xResizeVector( m_fQP );
    … …  
    12831281  xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. ");
    12841282 
    1285 #if H_MV5
    12861283#if H_3D
    12871284  xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. ");
    … …  
    12981295
    12991296  m_dimIds.push_back( m_viewOrderIndex );   
    1300 #else
    1301 #if H_3D
    1302   xConfirmPara( m_scalabilityMask != 1 && m_scalabilityMask != 3, "Scalability Mask must be equal to 1 or 3. ");
    1303 #else
    1304   xConfirmPara( m_scalabilityMask != 1 , "Scalability Mask must be equal to 1. ");
    1305 #endif
    1306  
    1307   m_dimIds.push_back( m_viewId );
    1308   const Int viewDimPosition = 0;
    1309 #if H_3D
    1310   if ( m_scalabilityMask & ( 1 << DEPTH_ID ) )
    1311     m_dimIds.push_back( m_depthFlag );
    1312 #endif
    1313 
    1314 #endif
    13151297  xConfirmPara(  m_dimensionIdLen.size() < m_dimIds.size(), "DimensionIdLen must be given for all dimensions. "   );   Int dimBitOffset[MAX_NUM_SCALABILITY_TYPES+1];
    13161298
    … …  
    13291311  {   
    13301312    xConfirmPara( m_dimIds[j].size() < m_numberOfLayers,  "DimensionId must be given for all layers and all dimensions. ");   
    1331 #if H_MV5   
    13321313    xConfirmPara( (m_dimIds[j][0] != 0)                 , "DimensionId of layer 0 must be 0. " );
    1333 #else
    1334     xConfirmPara( ( j != viewDimPosition ) &&  (m_dimIds[j][0] != 0), "DimensionId of layer 0 must be 0. " );
    1335 #endif
    13361314    xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " );
    13371315     
    … …  
    13721350     xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );
    13731351
     1352#if !H_3D_FCO
    13741353     if ( numDiff  == 1 )
    13751354     {
    13761355       Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];
    1377 #if H_MV5
    13781356       Bool shallBeButIsNotIncreasing = ( !inc  ) ;
    1379 #else
    1380        Bool shallBeButIsNotIncreasing = ( !inc && ( lastDiff != viewDimPosition ) ) ;
    1381 #endif
    13821357       if ( shallBeButIsNotIncreasing )
    13831358       {       
    13841359         printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);       
    13851360       }
    1386 #if H_MV5
    13871361       xConfirmPara( shallBeButIsNotIncreasing,  "DimensionIds shall be increasing within one dimension. " );
    1388 #else
    1389        xConfirmPara( shallBeButIsNotIncreasing && ( lastDiff != viewDimPosition ),  "DimensionIds shall be increasing within one dimension. " );
    1390 #endif
    13911362     }
     1363#endif
    13921364   }
    13931365 }
    13941366
    1395 #if H_MV5
    13961367 /// ViewId
    13971368 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );
    … …  
    13991370  /// Layer sets
    14001371  xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025. ") ;
    1401 #else
    1402   xConfirmPara( m_vpsNumLayerSets < 0 || m_vpsNumLayerSets > 1024, "VpsNumLayerSets must be greater than 0 and less than 1025") ;
    1403 #endif
    14041372  for( Int lsIdx = 0; lsIdx < m_vpsNumLayerSets; lsIdx++ )
    14051373  {
    … …  
    17431711  Bool errorGOP=false;
    17441712  Int checkGOP=1;
    1745   Int numRefs = 1;
     1713  Int numRefs = m_isField ? 2 : 1;
    17461714  Int refList[MAX_NUM_REF_PICS+1];
    17471715  refList[0]=0;
     1716  if(m_isField)
     1717  {
     1718    refList[1] = 1;
     1719  }
    17481720  Bool isOK[MAX_GOP];
    17491721  for(Int i=0; i<MAX_GOP; i++)
    … …  
    21572129    xConfirmPara( (numLCUInPic % m_numLCUInUnit) != 0, "total number of LCUs in a frame should be completely divided by NumLCUInUnit" );
    21582130
     2131#if !KWU_FIX_URQ
    21592132    m_iMaxDeltaQP       = MAX_DELTA_QP;
     2133#endif
    21602134    m_iMaxCuDQPDepth    = MAX_CUDQP_DEPTH;
    21612135  }
    21622136#endif
    2163 #if H_MV5
    21642137#if H_MV
    21652138  // VPS VUI
    … …  
    21842157  }
    21852158#endif
    2186 #endif
    21872159
    21882160  xConfirmPara(!m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagValue, "CUTransquantBypassFlagValue cannot be 1 when TransquantBypassEnableFlag is 0");
    … …  
    22502222#endif
    22512223#if H_MV
    2252 #if H_MV5
    22532224  xPrintParaVector( "ViewIdVal"     , m_viewId );
    22542225  xPrintParaVector( "ViewOrderIndex", m_viewOrderIndex );
    2255 #else
    2256   xPrintParaVector( "ViewId", m_viewId );
    2257 #endif
    22582226#endif
    22592227#if H_3D
    … …  
    22682236  printf("Real     Format              : %dx%d %dHz\n", m_iSourceWidth - m_confLeft - m_confRight, m_iSourceHeight - m_confTop - m_confBottom, m_iFrameRate );
    22692237  printf("Internal Format              : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate );
     2238  if (m_isField)
     2239  {
     2240    printf("Frame/Field          : Field based coding\n");
     2241    printf("Field index          : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
     2242    if (m_isTopFieldFirst)
     2243    {
     2244      printf("Field Order            : Top field first\n");
     2245    }
     2246    else
     2247    {
     2248      printf("Field Order            : Bottom field first\n");
     2249    }
     2250  }
     2251  else
     2252  {
     2253    printf("Frame/Field                  : Frame based coding\n");
    22702254  printf("Frame index                  : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded );
     2255  }
    22712256  printf("CU size / depth              : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth );
    22722257  printf("RQT trans. size (min / max)  : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize );
    … …  
    22992284    printf("InitialQP                    : %d\n", m_RCInitialQP );
    23002285    printf("ForceIntraQP                 : %d\n", m_RCForceIntraQP );
     2286
     2287#if KWU_RC_MADPRED_E0227
     2288    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
     2289#endif
     2290#if KWU_RC_VIEWRC_E0227
     2291    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
     2292    if(m_viewWiseRateCtrl)
     2293    {
     2294
     2295      printf("ViewWiseTargetBits           : ");
     2296      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
     2297        printf("%d ", m_viewTargetBits[i]);
     2298      printf("\n");
     2299    }
     2300    else
     2301    {
     2302      printf("TargetBitrate                : %d\n", m_RCTargetBitrate );
     2303    }
     2304#endif
    23012305  }
    23022306#else
    … …  
    23062310    printf("TargetBitrate                : %d\n", m_targetBitrate);
    23072311    printf("NumLCUInUnit                 : %d\n", m_numLCUInUnit);
     2312
     2313#if KWU_RC_MADPRED_E0227
     2314    printf("Depth based MAD prediction   : %d\n", m_depthMADPred);
     2315#endif
     2316#if KWU_RC_VIEWRC_E0227
     2317    printf("View-wise Rate control       : %d\n", m_viewWiseRateCtrl);
     2318    if(m_viewWiseRateCtrl)
     2319    {
     2320
     2321      printf("ViewWiseTargetBits           : ");
     2322      for (Int i = 0 ; i < m_iNumberOfViews ; i++)
     2323        printf("%d ", m_viewTargetBits[i]);
     2324      printf("\n");
     2325    }
     2326    else
     2327    {
     2328      printf("TargetBitrate                : %d\n", m_targetBitrate );
     2329    }
     2330#endif
    23082331  }
    23092332#endif
    … …  
    24142437  printf("DLT:%d ", m_useDLT );
    24152438#endif
    2416 #if LGE_INTER_SDC_E0156
     2439#if H_3D_INTER_SDC
    24172440  printf( "interSDC: %d ", m_bDepthInterSDCFlag ? 1 : 0 );
    24182441#endif

  • trunk/source/App/TAppEncoder/TAppEncCfg.h

    r622 r655  
    6969  std::vector<char*>     m_pchReconFileList;                  ///< output reconstruction file names
    7070  Int                    m_numberOfLayers;                    ///< number of Layers to Encode
    71 #if H_MV5
    7271  Int                    m_iNumberOfViews;                    ///< number of Layers that are views
    73 #else
    74 #if H_3D
    75   Int                    m_iNumberOfViews;                    ///< number of Layers that are views
    76 #endif
    77 #endif
    7872#else
    7973  Char*     m_pchReconFile;                                   ///< output reconstruction file
    … …  
    8377  std::vector< std::vector<Int> > m_dimIds;                   ///< dimension ids ( pointers to m_viewId and m_depthFlag
    8478  std::vector<Int>       m_viewId;                            ///< view id
    85 #if H_MV5
    8679  std::vector<Int>       m_viewOrderIndex;                    ///< view order index 
    87 #endif
    8880#if H_3D
    8981  std::vector<Int>       m_depthFlag;                         ///< depth flag
    … …  
    10698  std::vector< std::vector<Int> > m_dependencyTypes;          ///< Dependency types of direct reference layers
    10799
    108 #if H_MV5
    109100  // VPS VUI
    110101  Bool m_vpsVuiPresentFlag;
    … …  
    122113  std::vector< std::vector<Bool > > m_ctuBasedOffsetEnabledFlag;
    123114  std::vector< std::vector<Int  > > m_minHorizontalCtuOffsetPlus1;
    124 #endif
    125115
    126116#if H_3D_IV_MERGE
    … …  
    149139  UInt      m_FrameSkip;                                      ///< number of skipped frames from the beginning
    150140  Int       m_iSourceWidth;                                   ///< source width in pixel
    151   Int       m_iSourceHeight;                                  ///< source height in pixel
     141  Int       m_iSourceHeight;                                  ///< source height in pixel (when interlaced = field height)
     142 
     143  Int       m_iSourceHeightOrg;                               ///< original source height in pixel (when interlaced = frame height)
     144 
     145  bool      m_isField;                                        ///< enable field coding
     146  bool      m_isTopFieldFirst;
     147 
    152148  Int       m_conformanceMode;
    153149  Int       m_confLeft;
    … …  
    367363  Int       m_RCInitialQP;                        ///< inital QP for rate control
    368364  Bool      m_RCForceIntraQP;                     ///< force all intra picture to use initial QP or not
     365
     366#if KWU_RC_VIEWRC_E0227
     367  vector<Int>     m_viewTargetBits;
     368  Bool      m_viewWiseRateCtrl;                              ///< Flag for using view-wise rate control
     369#endif
     370#if KWU_RC_MADPRED_E0227
     371  UInt       m_depthMADPred;
     372#endif
    369373#else
    370374  Bool      m_enableRateCtrl;                                   ///< Flag for using rate control algorithm
    371375  Int       m_targetBitrate;                                 ///< target bitrate
    372376  Int       m_numLCUInUnit;                                  ///< Total number of LCUs in a frame should be completely divided by the NumLCUInUnit
     377
     378#if KWU_RC_VIEWRC_E0227
     379  vector<Int>     m_viewTargetBits;
     380  Bool      m_viewWiseRateCtrl;                              ///< Flag for using view-wise rate control
     381#endif
     382#if KWU_RC_MADPRED_E0227
     383  UInt       m_depthMADPred;
     384#endif
    373385#endif
    374386  Int       m_useScalingListId;                               ///< using quantization matrix
    … …  
    457469  Bool      m_bUsePC;                                         ///< flag for using Predictive Coding with QTL
    458470#endif
    459 #if LGE_INTER_SDC_E0156
     471#if H_3D_INTER_SDC
    460472  Bool m_bDepthInterSDCFlag;                                ///< flag for inter SDC of depth map coding
    461473#endif

  • trunk/source/App/TAppEncoder/TAppEncTop.cpp

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

  • trunk/source/App/TAppEncoder/TAppEncTop.h

    r622 r655  
    5050#endif
    5151
     52#if KWU_RC_MADPRED_E0227
     53class TEncTop;
     54#endif
    5255//! \ingroup TAppEncoder
    5356//! \{
    … …  
    9396  Void  xCreateLib        ();                               ///< create files & encoder class
    9497  Void  xInitLibCfg       ();                               ///< initialize internal variables
    95   Void  xInitLib          ();                               ///< initialize encoder class
     98  Void  xInitLib          (Bool isFieldCoding);             ///< initialize encoder class
    9699  Void  xDestroyLib       ();                               ///< destroy encoder class
    97100 
    … …  
    121124  Void xSetLayerSets              ( TComVPS& vps );
    122125  Void xSetProfileTierLevel       ( TComVPS& vps );
    123 #if H_MV5
    124126  Void xSetRepFormat              ( TComVPS& vps );
    125127  Void xSetVPSVUI                 ( TComVPS& vps );
    126128  GOPEntry* xGetGopEntry( Int layerIdInVps, Int poc );
    127 #endif
    128129  Int  xGetMax( std::vector<Int>& vec);
    129130#endif
Note: See TracChangeset for help on using the changeset viewer.