Changeset 849 in SHVCSoftware for branches/SHM-dev/source/App/TAppEncoder


Ignore:
Timestamp:
29 Jul 2014, 14:03:05 (10 years ago)
Author:
sharp
Message:

JCTVC-R0340 Resampling modifications (Macro:R0340_RESAMPLING_MODIFICATION)

Include generic phase (R0209), ref. region offset (R0013), move scaled ref offset to PPS (R0013), remove clip to scaled ref window (R0220) and ref offset signal change (R0220).

From: Tomoyuki Yamamoto <yamamoto.tomoyuki@…>

Location:
branches/SHM-dev/source/App/TAppEncoder
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r829 r849  
    384384  string    cfg_scaledRefLayerBottomOffset [MAX_LAYERS];
    385385  Int*      cfg_numScaledRefLayerOffsets[MAX_LAYERS];
     386#if REF_REGION_OFFSET
     387  string    cfg_scaledRefLayerOffsetPresentFlag [MAX_LAYERS];
     388  string    cfg_refRegionOffsetPresentFlag      [MAX_LAYERS];
     389  string    cfg_refRegionLeftOffset   [MAX_LAYERS];
     390  string    cfg_refRegionTopOffset    [MAX_LAYERS];
     391  string    cfg_refRegionRightOffset  [MAX_LAYERS];
     392  string    cfg_refRegionBottomOffset [MAX_LAYERS];
     393#endif
     394#if R0209_GENERIC_PHASE
     395  string    cfg_resamplePhaseSetPresentFlag [MAX_LAYERS];
     396  string    cfg_phaseHorLuma   [MAX_LAYERS];
     397  string    cfg_phaseVerLuma   [MAX_LAYERS];
     398  string    cfg_phaseHorChroma [MAX_LAYERS];
     399  string    cfg_phaseVerChroma [MAX_LAYERS];
     400#else
    386401#if P0312_VERT_PHASE_ADJ
    387402  string    cfg_vertPhasePositionEnableFlag[MAX_LAYERS];
     403#endif
    388404#endif
    389405
    … …  
    395411  string*    cfg_scaledRefLayerRightOffsetPtr  [MAX_LAYERS];
    396412  string*    cfg_scaledRefLayerBottomOffsetPtr [MAX_LAYERS];
     413#if REF_REGION_OFFSET
     414  string*    cfg_scaledRefLayerOffsetPresentFlagPtr [MAX_LAYERS];
     415  string*    cfg_refRegionOffsetPresentFlagPtr      [MAX_LAYERS];
     416  string*    cfg_refRegionLeftOffsetPtr   [MAX_LAYERS];
     417  string*    cfg_refRegionTopOffsetPtr    [MAX_LAYERS];
     418  string*    cfg_refRegionRightOffsetPtr  [MAX_LAYERS];
     419  string*    cfg_refRegionBottomOffsetPtr [MAX_LAYERS];
     420#endif
     421#if R0209_GENERIC_PHASE
     422  string*    cfg_resamplePhaseSetPresentFlagPtr [MAX_LAYERS];
     423  string*    cfg_phaseHorLumaPtr   [MAX_LAYERS];
     424  string*    cfg_phaseVerLumaPtr   [MAX_LAYERS];
     425  string*    cfg_phaseHorChromaPtr [MAX_LAYERS];
     426  string*    cfg_phaseVerChromaPtr [MAX_LAYERS];
     427#endif
    397428#if P0312_VERT_PHASE_ADJ
    398429  string*    cfg_vertPhasePositionEnableFlagPtr[MAX_LAYERS];
    … …  
    466497#if P0312_VERT_PHASE_ADJ
    467498      cfg_vertPhasePositionEnableFlagPtr[layer] = &cfg_vertPhasePositionEnableFlag[layer];
     499#endif
     500#if REF_REGION_OFFSET
     501      cfg_scaledRefLayerOffsetPresentFlagPtr [layer] = &cfg_scaledRefLayerOffsetPresentFlag [layer];
     502      cfg_refRegionOffsetPresentFlagPtr      [layer] = &cfg_refRegionOffsetPresentFlag      [layer];
     503      cfg_refRegionLeftOffsetPtr  [layer] = &cfg_refRegionLeftOffset  [layer];
     504      cfg_refRegionTopOffsetPtr   [layer] = &cfg_refRegionTopOffset   [layer];
     505      cfg_refRegionRightOffsetPtr [layer] = &cfg_refRegionRightOffset [layer];
     506      cfg_refRegionBottomOffsetPtr[layer] = &cfg_refRegionBottomOffset[layer];
     507#endif
     508#if R0209_GENERIC_PHASE
     509      cfg_resamplePhaseSetPresentFlagPtr [layer] = &cfg_resamplePhaseSetPresentFlag [layer];
     510      cfg_phaseHorLumaPtr   [layer] = &cfg_phaseHorLuma   [layer];
     511      cfg_phaseVerLumaPtr   [layer] = &cfg_phaseVerLuma   [layer];
     512      cfg_phaseHorChromaPtr [layer] = &cfg_phaseHorChroma [layer];
     513      cfg_phaseVerChromaPtr [layer] = &cfg_phaseVerChroma [layer];
    468514#endif
    469515    }
    … …  
    597643  ("ScaledRefLayerBottomOffset%d", cfg_scaledRefLayerBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of scaled base layer picture with respect to"
    598644  " bottom-right luma sample of the EL picture, in units of two luma samples")
     645#if REF_REGION_OFFSET
     646  ("ScaledRefLayerOffsetPresentFlag%d",      cfg_scaledRefLayerOffsetPresentFlagPtr,     string(""), MAX_LAYERS, "presense flag of scaled reference layer offsets")
     647  ("RefRegionOffsetPresentFlag%d",           cfg_refRegionOffsetPresentFlagPtr,          string(""), MAX_LAYERS, "presense flag of reference region offsets")
     648  ("RefRegionLeftOffset%d",   cfg_refRegionLeftOffsetPtr,  string(""), MAX_LAYERS, "Horizontal offset of top-left luma sample of ref region with respect to"
     649                                                                 " top-left luma sample of the BL picture, in units of two luma samples")
     650  ("RefRegionTopOffset%d",    cfg_refRegionTopOffsetPtr,   string(""), MAX_LAYERS,   "Vertical offset of top-left luma sample of ref region with respect to"
     651                                                                 " top-left luma sample of the BL picture, in units of two luma samples")
     652  ("RefRegionRightOffset%d",  cfg_refRegionRightOffsetPtr, string(""), MAX_LAYERS, "Horizontal offset of bottom-right luma sample of ref region with respect to"
     653                                                                 " bottom-right luma sample of the BL picture, in units of two luma samples")
     654  ("RefRegionBottomOffset%d", cfg_refRegionBottomOffsetPtr,string(""), MAX_LAYERS, "Vertical offset of bottom-right luma sample of ref region with respect to"
     655                                                                 " bottom-right luma sample of the BL picture, in units of two luma samples")
     656#endif
     657#if R0209_GENERIC_PHASE
     658  ("ResamplePhaseSetPresentFlag%d",  cfg_resamplePhaseSetPresentFlagPtr, string(""), MAX_LAYERS, "presense flag of resample phase set")
     659  ("PhaseHorLuma%d",   cfg_phaseHorLumaPtr,   string(""), MAX_LAYERS, "luma shift in the horizontal direction used in resampling proces")
     660  ("PhaseVerLuma%d",   cfg_phaseVerLumaPtr,   string(""), MAX_LAYERS, "luma shift in the vertical   direction used in resampling proces")
     661  ("PhaseHorChroma%d", cfg_phaseHorChromaPtr, string(""), MAX_LAYERS, "chroma shift in the horizontal direction used in resampling proces")
     662  ("PhaseVerChroma%d", cfg_phaseVerChromaPtr, string(""), MAX_LAYERS, "chroma shift in the vertical   direction used in resampling proces")
     663#endif
    599664#if P0312_VERT_PHASE_ADJ
    600665  ("VertPhasePositionEnableFlag%d", cfg_vertPhasePositionEnableFlagPtr,string(""), MAX_LAYERS, "VertPhasePositionEnableFlag for layer %d")
    … …  
    11871252      assert( strcmp(cfg_scaledRefLayerId[layer].c_str(),  ""));
    11881253#endif
     1254#if REF_REGION_OFFSET
     1255      Bool srloFlag =
     1256        strcmp(cfg_scaledRefLayerLeftOffset   [layer].c_str(), "") ||
     1257        strcmp(cfg_scaledRefLayerRightOffset  [layer].c_str(), "") ||
     1258        strcmp(cfg_scaledRefLayerTopOffset    [layer].c_str(), "") ||
     1259        strcmp(cfg_scaledRefLayerBottomOffset [layer].c_str(), "");
     1260      Bool rroFlag =
     1261        strcmp(cfg_refRegionLeftOffset   [layer].c_str(), "") ||
     1262        strcmp(cfg_refRegionRightOffset  [layer].c_str(), "") ||
     1263        strcmp(cfg_refRegionTopOffset    [layer].c_str(), "") ||
     1264        strcmp(cfg_refRegionBottomOffset [layer].c_str(), "");
     1265#if R0209_GENERIC_PHASE
     1266      Bool phaseSetFlag =
     1267        strcmp(cfg_phaseHorLuma   [layer].c_str(), "") ||
     1268        strcmp(cfg_phaseVerLuma  [layer].c_str(), "") ||
     1269        strcmp(cfg_phaseHorChroma    [layer].c_str(), "") ||
     1270        strcmp(cfg_phaseVerChroma [layer].c_str(), "");
     1271      assert( srloFlag || rroFlag || phaseSetFlag);
     1272#else
     1273      assert( srloFlag || rroFlag );
     1274#endif
     1275#else
    11891276#if P0312_VERT_PHASE_ADJ
    11901277      assert( strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(),  "") ||
    … …  
    11991286              strcmp(cfg_scaledRefLayerBottomOffset[layer].c_str(),"") );
    12001287#endif
     1288#endif
    12011289    }
    12021290
    … …  
    12191307#endif
    12201308
     1309#if REF_REGION_OFFSET
     1310    // Presense Flag //
     1311    if(strcmp(cfg_scaledRefLayerOffsetPresentFlag[layer].c_str(),  ""))
     1312    {
     1313      cfgStringToArray( &tempArray, cfg_scaledRefLayerOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "ScaledRefLayerOffsetPresentFlag");
     1314      if(tempArray)
     1315      {
     1316        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1317        {
     1318          m_acLayerCfg[layer].m_scaledRefLayerOffsetPresentFlag[i] = tempArray[i];
     1319        }
     1320        delete [] tempArray; tempArray = NULL;
     1321      }
     1322    }
     1323#endif
     1324
    12211325    // Left offset //
    12221326    if(strcmp(cfg_scaledRefLayerLeftOffset[layer].c_str(),  ""))
    … …  
    12891393    }
    12901394#endif
    1291   }
     1395#if REF_REGION_OFFSET
     1396    // Presense Flag //
     1397    if(strcmp(cfg_refRegionOffsetPresentFlag[layer].c_str(),  ""))
     1398    {
     1399      cfgStringToArray( &tempArray, cfg_refRegionOffsetPresentFlag[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionOffsetPresentFlag");
     1400      if(tempArray)
     1401      {
     1402        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1403        {
     1404          m_acLayerCfg[layer].m_refRegionOffsetPresentFlag[i] = tempArray[i];
     1405        }
     1406        delete [] tempArray; tempArray = NULL;
     1407      }
     1408    }
     1409
     1410    // Left offset //
     1411    if(strcmp(cfg_refRegionLeftOffset[layer].c_str(),  ""))
     1412    {
     1413      cfgStringToArray( &tempArray, cfg_refRegionLeftOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionLeftOffset");
     1414      if(tempArray)
     1415      {
     1416        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1417        {
     1418          m_acLayerCfg[layer].m_refRegionLeftOffset[i] = tempArray[i];
     1419        }
     1420        delete [] tempArray; tempArray = NULL;
     1421      }
     1422    }
     1423
     1424    // Top offset //
     1425    if(strcmp(cfg_refRegionTopOffset[layer].c_str(),  ""))
     1426    {
     1427      cfgStringToArray( &tempArray, cfg_refRegionTopOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionTopOffset");
     1428      if(tempArray)
     1429      {
     1430        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1431        {
     1432          m_acLayerCfg[layer].m_refRegionTopOffset[i] = tempArray[i];
     1433        }
     1434        delete [] tempArray; tempArray = NULL;
     1435      }
     1436    }
     1437
     1438    // Right offset //
     1439    if(strcmp(cfg_refRegionRightOffset[layer].c_str(),  ""))
     1440    {
     1441      cfgStringToArray( &tempArray, cfg_refRegionRightOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionRightOffset");
     1442      if(tempArray)
     1443      {
     1444        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1445        {
     1446          m_acLayerCfg[layer].m_refRegionRightOffset[i] = tempArray[i];
     1447        }
     1448        delete [] tempArray; tempArray = NULL;
     1449      }
     1450    }
     1451
     1452    // Bottom offset //
     1453    if(strcmp(cfg_refRegionBottomOffset[layer].c_str(),  ""))
     1454    {
     1455      cfgStringToArray( &tempArray, cfg_refRegionBottomOffset[layer], m_acLayerCfg[layer].m_numScaledRefLayerOffsets, "RefRegionBottomOffset");
     1456      if(tempArray)
     1457      {
     1458        for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     1459        {
     1460          m_acLayerCfg[layer].m_refRegionBottomOffset[i] = tempArray[i];
     1461        }
     1462        delete [] tempArray; tempArray = NULL;
     1463      }
     1464    }
     1465#endif
     1466#if R0209_GENERIC_PHASE
     1467    Int numPhaseSet = m_acLayerCfg[layer].m_numScaledRefLayerOffsets;
     1468
     1469    // Presense Flag //
     1470    if(strcmp(cfg_resamplePhaseSetPresentFlag[layer].c_str(),  ""))
     1471    {
     1472      cfgStringToArray( &tempArray, cfg_resamplePhaseSetPresentFlag[layer], numPhaseSet, "resamplePhaseSetPresentFlag");
     1473      if(tempArray)
     1474      {
     1475        for(Int i = 0; i < numPhaseSet; i++)
     1476        {
     1477          m_acLayerCfg[layer].m_resamplePhaseSetPresentFlag[i] = tempArray[i];
     1478        }
     1479        delete [] tempArray; tempArray = NULL;
     1480      }
     1481    }
     1482
     1483    // Luma horizontal phase //
     1484    if(strcmp(cfg_phaseHorLuma[layer].c_str(),  ""))
     1485    {
     1486      cfgStringToArray( &tempArray, cfg_phaseHorLuma[layer], numPhaseSet, "phaseHorLuma");
     1487      if(tempArray)
     1488      {
     1489        for(Int i = 0; i < numPhaseSet; i++)
     1490        {
     1491          m_acLayerCfg[layer].m_phaseHorLuma[i] = tempArray[i];
     1492        }
     1493        delete [] tempArray; tempArray = NULL;
     1494      }
     1495    }
     1496
     1497    // Luma vertical phase //
     1498    if(strcmp(cfg_phaseVerLuma[layer].c_str(),  ""))
     1499    {
     1500      cfgStringToArray( &tempArray, cfg_phaseVerLuma[layer], numPhaseSet, "phaseVerLuma");
     1501      if(tempArray)
     1502      {
     1503        for(Int i = 0; i < numPhaseSet; i++)
     1504        {
     1505          m_acLayerCfg[layer].m_phaseVerLuma[i] = tempArray[i];
     1506        }
     1507        delete [] tempArray; tempArray = NULL;
     1508      }
     1509    }
     1510
     1511    // Chroma horizontal phase //
     1512    if(strcmp(cfg_phaseHorChroma[layer].c_str(),  ""))
     1513    {
     1514      cfgStringToArray( &tempArray, cfg_phaseHorChroma[layer], numPhaseSet, "phaseHorChroma");
     1515      if(tempArray)
     1516      {
     1517        for(Int i = 0; i < numPhaseSet; i++)
     1518        {
     1519          m_acLayerCfg[layer].m_phaseHorChroma[i] = tempArray[i];
     1520        }
     1521        delete [] tempArray; tempArray = NULL;
     1522      }
     1523    }
     1524
     1525    // Chroma vertical phase //
     1526    if(strcmp(cfg_phaseVerChroma[layer].c_str(),  ""))
     1527    {
     1528      cfgStringToArray( &tempArray, cfg_phaseVerChroma[layer], numPhaseSet, "phaseVerChroma");
     1529      if(tempArray)
     1530      {
     1531        for(Int i = 0; i < numPhaseSet; i++)
     1532        {
     1533          m_acLayerCfg[layer].m_phaseVerChroma[i] = tempArray[i];
     1534        }
     1535        delete [] tempArray; tempArray = NULL;
     1536      }
     1537    }
     1538#endif
     1539  }
     1540
    12921541#if VPS_EXTN_DIRECT_REF_LAYERS
    12931542  for(Int layer = 0; layer < MAX_LAYERS; layer++)

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

    r823 r849  
    6060  ::memset(m_scaledRefLayerRightOffset,  0, sizeof(m_scaledRefLayerRightOffset));
    6161  ::memset(m_scaledRefLayerBottomOffset, 0, sizeof(m_scaledRefLayerBottomOffset));
     62#if REF_REGION_OFFSET
     63  ::memset(m_scaledRefLayerOffsetPresentFlag, 0, sizeof(m_scaledRefLayerOffsetPresentFlag));
     64  ::memset(m_refRegionOffsetPresentFlag, 0, sizeof(m_refRegionOffsetPresentFlag));
     65  ::memset(m_refRegionLeftOffset,   0, sizeof(m_refRegionLeftOffset));
     66  ::memset(m_refRegionTopOffset,    0, sizeof(m_refRegionTopOffset));
     67  ::memset(m_refRegionRightOffset,  0, sizeof(m_refRegionRightOffset));
     68  ::memset(m_refRegionBottomOffset, 0, sizeof(m_refRegionBottomOffset));
     69#endif
     70#if R0209_GENERIC_PHASE
     71  ::memset(m_resamplePhaseSetPresentFlag, 0, sizeof(m_resamplePhaseSetPresentFlag));
     72  ::memset(m_phaseHorLuma,   0, sizeof(m_phaseHorLuma));
     73  ::memset(m_phaseVerLuma,   0, sizeof(m_phaseVerLuma));
     74  ::memset(m_phaseHorChroma, 0, sizeof(m_phaseHorChroma));
     75  ::memset(m_phaseVerChroma, 0, sizeof(m_phaseVerChroma));
     76#else
    6277#if P0312_VERT_PHASE_ADJ
    6378  ::memset(m_vertPhasePositionEnableFlag, 0, sizeof(m_vertPhasePositionEnableFlag));
     79#endif
    6480#endif
    6581}

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

    r823 r849  
    9898  Int       m_scaledRefLayerRightOffset [MAX_LAYERS];
    9999  Int       m_scaledRefLayerBottomOffset[MAX_LAYERS];
    100 #if P0312_VERT_PHASE_ADJ
     100#if REF_REGION_OFFSET
     101  Bool      m_scaledRefLayerOffsetPresentFlag [MAX_LAYERS];
     102  Bool      m_refRegionOffsetPresentFlag      [MAX_LAYERS];
     103  Int       m_refRegionLeftOffset  [MAX_LAYERS];
     104  Int       m_refRegionTopOffset   [MAX_LAYERS];
     105  Int       m_refRegionRightOffset [MAX_LAYERS];
     106  Int       m_refRegionBottomOffset[MAX_LAYERS];
     107#endif
     108#if P0312_VERT_PHASE_ADJ
    101109  Bool      m_vertPhasePositionEnableFlag[MAX_LAYERS];
     110#endif
     111#if R0209_GENERIC_PHASE
     112  Int       m_phaseHorLuma  [MAX_LAYERS];
     113  Int       m_phaseVerLuma  [MAX_LAYERS];
     114  Int       m_phaseHorChroma[MAX_LAYERS];
     115  Int       m_phaseVerChroma[MAX_LAYERS];
     116  Bool      m_resamplePhaseSetPresentFlag [MAX_LAYERS];
    102117#endif
    103118

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

    r835 r849  
    351351        }
    352352      }
     353#if REF_REGION_OFFSET
     354      for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
     355      {
     356#if AUXILIARY_PICTURES
     357        Int cf = m_acLayerCfg[i].m_chromaFormatIDC;
     358        Int rlSubWidthC  = ( cf == CHROMA_420 || cf == CHROMA_422 ) ? 2 : 1;
     359        Int rlSubHeightC = ( cf == CHROMA_420 ) ? 2 : 1;
     360#else
     361        Int rlSubWidthC  = 2;
     362        Int rlSubHeightC = 2;
     363#endif
     364        m_acTEncTop[layer].setRefRegionOffsetPresentFlag( i, m_acLayerCfg[layer].m_refRegionOffsetPresentFlag );
     365        m_acTEncTop[layer].getRefLayerWindow(i).setWindow( rlSubWidthC  * m_acLayerCfg[layer].m_refRegionLeftOffset[i], rlSubWidthC  * m_acLayerCfg[layer].m_refRegionRightOffset[i],
     366                                                           rlSubHeightC * m_acLayerCfg[layer].m_refRegionTopOffset[i],  rlSubHeightC * m_acLayerCfg[layer].m_refRegionBottomOffset[i]);
     367      }
     368#endif
    353369    }
    354370    else
    … …  
    622638    if( layer > 0 )
    623639    {
     640#if REF_REGION_OFFSET
     641#if AUXILIARY_PICTURES
     642      Int cf = m_acLayerCfg[layer].m_chromaFormatIDC;
     643      Int subWidthC  = ( cf == CHROMA_420 || cf == CHROMA_422 ) ? 2 : 1;
     644      Int subHeightC = ( cf == CHROMA_420 ) ? 2 : 1;
     645#else
     646      Int subWidthC  = 2;
     647      Int subHeightC = 2;
     648#endif
     649#endif
    624650      m_acTEncTop[layer].setNumScaledRefLayerOffsets( m_acLayerCfg[layer].m_numScaledRefLayerOffsets );
    625651      for(Int i = 0; i < m_acLayerCfg[layer].m_numScaledRefLayerOffsets; i++)
    … …  
    628654        m_acTEncTop[layer].setScaledRefLayerId(i, m_acLayerCfg[layer].m_scaledRefLayerId[i]);
    629655#endif
     656#if REF_REGION_OFFSET
     657        m_acTEncTop[layer].setScaledRefLayerOffsetPresentFlag( i, m_acLayerCfg[layer].m_scaledRefLayerOffsetPresentFlag[i] );
     658        m_acTEncTop[layer].getScaledRefLayerWindow(i).setWindow( subWidthC  * m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i], subWidthC  * m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i],
     659                                                                 subHeightC * m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i],  subHeightC * m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i]);
     660#else
    630661#if P0312_VERT_PHASE_ADJ
    631662        m_acTEncTop[layer].setVertPhasePositionEnableFlag( i, m_acLayerCfg[layer].m_vertPhasePositionEnableFlag[i] );
    … …  
    635666        m_acTEncTop[layer].getScaledRefLayerWindow(i).setWindow( 2*m_acLayerCfg[layer].m_scaledRefLayerLeftOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerRightOffset[i],
    636667                                                  2*m_acLayerCfg[layer].m_scaledRefLayerTopOffset[i], 2*m_acLayerCfg[layer].m_scaledRefLayerBottomOffset[i]);
     668#endif
     669#endif
     670#if R0209_GENERIC_PHASE
     671        m_acTEncTop[layer].setResamplePhaseSetPresentFlag( i, m_acLayerCfg[layer].m_resamplePhaseSetPresentFlag[i] );
     672        m_acTEncTop[layer].setPhaseHorLuma( i, m_acLayerCfg[layer].m_phaseHorLuma[i] );
     673        m_acTEncTop[layer].setPhaseVerLuma( i, m_acLayerCfg[layer].m_phaseVerLuma[i] );
     674        m_acTEncTop[layer].setPhaseHorChroma( i, m_acLayerCfg[layer].m_phaseHorChroma[i] );
     675        m_acTEncTop[layer].setPhaseVerChroma( i, m_acLayerCfg[layer].m_phaseVerChroma[i] );
    637676#endif
    638677      }
Note: See TracChangeset for help on using the changeset viewer.