Changeset 608 in 3DVCSoftware for trunk/source/Lib/TLibEncoder/SEIwrite.cpp


Ignore:
Timestamp:
1 Sep 2013, 22:47:26 (11 years ago)
Author:
tech
Message:

Merged DEV-2.0-dev0@604.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/Lib/TLibEncoder/SEIwrite.cpp

    r56 r608  
    44 * granted under this license.
    55 *
    6  * Copyright (c) 2010-2012, ITU/ISO/IEC
     6 * Copyright (c) 2010-2013, ITU/ISO/IEC
    77 * All rights reserved.
    88 *
    … …  
    3535#include "TLibCommon/TComBitStream.h"
    3636#include "TLibCommon/SEI.h"
     37#include "TLibCommon/TComSlice.h"
    3738#include "SEIwrite.h"
    3839
    … …  
    4041//! \{
    4142
    42 static void writeSEIuserDataUnregistered(TComBitIf& bs, const SEIuserDataUnregistered &sei);
    43 static void writeSEIpictureDigest(TComBitIf& bs, const SEIpictureDigest& sei);
    44 
    45 void writeSEIpayloadData(TComBitIf& bs, const SEI& sei)
     43#if ENC_DEC_TRACE
     44Void  xTraceSEIHeader()
     45{
     46  fprintf( g_hTrace, "=========== SEI message ===========\n");
     47}
     48
     49Void  xTraceSEIMessageType(SEI::PayloadType payloadType)
     50{
     51  switch (payloadType)
     52  {
     53  case SEI::DECODED_PICTURE_HASH:
     54    fprintf( g_hTrace, "=========== Decoded picture hash SEI message ===========\n");
     55    break;
     56  case SEI::USER_DATA_UNREGISTERED:
     57    fprintf( g_hTrace, "=========== User Data Unregistered SEI message ===========\n");
     58    break;
     59  case SEI::ACTIVE_PARAMETER_SETS:
     60    fprintf( g_hTrace, "=========== Active Parameter sets SEI message ===========\n");
     61    break;
     62  case SEI::BUFFERING_PERIOD:
     63    fprintf( g_hTrace, "=========== Buffering period SEI message ===========\n");
     64    break;
     65  case SEI::PICTURE_TIMING:
     66    fprintf( g_hTrace, "=========== Picture timing SEI message ===========\n");
     67    break;
     68  case SEI::RECOVERY_POINT:
     69    fprintf( g_hTrace, "=========== Recovery point SEI message ===========\n");
     70    break;
     71  case SEI::FRAME_PACKING:
     72    fprintf( g_hTrace, "=========== Frame Packing Arrangement SEI message ===========\n");
     73    break;
     74  case SEI::DISPLAY_ORIENTATION:
     75    fprintf( g_hTrace, "=========== Display Orientation SEI message ===========\n");
     76    break;
     77  case SEI::TEMPORAL_LEVEL0_INDEX:
     78    fprintf( g_hTrace, "=========== Temporal Level Zero Index SEI message ===========\n");
     79    break;
     80  case SEI::REGION_REFRESH_INFO:
     81    fprintf( g_hTrace, "=========== Gradual Decoding Refresh Information SEI message ===========\n");
     82    break;
     83  case SEI::DECODING_UNIT_INFO:
     84    fprintf( g_hTrace, "=========== Decoding Unit Information SEI message ===========\n");
     85    break;
     86  case SEI::TONE_MAPPING_INFO:
     87    fprintf( g_hTrace, "=========== Tone Mapping Info SEI message ===========\n");
     88    break;
     89  case SEI::SOP_DESCRIPTION:
     90    fprintf( g_hTrace, "=========== SOP Description SEI message ===========\n");
     91    break;
     92  case SEI::SCALABLE_NESTING:
     93    fprintf( g_hTrace, "=========== Scalable Nesting SEI message ===========\n");
     94    break;
     95  default:
     96    fprintf( g_hTrace, "=========== Unknown SEI message ===========\n");
     97    break;
     98  }
     99}
     100#endif
     101
     102void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, TComSPS *sps)
    46103{
    47104  switch (sei.payloadType())
    48105  {
    49106  case SEI::USER_DATA_UNREGISTERED:
    50     writeSEIuserDataUnregistered(bs, *static_cast<const SEIuserDataUnregistered*>(&sei));
    51     break;
    52   case SEI::PICTURE_DIGEST:
    53     writeSEIpictureDigest(bs, *static_cast<const SEIpictureDigest*>(&sei));
     107    xWriteSEIuserDataUnregistered(*static_cast<const SEIuserDataUnregistered*>(&sei));
     108    break;
     109  case SEI::ACTIVE_PARAMETER_SETS:
     110    xWriteSEIActiveParameterSets(*static_cast<const SEIActiveParameterSets*>(& sei));
     111    break;
     112  case SEI::DECODING_UNIT_INFO:
     113    xWriteSEIDecodingUnitInfo(*static_cast<const SEIDecodingUnitInfo*>(& sei), sps);
     114    break;
     115  case SEI::DECODED_PICTURE_HASH:
     116    xWriteSEIDecodedPictureHash(*static_cast<const SEIDecodedPictureHash*>(&sei));
     117    break;
     118  case SEI::BUFFERING_PERIOD:
     119    xWriteSEIBufferingPeriod(*static_cast<const SEIBufferingPeriod*>(&sei), sps);
     120    break;
     121  case SEI::PICTURE_TIMING:
     122    xWriteSEIPictureTiming(*static_cast<const SEIPictureTiming*>(&sei), sps);
     123    break;
     124  case SEI::RECOVERY_POINT:
     125    xWriteSEIRecoveryPoint(*static_cast<const SEIRecoveryPoint*>(&sei));
     126    break;
     127  case SEI::FRAME_PACKING:
     128    xWriteSEIFramePacking(*static_cast<const SEIFramePacking*>(&sei));
     129    break;
     130  case SEI::DISPLAY_ORIENTATION:
     131    xWriteSEIDisplayOrientation(*static_cast<const SEIDisplayOrientation*>(&sei));
     132    break;
     133  case SEI::TEMPORAL_LEVEL0_INDEX:
     134    xWriteSEITemporalLevel0Index(*static_cast<const SEITemporalLevel0Index*>(&sei));
     135    break;
     136  case SEI::REGION_REFRESH_INFO:
     137    xWriteSEIGradualDecodingRefreshInfo(*static_cast<const SEIGradualDecodingRefreshInfo*>(&sei));
     138    break;
     139  case SEI::TONE_MAPPING_INFO:
     140    xWriteSEIToneMappingInfo(*static_cast<const SEIToneMappingInfo*>(&sei));
     141    break;
     142  case SEI::SOP_DESCRIPTION:
     143    xWriteSEISOPDescription(*static_cast<const SEISOPDescription*>(&sei));
     144    break;
     145  case SEI::SCALABLE_NESTING:
     146    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
    54147    break;
    55148  default:
    … …  
    62155 * in bitstream bs.
    63156 */
    64 void writeSEImessage(TComBitIf& bs, const SEI& sei)
     157Void SEIWriter::writeSEImessage(TComBitIf& bs, const SEI& sei, TComSPS *sps)
    65158{
    66159  /* calculate how large the payload data is */
    … …  
    68161  TComBitCounter bs_count;
    69162  bs_count.resetBits();
    70   writeSEIpayloadData(bs_count, sei);
    71   unsigned payload_data_num_bits = bs_count.getNumberOfWrittenBits();
     163  setBitstream(&bs_count);
     164
     165
     166#if ENC_DEC_TRACE
     167  Bool traceEnable = g_HLSTraceEnable;
     168  g_HLSTraceEnable = false;
     169#endif
     170  xWriteSEIpayloadData(bs_count, sei, sps);
     171#if ENC_DEC_TRACE
     172  g_HLSTraceEnable = traceEnable;
     173#endif
     174
     175  UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
    72176  assert(0 == payload_data_num_bits % 8);
    73177
    74   unsigned payloadType = sei.payloadType();
     178  setBitstream(&bs);
     179
     180#if ENC_DEC_TRACE
     181  if (g_HLSTraceEnable)
     182  xTraceSEIHeader();
     183#endif
     184
     185  UInt payloadType = sei.payloadType();
    75186  for (; payloadType >= 0xff; payloadType -= 0xff)
    76     bs.write(0xff, 8);
    77   bs.write(payloadType, 8);
    78 
    79   unsigned payloadSize = payload_data_num_bits/8;
     187  {
     188    WRITE_CODE(0xff, 8, "payload_type");
     189  }
     190  WRITE_CODE(payloadType, 8, "payload_type");
     191
     192  UInt payloadSize = payload_data_num_bits/8;
    80193  for (; payloadSize >= 0xff; payloadSize -= 0xff)
    81     bs.write(0xff, 8);
    82   bs.write(payloadSize, 8);
     194  {
     195    WRITE_CODE(0xff, 8, "payload_size");
     196  }
     197  WRITE_CODE(payloadSize, 8, "payload_size");
    83198
    84199  /* payloadData */
    85   writeSEIpayloadData(bs, sei);
     200#if ENC_DEC_TRACE
     201  if (g_HLSTraceEnable)
     202  xTraceSEIMessageType(sei.payloadType());
     203#endif
     204
     205  xWriteSEIpayloadData(bs, sei, sps);
    86206}
    87207
    … …  
    90210 * representation in bitstream bs.
    91211 */
    92 static void writeSEIuserDataUnregistered(TComBitIf& bs, const SEIuserDataUnregistered &sei)
    93 {
    94   for (unsigned i = 0; i < 16; i++)
    95   {
    96     bs.write(sei.uuid_iso_iec_11578[i], 8);
    97   }
    98 
    99   for (unsigned i = 0; i < sei.userDataLength; i++)
    100   {
    101     bs.write(sei.userData[i], 8);
     212Void SEIWriter::xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei)
     213{
     214  for (UInt i = 0; i < 16; i++)
     215  {
     216    WRITE_CODE(sei.uuid_iso_iec_11578[i], 8 , "sei.uuid_iso_iec_11578[i]");
     217  }
     218
     219  for (UInt i = 0; i < sei.userDataLength; i++)
     220  {
     221    WRITE_CODE(sei.userData[i], 8 , "user_data");
    102222  }
    103223}
    104224
    105225/**
    106  * marshal a picture_digest SEI message, storing the marshalled
     226 * marshal a decoded picture hash SEI message, storing the marshalled
    107227 * representation in bitstream bs.
    108228 */
    109 static void writeSEIpictureDigest(TComBitIf& bs, const SEIpictureDigest& sei)
    110 {
    111   bs.write(sei.method, 8);
    112   for (unsigned i = 0; i < 16; i++)
    113   {
    114     bs.write(sei.digest[i], 8);
    115   }
    116 }
     229Void SEIWriter::xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei)
     230{
     231  UInt val;
     232
     233  WRITE_CODE(sei.method, 8, "hash_type");
     234
     235  for(Int yuvIdx = 0; yuvIdx < 3; yuvIdx++)
     236  {
     237    if(sei.method == SEIDecodedPictureHash::MD5)
     238    {
     239      for (UInt i = 0; i < 16; i++)
     240      {
     241        WRITE_CODE(sei.digest[yuvIdx][i], 8, "picture_md5");
     242      }
     243    }
     244    else if(sei.method == SEIDecodedPictureHash::CRC)
     245    {
     246      val = (sei.digest[yuvIdx][0] << 8)  + sei.digest[yuvIdx][1];
     247      WRITE_CODE(val, 16, "picture_crc");
     248    }
     249    else if(sei.method == SEIDecodedPictureHash::CHECKSUM)
     250    {
     251      val = (sei.digest[yuvIdx][0] << 24)  + (sei.digest[yuvIdx][1] << 16) + (sei.digest[yuvIdx][2] << 8) + sei.digest[yuvIdx][3];
     252      WRITE_CODE(val, 32, "picture_checksum");
     253    }
     254  }
     255}
     256
     257Void SEIWriter::xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei)
     258{
     259  WRITE_CODE(sei.activeVPSId,     4, "active_vps_id");
     260  WRITE_FLAG(sei.m_fullRandomAccessFlag, "full_random_access_flag");
     261  WRITE_FLAG(sei.m_noParamSetUpdateFlag, "no_param_set_update_flag");
     262  WRITE_UVLC(sei.numSpsIdsMinus1,    "num_sps_ids_minus1");
     263
     264  assert (sei.activeSeqParamSetId.size() == (sei.numSpsIdsMinus1 + 1));
     265
     266  for (Int i = 0; i < sei.activeSeqParamSetId.size(); i++)
     267  {
     268    WRITE_UVLC(sei.activeSeqParamSetId[i], "active_seq_param_set_id");
     269  }
     270
     271  UInt uiBits = m_pcBitIf->getNumberOfWrittenBits();
     272  UInt uiAlignedBits = ( 8 - (uiBits&7) ) % 8; 
     273  if(uiAlignedBits)
     274  {
     275    WRITE_FLAG(1, "alignment_bit" );
     276    uiAlignedBits--;
     277    while(uiAlignedBits--)
     278    {
     279      WRITE_FLAG(0, "alignment_bit" );
     280    }
     281  }
     282}
     283
     284Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, TComSPS *sps)
     285{
     286  TComVUI *vui = sps->getVuiParameters();
     287  WRITE_UVLC(sei.m_decodingUnitIdx, "decoding_unit_idx");
     288  if(vui->getHrdParameters()->getSubPicCpbParamsInPicTimingSEIFlag())
     289  {
     290    WRITE_CODE( sei.m_duSptCpbRemovalDelay, (vui->getHrdParameters()->getDuCpbRemovalDelayLengthMinus1() + 1), "du_spt_cpb_removal_delay");
     291  }
     292  WRITE_FLAG( sei.m_dpbOutputDuDelayPresentFlag, "dpb_output_du_delay_present_flag");
     293  if(sei.m_dpbOutputDuDelayPresentFlag)
     294  {
     295    WRITE_CODE(sei.m_picSptDpbOutputDuDelay, vui->getHrdParameters()->getDpbOutputDelayDuLengthMinus1() + 1, "pic_spt_dpb_output_du_delay");
     296  }
     297  xWriteByteAlign();
     298}
     299
     300Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, TComSPS *sps)
     301{
     302  Int i, nalOrVcl;
     303  TComVUI *vui = sps->getVuiParameters();
     304  TComHRD *hrd = vui->getHrdParameters();
     305
     306  WRITE_UVLC( sei.m_bpSeqParameterSetId, "bp_seq_parameter_set_id" );
     307  if( !hrd->getSubPicCpbParamsPresentFlag() )
     308  {
     309    WRITE_FLAG( sei.m_rapCpbParamsPresentFlag, "rap_cpb_params_present_flag" );
     310  }
     311  WRITE_FLAG( sei.m_concatenationFlag, "concatenation_flag");
     312  WRITE_CODE( sei.m_auCpbRemovalDelayDelta - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), "au_cpb_removal_delay_delta_minus1" );
     313  if( sei.m_rapCpbParamsPresentFlag )
     314  {
     315    WRITE_CODE( sei.m_cpbDelayOffset, hrd->getCpbRemovalDelayLengthMinus1() + 1, "cpb_delay_offset" );
     316    WRITE_CODE( sei.m_dpbDelayOffset, hrd->getDpbOutputDelayLengthMinus1()  + 1, "dpb_delay_offset" );
     317  }
     318  for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
     319  {
     320    if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
     321        ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
     322    {
     323      for( i = 0; i < ( hrd->getCpbCntMinus1( 0 ) + 1 ); i ++ )
     324      {
     325        WRITE_CODE( sei.m_initialCpbRemovalDelay[i][nalOrVcl],( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ) ,           "initial_cpb_removal_delay" );
     326        WRITE_CODE( sei.m_initialCpbRemovalDelayOffset[i][nalOrVcl],( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ),      "initial_cpb_removal_delay_offset" );
     327        if( hrd->getSubPicCpbParamsPresentFlag() || sei.m_rapCpbParamsPresentFlag )
     328        {
     329          WRITE_CODE( sei.m_initialAltCpbRemovalDelay[i][nalOrVcl], ( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ) ,     "initial_alt_cpb_removal_delay" );
     330          WRITE_CODE( sei.m_initialAltCpbRemovalDelayOffset[i][nalOrVcl], ( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ),"initial_alt_cpb_removal_delay_offset" );
     331        }
     332      }
     333    }
     334  }
     335  xWriteByteAlign();
     336}
     337Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei,  TComSPS *sps)
     338{
     339  Int i;
     340  TComVUI *vui = sps->getVuiParameters();
     341  TComHRD *hrd = vui->getHrdParameters();
     342
     343  if( vui->getFrameFieldInfoPresentFlag() )
     344  {
     345    WRITE_CODE( sei.m_picStruct, 4,              "pic_struct" );
     346    WRITE_CODE( sei.m_sourceScanType, 2,         "source_scan_type" );
     347    WRITE_FLAG( sei.m_duplicateFlag ? 1 : 0,     "duplicate_flag" );
     348  }
     349
     350  if( hrd->getCpbDpbDelaysPresentFlag() )
     351  {
     352    WRITE_CODE( sei.m_auCpbRemovalDelay - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ),                                         "au_cpb_removal_delay_minus1" );
     353    WRITE_CODE( sei.m_picDpbOutputDelay, ( hrd->getDpbOutputDelayLengthMinus1() + 1 ),                                          "pic_dpb_output_delay" );
     354    if(hrd->getSubPicCpbParamsPresentFlag())
     355    {
     356      WRITE_CODE(sei.m_picDpbOutputDuDelay, hrd->getDpbOutputDelayDuLengthMinus1()+1, "pic_dpb_output_du_delay" );
     357    }
     358    if( hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag() )
     359    {
     360      WRITE_UVLC( sei.m_numDecodingUnitsMinus1,     "num_decoding_units_minus1" );
     361      WRITE_FLAG( sei.m_duCommonCpbRemovalDelayFlag, "du_common_cpb_removal_delay_flag" );
     362      if( sei.m_duCommonCpbRemovalDelayFlag )
     363      {
     364        WRITE_CODE( sei.m_duCommonCpbRemovalDelayMinus1, ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ),                       "du_common_cpb_removal_delay_minus1" );
     365      }
     366      for( i = 0; i <= sei.m_numDecodingUnitsMinus1; i ++ )
     367      {
     368        WRITE_UVLC( sei.m_numNalusInDuMinus1[ i ],  "num_nalus_in_du_minus1");
     369        if( ( !sei.m_duCommonCpbRemovalDelayFlag ) && ( i < sei.m_numDecodingUnitsMinus1 ) )
     370        {
     371          WRITE_CODE( sei.m_duCpbRemovalDelayMinus1[ i ], ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ),                        "du_cpb_removal_delay_minus1" );
     372        }
     373      }
     374    }
     375  }
     376  xWriteByteAlign();
     377}
     378Void SEIWriter::xWriteSEIRecoveryPoint(const SEIRecoveryPoint& sei)
     379{
     380  WRITE_SVLC( sei.m_recoveryPocCnt,    "recovery_poc_cnt"    );
     381  WRITE_FLAG( sei.m_exactMatchingFlag, "exact_matching_flag" );
     382  WRITE_FLAG( sei.m_brokenLinkFlag,    "broken_link_flag"    );
     383  xWriteByteAlign();
     384}
     385Void SEIWriter::xWriteSEIFramePacking(const SEIFramePacking& sei)
     386{
     387  WRITE_UVLC( sei.m_arrangementId,                  "frame_packing_arrangement_id" );
     388  WRITE_FLAG( sei.m_arrangementCancelFlag,          "frame_packing_arrangement_cancel_flag" );
     389
     390  if( sei.m_arrangementCancelFlag == 0 ) {
     391    WRITE_CODE( sei.m_arrangementType, 7,           "frame_packing_arrangement_type" );
     392
     393    WRITE_FLAG( sei.m_quincunxSamplingFlag,         "quincunx_sampling_flag" );
     394    WRITE_CODE( sei.m_contentInterpretationType, 6, "content_interpretation_type" );
     395    WRITE_FLAG( sei.m_spatialFlippingFlag,          "spatial_flipping_flag" );
     396    WRITE_FLAG( sei.m_frame0FlippedFlag,            "frame0_flipped_flag" );
     397    WRITE_FLAG( sei.m_fieldViewsFlag,               "field_views_flag" );
     398    WRITE_FLAG( sei.m_currentFrameIsFrame0Flag,     "current_frame_is_frame0_flag" );
     399
     400    WRITE_FLAG( sei.m_frame0SelfContainedFlag,      "frame0_self_contained_flag" );
     401    WRITE_FLAG( sei.m_frame1SelfContainedFlag,      "frame1_self_contained_flag" );
     402
     403    if(sei.m_quincunxSamplingFlag == 0 && sei.m_arrangementType != 5)
     404    {
     405      WRITE_CODE( sei.m_frame0GridPositionX, 4,     "frame0_grid_position_x" );
     406      WRITE_CODE( sei.m_frame0GridPositionY, 4,     "frame0_grid_position_y" );
     407      WRITE_CODE( sei.m_frame1GridPositionX, 4,     "frame1_grid_position_x" );
     408      WRITE_CODE( sei.m_frame1GridPositionY, 4,     "frame1_grid_position_y" );
     409    }
     410
     411    WRITE_CODE( sei.m_arrangementReservedByte, 8,   "frame_packing_arrangement_reserved_byte" );
     412    WRITE_FLAG( sei.m_arrangementPersistenceFlag,   "frame_packing_arrangement_persistence_flag" );
     413  }
     414
     415  WRITE_FLAG( sei.m_upsampledAspectRatio,           "upsampled_aspect_ratio" );
     416
     417  xWriteByteAlign();
     418}
     419
     420Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei)
     421{
     422  Int i;
     423  WRITE_UVLC( sei.m_toneMapId,                    "tone_map_id" );
     424  WRITE_FLAG( sei.m_toneMapCancelFlag,            "tone_map_cancel_flag" );
     425  if( !sei.m_toneMapCancelFlag )
     426  {
     427    WRITE_FLAG( sei.m_toneMapPersistenceFlag,     "tone_map_persistence_flag" );
     428    WRITE_CODE( sei.m_codedDataBitDepth,    8,    "coded_data_bit_depth" );
     429    WRITE_CODE( sei.m_targetBitDepth,       8,    "target_bit_depth" );
     430    WRITE_UVLC( sei.m_modelId,                    "model_id" );
     431    switch(sei.m_modelId)
     432    {
     433    case 0:
     434      {
     435        WRITE_CODE( sei.m_minValue,  32,        "min_value" );
     436        WRITE_CODE( sei.m_maxValue, 32,         "max_value" );
     437        break;
     438      }
     439    case 1:
     440      {
     441        WRITE_CODE( sei.m_sigmoidMidpoint, 32,  "sigmoid_midpoint" );
     442        WRITE_CODE( sei.m_sigmoidWidth,    32,  "sigmoid_width"    );
     443        break;
     444      }
     445    case 2:
     446      {
     447        UInt num = 1u << sei.m_targetBitDepth;
     448        for(i = 0; i < num; i++)
     449        {
     450          WRITE_CODE( sei.m_startOfCodedInterval[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,  "start_of_coded_interval" );
     451        }
     452        break;
     453      }
     454    case 3:
     455      {
     456        WRITE_CODE( sei.m_numPivots, 16,          "num_pivots" );
     457        for(i = 0; i < sei.m_numPivots; i++ )
     458        {
     459          WRITE_CODE( sei.m_codedPivotValue[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,       "coded_pivot_value" );
     460          WRITE_CODE( sei.m_targetPivotValue[i], (( sei.m_targetBitDepth + 7 ) >> 3 ) << 3,         "target_pivot_value");
     461        }
     462        break;
     463      }
     464    case 4:
     465      {
     466        WRITE_CODE( sei.m_cameraIsoSpeedIdc,    8,    "camera_iso_speed_idc" );
     467        if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO
     468        {
     469          WRITE_CODE( sei.m_cameraIsoSpeedValue,    32,    "camera_iso_speed_value" );
     470        }
     471        WRITE_FLAG( sei.m_exposureCompensationValueSignFlag,           "exposure_compensation_value_sign_flag" );
     472        WRITE_CODE( sei.m_exposureCompensationValueNumerator,     16,  "exposure_compensation_value_numerator" );
     473        WRITE_CODE( sei.m_exposureCompensationValueDenomIdc,      16,  "exposure_compensation_value_denom_idc" );
     474        WRITE_CODE( sei.m_refScreenLuminanceWhite,                32,  "ref_screen_luminance_white" );
     475        WRITE_CODE( sei.m_extendedRangeWhiteLevel,                32,  "extended_range_white_level" );
     476        WRITE_CODE( sei.m_nominalBlackLevelLumaCodeValue,         16,  "nominal_black_level_luma_code_value" );
     477        WRITE_CODE( sei.m_nominalWhiteLevelLumaCodeValue,         16,  "nominal_white_level_luma_code_value" );
     478        WRITE_CODE( sei.m_extendedWhiteLevelLumaCodeValue,        16,  "extended_white_level_luma_code_value" );
     479        break;
     480      }
     481    default:
     482      {
     483        assert(!"Undefined SEIToneMapModelId");
     484        break;
     485      }
     486    }//switch m_modelId
     487  }//if(!sei.m_toneMapCancelFlag)
     488
     489  xWriteByteAlign();
     490}
     491
     492Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei)
     493{
     494  WRITE_FLAG( sei.cancelFlag,           "display_orientation_cancel_flag" );
     495  if( !sei.cancelFlag )
     496  {
     497    WRITE_FLAG( sei.horFlip,                   "hor_flip" );
     498    WRITE_FLAG( sei.verFlip,                   "ver_flip" );
     499    WRITE_CODE( sei.anticlockwiseRotation, 16, "anticlockwise_rotation" );
     500    WRITE_FLAG( sei.persistenceFlag,          "display_orientation_persistence_flag" );
     501  }
     502  xWriteByteAlign();
     503}
     504
     505Void SEIWriter::xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei)
     506{
     507  WRITE_CODE( sei.tl0Idx, 8 , "tl0_idx" );
     508  WRITE_CODE( sei.rapIdx, 8 , "rap_idx" );
     509  xWriteByteAlign();
     510}
     511
     512Void SEIWriter::xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei)
     513{
     514  WRITE_FLAG( sei.m_gdrForegroundFlag, "gdr_foreground_flag");
     515  xWriteByteAlign();
     516}
     517
     518Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei)
     519{
     520  WRITE_UVLC( sei.m_sopSeqParameterSetId,           "sop_seq_parameter_set_id"               );
     521  WRITE_UVLC( sei.m_numPicsInSopMinus1,             "num_pics_in_sop_minus1"               );
     522  for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
     523  {
     524    WRITE_CODE( sei.m_sopDescVclNaluType[i], 6, "sop_desc_vcl_nalu_type" );
     525    WRITE_CODE( sei.m_sopDescTemporalId[i],  3, "sop_desc_temporal_id" );
     526    if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
     527    {
     528      WRITE_UVLC( sei.m_sopDescStRpsIdx[i],           "sop_desc_st_rps_idx"               );
     529    }
     530    if (i > 0)
     531    {
     532      WRITE_SVLC( sei.m_sopDescPocDelta[i],           "sop_desc_poc_delta"               );
     533    }
     534  }
     535
     536  xWriteByteAlign();
     537}
     538
     539Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, TComSPS *sps)
     540{
     541  WRITE_FLAG( sei.m_bitStreamSubsetFlag,             "bitstream_subset_flag"         );
     542  WRITE_FLAG( sei.m_nestingOpFlag,                   "nesting_op_flag      "         );
     543  if (sei.m_nestingOpFlag)
     544  {
     545    WRITE_FLAG( sei.m_defaultOpFlag,                 "default_op_flag"               );
     546    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops"               );
     547    for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++)
     548    {
     549      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
     550      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id"       );
     551      WRITE_UVLC( sei.m_nestingOpIdx[i],                  "nesting_op_idx"                );
     552    }
     553  }
     554  else
     555  {
     556    WRITE_FLAG( sei.m_allLayersFlag,                      "all_layers_flag"               );
     557    if (!sei.m_allLayersFlag)
     558    {
     559      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id" );
     560      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"            );
     561      for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
     562      {
     563        WRITE_CODE( sei.m_nestingLayerId[i], 6,           "nesting_layer_id"              );
     564      }
     565    }
     566  }
     567 
     568  // byte alignment
     569  while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
     570  {
     571    WRITE_FLAG( 0, "nesting_zero_bit" );
     572  }
     573
     574  // write nested SEI messages
     575  for (SEIMessages::const_iterator it = sei.m_nestedSEIs.begin(); it != sei.m_nestedSEIs.end(); it++)
     576  {
     577    writeSEImessage(bs, *(*it), sps);
     578  }
     579}
     580
     581Void SEIWriter::xWriteByteAlign()
     582{
     583  if( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0)
     584  {
     585    WRITE_FLAG( 1, "bit_equal_to_one" );
     586    while( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
     587    {
     588      WRITE_FLAG( 0, "bit_equal_to_zero" );
     589    }
     590  }
     591};
     592
    117593//! \}
Note: See TracChangeset for help on using the changeset viewer.