source: SHVCSoftware/branches/SHM-upgrade/source/Lib/TLibDecoder/TDecGop.cpp @ 920

Last change on this file since 920 was 916, checked in by seregin, 11 years ago

initial porting
  • Property svn:eol-style set to native
File size: 18.8 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-2014, 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/** \file     TDecGop.cpp
35    \brief    GOP decoder class
36*/
37
38#include "TDecGop.h"
39#include "TDecCAVLC.h"
40#include "TDecSbac.h"
41#include "TDecBinCoder.h"
42#include "TDecBinCoderCABAC.h"
43#include "libmd5/MD5.h"
44#include "TLibCommon/SEI.h"
45#if SVC_EXTENSION
46#include "TDecTop.h"
47#endif
48
49#include <time.h>
50
51extern Bool g_md5_mismatch; ///< top level flag to signal when there is a decode problem
52
53//! \ingroup TLibDecoder
54//! \{
55static Void calcAndPrintHashStatus(TComPicYuv& pic, const SEIDecodedPictureHash* pictureHashSEI);
56#if Q0074_COLOUR_REMAPPING_SEI
57static Void applyColourRemapping(TComPicYuv& pic, const SEIColourRemappingInfo* colourRemappingInfoSEI, UInt layerId=0 );
58static std::vector<SEIColourRemappingInfo> storeCriSEI; //Persistent Colour Remapping Information SEI
59#endif
60// ====================================================================================================================
61// Constructor / destructor / initialization / destroy
62// ====================================================================================================================
63
64TDecGop::TDecGop()
65{
66  m_dDecTime = 0;
67}
68
69TDecGop::~TDecGop()
70{
71
72}
73
74#if SVC_EXTENSION
75Void TDecGop::create(UInt layerId)
76{
77  m_layerId = layerId;
78}
79#else
80Void TDecGop::create()
81{
82
83}
84#endif
85
86Void TDecGop::destroy()
87{
88}
89
90#if SVC_EXTENSION
91Void TDecGop::init( TDecTop**               ppcDecTop,
92                   TDecEntropy*             pcEntropyDecoder,
93#else
94Void TDecGop::init( TDecEntropy*            pcEntropyDecoder,
95#endif
96                   TDecSbac*               pcSbacDecoder,
97                   TDecBinCABAC*           pcBinCABAC,
98                   TDecCavlc*              pcCavlcDecoder,
99                   TDecSlice*              pcSliceDecoder,
100                   TComLoopFilter*         pcLoopFilter,
101                   TComSampleAdaptiveOffset* pcSAO
102                   )
103{
104  m_pcEntropyDecoder      = pcEntropyDecoder;
105  m_pcSbacDecoder         = pcSbacDecoder;
106  m_pcBinCABAC            = pcBinCABAC;
107  m_pcCavlcDecoder        = pcCavlcDecoder;
108  m_pcSliceDecoder        = pcSliceDecoder;
109  m_pcLoopFilter          = pcLoopFilter;
110  m_pcSAO  = pcSAO;
111#if SVC_EXTENSION   
112  m_ppcTDecTop            = ppcDecTop;
113#endif
114}
115
116
117// ====================================================================================================================
118// Private member functions
119// ====================================================================================================================
120// ====================================================================================================================
121// Public member functions
122// ====================================================================================================================
123
124Void TDecGop::decompressSlice(TComInputBitstream* pcBitstream, TComPic* pcPic)
125{
126  TComSlice*  pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
127  // Table of extracted substreams.
128  // These must be deallocated AND their internal fifos, too.
129  TComInputBitstream **ppcSubstreams = NULL;
130
131  //-- For time output for each slice
132  clock_t iBeforeTime = clock();
133  m_pcSbacDecoder->init( (TDecBinIf*)m_pcBinCABAC );
134  m_pcEntropyDecoder->setEntropyDecoder (m_pcSbacDecoder);
135
136  const UInt uiNumSubstreams = pcSlice->getNumberOfSubstreamSizes()+1;
137//  const UInt uiNumSubstreams = pcSlice->getPPS()->getEntropyCodingSyncEnabledFlag() ? pcSlice->getNumberOfSubstreamSizes()+1 : pcSlice->getPPS()->getNumSubstreams();
138
139  // init each couple {EntropyDecoder, Substream}
140  ppcSubstreams    = new TComInputBitstream*[uiNumSubstreams];
141  for ( UInt ui = 0 ; ui < uiNumSubstreams ; ui++ )
142  {
143    ppcSubstreams[ui] = pcBitstream->extractSubstream(ui+1 < uiNumSubstreams ? (pcSlice->getSubstreamSize(ui)<<3) : pcBitstream->getNumBitsLeft());
144  }
145
146  m_pcSliceDecoder->decompressSlice( ppcSubstreams, pcPic, m_pcSbacDecoder);
147  // deallocate all created substreams, including internal buffers.
148  for (UInt ui = 0; ui < uiNumSubstreams; ui++)
149  {
150    ppcSubstreams[ui]->deleteFifo();
151    delete ppcSubstreams[ui];
152  }
153  delete[] ppcSubstreams;
154
155  m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
156}
157
158Void TDecGop::filterPicture(TComPic* pcPic)
159{
160  TComSlice*  pcSlice = pcPic->getSlice(pcPic->getCurrSliceIdx());
161
162  //-- For time output for each slice
163  clock_t iBeforeTime = clock();
164
165  // deblocking filter
166  Bool bLFCrossTileBoundary = pcSlice->getPPS()->getLoopFilterAcrossTilesEnabledFlag();
167  m_pcLoopFilter->setCfg(bLFCrossTileBoundary);
168  m_pcLoopFilter->loopFilterPic( pcPic );
169
170  if( pcSlice->getSPS()->getUseSAO() )
171  {
172    m_pcSAO->reconstructBlkSAOParams(pcPic, pcPic->getPicSym()->getSAOBlkParam());
173    m_pcSAO->SAOProcess(pcPic);
174    m_pcSAO->PCMLFDisableProcess(pcPic);
175  }
176
177  pcPic->compressMotion();
178  Char c = (pcSlice->isIntra() ? 'I' : pcSlice->isInterP() ? 'P' : 'B');
179  if (!pcSlice->isReferenced()) c += 32;
180
181  //-- For time output for each slice
182#if SVC_EXTENSION
183  printf("\nPOC %4d LId: %1d TId: %1d ( %c-SLICE %s, QP%3d ) ", pcSlice->getPOC(),
184                                                    pcPic->getLayerId(),
185                                                    pcSlice->getTLayer(),
186                                                    c,
187                                                    NaluToStr( pcSlice->getNalUnitType() ).data(),
188                                                    pcSlice->getSliceQp() );
189#else
190  printf("POC %4d TId: %1d ( %c-SLICE, QP%3d ) ", pcSlice->getPOC(),
191                                                  pcSlice->getTLayer(),
192                                                  c,
193                                                  pcSlice->getSliceQp() );
194
195#endif
196  m_dDecTime += (Double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
197  printf ("[DT %6.3f] ", m_dDecTime );
198  m_dDecTime  = 0;
199
200  for (Int iRefList = 0; iRefList < 2; iRefList++)
201  {
202    printf ("[L%d ", iRefList);
203    for (Int iRefIndex = 0; iRefIndex < pcSlice->getNumRefIdx(RefPicList(iRefList)); iRefIndex++)
204    {
205#if SVC_EXTENSION
206#if VPS_EXTN_DIRECT_REF_LAYERS
207      if( pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->isILR( m_layerId ) )
208      {
209        UInt refLayerId = pcSlice->getRefPic(RefPicList(iRefList), iRefIndex)->getLayerId();
210        UInt refLayerIdc = pcSlice->getReferenceLayerIdc(refLayerId);
211        assert( g_posScalingFactor[refLayerIdc][0] );
212        assert( g_posScalingFactor[refLayerIdc][1] );
213
214        printf( "%d(%d, {%1.2f, %1.2f}x)", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex), refLayerId, 65536.0/g_posScalingFactor[refLayerIdc][0], 65536.0/g_posScalingFactor[refLayerIdc][1] );
215      }
216      else
217      {
218        printf ("%d", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex));
219      }
220#endif
221      if( pcSlice->getEnableTMVPFlag() && iRefList == 1 - pcSlice->getColFromL0Flag() && iRefIndex == pcSlice->getColRefIdx() )
222      {
223        printf( "c" );
224      }
225
226      printf( " " );
227#else
228      printf ("%d ", pcSlice->getRefPOC(RefPicList(iRefList), iRefIndex));
229#endif
230    }
231    printf ("] ");
232  }
233  if (m_decodedPictureHashSEIEnabled)
234  {
235    SEIMessages pictureHashes = getSeisByType(pcPic->getSEIs(), SEI::DECODED_PICTURE_HASH );
236    const SEIDecodedPictureHash *hash = ( pictureHashes.size() > 0 ) ? (SEIDecodedPictureHash*) *(pictureHashes.begin()) : NULL;
237    if (pictureHashes.size() > 1)
238    {
239      printf ("Warning: Got multiple decoded picture hash SEI messages. Using first.");
240    }
241    calcAndPrintHashStatus(*(pcPic->getPicYuvRec()), hash);
242  }
243#if Q0074_COLOUR_REMAPPING_SEI
244  if (m_colourRemapSEIEnabled)
245  {
246    SEIMessages colourRemappingInfo = getSeisByType(pcPic->getSEIs(), SEI::COLOUR_REMAPPING_INFO );
247    const SEIColourRemappingInfo *seiColourRemappingInfo = ( colourRemappingInfo.size() > 0 ) ? (SEIColourRemappingInfo*) *(colourRemappingInfo.begin()) : NULL;
248    if (colourRemappingInfo.size() > 1)
249    {
250      printf ("Warning: Got multiple Colour Remapping Information SEI messages. Using first.");
251    }
252    applyColourRemapping(*pcPic->getPicYuvRec(), seiColourRemappingInfo
253#if SVC_EXTENSION
254     , pcPic->getLayerId()
255#endif
256     );
257  }
258#endif
259
260  printf("\n");
261
262  pcPic->setOutputMark(pcPic->getSlice(0)->getPicOutputFlag() ? true : false);
263  pcPic->setReconMark(true);
264}
265
266/**
267 * Calculate and print hash for pic, compare to picture_digest SEI if
268 * present in seis.  seis may be NULL.  Hash is printed to stdout, in
269 * a manner suitable for the status line. Theformat is:
270 *  [Hash_type:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,(yyy)]
271 * Where, x..x is the hash
272 *        yyy has the following meanings:
273 *            OK          - calculated hash matches the SEI message
274 *            ***ERROR*** - calculated hash does not match the SEI message
275 *            unk         - no SEI message was available for comparison
276 */
277static Void calcAndPrintHashStatus(TComPicYuv& pic, const SEIDecodedPictureHash* pictureHashSEI)
278{
279  /* calculate MD5sum for entire reconstructed picture */
280  TComDigest recon_digest;
281  Int numChar=0;
282  const Char* hashType = "\0";
283
284  if (pictureHashSEI)
285  {
286    switch (pictureHashSEI->method)
287    {
288      case SEIDecodedPictureHash::MD5:
289        {
290          hashType = "MD5";
291          numChar = calcMD5(pic, recon_digest);
292          break;
293        }
294      case SEIDecodedPictureHash::CRC:
295        {
296          hashType = "CRC";
297          numChar = calcCRC(pic, recon_digest);
298          break;
299        }
300      case SEIDecodedPictureHash::CHECKSUM:
301        {
302          hashType = "Checksum";
303          numChar = calcChecksum(pic, recon_digest);
304          break;
305        }
306      default:
307        {
308          assert (!"unknown hash type");
309          break;
310        }
311    }
312  }
313
314  /* compare digest against received version */
315  const Char* ok = "(unk)";
316  Bool mismatch = false;
317
318  if (pictureHashSEI)
319  {
320    ok = "(OK)";
321    if (recon_digest != pictureHashSEI->m_digest)
322    {
323      ok = "(***ERROR***)";
324      mismatch = true;
325    }
326  }
327
328  printf("[%s:%s,%s] ", hashType, digestToString(recon_digest, numChar).c_str(), ok);
329
330  if (mismatch)
331  {
332    g_md5_mismatch = true;
333    printf("[rx%s:%s] ", hashType, digestToString(pictureHashSEI->m_digest, numChar).c_str());
334  }
335}
336
337#if Q0074_COLOUR_REMAPPING_SEI
338Void xInitColourRemappingLut( const Int bitDepthY, const Int bitDepthC, std::vector<Int>(&preLut)[3], std::vector<Int>(&postLut)[3], const SEIColourRemappingInfo* const pCriSEI )
339{
340  for ( Int c=0 ; c<3 ; c++ )
341  { 
342    Int bitDepth = c ? bitDepthC : bitDepthY ;
343    preLut[c].resize(1 << bitDepth);
344    postLut[c].resize(1 << pCriSEI->m_colourRemapBitDepth);
345   
346    Int bitDepthDiff = pCriSEI->m_colourRemapBitDepth - bitDepth;
347    Int iShift1 = (bitDepthDiff>0) ? bitDepthDiff : 0; //bit scale from bitdepth to ColourRemapBitdepth (manage only case colourRemapBitDepth>= bitdepth)
348    if( bitDepthDiff<0 )
349      printf ("Warning: CRI SEI - colourRemapBitDepth (%d) <bitDepth (%d) - case not handled\n", pCriSEI->m_colourRemapBitDepth, bitDepth);
350    bitDepthDiff = pCriSEI->m_colourRemapBitDepth - pCriSEI->m_colourRemapInputBitDepth;
351    Int iShift2 = (bitDepthDiff>0) ? bitDepthDiff : 0; //bit scale from ColourRemapInputBitdepth to ColourRemapBitdepth (manage only case colourRemapBitDepth>= colourRemapInputBitDepth)
352    if( bitDepthDiff<0 )
353      printf ("Warning: CRI SEI - colourRemapBitDepth (%d) <colourRemapInputBitDepth (%d) - case not handled\n", pCriSEI->m_colourRemapBitDepth, pCriSEI->m_colourRemapInputBitDepth);
354
355    //Fill preLut
356    for ( Int k=0 ; k<(1<<bitDepth) ; k++ )
357    {
358      Int iSample = k << iShift1 ;
359      for ( Int iPivot=0 ; iPivot<=pCriSEI->m_preLutNumValMinus1[c] ; iPivot++ )
360      {
361        Int iCodedPrev  = pCriSEI->m_preLutCodedValue[c][iPivot]    << iShift2; //Coded in CRInputBitdepth
362        Int iCodedNext  = pCriSEI->m_preLutCodedValue[c][iPivot+1]  << iShift2; //Coded in CRInputBitdepth
363        Int iTargetPrev = pCriSEI->m_preLutTargetValue[c][iPivot];              //Coded in CRBitdepth
364        Int iTargetNext = pCriSEI->m_preLutTargetValue[c][iPivot+1];            //Coded in CRBitdepth
365        if ( iCodedPrev <= iSample && iSample <= iCodedNext )
366        {
367          Float fInterpol = (Float)( (iCodedNext - iSample)*iTargetPrev + (iSample - iCodedPrev)*iTargetNext ) * 1.f / (Float)(iCodedNext - iCodedPrev);
368          preLut[c][k]  = (Int)( 0.5f + fInterpol );
369          iPivot = pCriSEI->m_preLutNumValMinus1[c] + 1;
370        }
371      }
372    }
373   
374    //Fill postLut
375    for ( Int k=0 ; k<(1<<pCriSEI->m_colourRemapBitDepth) ; k++ )
376    {
377      Int iSample = k;
378      for ( Int iPivot=0 ; iPivot<=pCriSEI->m_postLutNumValMinus1[c] ; iPivot++ )
379      {
380        Int iCodedPrev  = pCriSEI->m_postLutCodedValue[c][iPivot];    //Coded in CRBitdepth
381        Int iCodedNext  = pCriSEI->m_postLutCodedValue[c][iPivot+1];  //Coded in CRBitdepth
382        Int iTargetPrev = pCriSEI->m_postLutTargetValue[c][iPivot];   //Coded in CRBitdepth
383        Int iTargetNext = pCriSEI->m_postLutTargetValue[c][iPivot+1]; //Coded in CRBitdepth
384        if ( iCodedPrev <= iSample && iSample <= iCodedNext )
385        {
386          Float fInterpol =  (Float)( (iCodedNext - iSample)*iTargetPrev + (iSample - iCodedPrev)*iTargetNext ) * 1.f / (Float)(iCodedNext - iCodedPrev) ;
387          postLut[c][k]  = (Int)( 0.5f + fInterpol );
388          iPivot = pCriSEI->m_postLutNumValMinus1[c] + 1;
389        }
390      }
391    }
392  }
393}
394
395static Void applyColourRemapping(TComPicYuv& pic, const SEIColourRemappingInfo* pCriSEI, UInt layerId )
396{ 
397  if( !storeCriSEI.size() )
398#if SVC_EXTENSION
399    storeCriSEI.resize(MAX_LAYERS);
400#else
401    storeCriSEI.resize(1);
402#endif
403
404  if ( pCriSEI ) //if a CRI SEI has just been retrieved, keep it in memory (persistence management)
405    storeCriSEI[layerId] = *pCriSEI;
406
407  if( !storeCriSEI[layerId].m_colourRemapCancelFlag )
408  {
409    Int iHeight  = pic.getHeight(COMPONENT_Y);
410    Int iWidth   = pic.getWidth(COMPONENT_Y);
411    Int iStride  = pic.getStride(COMPONENT_Y);
412    Int iCStride = pic.getStride(COMPONENT_Cb);
413
414    Pel *YUVIn[3], *YUVOut[3];
415    YUVIn[0] = pic.getAddr(COMPONENT_Y);
416    YUVIn[1] = pic.getAddr(COMPONENT_Cb);
417    YUVIn[2] = pic.getAddr(COMPONENT_Cr);
418   
419    TComPicYuv picColourRemapped;
420#if SVC_EXTENSION
421    picColourRemapped.create( pic.getWidth(COMPONENT_Y), pic.getHeight(COMPONENT_Y), pic.getChromaFormat(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, NULL );
422#else
423    picColourRemapped.create( pic.getWidth(COMPONENT_Y), pic.getHeight(COMPONENT_Y), pic.getChromaFormat(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
424#endif
425    YUVOut[0] = picColourRemapped.getAddr(COMPONENT_Y);
426    YUVOut[1] = picColourRemapped.getAddr(COMPONENT_Cb);
427    YUVOut[2] = picColourRemapped.getAddr(COMPONENT_Cr);
428
429#if SVC_EXTENSION
430    Int bitDepthY = g_bitDepthLayer[CHANNEL_TYPE_LUMA][layerId];
431    Int bitDepthC = g_bitDepthLayer[CHANNEL_TYPE_CHROMA][layerId];
432
433    assert( g_bitDepth[CHANNEL_TYPE_LUMA] == bitDepthY );
434    assert( g_bitDepth[CHANNEL_TYPE_CHROMA] == bitDepthC );
435#else
436    Int bitDepthY = g_bitDepth[CHANNEL_TYPE_LUMA];
437    Int bitDepthC = g_bitDepth[CHANNEL_TYPE_CHROMA];
438#endif
439
440    std::vector<Int> preLut[3];
441    std::vector<Int> postLut[3];
442    xInitColourRemappingLut( bitDepthY, bitDepthC, preLut, postLut, &storeCriSEI[layerId] );
443   
444    Int roundingOffset = (storeCriSEI[layerId].m_log2MatrixDenom==0) ? 0 : (1 << (storeCriSEI[layerId].m_log2MatrixDenom - 1));
445
446    for( Int y = 0; y < iHeight ; y++ )
447    {
448      for( Int x = 0; x < iWidth ; x++ )
449      {
450        Int YUVPre[3], YUVMat[3];
451        YUVPre[0] = preLut[0][ YUVIn[0][x]   ];
452        YUVPre[1] = preLut[1][ YUVIn[1][x>>1] ];
453        YUVPre[2] = preLut[2][ YUVIn[2][x>>1] ];
454
455        YUVMat[0] = ( storeCriSEI[layerId].m_colourRemapCoeffs[0][0]*YUVPre[0]
456                    + storeCriSEI[layerId].m_colourRemapCoeffs[0][1]*YUVPre[1] 
457                    + storeCriSEI[layerId].m_colourRemapCoeffs[0][2]*YUVPre[2] 
458                    + roundingOffset ) >> ( storeCriSEI[layerId].m_log2MatrixDenom );
459        YUVMat[0] = Clip3( 0, (1<<storeCriSEI[layerId].m_colourRemapBitDepth)-1, YUVMat[0] );
460        YUVOut[0][x] = postLut[0][ YUVMat[0] ];
461
462        if( (y&1) && (x&1) )
463        {
464          for(Int c=1 ; c<3 ; c++)
465          {
466            YUVMat[c] = ( storeCriSEI[layerId].m_colourRemapCoeffs[c][0]*YUVPre[0] 
467                        + storeCriSEI[layerId].m_colourRemapCoeffs[c][1]*YUVPre[1] 
468                        + storeCriSEI[layerId].m_colourRemapCoeffs[c][2]*YUVPre[2] 
469                        + roundingOffset ) >> ( storeCriSEI[layerId].m_log2MatrixDenom );
470            YUVMat[c] = Clip3( 0, (1<<storeCriSEI[layerId].m_colourRemapBitDepth)-1, YUVMat[c] );
471            YUVOut[c][x>>1] = postLut[c][ YUVMat[c] ];   
472          }
473        }
474      }
475      YUVIn[0]  += iStride;
476      YUVOut[0] += iStride;
477      if( y&1 )
478      {
479        YUVIn[1]  += iCStride;
480        YUVIn[2]  += iCStride;
481        YUVOut[1] += iCStride;
482        YUVOut[2] += iCStride;
483      }
484    }
485
486    //Write remapped picture in decoding order
487    Char  cTemp[255];
488    sprintf(cTemp, "seiColourRemappedPic_L%d_%dx%d_%dbits.yuv", layerId, iWidth, iHeight, storeCriSEI[layerId].m_colourRemapBitDepth );
489    picColourRemapped.dump( cTemp, true, storeCriSEI[layerId].m_colourRemapBitDepth );
490
491    picColourRemapped.destroy();
492
493    storeCriSEI[layerId].m_colourRemapCancelFlag = !storeCriSEI[layerId].m_colourRemapPersistenceFlag; //Handling persistence
494  }
495}
496#endif
497//! \}
Note: See TracBrowser for help on using the repository browser.