source: 3DVCSoftware/branches/HTM-15.1-dev0-Nokia/source/Lib/TLibEncoder/SEIwrite.cpp @ 1339

Last change on this file since 1339 was 1339, checked in by chen, 9 years ago

Commit the integration of 3D depth representation information SEI on behalf of Nokia.

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