Changeset 1460 in SHVCSoftware for branches/SHM-dev/source/Lib/TLibEncoder


Ignore:
Timestamp:
20 Aug 2015, 20:54:17 (10 years ago)
Author:
seregin
Message:

port rev 4594

Location:
branches/SHM-dev/source/Lib/TLibEncoder
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r1459 r1460  
    421421}
    422422
     423#if Q0074_COLOUR_REMAPPING_SEI
     424template <typename T>
     425static Void readTokenValue(T            &returnedValue, /// value returned
     426                           Bool         &failed,        /// used and updated
     427                           std::istream &is,            /// stream to read token from
     428                           const TChar  *pToken)        /// token string
     429{
     430  returnedValue=T();
     431  if (failed)
     432  {
     433    return;
     434  }
     435
     436  Int c;
     437  // Ignore any whitespace
     438  while ((c=is.get())!=EOF && isspace(c));
     439  // test for comment mark
     440  while (c=='#')
     441  {
     442    // Ignore to the end of the line
     443    while ((c=is.get())!=EOF && (c!=10 && c!=13));
     444    // Ignore any white space at the start of the next line
     445    while ((c=is.get())!=EOF && isspace(c));
     446  }
     447  // test first character of token
     448  failed=(c!=pToken[0]);
     449  // test remaining characters of token
     450  Int pos;
     451  for(pos=1;!failed && pToken[pos]!=0 && is.get()==pToken[pos]; pos++);
     452  failed|=(pToken[pos]!=0);
     453  // Ignore any whitespace before the ':'
     454  while (!failed && (c=is.get())!=EOF && isspace(c));
     455  failed|=(c!=':');
     456  // Now read the value associated with the token:
     457  if (!failed)
     458  {
     459    is >> returnedValue;
     460    failed=!is.good();
     461    if (!failed)
     462    {
     463      c=is.get();
     464      failed=(c!=EOF && !isspace(c));
     465    }
     466  }
     467  if (failed)
     468  {
     469    std::cerr << "Unable to read token '" << pToken << "'\n";
     470  }
     471}
     472
     473template <typename T>
     474static Void readTokenValueAndValidate(T            &returnedValue, /// value returned
     475                                      Bool         &failed,        /// used and updated
     476                                      std::istream &is,            /// stream to read token from
     477                                      const TChar  *pToken,        /// token string
     478                                      const T      &minInclusive,  /// minimum value allowed, inclusive
     479                                      const T      &maxInclusive)  /// maximum value allowed, inclusive
     480{
     481  readTokenValue(returnedValue, failed, is, pToken);
     482  if (!failed)
     483  {
     484    if (returnedValue<minInclusive || returnedValue>maxInclusive)
     485    {
     486      failed=true;
     487      std::cerr << "Value for token " << pToken << " must be in the range " << minInclusive << " to " << maxInclusive << " (inclusive); value read: " << returnedValue << std::endl;
     488    }
     489  }
     490}
     491
     492// Bool version does not have maximum and minimum values.
     493static Void readTokenValueAndValidate(Bool         &returnedValue, /// value returned
     494                                      Bool         &failed,        /// used and updated
     495                                      std::istream &is,            /// stream to read token from
     496                                      const TChar  *pToken)        /// token string
     497{
     498  readTokenValue(returnedValue, failed, is, pToken);
     499}
     500
     501Bool SEIEncoder::initSEIColourRemappingInfo(SEIColourRemappingInfo* seiColourRemappingInfo, Int currPOC) // returns true on success, false on failure.
     502{
     503  assert (m_isInitialized);
     504  assert (seiColourRemappingInfo!=NULL);
     505
     506  // reading external Colour Remapping Information SEI message parameters from file
     507  if( !m_pcCfg->getColourRemapInfoSEIFileRoot().empty())
     508  {
     509    Bool failed=false;
     510
     511    // building the CRI file name with poc num in prefix "_poc.txt"
     512    std::string colourRemapSEIFileWithPoc(m_pcCfg->getColourRemapInfoSEIFileRoot());
     513    {
     514      std::stringstream suffix;
     515      suffix << "_" << currPOC << ".txt";
     516      colourRemapSEIFileWithPoc+=suffix.str();
     517    }
     518
     519    std::ifstream fic(colourRemapSEIFileWithPoc.c_str());
     520    if (!fic.good() || !fic.is_open())
     521    {
     522      std::cerr <<  "No Colour Remapping Information SEI parameters file " << colourRemapSEIFileWithPoc << " for POC " << currPOC << std::endl;
     523      return false;
     524    }
     525
     526    // TODO: identify and remove duplication with decoder parsing through abstraction.
     527
     528    readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapId,         failed, fic, "colour_remap_id",        UInt(0), UInt(0x7fffffff) );
     529    readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapCancelFlag, failed, fic, "colour_remap_cancel_flag" );
     530    if( !seiColourRemappingInfo->m_colourRemapCancelFlag )
     531    {
     532      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapPersistenceFlag,            failed, fic, "colour_remap_persistence_flag" );
     533      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag, failed, fic, "colour_remap_video_signal_info_present_flag");
     534      if( seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag )
     535      {
     536        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapFullRangeFlag,      failed, fic, "colour_remap_full_range_flag" );
     537        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapPrimaries,          failed, fic, "colour_remap_primaries",           Int(0), Int(255) );
     538        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapTransferFunction,   failed, fic, "colour_remap_transfer_function",   Int(0), Int(255) );
     539        readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapMatrixCoefficients, failed, fic, "colour_remap_matrix_coefficients", Int(0), Int(255) );
     540      }
     541      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapInputBitDepth, failed, fic, "colour_remap_input_bit_depth",            Int(8), Int(16) );
     542      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapBitDepth,      failed, fic, "colour_remap_bit_depth",                  Int(8), Int(16) );
     543
     544      const Int maximumInputValue    = (1<<seiColourRemappingInfo->m_colourRemapInputBitDepth)-1;
     545      const Int maximumRemappedValue = (1<<seiColourRemappingInfo->m_colourRemapBitDepth)-1;
     546
     547      for( Int c=0 ; c<3 ; c++ )
     548      {
     549        readTokenValueAndValidate(seiColourRemappingInfo->m_preLutNumValMinus1[c],         failed, fic, "pre_lut_num_val_minus1[c]",        Int(0), Int(32) );
     550        if( seiColourRemappingInfo->m_preLutNumValMinus1[c]>0 )
     551        {
     552          seiColourRemappingInfo->m_preLut[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
     553          for( Int i=0 ; i<=seiColourRemappingInfo->m_preLutNumValMinus1[c] ; i++ )
     554          {
     555            readTokenValueAndValidate(seiColourRemappingInfo->m_preLut[c][i].codedValue,   failed, fic, "pre_lut_coded_value[c][i]",  Int(0), maximumInputValue    );
     556            readTokenValueAndValidate(seiColourRemappingInfo->m_preLut[c][i].targetValue,  failed, fic, "pre_lut_target_value[c][i]", Int(0), maximumRemappedValue );
     557          }
     558        }
     559      }
     560      readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapMatrixPresentFlag, failed, fic, "colour_remap_matrix_present_flag" );
     561      if( seiColourRemappingInfo->m_colourRemapMatrixPresentFlag )
     562      {
     563        readTokenValueAndValidate(seiColourRemappingInfo->m_log2MatrixDenom, failed, fic, "log2_matrix_denom", Int(0), Int(15) );
     564        for( Int c=0 ; c<3 ; c++ )
     565        {
     566          for( Int i=0 ; i<3 ; i++ )
     567          {
     568            readTokenValueAndValidate(seiColourRemappingInfo->m_colourRemapCoeffs[c][i], failed, fic, "colour_remap_coeffs[c][i]", -32768, 32767 );
     569          }
     570        }
     571      }
     572      for( Int c=0 ; c<3 ; c++ )
     573      {
     574        readTokenValueAndValidate(seiColourRemappingInfo->m_postLutNumValMinus1[c], failed, fic, "post_lut_num_val_minus1[c]", Int(0), Int(32) );
     575        if( seiColourRemappingInfo->m_postLutNumValMinus1[c]>0 )
     576        {
     577          seiColourRemappingInfo->m_postLut[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
     578          for( Int i=0 ; i<=seiColourRemappingInfo->m_postLutNumValMinus1[c] ; i++ )
     579          {
     580            readTokenValueAndValidate(seiColourRemappingInfo->m_postLut[c][i].codedValue,  failed, fic, "post_lut_coded_value[c][i]",  Int(0), maximumRemappedValue );
     581            readTokenValueAndValidate(seiColourRemappingInfo->m_postLut[c][i].targetValue, failed, fic, "post_lut_target_value[c][i]", Int(0), maximumRemappedValue );
     582          }
     583        }
     584      }
     585    }
     586
     587    if( failed )
     588    {
     589      std::cerr << "Error while reading Colour Remapping Information SEI parameters file '" << colourRemapSEIFileWithPoc << "'" << std::endl;
     590      exit(EXIT_FAILURE);
     591    }
     592  }
     593  return true;
     594}
     595#endif
     596
    423597Void SEIEncoder::initSEIChromaResamplingFilterHint(SEIChromaResamplingFilterHint *seiChromaResamplingFilterHint, Int iHorFilterIndex, Int iVerFilterIndex)
    424598{
    … …  
    646820#endif
    647821
    648 #if Q0074_COLOUR_REMAPPING_SEI
    649 Void SEIEncoder::initSEIColourRemappingInfo(SEIColourRemappingInfo *seiColourRemappingInfo, TComSEIColourRemappingInfo* cfgSeiColourRemappingInfo)
    650 {
    651   seiColourRemappingInfo->m_colourRemapId         = cfgSeiColourRemappingInfo->m_colourRemapSEIId;
    652   seiColourRemappingInfo->m_colourRemapCancelFlag = cfgSeiColourRemappingInfo->m_colourRemapSEICancelFlag;
    653   printf("xCreateSEIColourRemappingInfo - m_colourRemapId = %d m_colourRemapCancelFlag = %d \n",seiColourRemappingInfo->m_colourRemapId, seiColourRemappingInfo->m_colourRemapCancelFlag);
    654 
    655   if( !seiColourRemappingInfo->m_colourRemapCancelFlag )
    656   {
    657     seiColourRemappingInfo->m_colourRemapPersistenceFlag            = cfgSeiColourRemappingInfo->m_colourRemapSEIPersistenceFlag;
    658     seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag = cfgSeiColourRemappingInfo->m_colourRemapSEIVideoSignalInfoPresentFlag;
    659     if( seiColourRemappingInfo->m_colourRemapVideoSignalInfoPresentFlag )
    660     {
    661       seiColourRemappingInfo->m_colourRemapFullRangeFlag           = cfgSeiColourRemappingInfo->m_colourRemapSEIFullRangeFlag;
    662       seiColourRemappingInfo->m_colourRemapPrimaries               = cfgSeiColourRemappingInfo->m_colourRemapSEIPrimaries;
    663       seiColourRemappingInfo->m_colourRemapTransferFunction        = cfgSeiColourRemappingInfo->m_colourRemapSEITransferFunction;
    664       seiColourRemappingInfo->m_colourRemapMatrixCoefficients      = cfgSeiColourRemappingInfo->m_colourRemapSEIMatrixCoefficients;
    665     }
    666     seiColourRemappingInfo->m_colourRemapInputBitDepth             = cfgSeiColourRemappingInfo->m_colourRemapSEIInputBitDepth;
    667     seiColourRemappingInfo->m_colourRemapBitDepth                  = cfgSeiColourRemappingInfo->m_colourRemapSEIBitDepth;
    668     for( Int c=0 ; c<3 ; c++ )
    669     {
    670       seiColourRemappingInfo->m_preLutNumValMinus1[c] = cfgSeiColourRemappingInfo->m_colourRemapSEIPreLutNumValMinus1[c];
    671       if( seiColourRemappingInfo->m_preLutNumValMinus1[c]>0 )
    672       {
    673         seiColourRemappingInfo->m_preLutCodedValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
    674         seiColourRemappingInfo->m_preLutTargetValue[c].resize(seiColourRemappingInfo->m_preLutNumValMinus1[c]+1);
    675         for( Int i=0 ; i<=seiColourRemappingInfo->m_preLutNumValMinus1[c] ; i++)
    676         {
    677           seiColourRemappingInfo->m_preLutCodedValue[c][i]  = cfgSeiColourRemappingInfo->m_colourRemapSEIPreLutCodedValue[c][i];
    678           seiColourRemappingInfo->m_preLutTargetValue[c][i] = cfgSeiColourRemappingInfo->m_colourRemapSEIPreLutTargetValue[c][i];
    679         }
    680       }
    681     }
    682     seiColourRemappingInfo->m_colourRemapMatrixPresentFlag = cfgSeiColourRemappingInfo->m_colourRemapSEIMatrixPresentFlag;
    683     if( seiColourRemappingInfo->m_colourRemapMatrixPresentFlag )
    684     {
    685       seiColourRemappingInfo->m_log2MatrixDenom = cfgSeiColourRemappingInfo->m_colourRemapSEILog2MatrixDenom;
    686       for( Int c=0 ; c<3 ; c++ )
    687         for( Int i=0 ; i<3 ; i++ )
    688           seiColourRemappingInfo->m_colourRemapCoeffs[c][i] = cfgSeiColourRemappingInfo->m_colourRemapSEICoeffs[c][i];
    689     }
    690     for( Int c=0 ; c<3 ; c++ )
    691     {
    692       seiColourRemappingInfo->m_postLutNumValMinus1[c] = cfgSeiColourRemappingInfo->m_colourRemapSEIPostLutNumValMinus1[c];
    693       if( seiColourRemappingInfo->m_postLutNumValMinus1[c]>0 )
    694       {
    695         seiColourRemappingInfo->m_postLutCodedValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
    696         seiColourRemappingInfo->m_postLutTargetValue[c].resize(seiColourRemappingInfo->m_postLutNumValMinus1[c]+1);
    697         for( Int i=0 ; i<=seiColourRemappingInfo->m_postLutNumValMinus1[c] ; i++)
    698         {
    699           seiColourRemappingInfo->m_postLutCodedValue[c][i]  = cfgSeiColourRemappingInfo->m_colourRemapSEIPostLutCodedValue[c][i];
    700           seiColourRemappingInfo->m_postLutTargetValue[c][i] = cfgSeiColourRemappingInfo->m_colourRemapSEIPostLutTargetValue[c][i];
    701         }
    702       }
    703     }
    704   }
    705 }
    706 #endif
    707 
    708 
    709822#if O0164_MULTI_LAYER_HRD
    710823Void SEIEncoder::initBspNestingSEI(SEIScalableNesting *seiScalableNesting, const TComVPS *vps, const TComSPS *sps, Int olsIdx, Int partitioningSchemeIdx, Int bspIdx)

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

    r1434 r1460  
    8181  Void initSEIChromaResamplingFilterHint(SEIChromaResamplingFilterHint *sei, Int iHorFilterIndex, Int iVerFilterIndex);
    8282  Void initSEITimeCode(SEITimeCode *sei);
     83#if Q0074_COLOUR_REMAPPING_SEI
     84  Bool initSEIColourRemappingInfo(SEIColourRemappingInfo *sei, Int currPOC); // returns true on success, false on failure.
     85#endif
    8386
    8487#if LAYERS_NOT_PRESENT_SEI
    … …  
    9396#if Q0096_OVERLAY_SEI
    9497  Void initSEIOverlayInfo(SEIOverlayInfo *seiOverlayInfo);
    95 #endif
    96 #if Q0074_COLOUR_REMAPPING_SEI
    97   Void initSEIColourRemappingInfo(SEIColourRemappingInfo *seiColourRemappingInfo, TComSEIColourRemappingInfo* cfgSeiColourRemappingInfo);
    9898#endif
    9999#if O0164_MULTI_LAYER_HRD

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

    r1459 r1460  
    152152    xWriteSEIKneeFunctionInfo(*static_cast<const SEIKneeFunctionInfo*>(&sei));
    153153    break;
    154   case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
    155     xWriteSEIMasteringDisplayColourVolume(*static_cast<const SEIMasteringDisplayColourVolume*>(&sei));
    156     break;
    157154#if Q0074_COLOUR_REMAPPING_SEI
    158155  case SEI::COLOUR_REMAPPING_INFO:
    … …  
    160157    break;
    161158#endif
     159  case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
     160    xWriteSEIMasteringDisplayColourVolume(*static_cast<const SEIMasteringDisplayColourVolume*>(&sei));
     161    break;
    162162#if SVC_EXTENSION
    163163#if LAYERS_NOT_PRESENT_SEI
    … …  
    987987}
    988988
     989#if Q0074_COLOUR_REMAPPING_SEI
     990Void SEIWriter::xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei)
     991{
     992  WRITE_UVLC( sei.m_colourRemapId,                             "colour_remap_id" );
     993  WRITE_FLAG( sei.m_colourRemapCancelFlag,                     "colour_remap_cancel_flag" );
     994  if( !sei.m_colourRemapCancelFlag )
     995  {
     996    WRITE_FLAG( sei.m_colourRemapPersistenceFlag,              "colour_remap_persistence_flag" );
     997    WRITE_FLAG( sei.m_colourRemapVideoSignalInfoPresentFlag,   "colour_remap_video_signal_info_present_flag" );
     998    if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
     999    {
     1000      WRITE_FLAG( sei.m_colourRemapFullRangeFlag,              "colour_remap_full_range_flag" );
     1001      WRITE_CODE( sei.m_colourRemapPrimaries,               8, "colour_remap_primaries" );
     1002      WRITE_CODE( sei.m_colourRemapTransferFunction,        8, "colour_remap_transfer_function" );
     1003      WRITE_CODE( sei.m_colourRemapMatrixCoefficients,      8, "colour_remap_matrix_coefficients" );
     1004    }
     1005    WRITE_CODE( sei.m_colourRemapInputBitDepth,             8, "colour_remap_input_bit_depth" );
     1006    WRITE_CODE( sei.m_colourRemapBitDepth,                  8, "colour_remap_bit_depth" );
     1007    for( Int c=0 ; c<3 ; c++ )
     1008    {
     1009      WRITE_CODE( sei.m_preLutNumValMinus1[c],              8, "pre_lut_num_val_minus1[c]" );
     1010      if( sei.m_preLutNumValMinus1[c]>0 )
     1011      {
     1012        for( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
     1013        {
     1014          WRITE_CODE( sei.m_preLut[c][i].codedValue,  (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, "pre_lut_coded_value[c][i]" );
     1015          WRITE_CODE( sei.m_preLut[c][i].targetValue, (( sei.m_colourRemapBitDepth      + 7 ) >> 3 ) << 3, "pre_lut_target_value[c][i]" );
     1016        }
     1017      }
     1018    }
     1019    WRITE_FLAG( sei.m_colourRemapMatrixPresentFlag,            "colour_remap_matrix_present_flag" );
     1020    if( sei.m_colourRemapMatrixPresentFlag )
     1021    {
     1022      WRITE_CODE( sei.m_log2MatrixDenom,                    4, "log2_matrix_denom" );
     1023      for( Int c=0 ; c<3 ; c++ )
     1024      {
     1025        for( Int i=0 ; i<3 ; i++ )
     1026        {
     1027          WRITE_SVLC( sei.m_colourRemapCoeffs[c][i],           "colour_remap_coeffs[c][i]" );
     1028        }
     1029      }
     1030    }
     1031
     1032    for( Int c=0 ; c<3 ; c++ )
     1033    {
     1034      WRITE_CODE( sei.m_postLutNumValMinus1[c],             8, "m_postLutNumValMinus1[c]" );
     1035      if( sei.m_postLutNumValMinus1[c]>0 )
     1036      {
     1037        for( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
     1038        {
     1039          WRITE_CODE( sei.m_postLut[c][i].codedValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_coded_value[c][i]" );
     1040          WRITE_CODE( sei.m_postLut[c][i].targetValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_target_value[c][i]" );
     1041        }
     1042      }
     1043    }
     1044  }
     1045}
     1046#endif
    9891047
    9901048Void SEIWriter::xWriteSEIMasteringDisplayColourVolume(const SEIMasteringDisplayColourVolume& sei)
    … …  
    13261384#endif //SVC_EXTENSION
    13271385
    1328 #if Q0074_COLOUR_REMAPPING_SEI
    1329 Void SEIWriter::xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei)
    1330 {
    1331   WRITE_UVLC( sei.m_colourRemapId,                             "colour_remap_id" );
    1332   WRITE_FLAG( sei.m_colourRemapCancelFlag,                     "colour_remap_cancel_flag" );
    1333   if( !sei.m_colourRemapCancelFlag )
    1334   {
    1335     WRITE_FLAG( sei.m_colourRemapPersistenceFlag,              "colour_remap_persistence_flag" );
    1336     WRITE_FLAG( sei.m_colourRemapVideoSignalInfoPresentFlag,   "colour_remap_video_signal_info_present_flag" );
    1337     if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
    1338     {
    1339       WRITE_FLAG( sei.m_colourRemapFullRangeFlag,              "colour_remap_full_range_flag" );
    1340       WRITE_CODE( sei.m_colourRemapPrimaries,               8, "colour_remap_primaries" );
    1341       WRITE_CODE( sei.m_colourRemapTransferFunction,        8, "colour_remap_transfer_function" );
    1342       WRITE_CODE( sei.m_colourRemapMatrixCoefficients,      8, "colour_remap_matrix_coefficients" );
    1343     }
    1344     WRITE_CODE( sei.m_colourRemapInputBitDepth,             8, "colour_remap_input_bit_depth" );
    1345     WRITE_CODE( sei.m_colourRemapBitDepth,                  8, "colour_remap_bit_depth" );
    1346     for( Int c=0 ; c<3 ; c++ )
    1347     {
    1348       WRITE_CODE( sei.m_preLutNumValMinus1[c],              8, "pre_lut_num_val_minus1[c]" );
    1349       if( sei.m_preLutNumValMinus1[c]>0 )
    1350         for( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
    1351         {
    1352           WRITE_CODE( sei.m_preLutCodedValue[c][i], (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, "pre_lut_coded_value[c][i]" );
    1353           WRITE_CODE( sei.m_preLutTargetValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "pre_lut_target_value[c][i]" );
    1354         }
    1355     }
    1356     WRITE_FLAG( sei.m_colourRemapMatrixPresentFlag,            "colour_remap_matrix_present_flag" );
    1357     if( sei.m_colourRemapMatrixPresentFlag )
    1358     {
    1359       WRITE_CODE( sei.m_log2MatrixDenom,                    4, "log2_matrix_denom" );
    1360       for( Int c=0 ; c<3 ; c++ )
    1361         for( Int i=0 ; i<3 ; i++ )
    1362           WRITE_SVLC( sei.m_colourRemapCoeffs[c][i],           "colour_remap_coeffs[c][i]" );
    1363     }
    1364 
    1365     for( Int c=0 ; c<3 ; c++ )
    1366     {
    1367       WRITE_CODE( sei.m_postLutNumValMinus1[c],             8, "m_postLutNumValMinus1[c]" );
    1368       if( sei.m_postLutNumValMinus1[c]>0 )
    1369         for( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
    1370         {
    1371           WRITE_CODE( sei.m_postLutCodedValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_coded_value[c][i]" );       
    1372           WRITE_CODE( sei.m_postLutTargetValue[c][i], (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_target_value[c][i]" );
    1373         }
    1374     }
    1375   }
    1376 }
    1377 #endif
    1378 
    13791386//! \}

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

    r1434 r1460  
    8989  Void xWriteSEIChromaResamplingFilterHint(const SEIChromaResamplingFilterHint& sei);
    9090  Void xWriteSEIKneeFunctionInfo(const SEIKneeFunctionInfo &sei);
     91#if Q0074_COLOUR_REMAPPING_SEI
     92  Void xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei);
     93#endif
    9194  Void xWriteSEIMasteringDisplayColourVolume( const SEIMasteringDisplayColourVolume& sei);
    9295
    … …  
    97100#endif
    98101  Void xWriteByteAlign();
    99 #if Q0074_COLOUR_REMAPPING_SEI
    100   Void xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei);
    101 #endif
     102
    102103#if SVC_EXTENSION
    103104#if LAYERS_NOT_PRESENT_SEI

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

    r1459 r1460  
    321321  Int*      m_kneeSEIInputKneePoint;
    322322  Int*      m_kneeSEIOutputKneePoint;
     323#if Q0074_COLOUR_REMAPPING_SEI
     324  std::string m_colourRemapSEIFileRoot;          ///< SEI Colour Remapping File (initialized from external file)
     325#endif
    323326  TComSEIMasteringDisplay m_masteringDisplay;
    324327  //====== Weighted Prediction ========
    … …  
    907910  Void  setKneeSEIOutputKneePoint(Int *p)                            { m_kneeSEIOutputKneePoint = p; }
    908911  Int*  getKneeSEIOutputKneePoint()                                  { return m_kneeSEIOutputKneePoint; }
     912#if Q0074_COLOUR_REMAPPING_SEI
     913  Void  setColourRemapInfoSEIFileRoot( const std::string &s )        { m_colourRemapSEIFileRoot = s; }
     914  const std::string &getColourRemapInfoSEIFileRoot() const           { return m_colourRemapSEIFileRoot; }
     915#endif
    909916  Void  setMasteringDisplaySEI(const TComSEIMasteringDisplay &src)   { m_masteringDisplay = src; }
    910917  const TComSEIMasteringDisplay &getMasteringDisplaySEI() const      { return m_masteringDisplay; }
    … …  
    10991106  Bool  getAlphaClipTypeFlag()                               { return m_alphaClipTypeFlag; }
    11001107#endif
    1101 #if Q0074_COLOUR_REMAPPING_SEI
    1102   Void  xSetCRISEIFileRoot( std::string pch )                { m_colourRemapSEIFileName = pch; }
    1103   std::string& getCRISEIFileRoot()                           { return m_colourRemapSEIFileName; }
    1104 #endif
    11051108#if SVC_EXTENSION
    11061109  UInt      getLayerId()                                     { return m_layerId;    }

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

    r1459 r1460  
    117117  m_prevPicHasEos    = false;
    118118#endif //SVC_EXTENSION
    119 
    120 #if Q0074_COLOUR_REMAPPING_SEI
    121   memset( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue,   0, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue));
    122   memset( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue,  0, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue));
    123   memset( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue,  0, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue));
    124   memset( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue, 0, sizeof(m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue));
    125 #endif
    126119  return;
    127120}
    … …  
    702695}
    703696
    704 #if Q0074_COLOUR_REMAPPING_SEI
    705 Void TEncGOP::xFreeColourCRI()
    706 {
    707   for( Int c=0 ; c<3 ; c++)
    708   {
    709     if ( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c] != NULL)
    710     {
    711       delete[] m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c];
    712       m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c] = NULL;
    713     }
    714     if ( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] != NULL)
    715     {
    716       delete[] m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c];
    717       m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] = NULL;
    718     }
    719     if ( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c] != NULL)
    720     {
    721       delete[] m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c];
    722       m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c] = NULL;
    723     }
    724     if ( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] != NULL)
    725     {
    726       delete[] m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c];
    727       m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] = NULL;
    728     }
    729   }
    730 }
    731 
    732 Int TEncGOP::xReadingCRIparameters(){
    733 
    734   // reading external Colour Remapping Information SEI message parameters from file
    735   if( m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str() )
    736   {
    737     FILE* fic;
    738     Int retval;
    739     if((fic = fopen(m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str(),"r")) == (FILE*)NULL)
    740     {
    741       //fprintf(stderr, "Can't open Colour Remapping Information SEI parameters file %s\n", m_colourRemapSEIFile.c_str());
    742       //exit(EXIT_FAILURE);
    743       return (-1);
    744     }
    745     Int tempCode;
    746     retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIId );
    747     retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEICancelFlag = tempCode ? 1 : 0;
    748     if( !m_seiColourRemappingInfo.m_colourRemapSEICancelFlag )
    749     {
    750       retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEIPersistenceFlag= tempCode ? 1 : 0;
    751       retval = fscanf( fic, "%d", &tempCode); m_seiColourRemappingInfo.m_colourRemapSEIVideoSignalInfoPresentFlag = tempCode ? 1 : 0;
    752       if( m_seiColourRemappingInfo.m_colourRemapSEIVideoSignalInfoPresentFlag )
    753       {
    754         retval = fscanf( fic, "%d", &tempCode  ); m_seiColourRemappingInfo.m_colourRemapSEIFullRangeFlag = tempCode ? 1 : 0;
    755         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPrimaries );
    756         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEITransferFunction );
    757         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIMatrixCoefficients );
    758       }
    759 
    760       retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth );
    761       retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIBitDepth );
    762  
    763       for( Int c=0 ; c<3 ; c++ )
    764       {
    765         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] );
    766         if( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]>0 )
    767         {
    768           m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c]  = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]+1];
    769           m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c] = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]+1];
    770           for( Int i=0 ; i<=m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] ; i++ )
    771           {
    772             retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] );
    773             retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] );
    774           }
    775         }
    776       }
    777 
    778       retval = fscanf( fic, "%d", &tempCode ); m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag = tempCode ? 1 : 0;
    779       if( m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag )
    780       {
    781         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom );
    782         for( Int c=0 ; c<3 ; c++ )
    783         {
    784           for( Int i=0 ; i<3 ; i++ )
    785           {
    786             retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] );
    787           }
    788         }
    789       }
    790 
    791       for( Int c=0 ; c<3 ; c++ )
    792       {
    793         retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] );
    794         if( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]>0 )
    795         {
    796           m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c]  = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]+1];
    797           m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c] = new Int[m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]+1];
    798           for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] ; i++ )
    799           {
    800             retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] );
    801             retval = fscanf( fic, "%d", &m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] );
    802           }
    803         }
    804       }
    805     }
    806 
    807     fclose( fic );
    808     if( retval != 1 )
    809     {
    810       fprintf(stderr, "Error while reading Colour Remapping Information SEI parameters file\n");
    811       exit(EXIT_FAILURE);
    812     }
    813   }
    814   return 1;
    815 }
    816 
    817 Bool confirmParameter(Bool bflag, const TChar* message);
    818 // ====================================================================================================================
    819 // Private member functions
    820 // ====================================================================================================================
    821 
    822 Void TEncGOP::xCheckParameter()
    823 {
    824   Bool check_failed = false; /* abort if there is a fatal configuration problem */
    825 #define xConfirmParameter(a,b) check_failed |= confirmParameter(a,b)
    826 
    827   if ( m_seiColourRemappingInfo.m_colourRemapSEIFile.c_str() && !m_seiColourRemappingInfo.m_colourRemapSEICancelFlag )
    828   {
    829     xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth < 8 || m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth > 16 , "colour_remap_coded_data_bit_depth shall be in the range of 8 to 16, inclusive");
    830     xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIBitDepth < 8 || (m_seiColourRemappingInfo.m_colourRemapSEIBitDepth > 16 && m_seiColourRemappingInfo.m_colourRemapSEIBitDepth < 255) , "colour_remap_target_bit_depth shall be in the range of 8 to 16, inclusive");
    831     for( Int c=0 ; c<3 ; c++)
    832     {
    833       xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] > 32, "pre_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
    834       if( m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c]>0 )
    835         for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPreLutNumValMinus1[c] ; i++)
    836         {
    837           xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutCodedValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIInputBitDepth)-1), "pre_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_coded_data_bit_depth)-1, inclusive");
    838           xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPreLutTargetValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "pre_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
    839         }
    840       xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] > 32, "post_lut_num_val_minus1[c] shall be in the range of 0 to 32, inclusive");
    841       if( m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c]>0 )
    842         for( Int i=0 ; i<= m_seiColourRemappingInfo.m_colourRemapSEIPostLutNumValMinus1[c] ; i++)
    843         {
    844           xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutCodedValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "post_lut_coded_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
    845           xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] < 0 || m_seiColourRemappingInfo.m_colourRemapSEIPostLutTargetValue[c][i] > ((1<<m_seiColourRemappingInfo.m_colourRemapSEIBitDepth)-1), "post_lut_target_value[c][i] shall be in the range of 0 to (1<<colour_remap_target_bit_depth)-1, inclusive");
    846         }
    847     }
    848     if ( m_seiColourRemappingInfo.m_colourRemapSEIMatrixPresentFlag )
    849     {
    850       xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom < 0 || m_seiColourRemappingInfo.m_colourRemapSEILog2MatrixDenom > 15, "log2_matrix_denom shall be in the range of 0 to 15, inclusive");
    851       for( Int c=0 ; c<3 ; c++)
    852         for( Int i=0 ; i<3 ; i++)
    853           xConfirmParameter( m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] < -32768 || m_seiColourRemappingInfo.m_colourRemapSEICoeffs[c][i] > 32767, "colour_remap_coeffs[c][i] shall be in the range of -32768 and 32767, inclusive");
    854     }
    855   }
    856 }
    857 #endif
    858 
    859697Void TEncGOP::xCreatePerPictureSEIMessages (Int picInGOP, SEIMessages& seiMessages, SEIMessages& nestedSeiMessages, TComSlice *slice)
    860698{
    … …  
    912750  }
    913751
     752#if Q0074_COLOUR_REMAPPING_SEI
     753  // insert one Colour Remapping Info SEI for the picture (if the file exists)
     754  if (!m_pcCfg->getColourRemapInfoSEIFileRoot().empty())
     755  {
     756    SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo();
     757    const Bool success = m_seiEncoder.initSEIColourRemappingInfo(seiColourRemappingInfo, slice->getPOC() );
     758
     759    if(success)
     760    {
     761      seiMessages.push_back(seiColourRemappingInfo);
     762    }
     763    else
     764    {
     765      delete seiColourRemappingInfo;
     766    }
     767  }
     768#endif
     769
    914770#if Q0189_TMVP_CONSTRAINTS
    915771  if( m_pcEncTop->getTMVPConstraintsSEIEnabled() == 1 && (m_pcEncTop->getTMVPModeId() == 1 || m_pcEncTop->getTMVPModeId() == 2) &&
    … …  
    930786    seiMessages.push_back(seiFFInfo);
    931787  }
    932 #endif
    933 #if Q0074_COLOUR_REMAPPING_SEI
    934     // insert one CRI by picture (if the file exist)   
    935     xFreeColourCRI();
    936 
    937     // building the CRI file name with poc num in suffix "_poc.txt"
    938     char suffix[10];
    939     sprintf(suffix, "_%d.txt",  slice->getPOC());
    940     string  colourRemapSEIFileWithPoc(m_pcCfg->getCRISEIFileRoot());
    941     colourRemapSEIFileWithPoc.append(suffix);
    942     xSetCRISEIFile( colourRemapSEIFileWithPoc );
    943  
    944     Int ret = xReadingCRIparameters();
    945 
    946     if(ret != -1 && !m_pcCfg->getCRISEIFileRoot().empty())
    947     {
    948       // check validity of input parameters
    949       xCheckParameter();
    950 
    951       SEIColourRemappingInfo *seiColourRemappingInfo = new SEIColourRemappingInfo;
    952       m_seiEncoder.initSEIColourRemappingInfo(seiColourRemappingInfo, &m_seiColourRemappingInfo);
    953       seiMessages.push_back(seiColourRemappingInfo);
    954     }
    955788#endif
    956789}
    … …  
    45904423#endif //SVC_EXTENSION
    45914424
    4592 #if Q0074_COLOUR_REMAPPING_SEI
    4593 Bool confirmParameter(Bool bflag, const TChar* message)
    4594 {
    4595   if (!bflag)
    4596     return false;
    4597 
    4598   printf("Error: %s\n",message);
    4599   return true;
    4600 }
    4601 #endif
    4602 
    46034425//! \}

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

    r1442 r1460  
    138138  SEIEncoder              m_seiEncoder;
    139139
    140 #if Q0074_COLOUR_REMAPPING_SEI
    141   TComSEIColourRemappingInfo m_seiColourRemappingInfo; 
    142 #endif
    143140#if SVC_EXTENSION
    144141  Int                     m_pocCraWithoutReset;
    … …  
    274271  Void applyDeblockingFilterMetric( TComPic* pcPic, UInt uiNumSlices );
    275272
    276 #if Q0074_COLOUR_REMAPPING_SEI
    277   TComSEIColourRemappingInfo* xGetSEIColourRemappingInfo()  { return &m_seiColourRemappingInfo; }
    278   Void xSetCRISEIFile( std::string pch )                    { m_seiColourRemappingInfo.m_colourRemapSEIFile = pch; }
    279 
    280   Void xFreeColourCRI();
    281   Int  xReadingCRIparameters();
    282   Void xCheckParameter();
    283 #endif
    284273#if SVC_EXTENSION
    285274#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
Note: See TracChangeset for help on using the changeset viewer.