source: 3DVCSoftware/branches/HTM-16.0-dev1/source/Lib/TLibEncoder/SEIwrite.cpp

Last change on this file was 1386, checked in by tech, 9 years ago

Merged 15.1-dev1@1381.
  • Property svn:eol-style set to native
File size: 58.5 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include "TLibCommon/TComBitCounter.h"
35#include "TLibCommon/TComBitStream.h"
36#include "TLibCommon/SEI.h"
37#include "TLibCommon/TComSlice.h"
38#include "TLibCommon/TComPicYuv.h"
39#include "SEIwrite.h"
40
41//! \ingroup TLibEncoder
42//! \{
43
44#if ENC_DEC_TRACE
45Void  xTraceSEIHeader()
46{
47  fprintf( g_hTrace, "=========== SEI message ===========\n");
48}
49
50Void  xTraceSEIMessageType(SEI::PayloadType payloadType)
51{
52  fprintf( g_hTrace, "=========== %s SEI message ===========\n", SEI::getSEIMessageString(payloadType));
53}
54#endif
55
56Void SEIWriter::xWriteSEIpayloadData(TComBitIf& bs, const SEI& sei, const TComSPS *sps)
57{
58  switch (sei.payloadType())
59  {
60  case SEI::USER_DATA_UNREGISTERED:
61    xWriteSEIuserDataUnregistered(*static_cast<const SEIuserDataUnregistered*>(&sei));
62    break;
63  case SEI::ACTIVE_PARAMETER_SETS:
64    xWriteSEIActiveParameterSets(*static_cast<const SEIActiveParameterSets*>(& sei));
65    break;
66  case SEI::DECODING_UNIT_INFO:
67    xWriteSEIDecodingUnitInfo(*static_cast<const SEIDecodingUnitInfo*>(& sei), sps);
68    break;
69  case SEI::DECODED_PICTURE_HASH:
70    xWriteSEIDecodedPictureHash(*static_cast<const SEIDecodedPictureHash*>(&sei));
71    break;
72  case SEI::BUFFERING_PERIOD:
73    xWriteSEIBufferingPeriod(*static_cast<const SEIBufferingPeriod*>(&sei), sps);
74    break;
75  case SEI::PICTURE_TIMING:
76    xWriteSEIPictureTiming(*static_cast<const SEIPictureTiming*>(&sei), sps);
77    break;
78  case SEI::RECOVERY_POINT:
79    xWriteSEIRecoveryPoint(*static_cast<const SEIRecoveryPoint*>(&sei));
80    break;
81  case SEI::FRAME_PACKING:
82    xWriteSEIFramePacking(*static_cast<const SEIFramePacking*>(&sei));
83    break;
84  case SEI::SEGM_RECT_FRAME_PACKING:
85    xWriteSEISegmentedRectFramePacking(*static_cast<const SEISegmentedRectFramePacking*>(&sei));
86    break;
87  case SEI::DISPLAY_ORIENTATION:
88    xWriteSEIDisplayOrientation(*static_cast<const SEIDisplayOrientation*>(&sei));
89    break;
90  case SEI::TEMPORAL_LEVEL0_INDEX:
91    xWriteSEITemporalLevel0Index(*static_cast<const SEITemporalLevel0Index*>(&sei));
92    break;
93  case SEI::REGION_REFRESH_INFO:
94    xWriteSEIGradualDecodingRefreshInfo(*static_cast<const SEIGradualDecodingRefreshInfo*>(&sei));
95    break;
96  case SEI::NO_DISPLAY:
97    xWriteSEINoDisplay(*static_cast<const SEINoDisplay*>(&sei));
98    break;
99  case SEI::TONE_MAPPING_INFO:
100    xWriteSEIToneMappingInfo(*static_cast<const SEIToneMappingInfo*>(&sei));
101    break;
102  case SEI::SOP_DESCRIPTION:
103    xWriteSEISOPDescription(*static_cast<const SEISOPDescription*>(&sei));
104    break;
105  case SEI::SCALABLE_NESTING:
106    xWriteSEIScalableNesting(bs, *static_cast<const SEIScalableNesting*>(&sei), sps);
107    break;
108  case SEI::CHROMA_RESAMPLING_FILTER_HINT:
109    xWriteSEIChromaResamplingFilterHint(*static_cast<const SEIChromaResamplingFilterHint*>(&sei));
110    break;
111  case SEI::TEMP_MOTION_CONSTRAINED_TILE_SETS:
112    xWriteSEITempMotionConstrainedTileSets(*static_cast<const SEITempMotionConstrainedTileSets*>(&sei));
113    break;
114  case SEI::TIME_CODE:
115    xWriteSEITimeCode(*static_cast<const SEITimeCode*>(&sei));
116    break;
117  case SEI::KNEE_FUNCTION_INFO:
118    xWriteSEIKneeFunctionInfo(*static_cast<const SEIKneeFunctionInfo*>(&sei));
119    break;
120  case SEI::COLOUR_REMAPPING_INFO:
121    xWriteSEIColourRemappingInfo(*static_cast<const SEIColourRemappingInfo*>(&sei));
122    break;
123  case SEI::MASTERING_DISPLAY_COLOUR_VOLUME:
124    xWriteSEIMasteringDisplayColourVolume(*static_cast<const SEIMasteringDisplayColourVolume*>(&sei));
125    break;
126#if NH_MV
127   case SEI::LAYERS_NOT_PRESENT:
128       xWriteSEILayersNotPresent(*static_cast<const SEILayersNotPresent*>(&sei));
129     break;
130   case SEI::INTER_LAYER_CONSTRAINED_TILE_SETS:
131     xWriteSEIInterLayerConstrainedTileSets(*static_cast<const SEIInterLayerConstrainedTileSets*>(&sei));
132     break;
133#if NH_MV_SEI_TBD
134   case SEI::BSP_NESTING:
135     xWriteSEIBspNesting(*static_cast<const SEIBspNesting*>(&sei));
136     break;
137   case SEI::BSP_INITIAL_ARRIVAL_TIME:
138     xWriteSEIBspInitialArrivalTime(*static_cast<const SEIBspInitialArrivalTime*>(&sei));
139     break;
140#endif
141   case SEI::SUB_BITSTREAM_PROPERTY:
142     xWriteSEISubBitstreamProperty(*static_cast<const SEISubBitstreamProperty*>(&sei));
143     break;
144   case SEI::ALPHA_CHANNEL_INFO:
145     xWriteSEIAlphaChannelInfo(*static_cast<const SEIAlphaChannelInfo*>(&sei));
146     break;
147   case SEI::OVERLAY_INFO:
148     xWriteSEIOverlayInfo(*static_cast<const SEIOverlayInfo*>(&sei));
149     break;
150   case SEI::TEMPORAL_MV_PREDICTION_CONSTRAINTS:
151     xWriteSEITemporalMvPredictionConstraints(*static_cast<const SEITemporalMvPredictionConstraints*>(&sei));
152     break;
153#if NH_MV_SEI_TBD
154   case SEI::FRAME_FIELD_INFO:
155     xWriteSEIFrameFieldInfo(*static_cast<const SEIFrameFieldInfo*>(&sei));
156     break;
157#endif
158   case SEI::THREE_DIMENSIONAL_REFERENCE_DISPLAYS_INFO:
159     xWriteSEIThreeDimensionalReferenceDisplaysInfo(*static_cast<const SEIThreeDimensionalReferenceDisplaysInfo*>(&sei));
160     break;
161   case SEI::DEPTH_REPRESENTATION_INFO:
162       xWriteSEIDepthRepresentationInfo(*static_cast<const SEIDepthRepresentationInfo*>(&sei));
163       break;
164   case SEI::MULTIVIEW_SCENE_INFO:
165     xWriteSEIMultiviewSceneInfo(*static_cast<const SEIMultiviewSceneInfo*>(&sei));
166     break;
167   case SEI::MULTIVIEW_ACQUISITION_INFO:
168     xWriteSEIMultiviewAcquisitionInfo(*static_cast<const SEIMultiviewAcquisitionInfo*>(&sei));
169     break;
170
171   case SEI::MULTIVIEW_VIEW_POSITION:
172     xWriteSEIMultiviewViewPosition(*static_cast<const SEIMultiviewViewPosition*>(&sei));
173     break;
174#if NH_3D
175   case SEI::ALTERNATIVE_DEPTH_INFO:
176     xWriteSEIAlternativeDepthInfo(*static_cast<const SEIAlternativeDepthInfo*>(&sei));
177     break;
178#endif
179#endif
180
181
182  default:
183    assert(!"Trying to write unhandled SEI message");
184    break;
185  }
186  xWriteByteAlign();
187}
188
189/**
190 * marshal all SEI messages in provided list into one bitstream bs
191 */
192Void SEIWriter::writeSEImessages(TComBitIf& bs, const SEIMessages &seiList, const TComSPS *sps, Bool isNested)
193{
194#if ENC_DEC_TRACE
195  if (g_HLSTraceEnable)
196    xTraceSEIHeader();
197#endif
198
199  TComBitCounter bs_count;
200
201  for (SEIMessages::const_iterator sei=seiList.begin(); sei!=seiList.end(); sei++)
202  {
203    // calculate how large the payload data is
204    // TODO: this would be far nicer if it used vectored buffers
205    bs_count.resetBits();
206    setBitstream(&bs_count);
207
208#if ENC_DEC_TRACE
209    Bool traceEnable = g_HLSTraceEnable;
210    g_HLSTraceEnable = false;
211#endif
212    xWriteSEIpayloadData(bs_count, **sei, sps);
213#if ENC_DEC_TRACE
214    g_HLSTraceEnable = traceEnable;
215#endif
216    UInt payload_data_num_bits = bs_count.getNumberOfWrittenBits();
217    assert(0 == payload_data_num_bits % 8);
218
219    setBitstream(&bs);
220    UInt payloadType = (*sei)->payloadType();
221    for (; payloadType >= 0xff; payloadType -= 0xff)
222    {
223      WRITE_CODE(0xff, 8, "payload_type");
224    }
225    WRITE_CODE(payloadType, 8, "payload_type");
226
227    UInt payloadSize = payload_data_num_bits/8;
228    for (; payloadSize >= 0xff; payloadSize -= 0xff)
229    {
230      WRITE_CODE(0xff, 8, "payload_size");
231    }
232    WRITE_CODE(payloadSize, 8, "payload_size");
233
234    /* payloadData */
235#if ENC_DEC_TRACE
236    if (g_HLSTraceEnable)
237      xTraceSEIMessageType((*sei)->payloadType());
238#endif
239
240    xWriteSEIpayloadData(bs, **sei, sps);
241  }
242  if (!isNested)
243  {
244    xWriteRbspTrailingBits();
245  }
246}
247
248/**
249 * marshal a user_data_unregistered SEI message sei, storing the marshalled
250 * representation in bitstream bs.
251 */
252Void SEIWriter::xWriteSEIuserDataUnregistered(const SEIuserDataUnregistered &sei)
253{
254  for (UInt i = 0; i < ISO_IEC_11578_LEN; i++)
255  {
256    WRITE_CODE(sei.uuid_iso_iec_11578[i], 8 , "sei.uuid_iso_iec_11578[i]");
257  }
258
259  for (UInt i = 0; i < sei.userDataLength; i++)
260  {
261    WRITE_CODE(sei.userData[i], 8 , "user_data");
262  }
263}
264
265/**
266 * marshal a decoded picture hash SEI message, storing the marshalled
267 * representation in bitstream bs.
268 */
269Void SEIWriter::xWriteSEIDecodedPictureHash(const SEIDecodedPictureHash& sei)
270{
271  const TChar *traceString="\0";
272  switch (sei.method)
273  {
274    case HASHTYPE_MD5: traceString="picture_md5"; break;
275    case HASHTYPE_CRC: traceString="picture_crc"; break;
276    case HASHTYPE_CHECKSUM: traceString="picture_checksum"; break;
277    default: assert(false); break;
278  }
279
280  if (traceString != 0) //use of this variable is needed to avoid a compiler error with G++ 4.6.1
281  {
282    WRITE_CODE(sei.method, 8, "hash_type");
283    for(UInt i=0; i<UInt(sei.m_pictureHash.hash.size()); i++)
284    {
285      WRITE_CODE(sei.m_pictureHash.hash[i], 8, traceString);
286    }
287  }
288}
289
290Void SEIWriter::xWriteSEIActiveParameterSets(const SEIActiveParameterSets& sei)
291{
292  WRITE_CODE(sei.activeVPSId,     4,         "active_video_parameter_set_id");
293  WRITE_FLAG(sei.m_selfContainedCvsFlag,     "self_contained_cvs_flag");
294  WRITE_FLAG(sei.m_noParameterSetUpdateFlag, "no_parameter_set_update_flag");
295  WRITE_UVLC(sei.numSpsIdsMinus1,            "num_sps_ids_minus1");
296
297  assert (sei.activeSeqParameterSetId.size() == (sei.numSpsIdsMinus1 + 1));
298
299  for (Int i = 0; i < sei.activeSeqParameterSetId.size(); i++)
300  {
301    WRITE_UVLC(sei.activeSeqParameterSetId[i], "active_seq_parameter_set_id");
302  }
303}
304
305Void SEIWriter::xWriteSEIDecodingUnitInfo(const SEIDecodingUnitInfo& sei, const TComSPS *sps)
306{
307  const TComVUI *vui = sps->getVuiParameters();
308  WRITE_UVLC(sei.m_decodingUnitIdx, "decoding_unit_idx");
309  if(vui->getHrdParameters()->getSubPicCpbParamsInPicTimingSEIFlag())
310  {
311    WRITE_CODE( sei.m_duSptCpbRemovalDelay, (vui->getHrdParameters()->getDuCpbRemovalDelayLengthMinus1() + 1), "du_spt_cpb_removal_delay_increment");
312  }
313  WRITE_FLAG( sei.m_dpbOutputDuDelayPresentFlag, "dpb_output_du_delay_present_flag");
314  if(sei.m_dpbOutputDuDelayPresentFlag)
315  {
316    WRITE_CODE(sei.m_picSptDpbOutputDuDelay, vui->getHrdParameters()->getDpbOutputDelayDuLengthMinus1() + 1, "pic_spt_dpb_output_du_delay");
317  }
318}
319
320Void SEIWriter::xWriteSEIBufferingPeriod(const SEIBufferingPeriod& sei, const TComSPS *sps)
321{
322  Int i, nalOrVcl;
323  const TComVUI *vui = sps->getVuiParameters();
324  const TComHRD *hrd = vui->getHrdParameters();
325
326  WRITE_UVLC( sei.m_bpSeqParameterSetId, "bp_seq_parameter_set_id" );
327  if( !hrd->getSubPicCpbParamsPresentFlag() )
328  {
329    WRITE_FLAG( sei.m_rapCpbParamsPresentFlag, "irap_cpb_params_present_flag" );
330  }
331  if( sei.m_rapCpbParamsPresentFlag )
332  {
333    WRITE_CODE( sei.m_cpbDelayOffset, hrd->getCpbRemovalDelayLengthMinus1() + 1, "cpb_delay_offset" );
334    WRITE_CODE( sei.m_dpbDelayOffset, hrd->getDpbOutputDelayLengthMinus1()  + 1, "dpb_delay_offset" );
335  }
336  WRITE_FLAG( sei.m_concatenationFlag, "concatenation_flag");
337  WRITE_CODE( sei.m_auCpbRemovalDelayDelta - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ), "au_cpb_removal_delay_delta_minus1" );
338  for( nalOrVcl = 0; nalOrVcl < 2; nalOrVcl ++ )
339  {
340    if( ( ( nalOrVcl == 0 ) && ( hrd->getNalHrdParametersPresentFlag() ) ) ||
341        ( ( nalOrVcl == 1 ) && ( hrd->getVclHrdParametersPresentFlag() ) ) )
342    {
343      for( i = 0; i < ( hrd->getCpbCntMinus1( 0 ) + 1 ); i ++ )
344      {
345        WRITE_CODE( sei.m_initialCpbRemovalDelay[i][nalOrVcl],( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ) ,           "initial_cpb_removal_delay" );
346        WRITE_CODE( sei.m_initialCpbRemovalDelayOffset[i][nalOrVcl],( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ),      "initial_cpb_removal_delay_offset" );
347        if( hrd->getSubPicCpbParamsPresentFlag() || sei.m_rapCpbParamsPresentFlag )
348        {
349          WRITE_CODE( sei.m_initialAltCpbRemovalDelay[i][nalOrVcl], ( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ) ,     "initial_alt_cpb_removal_delay" );
350          WRITE_CODE( sei.m_initialAltCpbRemovalDelayOffset[i][nalOrVcl], ( hrd->getInitialCpbRemovalDelayLengthMinus1() + 1 ),"initial_alt_cpb_removal_delay_offset" );
351        }
352      }
353    }
354  }
355}
356Void SEIWriter::xWriteSEIPictureTiming(const SEIPictureTiming& sei, const TComSPS *sps)
357{
358  Int i;
359  const TComVUI *vui = sps->getVuiParameters();
360  const TComHRD *hrd = vui->getHrdParameters();
361
362  if( vui->getFrameFieldInfoPresentFlag() )
363  {
364    WRITE_CODE( sei.m_picStruct, 4,              "pic_struct" );
365    WRITE_CODE( sei.m_sourceScanType, 2,         "source_scan_type" );
366    WRITE_FLAG( sei.m_duplicateFlag ? 1 : 0,     "duplicate_flag" );
367  }
368
369  if( hrd->getCpbDpbDelaysPresentFlag() )
370  {
371    WRITE_CODE( sei.m_auCpbRemovalDelay - 1, ( hrd->getCpbRemovalDelayLengthMinus1() + 1 ),                                         "au_cpb_removal_delay_minus1" );
372    WRITE_CODE( sei.m_picDpbOutputDelay, ( hrd->getDpbOutputDelayLengthMinus1() + 1 ),                                          "pic_dpb_output_delay" );
373    if(hrd->getSubPicCpbParamsPresentFlag())
374    {
375      WRITE_CODE(sei.m_picDpbOutputDuDelay, hrd->getDpbOutputDelayDuLengthMinus1()+1, "pic_dpb_output_du_delay" );
376    }
377    if( hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag() )
378    {
379      WRITE_UVLC( sei.m_numDecodingUnitsMinus1,     "num_decoding_units_minus1" );
380      WRITE_FLAG( sei.m_duCommonCpbRemovalDelayFlag, "du_common_cpb_removal_delay_flag" );
381      if( sei.m_duCommonCpbRemovalDelayFlag )
382      {
383        WRITE_CODE( sei.m_duCommonCpbRemovalDelayMinus1, ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ),                       "du_common_cpb_removal_delay_minus1" );
384      }
385      for( i = 0; i <= sei.m_numDecodingUnitsMinus1; i ++ )
386      {
387        WRITE_UVLC( sei.m_numNalusInDuMinus1[ i ],  "num_nalus_in_du_minus1");
388        if( ( !sei.m_duCommonCpbRemovalDelayFlag ) && ( i < sei.m_numDecodingUnitsMinus1 ) )
389        {
390          WRITE_CODE( sei.m_duCpbRemovalDelayMinus1[ i ], ( hrd->getDuCpbRemovalDelayLengthMinus1() + 1 ),                        "du_cpb_removal_delay_minus1" );
391        }
392      }
393    }
394  }
395}
396Void SEIWriter::xWriteSEIRecoveryPoint(const SEIRecoveryPoint& sei)
397{
398  WRITE_SVLC( sei.m_recoveryPocCnt,    "recovery_poc_cnt"    );
399  WRITE_FLAG( sei.m_exactMatchingFlag, "exact_matching_flag" );
400  WRITE_FLAG( sei.m_brokenLinkFlag,    "broken_link_flag"    );
401}
402Void SEIWriter::xWriteSEIFramePacking(const SEIFramePacking& sei)
403{
404  WRITE_UVLC( sei.m_arrangementId,                  "frame_packing_arrangement_id" );
405  WRITE_FLAG( sei.m_arrangementCancelFlag,          "frame_packing_arrangement_cancel_flag" );
406
407  if( sei.m_arrangementCancelFlag == 0 )
408  {
409    WRITE_CODE( sei.m_arrangementType, 7,           "frame_packing_arrangement_type" );
410
411    WRITE_FLAG( sei.m_quincunxSamplingFlag,         "quincunx_sampling_flag" );
412    WRITE_CODE( sei.m_contentInterpretationType, 6, "content_interpretation_type" );
413    WRITE_FLAG( sei.m_spatialFlippingFlag,          "spatial_flipping_flag" );
414    WRITE_FLAG( sei.m_frame0FlippedFlag,            "frame0_flipped_flag" );
415    WRITE_FLAG( sei.m_fieldViewsFlag,               "field_views_flag" );
416    WRITE_FLAG( sei.m_currentFrameIsFrame0Flag,     "current_frame_is_frame0_flag" );
417
418    WRITE_FLAG( sei.m_frame0SelfContainedFlag,      "frame0_self_contained_flag" );
419    WRITE_FLAG( sei.m_frame1SelfContainedFlag,      "frame1_self_contained_flag" );
420
421    if(sei.m_quincunxSamplingFlag == 0 && sei.m_arrangementType != 5)
422    {
423      WRITE_CODE( sei.m_frame0GridPositionX, 4,     "frame0_grid_position_x" );
424      WRITE_CODE( sei.m_frame0GridPositionY, 4,     "frame0_grid_position_y" );
425      WRITE_CODE( sei.m_frame1GridPositionX, 4,     "frame1_grid_position_x" );
426      WRITE_CODE( sei.m_frame1GridPositionY, 4,     "frame1_grid_position_y" );
427    }
428
429    WRITE_CODE( sei.m_arrangementReservedByte, 8,   "frame_packing_arrangement_reserved_byte" );
430    WRITE_FLAG( sei.m_arrangementPersistenceFlag,   "frame_packing_arrangement_persistence_flag" );
431  }
432
433  WRITE_FLAG( sei.m_upsampledAspectRatio,           "upsampled_aspect_ratio" );
434}
435
436Void SEIWriter::xWriteSEISegmentedRectFramePacking(const SEISegmentedRectFramePacking& sei)
437{
438  WRITE_FLAG( sei.m_arrangementCancelFlag,          "segmented_rect_frame_packing_arrangement_cancel_flag" );
439  if( sei.m_arrangementCancelFlag == 0 )
440  {
441    WRITE_CODE( sei.m_contentInterpretationType, 2, "segmented_rect_content_interpretation_type" );
442    WRITE_FLAG( sei.m_arrangementPersistenceFlag,   "segmented_rect_frame_packing_arrangement_persistence" );
443  }
444}
445
446Void SEIWriter::xWriteSEIToneMappingInfo(const SEIToneMappingInfo& sei)
447{
448  Int i;
449  WRITE_UVLC( sei.m_toneMapId,                    "tone_map_id" );
450  WRITE_FLAG( sei.m_toneMapCancelFlag,            "tone_map_cancel_flag" );
451  if( !sei.m_toneMapCancelFlag )
452  {
453    WRITE_FLAG( sei.m_toneMapPersistenceFlag,     "tone_map_persistence_flag" );
454    WRITE_CODE( sei.m_codedDataBitDepth,    8,    "coded_data_bit_depth" );
455    WRITE_CODE( sei.m_targetBitDepth,       8,    "target_bit_depth" );
456    WRITE_UVLC( sei.m_modelId,                    "model_id" );
457    switch(sei.m_modelId)
458    {
459    case 0:
460      {
461        WRITE_CODE( sei.m_minValue,  32,        "min_value" );
462        WRITE_CODE( sei.m_maxValue, 32,         "max_value" );
463        break;
464      }
465    case 1:
466      {
467        WRITE_CODE( sei.m_sigmoidMidpoint, 32,  "sigmoid_midpoint" );
468        WRITE_CODE( sei.m_sigmoidWidth,    32,  "sigmoid_width"    );
469        break;
470      }
471    case 2:
472      {
473        UInt num = 1u << sei.m_targetBitDepth;
474        for(i = 0; i < num; i++)
475        {
476          WRITE_CODE( sei.m_startOfCodedInterval[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,  "start_of_coded_interval" );
477        }
478        break;
479      }
480    case 3:
481      {
482        WRITE_CODE( sei.m_numPivots, 16,          "num_pivots" );
483        for(i = 0; i < sei.m_numPivots; i++ )
484        {
485          WRITE_CODE( sei.m_codedPivotValue[i], (( sei.m_codedDataBitDepth + 7 ) >> 3 ) << 3,       "coded_pivot_value" );
486          WRITE_CODE( sei.m_targetPivotValue[i], (( sei.m_targetBitDepth + 7 ) >> 3 ) << 3,         "target_pivot_value");
487        }
488        break;
489      }
490    case 4:
491      {
492        WRITE_CODE( sei.m_cameraIsoSpeedIdc,    8,    "camera_iso_speed_idc" );
493        if( sei.m_cameraIsoSpeedIdc == 255) //Extended_ISO
494        {
495          WRITE_CODE( sei.m_cameraIsoSpeedValue,    32,    "camera_iso_speed_value" );
496        }
497        WRITE_CODE( sei.m_exposureIndexIdc,     8,    "exposure_index_idc" );
498        if( sei.m_exposureIndexIdc == 255) //Extended_ISO
499        {
500          WRITE_CODE( sei.m_exposureIndexValue,     32,    "exposure_index_value" );
501        }
502        WRITE_FLAG( sei.m_exposureCompensationValueSignFlag,           "exposure_compensation_value_sign_flag" );
503        WRITE_CODE( sei.m_exposureCompensationValueNumerator,     16,  "exposure_compensation_value_numerator" );
504        WRITE_CODE( sei.m_exposureCompensationValueDenomIdc,      16,  "exposure_compensation_value_denom_idc" );
505        WRITE_CODE( sei.m_refScreenLuminanceWhite,                32,  "ref_screen_luminance_white" );
506        WRITE_CODE( sei.m_extendedRangeWhiteLevel,                32,  "extended_range_white_level" );
507        WRITE_CODE( sei.m_nominalBlackLevelLumaCodeValue,         16,  "nominal_black_level_luma_code_value" );
508        WRITE_CODE( sei.m_nominalWhiteLevelLumaCodeValue,         16,  "nominal_white_level_luma_code_value" );
509        WRITE_CODE( sei.m_extendedWhiteLevelLumaCodeValue,        16,  "extended_white_level_luma_code_value" );
510        break;
511      }
512    default:
513      {
514        assert(!"Undefined SEIToneMapModelId");
515        break;
516      }
517    }//switch m_modelId
518  }//if(!sei.m_toneMapCancelFlag)
519}
520
521Void SEIWriter::xWriteSEIDisplayOrientation(const SEIDisplayOrientation &sei)
522{
523  WRITE_FLAG( sei.cancelFlag,           "display_orientation_cancel_flag" );
524  if( !sei.cancelFlag )
525  {
526    WRITE_FLAG( sei.horFlip,                   "hor_flip" );
527    WRITE_FLAG( sei.verFlip,                   "ver_flip" );
528    WRITE_CODE( sei.anticlockwiseRotation, 16, "anticlockwise_rotation" );
529    WRITE_FLAG( sei.persistenceFlag,          "display_orientation_persistence_flag" );
530  }
531}
532
533Void SEIWriter::xWriteSEITemporalLevel0Index(const SEITemporalLevel0Index &sei)
534{
535  WRITE_CODE( sei.tl0Idx, 8 , "tl0_idx" );
536  WRITE_CODE( sei.rapIdx, 8 , "rap_idx" );
537}
538
539Void SEIWriter::xWriteSEIGradualDecodingRefreshInfo(const SEIGradualDecodingRefreshInfo &sei)
540{
541  WRITE_FLAG( sei.m_gdrForegroundFlag, "gdr_foreground_flag");
542}
543
544Void SEIWriter::xWriteSEINoDisplay(const SEINoDisplay& /*sei*/)
545{
546}
547
548Void SEIWriter::xWriteSEISOPDescription(const SEISOPDescription& sei)
549{
550  WRITE_UVLC( sei.m_sopSeqParameterSetId,           "sop_seq_parameter_set_id"               );
551  WRITE_UVLC( sei.m_numPicsInSopMinus1,             "num_pics_in_sop_minus1"               );
552  for (UInt i = 0; i <= sei.m_numPicsInSopMinus1; i++)
553  {
554    WRITE_CODE( sei.m_sopDescVclNaluType[i], 6, "sop_desc_vcl_nalu_type" );
555    WRITE_CODE( sei.m_sopDescTemporalId[i],  3, "sop_desc_temporal_id" );
556    if (sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_W_RADL && sei.m_sopDescVclNaluType[i] != NAL_UNIT_CODED_SLICE_IDR_N_LP)
557    {
558      WRITE_UVLC( sei.m_sopDescStRpsIdx[i],           "sop_desc_st_rps_idx"               );
559    }
560    if (i > 0)
561    {
562      WRITE_SVLC( sei.m_sopDescPocDelta[i],           "sop_desc_poc_delta"               );
563    }
564  }
565}
566
567Void SEIWriter::xWriteSEIScalableNesting(TComBitIf& bs, const SEIScalableNesting& sei, const TComSPS *sps)
568{
569  WRITE_FLAG( sei.m_bitStreamSubsetFlag,             "bitstream_subset_flag"         );
570  WRITE_FLAG( sei.m_nestingOpFlag,                   "nesting_op_flag      "         );
571  if (sei.m_nestingOpFlag)
572  {
573    WRITE_FLAG( sei.m_defaultOpFlag,                 "default_op_flag"               );
574    WRITE_UVLC( sei.m_nestingNumOpsMinus1,           "nesting_num_ops_minus1"        );
575    for (UInt i = (sei.m_defaultOpFlag ? 1 : 0); i <= sei.m_nestingNumOpsMinus1; i++)
576    {
577      WRITE_CODE( sei.m_nestingMaxTemporalIdPlus1[i], 3,  "nesting_max_temporal_id_plus1" );
578      WRITE_UVLC( sei.m_nestingOpIdx[i],                  "nesting_op_idx"                );
579    }
580  }
581  else
582  {
583    WRITE_FLAG( sei.m_allLayersFlag,                      "all_layers_flag"               );
584    if (!sei.m_allLayersFlag)
585    {
586      WRITE_CODE( sei.m_nestingNoOpMaxTemporalIdPlus1, 3, "nesting_no_op_max_temporal_id_plus1" );
587      WRITE_UVLC( sei.m_nestingNumLayersMinus1,           "nesting_num_layers"                  );
588      for (UInt i = 0; i <= sei.m_nestingNumLayersMinus1; i++)
589      {
590        WRITE_CODE( sei.m_nestingLayerId[i], 6,           "nesting_layer_id"              );
591      }
592    }
593  }
594
595  // byte alignment
596  while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
597  {
598    WRITE_FLAG( 0, "nesting_zero_bit" );
599  }
600
601  // write nested SEI messages
602  writeSEImessages(bs, sei.m_nestedSEIs, sps, true);
603}
604
605Void SEIWriter::xWriteSEITempMotionConstrainedTileSets(const SEITempMotionConstrainedTileSets& sei)
606{
607  //UInt code;
608  WRITE_FLAG((sei.m_mc_all_tiles_exact_sample_value_match_flag ? 1 : 0), "mc_all_tiles_exact_sample_value_match_flag");
609  WRITE_FLAG((sei.m_each_tile_one_tile_set_flag                ? 1 : 0), "each_tile_one_tile_set_flag"               );
610
611  if(!sei.m_each_tile_one_tile_set_flag)
612  {
613    WRITE_FLAG((sei.m_limited_tile_set_display_flag ? 1 : 0), "limited_tile_set_display_flag");
614    WRITE_UVLC((sei.getNumberOfTileSets() - 1),               "num_sets_in_message_minus1"   );
615
616    if(sei.getNumberOfTileSets() > 0)
617    {
618      for(Int i = 0; i < sei.getNumberOfTileSets(); i++)
619      {
620        WRITE_UVLC(sei.tileSetData(i).m_mcts_id, "mcts_id");
621
622        if(sei.m_limited_tile_set_display_flag)
623        {
624          WRITE_FLAG((sei.tileSetData(i).m_display_tile_set_flag ? 1 : 0), "display_tile_set_flag");
625        }
626
627        WRITE_UVLC((sei.tileSetData(i).getNumberOfTileRects() - 1), "num_tile_rects_in_set_minus1");
628
629        for(Int j = 0; j < sei.tileSetData(i).getNumberOfTileRects(); j++)
630        {
631          WRITE_UVLC(sei.tileSetData(i).topLeftTileIndex    (j), "top_left_tile_index");
632          WRITE_UVLC(sei.tileSetData(i).bottomRightTileIndex(j), "bottom_right_tile_index");
633        }
634
635        if(!sei.m_mc_all_tiles_exact_sample_value_match_flag)
636        {
637          WRITE_FLAG((sei.tileSetData(i).m_exact_sample_value_match_flag ? 1 : 0), "exact_sample_value_match_flag");
638        }
639
640        WRITE_FLAG((sei.tileSetData(i).m_mcts_tier_level_idc_present_flag ? 1 : 0), "mcts_tier_level_idc_present_flag");
641
642        if(sei.tileSetData(i).m_mcts_tier_level_idc_present_flag)
643        {
644          WRITE_FLAG((sei.tileSetData(i).m_mcts_tier_flag ? 1 : 0), "mcts_tier_flag");
645          WRITE_CODE( sei.tileSetData(i).m_mcts_level_idc, 8,       "mcts_level_idc");
646        }
647      }
648    }
649  }
650  else
651  {
652    WRITE_FLAG((sei.m_max_mcs_tier_level_idc_present_flag ? 1 : 0), "max_mcs_tier_level_idc_present_flag");
653
654    if(sei.m_max_mcs_tier_level_idc_present_flag)
655    {
656      WRITE_FLAG((sei.m_max_mcts_tier_flag ? 1 : 0), "max_mcts_tier_flag");
657      WRITE_CODE( sei.m_max_mcts_level_idc, 8,       "max_mcts_level_idc");
658    }
659  }
660}
661
662Void SEIWriter::xWriteSEITimeCode(const SEITimeCode& sei)
663{
664  WRITE_CODE(sei.numClockTs, 2, "num_clock_ts");
665  for(Int i = 0; i < sei.numClockTs; i++)
666  {
667    const TComSEITimeSet &currentTimeSet = sei.timeSetArray[i];
668    WRITE_FLAG(currentTimeSet.clockTimeStampFlag, "clock_time_stamp_flag");
669    if(currentTimeSet.clockTimeStampFlag)
670    {
671      WRITE_FLAG(currentTimeSet.numUnitFieldBasedFlag, "units_field_based_flag");
672      WRITE_CODE(currentTimeSet.countingType, 5, "counting_type");
673      WRITE_FLAG(currentTimeSet.fullTimeStampFlag, "full_timestamp_flag");
674      WRITE_FLAG(currentTimeSet.discontinuityFlag, "discontinuity_flag");
675      WRITE_FLAG(currentTimeSet.cntDroppedFlag, "cnt_dropped_flag");
676      WRITE_CODE(currentTimeSet.numberOfFrames, 9, "n_frames");
677      if(currentTimeSet.fullTimeStampFlag)
678      {
679        WRITE_CODE(currentTimeSet.secondsValue, 6, "seconds_value");
680        WRITE_CODE(currentTimeSet.minutesValue, 6, "minutes_value");
681        WRITE_CODE(currentTimeSet.hoursValue, 5, "hours_value");
682      }
683      else
684      {
685        WRITE_FLAG(currentTimeSet.secondsFlag, "seconds_flag");
686        if(currentTimeSet.secondsFlag)
687        {
688          WRITE_CODE(currentTimeSet.secondsValue, 6, "seconds_value");
689          WRITE_FLAG(currentTimeSet.minutesFlag, "minutes_flag");
690          if(currentTimeSet.minutesFlag)
691          {
692            WRITE_CODE(currentTimeSet.minutesValue, 6, "minutes_value");
693            WRITE_FLAG(currentTimeSet.hoursFlag, "hours_flag");
694            if(currentTimeSet.hoursFlag)
695            {
696              WRITE_CODE(currentTimeSet.hoursValue, 5, "hours_value");
697            }
698          }
699        }
700      }
701      WRITE_CODE(currentTimeSet.timeOffsetLength, 5, "time_offset_length");
702      if(currentTimeSet.timeOffsetLength > 0)
703      {
704        if(currentTimeSet.timeOffsetValue >= 0)
705        {
706          WRITE_CODE((UInt)currentTimeSet.timeOffsetValue, currentTimeSet.timeOffsetLength, "time_offset_value");
707        }
708        else
709        {
710          //  Two's complement conversion
711          UInt offsetValue = ~(currentTimeSet.timeOffsetValue) + 1;
712          offsetValue |= (1 << (currentTimeSet.timeOffsetLength-1));
713          WRITE_CODE(offsetValue, currentTimeSet.timeOffsetLength, "time_offset_value");
714        }
715      }
716    }
717  }
718}
719
720Void SEIWriter::xWriteSEIChromaResamplingFilterHint(const SEIChromaResamplingFilterHint &sei)
721{
722  WRITE_CODE(sei.m_verChromaFilterIdc, 8, "ver_chroma_filter_idc");
723  WRITE_CODE(sei.m_horChromaFilterIdc, 8, "hor_chroma_filter_idc");
724  WRITE_FLAG(sei.m_verFilteringFieldProcessingFlag, "ver_filtering_field_processing_flag");
725  if(sei.m_verChromaFilterIdc == 1 || sei.m_horChromaFilterIdc == 1)
726  {
727    WRITE_UVLC(sei.m_targetFormatIdc, "target_format_idc");
728    if(sei.m_verChromaFilterIdc == 1)
729    {
730      const Int numVerticalFilter = (Int)sei.m_verFilterCoeff.size();
731      WRITE_UVLC(numVerticalFilter, "num_vertical_filters");
732      if(numVerticalFilter > 0)
733      {
734        for(Int i = 0; i < numVerticalFilter; i ++)
735        {
736          const Int verTapLengthMinus1 = (Int) sei.m_verFilterCoeff[i].size() - 1;
737          WRITE_UVLC(verTapLengthMinus1, "ver_tap_length_minus_1");
738          for(Int j = 0; j < (verTapLengthMinus1 + 1); j ++)
739          {
740            WRITE_SVLC(sei.m_verFilterCoeff[i][j], "ver_filter_coeff");
741          }
742        }
743      }
744    }
745    if(sei.m_horChromaFilterIdc == 1)
746    {
747      const Int numHorizontalFilter = (Int) sei.m_horFilterCoeff.size();
748      WRITE_UVLC(numHorizontalFilter, "num_horizontal_filters");
749      if(numHorizontalFilter > 0)
750      {
751        for(Int i = 0; i < numHorizontalFilter; i ++)
752        {
753          const Int horTapLengthMinus1 = (Int) sei.m_horFilterCoeff[i].size() - 1;
754          WRITE_UVLC(horTapLengthMinus1, "hor_tap_length_minus_1");
755          for(Int j = 0; j < (horTapLengthMinus1 + 1); j ++)
756          {
757            WRITE_SVLC(sei.m_horFilterCoeff[i][j], "hor_filter_coeff");
758          }
759        }
760      }
761    }
762  }
763}
764
765Void SEIWriter::xWriteSEIKneeFunctionInfo(const SEIKneeFunctionInfo &sei)
766{
767  WRITE_UVLC( sei.m_kneeId, "knee_function_id" );
768  WRITE_FLAG( sei.m_kneeCancelFlag, "knee_function_cancel_flag" );
769  if ( !sei.m_kneeCancelFlag )
770  {
771    WRITE_FLAG( sei.m_kneePersistenceFlag, "knee_function_persistence_flag" );
772    WRITE_CODE( (UInt)sei.m_kneeInputDrange , 32,  "input_d_range" );
773    WRITE_CODE( (UInt)sei.m_kneeInputDispLuminance, 32,  "input_disp_luminance" );
774    WRITE_CODE( (UInt)sei.m_kneeOutputDrange, 32,  "output_d_range" );
775    WRITE_CODE( (UInt)sei.m_kneeOutputDispLuminance, 32,  "output_disp_luminance" );
776    WRITE_UVLC( sei.m_kneeNumKneePointsMinus1, "num_knee_points_minus1" );
777    for(Int i = 0; i <= sei.m_kneeNumKneePointsMinus1; i++ )
778    {
779      WRITE_CODE( (UInt)sei.m_kneeInputKneePoint[i], 10,"input_knee_point" );
780      WRITE_CODE( (UInt)sei.m_kneeOutputKneePoint[i], 10, "output_knee_point" );
781    }
782  }
783}
784
785Void SEIWriter::xWriteSEIColourRemappingInfo(const SEIColourRemappingInfo& sei)
786{
787  WRITE_UVLC( sei.m_colourRemapId,                             "colour_remap_id" );
788  WRITE_FLAG( sei.m_colourRemapCancelFlag,                     "colour_remap_cancel_flag" );
789  if( !sei.m_colourRemapCancelFlag ) 
790  {
791    WRITE_FLAG( sei.m_colourRemapPersistenceFlag,              "colour_remap_persistence_flag" );
792    WRITE_FLAG( sei.m_colourRemapVideoSignalInfoPresentFlag,   "colour_remap_video_signal_info_present_flag" );
793    if ( sei.m_colourRemapVideoSignalInfoPresentFlag )
794    {
795      WRITE_FLAG( sei.m_colourRemapFullRangeFlag,              "colour_remap_full_range_flag" );
796      WRITE_CODE( sei.m_colourRemapPrimaries,               8, "colour_remap_primaries" );
797      WRITE_CODE( sei.m_colourRemapTransferFunction,        8, "colour_remap_transfer_function" );
798      WRITE_CODE( sei.m_colourRemapMatrixCoefficients,      8, "colour_remap_matrix_coefficients" );
799    }
800    WRITE_CODE( sei.m_colourRemapInputBitDepth,             8, "colour_remap_input_bit_depth" );
801    WRITE_CODE( sei.m_colourRemapBitDepth,                  8, "colour_remap_bit_depth" );
802    for( Int c=0 ; c<3 ; c++ )
803    {
804      WRITE_CODE( sei.m_preLutNumValMinus1[c],              8, "pre_lut_num_val_minus1[c]" );
805      if( sei.m_preLutNumValMinus1[c]>0 )
806      {
807        for( Int i=0 ; i<=sei.m_preLutNumValMinus1[c] ; i++ )
808        {
809          WRITE_CODE( sei.m_preLut[c][i].codedValue,  (( sei.m_colourRemapInputBitDepth + 7 ) >> 3 ) << 3, "pre_lut_coded_value[c][i]" );
810          WRITE_CODE( sei.m_preLut[c][i].targetValue, (( sei.m_colourRemapBitDepth      + 7 ) >> 3 ) << 3, "pre_lut_target_value[c][i]" );
811        }
812      }
813    }
814    WRITE_FLAG( sei.m_colourRemapMatrixPresentFlag,            "colour_remap_matrix_present_flag" );
815    if( sei.m_colourRemapMatrixPresentFlag )
816    {
817      WRITE_CODE( sei.m_log2MatrixDenom,                    4, "log2_matrix_denom" );
818      for( Int c=0 ; c<3 ; c++ )
819      {
820        for( Int i=0 ; i<3 ; i++ )
821        {
822          WRITE_SVLC( sei.m_colourRemapCoeffs[c][i],           "colour_remap_coeffs[c][i]" );
823        }
824      }
825    }
826
827    for( Int c=0 ; c<3 ; c++ )
828    {
829      WRITE_CODE( sei.m_postLutNumValMinus1[c],             8, "m_postLutNumValMinus1[c]" );
830      if( sei.m_postLutNumValMinus1[c]>0 )
831      {
832        for( Int i=0 ; i<=sei.m_postLutNumValMinus1[c] ; i++ )
833        {
834          WRITE_CODE( sei.m_postLut[c][i].codedValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_coded_value[c][i]" );
835          WRITE_CODE( sei.m_postLut[c][i].targetValue, (( sei.m_colourRemapBitDepth + 7 ) >> 3 ) << 3, "post_lut_target_value[c][i]" );
836        }
837      }
838    }
839  }
840}
841
842Void SEIWriter::xWriteSEIMasteringDisplayColourVolume(const SEIMasteringDisplayColourVolume& sei)
843{
844  WRITE_CODE( sei.values.primaries[0][0],  16,  "display_primaries_x[0]" );
845  WRITE_CODE( sei.values.primaries[0][1],  16,  "display_primaries_y[0]" );
846
847  WRITE_CODE( sei.values.primaries[1][0],  16,  "display_primaries_x[1]" );
848  WRITE_CODE( sei.values.primaries[1][1],  16,  "display_primaries_y[1]" );
849
850  WRITE_CODE( sei.values.primaries[2][0],  16,  "display_primaries_x[2]" );
851  WRITE_CODE( sei.values.primaries[2][1],  16,  "display_primaries_y[2]" );
852
853  WRITE_CODE( sei.values.whitePoint[0],    16,  "white_point_x" );
854  WRITE_CODE( sei.values.whitePoint[1],    16,  "white_point_y" );
855   
856  WRITE_CODE( sei.values.maxLuminance,     32,  "max_display_mastering_luminance" );
857  WRITE_CODE( sei.values.minLuminance,     32,  "min_display_mastering_luminance" );
858}
859
860
861Void SEIWriter::xWriteByteAlign()
862{
863  if( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0)
864  {
865    WRITE_FLAG( 1, "payload_bit_equal_to_one" );
866    while( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
867    {
868      WRITE_FLAG( 0, "payload_bit_equal_to_zero" );
869    }
870  }
871}
872
873#if NH_MV
874Void SEIWriter::xWriteSEILayersNotPresent(const SEILayersNotPresent& sei)
875{
876  WRITE_CODE( sei.m_lnpSeiActiveVpsId, 4, "lnp_sei_active_vps_id" );
877  for( Int i = 0; i  <  sei.m_lnpSeiMaxLayers; i++ )
878  {
879    WRITE_FLAG( ( sei.m_layerNotPresentFlag[i] ? 1 : 0 ), "layer_not_present_flag" );
880  }
881};
882
883Void SEIWriter::xWriteSEIInterLayerConstrainedTileSets( const SEIInterLayerConstrainedTileSets& sei)
884{
885  WRITE_FLAG( ( sei.m_ilAllTilesExactSampleValueMatchFlag ? 1 : 0 ), "il_all_tiles_exact_sample_value_match_flag" );
886  WRITE_FLAG( ( sei.m_ilOneTilePerTileSetFlag ? 1 : 0 ),             "il_one_tile_per_tile_set_flag" );
887  if( !sei.m_ilOneTilePerTileSetFlag )
888  {
889    WRITE_UVLC( sei.m_ilNumSetsInMessageMinus1, "il_num_sets_in_message_minus1" );
890    if( sei.m_ilNumSetsInMessageMinus1 )
891    {
892      WRITE_FLAG( ( sei.m_skippedTileSetPresentFlag ? 1 : 0 ), "skipped_tile_set_present_flag" );
893    }
894    Int numSignificantSets = sei.m_ilNumSetsInMessageMinus1 - sei.m_skippedTileSetPresentFlag + 1;
895    for( Int i = 0; i < numSignificantSets; i++ )
896    {
897      WRITE_UVLC( sei.m_ilctsId[i],                   "ilcts_id" );
898      WRITE_UVLC( sei.m_ilNumTileRectsInSetMinus1[i], "il_num_tile_rects_in_set_minus1" );
899      for( Int j = 0; j  <= sei.m_ilNumTileRectsInSetMinus1[ i ]; j++ )
900      {
901        WRITE_UVLC( sei.m_ilTopLeftTileIndex[i][j],     "il_top_left_tile_index" );
902        WRITE_UVLC( sei.m_ilBottomRightTileIndex[i][j], "il_bottom_right_tile_index" );
903      }
904      WRITE_CODE( sei.m_ilcIdc[i], 2, "ilc_idc" );
905      if ( !sei.m_ilAllTilesExactSampleValueMatchFlag )
906      {
907        WRITE_FLAG( ( sei.m_ilExactSampleValueMatchFlag[i] ? 1 : 0 ), "il_exact_sample_value_match_flag" );
908      }
909    }
910  }
911  else
912  {
913    WRITE_CODE( sei.m_allTilesIlcIdc, 2, "all_tiles_ilc_idc" );
914  }
915};
916
917#if NH_MV_SEI_TBD
918Void SEIWriter::xWriteSEIBspNesting( const SEIBspNesting& sei)
919{
920  WRITE_UVLC( sei.m_seiOlsIdx, "sei_ols_idx" );
921  WRITE_UVLC( sei.m_seiPartitioningSchemeIdx, "sei_partitioning_scheme_idx" );
922  WRITE_UVLC( sei.m_bspIdx, "bsp_idx" );
923  while( !ByteaLigned(() ) );
924  {
925    WRITE_CODE( sei.m_bspNestingZeroBit, *equalto0*/u1, "bsp_nesting_zero_bit" );
926  }
927  WRITE_UVLC( sei.m_numSeisInBspMinus1, "num_seis_in_bsp_minus1" );
928  for( Int i = 0; i  <=  NumSeisInBspMinus1( ); i++ )
929  {
930    SeiMessage(() );
931  }
932};
933
934Void SEIWriter::xWriteSEIBspInitialArrivalTime( const SEIBspInitialArrivalTime& sei)
935{
936  psIdx = SeiPartitioningSchemeIdx();
937  if( nalInitialArrivalDelayPresent )
938  {
939    for( Int i = 0; i < BspSchedCnt( SeiOlsIdx(), psIdx, MaxTemporalId( 0 ) ); i++ )
940    {
941      WRITE_CODE( sei.m_nalInitialArrivalDelay[i], getNalInitialArrivalDelayLen ), "nal_initial_arrival_delay" );
942    }
943  }
944  if( vclInitialArrivalDelayPresent )
945  {
946    for( Int i = 0; i < BspSchedCnt( SeiOlsIdx(), psIdx, MaxTemporalId( 0 ) ); i++ )
947    {
948      WRITE_CODE( sei.m_vclInitialArrivalDelay[i], getVclInitialArrivalDelayLen ), "vcl_initial_arrival_delay" );
949    }
950  }
951};
952#endif
953Void SEIWriter::xWriteSEISubBitstreamProperty( const SEISubBitstreamProperty& sei)
954{
955  WRITE_CODE( sei.m_sbPropertyActiveVpsId, 4,      "sb_property_active_vps_id"         );
956  WRITE_UVLC( sei.m_numAdditionalSubStreamsMinus1, "num_additional_sub_streams_minus1" );
957  for( Int i = 0; i  <=  sei.m_numAdditionalSubStreamsMinus1; i++ )
958  {
959    WRITE_CODE( sei.m_subBitstreamMode    [i], 2,  "sub_bitstream_mode"       );
960    WRITE_UVLC( sei.m_olsIdxToVps         [i],     "ols_idx_to_vps"           );
961    WRITE_CODE( sei.m_highestSublayerId   [i], 3,  "highest_sublayer_id"      );
962    WRITE_CODE( sei.m_avgSbPropertyBitRate[i], 16, "avg_sb_property_bit_rate" );
963    WRITE_CODE( sei.m_maxSbPropertyBitRate[i], 16, "max_sb_property_bit_rate" );
964  }
965};
966
967Void SEIWriter::xWriteSEIAlphaChannelInfo( const SEIAlphaChannelInfo& sei)
968{
969  WRITE_FLAG( ( sei.m_alphaChannelCancelFlag ? 1 : 0 ), "alpha_channel_cancel_flag" );
970  if( !sei.m_alphaChannelCancelFlag )
971  {
972    WRITE_CODE( sei.m_alphaChannelUseIdc, 3, "alpha_channel_use_idc" );
973    WRITE_CODE( sei.m_alphaChannelBitDepthMinus8, 3, "alpha_channel_bit_depth_minus8" );
974    WRITE_CODE( sei.m_alphaTransparentValue, sei.m_alphaChannelBitDepthMinus8+9, "alpha_transparent_value" );
975    WRITE_CODE( sei.m_alphaOpaqueValue, sei.m_alphaChannelBitDepthMinus8+9, "alpha_opaque_value" );
976    WRITE_FLAG( ( sei.m_alphaChannelIncrFlag ? 1 : 0 ), "alpha_channel_incr_flag" );
977    WRITE_FLAG( ( sei.m_alphaChannelClipFlag ? 1 : 0 ), "alpha_channel_clip_flag" );
978    if( sei.m_alphaChannelClipFlag )
979    {
980      WRITE_FLAG( ( sei.m_alphaChannelClipTypeFlag ? 1 : 0 ), "alpha_channel_clip_type_flag" );
981    }
982  }
983};
984
985Void SEIWriter::xWriteSEIOverlayInfo( const SEIOverlayInfo& sei)
986{
987  WRITE_FLAG( ( sei.m_overlayInfoCancelFlag ? 1 : 0 ), "overlay_info_cancel_flag" );
988  if( !sei.m_overlayInfoCancelFlag )
989  {
990    WRITE_UVLC( sei.m_overlayContentAuxIdMinus128, "overlay_content_aux_id_minus128" );
991    WRITE_UVLC( sei.m_overlayLabelAuxIdMinus128, "overlay_label_aux_id_minus128" );
992    WRITE_UVLC( sei.m_overlayAlphaAuxIdMinus128, "overlay_alpha_aux_id_minus128" );
993    WRITE_UVLC( sei.m_overlayElementLabelValueLengthMinus8, "overlay_element_label_value_length_minus8" );
994    WRITE_UVLC( sei.m_numOverlaysMinus1, "num_overlays_minus1" );
995    for( Int i = 0; i  <=  sei.m_numOverlaysMinus1 ; i++ )
996    {
997      WRITE_UVLC( sei.m_overlayIdx[i], "overlay_idx" );
998      WRITE_FLAG( ( sei.m_languageOverlayPresentFlag[i] ? 1 : 0 ), "language_overlay_present_flag" );
999      WRITE_CODE( sei.m_overlayContentLayerId[i], 6, "overlay_content_layer_id" );
1000      WRITE_FLAG( ( sei.m_overlayLabelPresentFlag[i] ? 1 : 0 ), "overlay_label_present_flag" );
1001      if( sei.m_overlayLabelPresentFlag[i] )
1002      {
1003        WRITE_CODE( sei.m_overlayLabelLayerId[i], 6, "overlay_label_layer_id" );
1004      }
1005      WRITE_FLAG( ( sei.m_overlayAlphaPresentFlag[i] ? 1 : 0 ), "overlay_alpha_present_flag" );
1006      if( sei.m_overlayAlphaPresentFlag[i] )
1007      {
1008        WRITE_CODE( sei.m_overlayAlphaLayerId[i], 6, "overlay_alpha_layer_id" );
1009      }
1010      if( sei.m_overlayLabelPresentFlag[i] )
1011      {
1012        WRITE_UVLC( sei.m_numOverlayElementsMinus1[i], "num_overlay_elements_minus1" );
1013        for( Int j = 0; j  <=  sei.m_numOverlayElementsMinus1[i]; j++ )
1014        {
1015          WRITE_CODE( sei.m_overlayElementLabelMin[i][j], (sei.m_overlayElementLabelValueLengthMinus8 + 8), "overlay_element_label_min" );
1016          WRITE_CODE( sei.m_overlayElementLabelMax[i][j], (sei.m_overlayElementLabelValueLengthMinus8 + 8), "overlay_element_label_max" );
1017        }
1018      }
1019    }
1020
1021    // byte alignment
1022    while ( m_pcBitIf->getNumberOfWrittenBits() % 8 != 0 )
1023    {
1024      WRITE_FLAG( 0, "overlay_zero_bit" );
1025    }
1026
1027    UChar* stmp;
1028    UInt ilength;
1029    for( Int i = 0; i  <=  sei.m_numOverlaysMinus1; i++ )
1030    {
1031      if( sei.m_languageOverlayPresentFlag[i] )
1032      {
1033        stmp = (UChar*) strdup( sei.m_overlayLanguage[i].c_str() );
1034        ilength = (UInt) sei.m_overlayLanguage[i].size();
1035        WRITE_STRING( stmp, ilength, "overlay_language" );
1036        free(stmp);
1037      }
1038      stmp = (UChar*) strdup( sei.m_overlayName[i].c_str() );
1039      ilength = (UInt) sei.m_overlayName[i].size();
1040      WRITE_STRING( stmp, ilength, "overlay_name" );
1041      free(stmp);
1042      if( sei.m_overlayLabelPresentFlag[i] )
1043      {
1044        for( Int j = 0; j  <=  sei.m_numOverlayElementsMinus1[i]; j++ )
1045        {
1046          stmp = (UChar*) strdup( sei.m_overlayElementName[i][j].c_str() );
1047          ilength = (UInt) sei.m_overlayElementName[i][j].size();
1048          WRITE_STRING( stmp, ilength, "overlay_element_name" );
1049          free(stmp);
1050        }
1051      }
1052    }
1053    WRITE_FLAG( ( sei.m_overlayInfoPersistenceFlag ? 1 : 0 ), "overlay_info_persistence_flag" );
1054  }
1055};
1056
1057
1058Void SEIWriter::xWriteSEITemporalMvPredictionConstraints( const SEITemporalMvPredictionConstraints& sei)
1059{
1060  WRITE_FLAG( ( sei.m_prevPicsNotUsedFlag    ? 1 : 0 ), "prev_pics_not_used_flag"     );
1061  WRITE_FLAG( ( sei.m_noIntraLayerColPicFlag ? 1 : 0 ), "no_intra_layer_col_pic_flag" );
1062};
1063
1064#if NH_MV_SEI_TBD
1065Void SEIWriter::xWriteSEIFrameFieldInfo( const SEIFrameFieldInfo& sei)
1066{
1067  WRITE_CODE( sei.m_ffinfoPicStruct, 4, "ffinfo_pic_struct" );
1068  WRITE_CODE( sei.m_ffinfoSourceScanType, 2, "ffinfo_source_scan_type" );
1069  WRITE_FLAG( ( sei.m_ffinfoDuplicateFlag ? 1 : 0 ), "ffinfo_duplicate_flag" );
1070};
1071#endif
1072
1073Void SEIWriter::xWriteSEIThreeDimensionalReferenceDisplaysInfo( const SEIThreeDimensionalReferenceDisplaysInfo& sei)
1074{
1075  WRITE_UVLC( sei.m_precRefDisplayWidth, "prec_ref_display_width" );
1076  WRITE_FLAG( ( sei.m_refViewingDistanceFlag ? 1 : 0 ), "ref_viewing_distance_flag" );
1077  if( sei.m_refViewingDistanceFlag )
1078  {
1079    WRITE_UVLC( sei.m_precRefViewingDist, "prec_ref_viewing_dist" );
1080  }
1081  WRITE_UVLC( sei.m_numRefDisplaysMinus1, "num_ref_displays_minus1" );
1082  for( Int i = 0; i  <=  sei.getNumRefDisplaysMinus1( ); i++ )
1083  {
1084    WRITE_UVLC( sei.m_leftViewId[i], "left_view_id" );
1085    WRITE_UVLC( sei.m_rightViewId[i], "right_view_id" );
1086    WRITE_CODE( sei.m_exponentRefDisplayWidth[i], 6, "exponent_ref_display_width" );
1087    WRITE_CODE( sei.m_mantissaRefDisplayWidth[i], sei.getMantissaReferenceDisplayWidthLen(i) , "mantissa_ref_display_width" );
1088    if( sei.m_refViewingDistanceFlag )
1089    {
1090      WRITE_CODE( sei.m_exponentRefViewingDistance[i], 6, "exponent_ref_viewing_distance" );
1091      WRITE_CODE( sei.m_mantissaRefViewingDistance[i], sei.getMantissaReferenceViewingDistanceLen(i), "mantissa_ref_viewing_distance" );
1092    }
1093    WRITE_FLAG( ( sei.m_additionalShiftPresentFlag[i] ? 1 : 0 ), "additional_shift_present_flag" );
1094    if( sei.m_additionalShiftPresentFlag[i] )
1095    {
1096      WRITE_CODE( sei.m_numSampleShiftPlus512[i], 10, "num_sample_shift_plus512" );
1097    }
1098  }
1099  WRITE_FLAG( ( sei.m_threeDimensionalReferenceDisplaysExtensionFlag ? 1 : 0 ), "three_dimensional_reference_displays_extension_flag" );
1100};
1101
1102Void SEIWriter::xWriteSEIDepthRepresentationInfo( const SEIDepthRepresentationInfo& sei)
1103{
1104
1105    assert(sei.m_currLayerID>=0);
1106
1107    WRITE_FLAG( ( sei.m_zNearFlag[sei.m_currLayerID] ? 1 : 0 ), "z_near_flag" );
1108    WRITE_FLAG( ( sei.m_zFarFlag[sei.m_currLayerID] ? 1 : 0 ), "z_far_flag" );
1109    WRITE_FLAG( ( sei.m_dMinFlag[sei.m_currLayerID] ? 1 : 0 ), "d_min_flag" );
1110    WRITE_FLAG( ( sei.m_dMaxFlag[sei.m_currLayerID] ? 1 : 0 ), "d_max_flag" );
1111    WRITE_UVLC( sei.m_depthRepresentationType[sei.m_currLayerID][0], "depth_representation_type" );
1112    if( sei.m_dMinFlag[sei.m_currLayerID]  ||  sei.m_dMaxFlag[sei.m_currLayerID] )
1113    {
1114        WRITE_UVLC( sei.m_disparityRefViewId[sei.m_currLayerID][0], "disparity_ref_view_id" );
1115    }
1116    if( sei.m_zNearFlag[sei.m_currLayerID] )
1117    {
1118        xWriteSEIDepthRepInfoElement(sei.m_zNear[sei.m_currLayerID][0]);
1119    }
1120    if( sei.m_zFarFlag[sei.m_currLayerID] )
1121    {
1122        xWriteSEIDepthRepInfoElement(sei.m_zFar[sei.m_currLayerID][0]);
1123    }
1124    if( sei.m_dMinFlag[sei.m_currLayerID] )
1125    {
1126        xWriteSEIDepthRepInfoElement(sei.m_dMin[sei.m_currLayerID][0]);
1127    }
1128    if( sei.m_dMaxFlag[sei.m_currLayerID] )
1129    {
1130        xWriteSEIDepthRepInfoElement(sei.m_dMax[sei.m_currLayerID][0]);
1131    }
1132
1133    if (sei.m_depthRepresentationType[sei.m_currLayerID][0] == 3)
1134    {
1135        WRITE_UVLC( sei.m_depthNonlinearRepresentationNumMinus1[sei.m_currLayerID][0], "depth_nonlinear_representation_num_minus1" );
1136        for( Int i = 1; i  <=  sei.m_depthNonlinearRepresentationNumMinus1[sei.m_currLayerID][0] + 1; i++ )
1137        {
1138            WRITE_UVLC(sei.m_depth_nonlinear_representation_model[sei.m_currLayerID][i-1],"depth_nonlinear_representation_model[ i ]");
1139        }
1140    }
1141}
1142
1143Void SEIWriter::xWriteSEIDepthRepInfoElement( double f)
1144{
1145    UInt x_sign, x_exp, x_mantissa,x_mantissa_len;
1146    if (f < 0)
1147    {
1148        f = f * (-1);
1149        x_sign = 1;
1150    }
1151    else
1152    {
1153        x_sign = 0;
1154    }
1155    int exponent=0;
1156    if(f >= 1)
1157    {
1158        while(f>=2)
1159        {
1160            exponent++;
1161            f = f/2;
1162        }
1163    }
1164    else
1165    {
1166        while (f<1)
1167        {
1168            exponent++;
1169            f = f*2;
1170        }
1171        exponent=-exponent;
1172    }
1173
1174    int i;
1175    f = f -1;
1176    double s = 1;
1177    char s_mantissa[32];
1178    double thr=1.0/(4.0*(1<<30));
1179
1180    if (f>=thr)
1181    {
1182        for(i=0;i<32;i++)
1183        {
1184            s /= 2;
1185            if(f>=s)
1186            {
1187                f = f-s;
1188                s_mantissa[i]=1;
1189
1190                if (f<thr)
1191                    break;
1192            }
1193            else
1194            {
1195                s_mantissa[i]=0;
1196            }
1197        }
1198
1199        if (i<32)
1200            x_mantissa_len=i+1;
1201        else
1202            x_mantissa_len=32;
1203
1204        x_mantissa=0;
1205
1206        for(i=0;i<x_mantissa_len;i++)
1207        {
1208            if (s_mantissa[i]==1)
1209                x_mantissa += (1u)<<(x_mantissa_len-1-i) ;
1210        }
1211
1212    }
1213    else
1214    {
1215        x_mantissa=0;
1216        x_mantissa_len=1;
1217    }
1218
1219    assert(exponent>=-31 && exponent<= (1<<7)-32);
1220    x_exp=exponent+31;
1221
1222    WRITE_FLAG(  x_sign,                         "da_sign_flag" );
1223    WRITE_CODE(  x_exp, 7 ,                      "da_exponent" );
1224    WRITE_CODE( x_mantissa_len-1, 5 ,            "da_mantissa_len_minus1" );
1225    WRITE_CODE( x_mantissa, x_mantissa_len ,     "da_mantissa" );
1226
1227};
1228
1229Void SEIWriter::xWriteSEIMultiviewSceneInfo( const SEIMultiviewSceneInfo& sei)
1230{
1231  WRITE_SVLC( sei.m_minDisparity     , "min_disparity"       );
1232  WRITE_UVLC( sei.m_maxDisparityRange, "max_disparity_range" );
1233};
1234
1235
1236Void SEIWriter::xWriteSEIMultiviewAcquisitionInfo( const SEIMultiviewAcquisitionInfo& sei)
1237{
1238  WRITE_FLAG( ( sei.m_intrinsicParamFlag ? 1 : 0 ), "intrinsic_param_flag" );
1239  WRITE_FLAG( ( sei.m_extrinsicParamFlag ? 1 : 0 ), "extrinsic_param_flag" );
1240  if( sei.m_intrinsicParamFlag )
1241  {
1242    WRITE_FLAG( ( sei.m_intrinsicParamsEqualFlag ? 1 : 0 ), "intrinsic_params_equal_flag" );
1243    WRITE_UVLC(   sei.m_precFocalLength                   , "prec_focal_length"           );
1244    WRITE_UVLC(   sei.m_precPrincipalPoint                , "prec_principal_point"        );
1245    WRITE_UVLC(   sei.m_precSkewFactor                    , "prec_skew_factor"            );
1246
1247    for( Int i = 0; i  <=  ( sei.m_intrinsicParamsEqualFlag ? 0 : sei.getNumViewsMinus1() ); i++ )
1248    {
1249      WRITE_FLAG( ( sei.m_signFocalLengthX       [i] ? 1 : 0 ),                                         "sign_focal_length_x"        );
1250      WRITE_CODE(   sei.m_exponentFocalLengthX   [i]          , 6                                  ,    "exponent_focal_length_x"    );
1251      WRITE_CODE(   sei.m_mantissaFocalLengthX   [i]          , sei.getMantissaFocalLengthXLen( i ),    "mantissa_focal_length_x"    );
1252      WRITE_FLAG( ( sei.m_signFocalLengthY       [i] ? 1 : 0 ),                                         "sign_focal_length_y"        );
1253      WRITE_CODE(   sei.m_exponentFocalLengthY   [i]          , 6                                  ,    "exponent_focal_length_y"    );
1254      WRITE_CODE(   sei.m_mantissaFocalLengthY   [i]          , sei.getMantissaFocalLengthYLen( i ),    "mantissa_focal_length_y"    );
1255      WRITE_FLAG( ( sei.m_signPrincipalPointX    [i] ? 1 : 0 ),                                         "sign_principal_point_x"     );
1256      WRITE_CODE(   sei.m_exponentPrincipalPointX[i]          , 6,                                      "exponent_principal_point_x" );
1257      WRITE_CODE(   sei.m_mantissaPrincipalPointX[i]          , sei.getMantissaPrincipalPointXLen( i ), "mantissa_principal_point_x" );
1258      WRITE_FLAG( ( sei.m_signPrincipalPointY    [i] ? 1 : 0 ),                                         "sign_principal_point_y"     );
1259      WRITE_CODE(   sei.m_exponentPrincipalPointY[i]          , 6,                                      "exponent_principal_point_y" );
1260      WRITE_CODE(   sei.m_mantissaPrincipalPointY[i]          , sei.getMantissaPrincipalPointYLen( i ), "mantissa_principal_point_y" );
1261      WRITE_FLAG( ( sei.m_signSkewFactor         [i] ? 1 : 0 ),                                         "sign_skew_factor"           );
1262      WRITE_CODE(   sei.m_exponentSkewFactor     [i]          , 6,                                      "exponent_skew_factor"       );
1263      WRITE_CODE(   sei.m_mantissaSkewFactor     [i]          , sei.getMantissaSkewFactorLen( i )  ,    "mantissa_skew_factor"       );
1264    }
1265  }
1266  if( sei.m_extrinsicParamFlag )
1267  {
1268    WRITE_UVLC( sei.m_precRotationParam   , "prec_rotation_param"    );
1269    WRITE_UVLC( sei.m_precTranslationParam, "prec_translation_param" );
1270    for( Int i = 0; i  <=  sei.getNumViewsMinus1(); i++ )
1271    {
1272      for( Int j = 0; j  <=  2; j++ )  /* row */
1273      {
1274        for( Int k = 0; k  <=  2; k++ )  /* column */
1275        {
1276          WRITE_FLAG( ( sei.m_signR    [i][j][k] ? 1 : 0 ),                                "sign_r"     );
1277          WRITE_CODE(   sei.m_exponentR[i][j][k]          , 6,                             "exponent_r" );
1278          WRITE_CODE(   sei.m_mantissaR[i][j][k]          , sei.getMantissaRLen( i,j,k ) , "mantissa_r" );
1279        }
1280        WRITE_FLAG( ( sei.m_signT    [i][j] ? 1 : 0 ),                          "sign_t"     );
1281        WRITE_CODE(   sei.m_exponentT[i][j]          , 6,                       "exponent_t" );
1282        WRITE_CODE(   sei.m_mantissaT[i][j]          , sei.getMantissaTLen( i,j ),"mantissa_t" );
1283      }
1284    }
1285  }
1286};
1287
1288Void SEIWriter::xWriteSEIMultiviewViewPosition( const SEIMultiviewViewPosition& sei)
1289{
1290  WRITE_UVLC( sei.m_numViewsMinus1, "num_views_minus1" );
1291  for( Int i = 0; i  <=  sei.m_numViewsMinus1; i++ )
1292  {
1293    WRITE_UVLC( sei.m_viewPosition[i], "view_position" );
1294  }
1295};
1296
1297#if NH_3D
1298Void SEIWriter::xWriteSEIAlternativeDepthInfo( const SEIAlternativeDepthInfo& sei)
1299{
1300  WRITE_FLAG( ( sei.m_alternativeDepthInfoCancelFlag ? 1 : 0 ), "alternative_depth_info_cancel_flag" );
1301  if( sei.m_alternativeDepthInfoCancelFlag  ==  0 )
1302  {
1303    WRITE_CODE( sei.m_depthType, 2, "depth_type" );
1304
1305    if( sei.m_depthType  ==  0 )
1306    {
1307      WRITE_UVLC( sei.m_numConstituentViewsGvdMinus1, "num_constituent_views_gvd_minus1" );
1308      WRITE_FLAG( ( sei.m_depthPresentGvdFlag ? 1 : 0 ), "depth_present_gvd_flag" );
1309      WRITE_FLAG( ( sei.m_zGvdFlag ? 1 : 0 ), "z_gvd_flag" );
1310      WRITE_FLAG( ( sei.m_intrinsicParamGvdFlag ? 1 : 0 ), "intrinsic_param_gvd_flag" );
1311      WRITE_FLAG( ( sei.m_rotationGvdFlag ? 1 : 0 ), "rotation_gvd_flag" );
1312      WRITE_FLAG( ( sei.m_translationGvdFlag ? 1 : 0 ), "translation_gvd_flag" );
1313      if( sei.m_zGvdFlag )
1314      {
1315        for( Int i = 0, j = 0; j  <=  sei.m_numConstituentViewsGvdMinus1 + 1; j++ )
1316        {
1317          WRITE_FLAG( ( sei.m_signGvdZNearFlag[i][j] ? 1 : 0 ), "sign_gvd_z_near_flag" );
1318          WRITE_CODE( sei.m_expGvdZNear[i][j], 7, "exp_gvd_z_near" );
1319          WRITE_CODE( sei.m_manLenGvdZNearMinus1[i][j], 5, "man_len_gvd_z_near_minus1" );
1320          WRITE_CODE( sei.m_manGvdZNear[i][j], sei.m_manLenGvdZNearMinus1[i][j] + 1, "man_gvd_z_near" );
1321          WRITE_FLAG( ( sei.m_signGvdZFarFlag[i][j] ? 1 : 0 ), "sign_gvd_z_far_flag" );
1322          WRITE_CODE( sei.m_expGvdZFar[i][j], 7, "exp_gvd_z_far" );
1323          WRITE_CODE( sei.m_manLenGvdZFarMinus1[i][j], 5, "man_len_gvd_z_far_minus1" );
1324          WRITE_CODE( sei.m_manGvdZFar[i][j], sei.m_manLenGvdZFarMinus1[i][j] + 1, "man_gvd_z_far" );
1325        }
1326      }
1327      if( sei.m_intrinsicParamGvdFlag )
1328      {
1329        WRITE_UVLC( sei.m_precGvdFocalLength, "prec_gvd_focal_length" );
1330        WRITE_UVLC( sei.m_precGvdPrincipalPoint, "prec_gvd_principal_point" );
1331      }
1332      if( sei.m_rotationGvdFlag )
1333      {
1334        WRITE_UVLC( sei.m_precGvdRotationParam, "prec_gvd_rotation_param" );
1335      }
1336      if( sei.m_translationGvdFlag )
1337      {
1338        WRITE_UVLC( sei.m_precGvdTranslationParam, "prec_gvd_translation_param" );
1339      }
1340      for( Int i = 0, j = 0; j  <=  sei.m_numConstituentViewsGvdMinus1 + 1; j++ )
1341      {
1342        if( sei.m_intrinsicParamGvdFlag )
1343        {
1344          WRITE_FLAG( ( sei.m_signGvdFocalLengthX[i][j] ? 1 : 0 ), "sign_gvd_focal_length_x" );
1345          WRITE_CODE( sei.m_expGvdFocalLengthX[i][j], 6, "exp_gvd_focal_length_x" );
1346          WRITE_CODE( sei.m_manGvdFocalLengthX[i][j], sei.getManGvdFocalLengthXLen(i,j), "man_gvd_focal_length_x" );
1347          WRITE_FLAG( ( sei.m_signGvdFocalLengthY[i][j] ? 1 : 0 ), "sign_gvd_focal_length_y" );
1348          WRITE_CODE( sei.m_expGvdFocalLengthY[i][j], 6, "exp_gvd_focal_length_y" );
1349          WRITE_CODE( sei.m_manGvdFocalLengthY[i][j], sei.getManGvdFocalLengthYLen(i,j), "man_gvd_focal_length_y" );
1350          WRITE_FLAG( ( sei.m_signGvdPrincipalPointX[i][j] ? 1 : 0 ), "sign_gvd_principal_point_x" );
1351          WRITE_CODE( sei.m_expGvdPrincipalPointX[i][j], 6, "exp_gvd_principal_point_x" );
1352          WRITE_CODE( sei.m_manGvdPrincipalPointX[i][j], sei.getManGvdPrincipalPointXLen(i,j), "man_gvd_principal_point_x" );
1353          WRITE_FLAG( ( sei.m_signGvdPrincipalPointY[i][j] ? 1 : 0 ), "sign_gvd_principal_point_y" );
1354          WRITE_CODE( sei.m_expGvdPrincipalPointY[i][j], 6, "exp_gvd_principal_point_y" );
1355          WRITE_CODE( sei.m_manGvdPrincipalPointY[i][j], sei.getManGvdPrincipalPointYLen(i,j), "man_gvd_principal_point_y" );
1356        }
1357        if( sei.m_rotationGvdFlag )
1358        {
1359          WRITE_FLAG( ( sei.m_signGvdR00[i][j] ? 1 : 0 ), "sign_gvd_r00" );
1360          WRITE_CODE( sei.m_expGvdR00[i][j], 6, "exp_gvd_r00" );
1361          WRITE_CODE( sei.m_manGvdR00[i][j], sei.m_precGvdRotationParam, "man_gvd_r00" );
1362          WRITE_FLAG( ( sei.m_signGvdR01[i][j] ? 1 : 0 ), "sign_gvd_r01" );
1363          WRITE_CODE( sei.m_expGvdR01[i][j], 6, "exp_gvd_r01" );
1364          WRITE_CODE( sei.m_manGvdR01[i][j], sei.m_precGvdRotationParam, "man_gvd_r01" );
1365          WRITE_FLAG( ( sei.m_signGvdR02[i][j] ? 1 : 0 ), "sign_gvd_r02" );
1366          WRITE_CODE( sei.m_expGvdR02[i][j], 6, "exp_gvd_r02" );
1367          WRITE_CODE( sei.m_manGvdR02[i][j], sei.m_precGvdRotationParam, "man_gvd_r02" );
1368          WRITE_FLAG( ( sei.m_signGvdR10[i][j] ? 1 : 0 ), "sign_gvd_r10" );
1369          WRITE_CODE( sei.m_expGvdR10[i][j], 6, "exp_gvd_r10" );
1370          WRITE_CODE( sei.m_manGvdR10[i][j], sei.m_precGvdRotationParam, "man_gvd_r10" );
1371          WRITE_FLAG( ( sei.m_signGvdR11[i][j] ? 1 : 0 ), "sign_gvd_r11" );
1372          WRITE_CODE( sei.m_expGvdR11[i][j], 6, "exp_gvd_r11" );
1373          WRITE_CODE( sei.m_manGvdR11[i][j], sei.m_precGvdRotationParam, "man_gvd_r11" );
1374          WRITE_FLAG( ( sei.m_signGvdR12[i][j] ? 1 : 0 ), "sign_gvd_r12" );
1375          WRITE_CODE( sei.m_expGvdR12[i][j], 6, "exp_gvd_r12" );
1376          WRITE_CODE( sei.m_manGvdR12[i][j], sei.m_precGvdRotationParam, "man_gvd_r12" );
1377          WRITE_FLAG( ( sei.m_signGvdR20[i][j] ? 1 : 0 ), "sign_gvd_r20" );
1378          WRITE_CODE( sei.m_expGvdR20[i][j], 6, "exp_gvd_r20" );
1379          WRITE_CODE( sei.m_manGvdR20[i][j], sei.m_precGvdRotationParam, "man_gvd_r20" );
1380          WRITE_FLAG( ( sei.m_signGvdR21[i][j] ? 1 : 0 ), "sign_gvd_r21" );
1381          WRITE_CODE( sei.m_expGvdR21[i][j], 6, "exp_gvd_r21" );
1382          WRITE_CODE( sei.m_manGvdR21[i][j], sei.m_precGvdRotationParam, "man_gvd_r21" );
1383          WRITE_FLAG( ( sei.m_signGvdR22[i][j] ? 1 : 0 ), "sign_gvd_r22" );
1384          WRITE_CODE( sei.m_expGvdR22[i][j], 6, "exp_gvd_r22" );
1385          WRITE_CODE( sei.m_manGvdR22[i][j], sei.m_precGvdRotationParam, "man_gvd_r22" );
1386        }
1387        if( sei.m_translationGvdFlag )
1388        {
1389          WRITE_FLAG( ( sei.m_signGvdTX[i][j] ? 1 : 0 ), "sign_gvd_t_x" );
1390          WRITE_CODE( sei.m_expGvdTX[i][j], 6, "exp_gvd_t_x" );
1391          WRITE_CODE( sei.m_manGvdTX[i][j], sei.getManGvdTXLen(i,j), "man_gvd_t_x" );
1392        }
1393      }
1394    }
1395
1396    if( sei.m_depthType  ==  1 )
1397    {
1398      WRITE_SVLC( sei.m_minOffsetXInt, "min_offset_x_int" );
1399      WRITE_CODE( sei.m_minOffsetXFrac, 8, "min_offset_x_frac" );
1400      WRITE_SVLC( sei.m_maxOffsetXInt, "max_offset_x_int" );
1401      WRITE_CODE( sei.m_maxOffsetXFrac, 8, "max_offset_x_frac" );
1402      WRITE_FLAG( ( sei.m_offsetYPresentFlag ? 1 : 0 ), "offset_y_present_flag" );
1403      if( sei.m_offsetYPresentFlag )
1404      {
1405        WRITE_SVLC( sei.m_minOffsetYInt, "min_offset_y_int" );
1406        WRITE_CODE( sei.m_minOffsetYFrac, 8, "min_offset_y_frac" );
1407        WRITE_SVLC( sei.m_maxOffsetYInt, "max_offset_y_int" );
1408        WRITE_CODE( sei.m_maxOffsetYFrac, 8, "max_offset_y_frac" );
1409      }
1410      WRITE_FLAG( ( sei.m_warpMapSizePresentFlag ? 1 : 0 ), "warp_map_size_present_flag" );
1411      if( sei.m_warpMapSizePresentFlag )
1412      {
1413        WRITE_UVLC( sei.m_warpMapWidthMinus2, "warp_map_width_minus2" );
1414        WRITE_UVLC( sei.m_warpMapHeightMinus2, "warp_map_height_minus2" );
1415      }
1416    }
1417  }
1418};
1419#endif
1420#endif
1421
1422//! \}
Note: See TracBrowser for help on using the repository browser.