source: 3DVCSoftware/branches/0.3-poznan-univ/source/Lib/TLibCommon/TComSlice.cpp @ 41

Last change on this file since 41 was 41, checked in by poznan-univ, 12 years ago

Adjustment for FlexCO, and high-level syntax improvement.

  • Property svn:eol-style set to native
File size: 25.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-2011, 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 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
35
36/** \file     TComSlice.cpp
37    \brief    slice header and SPS class
38*/
39
40#include "CommonDef.h"
41#include "TComSlice.h"
42#include "TComPic.h"
43
44TComSlice::TComSlice()
45{
46  m_uiPPSId             = 0;
47  m_iPOC                = 0;
48  m_eSliceType          = I_SLICE;
49  m_iSliceQp            = 0;
50  m_iSymbolMode         = 1;
51  m_aiNumRefIdx[0]      = 0;
52  m_aiNumRefIdx[1]      = 0;
53  m_bLoopFilterDisable  = false;
54 
55  m_iSliceQpDelta       = 0;
56 
57  m_iDepth              = 0;
58 
59  m_pcPic               = NULL;
60  m_bRefenced           = false;
61#ifdef ROUNDING_CONTROL_BIPRED
62  m_bRounding           = false;
63#endif
64  m_uiColDir = 0;
65 
66  m_iViewIdx = 0 ;
67
68#if SONY_COLPIC_AVAILABILITY
69  m_iViewOrderIdx = 0;
70#endif
71
72  initEqualRef();
73  m_bNoBackPredFlag = false;
74#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
75  m_bRefIdxCombineCoding = false;
76#endif
77#if DCM_COMB_LIST
78  m_bRefPicListCombinationFlag = false;
79  m_bRefPicListModificationFlagLC = false;
80#endif
81  m_uiSliceCurStartCUAddr        = 0;
82  m_uiEntropySliceCurStartCUAddr = 0;
83
84  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
85  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
86  m_pcTexturePic = NULL;
87  m_pcDepthPic = NULL; 
88#ifdef WEIGHT_PRED
89  resetWpScaling(m_weightPredTable);
90  initWpAcDcParam();
91#endif
92
93#if POZNAN_MP
94  m_pcMP = NULL;
95#endif
96}
97
98TComSlice::~TComSlice()
99{
100#if POZNAN_MP
101  m_pcMP = NULL;
102#endif
103}
104
105
106Void TComSlice::initSlice()
107{
108  m_aiNumRefIdx[0]      = 0;
109  m_aiNumRefIdx[1]      = 0;
110 
111  m_uiColDir = 0;
112
113  ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
114  ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
115  m_pcTexturePic = NULL;
116  m_pcDepthPic = NULL; 
117 
118  initEqualRef();
119  m_bNoBackPredFlag = false;
120#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
121  m_bRefIdxCombineCoding = false;
122#endif
123#if DCM_COMB_LIST
124  m_bRefPicListCombinationFlag = false;
125  m_bRefPicListModificationFlagLC = false;
126#endif
127}
128
129Void  TComSlice::sortPicList        (TComList<TComPic*>& rcListPic)
130{
131  TComPic*    pcPicExtract;
132  TComPic*    pcPicInsert;
133 
134  TComList<TComPic*>::iterator    iterPicExtract;
135  TComList<TComPic*>::iterator    iterPicExtract_1;
136  TComList<TComPic*>::iterator    iterPicInsert;
137 
138  for (Int i = 1; i < (Int)(rcListPic.size()); i++)
139  {
140    iterPicExtract = rcListPic.begin();
141    for (Int j = 0; j < i; j++) iterPicExtract++;
142    pcPicExtract = *(iterPicExtract);
143    pcPicExtract->setCurrSliceIdx(0);
144   
145    iterPicInsert = rcListPic.begin();
146    while (iterPicInsert != iterPicExtract)
147    {
148      pcPicInsert = *(iterPicInsert);
149      pcPicInsert->setCurrSliceIdx(0);
150      if (pcPicInsert->getPOC() >= pcPicExtract->getPOC())
151      {
152        break;
153      }
154     
155      iterPicInsert++;
156    }
157   
158    iterPicExtract_1 = iterPicExtract;    iterPicExtract_1++;
159   
160    //  swap iterPicExtract and iterPicInsert, iterPicExtract = curr. / iterPicInsert = insertion position
161    rcListPic.insert (iterPicInsert, iterPicExtract, iterPicExtract_1);
162    rcListPic.erase  (iterPicExtract);
163  }
164}
165
166Void TComSlice::setRefPOCList       ()
167{
168  for (Int iDir = 0; iDir < 2; iDir++)
169  {
170    for (Int iNumRefIdx = 0; iNumRefIdx < m_aiNumRefIdx[iDir]; iNumRefIdx++)
171    {
172      m_aiRefPOCList[iDir][iNumRefIdx] = m_apcRefPicList[iDir][iNumRefIdx]->getPOC();
173    }
174  }
175
176}
177
178#if DCM_COMB_LIST
179Void TComSlice::generateCombinedList()
180{
181  if(m_aiNumRefIdx[REF_PIC_LIST_C] > 0)
182  {
183    m_aiNumRefIdx[REF_PIC_LIST_C]=0;
184    for(Int iNumCount = 0; iNumCount < MAX_NUM_REF_LC; iNumCount++)
185    {
186      m_iRefIdxOfLC[REF_PIC_LIST_0][iNumCount]=-1;
187      m_iRefIdxOfLC[REF_PIC_LIST_1][iNumCount]=-1;
188      m_eListIdFromIdxOfLC[iNumCount]=0;
189      m_iRefIdxFromIdxOfLC[iNumCount]=0;
190      m_iRefIdxOfL0FromRefIdxOfL1[iNumCount] = -1;
191      m_iRefIdxOfL1FromRefIdxOfL0[iNumCount] = -1;
192    }
193
194    for (Int iNumRefIdx = 0; iNumRefIdx < MAX_NUM_REF; iNumRefIdx++)
195    {
196      if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_0]){
197        Bool bTempRefIdxInL2 = true;
198        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
199        {
200          if (( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() ) &&
201              ( m_apcRefPicList[REF_PIC_LIST_0][iNumRefIdx]->getViewIdx() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getViewIdx() ))
202          {
203            m_iRefIdxOfL1FromRefIdxOfL0[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
204            m_iRefIdxOfL0FromRefIdxOfL1[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
205            bTempRefIdxInL2 = false;
206            assert(m_eListIdFromIdxOfLC[iRefIdxLC]==REF_PIC_LIST_1);
207            break;
208          }
209        }
210
211        if(bTempRefIdxInL2 == true)
212        { 
213          m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_0;
214          m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
215          m_iRefIdxOfLC[REF_PIC_LIST_0][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
216        }
217      }
218
219      if(iNumRefIdx < m_aiNumRefIdx[REF_PIC_LIST_1]){
220        Bool bTempRefIdxInL2 = true;
221        for ( Int iRefIdxLC = 0; iRefIdxLC < m_aiNumRefIdx[REF_PIC_LIST_C]; iRefIdxLC++ )
222        {
223          if (( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getPOC() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getPOC() ) &&
224              ( m_apcRefPicList[REF_PIC_LIST_1][iNumRefIdx]->getViewIdx() == m_apcRefPicList[m_eListIdFromIdxOfLC[iRefIdxLC]][m_iRefIdxFromIdxOfLC[iRefIdxLC]]->getViewIdx() ))
225          {
226            m_iRefIdxOfL0FromRefIdxOfL1[iNumRefIdx] = m_iRefIdxFromIdxOfLC[iRefIdxLC];
227            m_iRefIdxOfL1FromRefIdxOfL0[m_iRefIdxFromIdxOfLC[iRefIdxLC]] = iNumRefIdx;
228            bTempRefIdxInL2 = false;
229            assert(m_eListIdFromIdxOfLC[iRefIdxLC]==REF_PIC_LIST_0);
230            break;
231          }
232        }
233        if(bTempRefIdxInL2 == true)
234        {
235          m_eListIdFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = REF_PIC_LIST_1;
236          m_iRefIdxFromIdxOfLC[m_aiNumRefIdx[REF_PIC_LIST_C]] = iNumRefIdx;
237          m_iRefIdxOfLC[REF_PIC_LIST_1][iNumRefIdx] = m_aiNumRefIdx[REF_PIC_LIST_C]++;
238        }
239      }
240    }
241  }
242}
243#endif
244
245Void TComSlice::setRefPicListFromGOPSTring( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcSpatRefPics )
246{
247
248  if (m_eSliceType == I_SLICE)
249  {
250    ::memset( m_apcRefPicList, 0, sizeof (m_apcRefPicList));
251    ::memset( m_aiNumRefIdx,   0, sizeof ( m_aiNumRefIdx ));
252
253    return;
254  }
255
256  sortPicList(rcListPic);
257  assert( m_eSliceType != P_SLICE || m_pcPic->getNumRefs( REF_PIC_LIST_1 ) == 0 );
258  for(Int iRefList = 0; iRefList<2; iRefList++ )
259  {
260    RefPicList eRefList = (RefPicList) iRefList;
261    m_aiNumRefIdx[eRefList] = m_pcPic->getNumRefs( eRefList );
262    for( Int i =0; i<m_pcPic->getNumRefs(eRefList); i++ )
263    {
264      const int iRefPoc = m_pcPic->getRefPOC( eRefList, i );
265      const int iRefViewIdx = m_pcPic->getRefViewIdx( eRefList, i );
266      m_aiRefPOCList[eRefList][i] = iRefPoc;
267      m_aiRefViewList[eRefList][i] = iRefViewIdx;
268
269      TComPic* pcRefPic = NULL;
270      if( iRefViewIdx == m_iViewIdx )
271      {
272        // temporal prediction from current view
273        for( TComList<TComPic*>::iterator it = rcListPic.begin(); it!=rcListPic.end(); it++)
274        {
275          if((*it)->getPOC() == iRefPoc)
276          {
277            pcRefPic = *it;
278            break;
279          }
280        }
281        assert( pcRefPic );
282        if( pcRefPic == NULL && iRefPoc > m_iPOC )
283        {
284          const int iAltRefPoc = m_iPOC-(iRefPoc-m_iPOC) ;
285          m_aiRefPOCList[eRefList][i] = iAltRefPoc ;
286          for( TComList<TComPic*>::iterator it = rcListPic.begin(); it!=rcListPic.end(); it++)
287          {
288            if((*it)->getPOC() == iAltRefPoc)
289            {
290              pcRefPic = *it ;
291              break;
292            }
293          }
294        }
295      }
296      else
297      {
298        // inter-view prediction
299        assert( iRefPoc == m_iPOC );
300        assert( 0 <= iRefViewIdx && iRefViewIdx < rapcSpatRefPics.size() );
301        pcRefPic = rapcSpatRefPics[iRefViewIdx];
302      }
303      if( pcRefPic )
304      {
305        m_apcRefPicList[eRefList][i] = pcRefPic;
306        pcRefPic->getPicYuvRec()->extendPicBorder();
307      }
308      else
309      {
310        printf("\n inconsistence in gop string!") ; // gop string inconsistent
311        assert(0) ;
312      }
313    }
314  }
315}
316Void TComSlice::setRefPicListExplicitlyDecoderSided( TComList<TComPic*>& rcListPic, std::vector<TComPic*>& rapcSpatRefPics )
317{
318  sortPicList(rcListPic);
319  TComPic*  pcRefPic = NULL;
320
321  for(Int iRefList = 0; iRefList<2; iRefList++)
322  {
323    RefPicList eRefList = (RefPicList) iRefList;
324    for( Int i=0; i<m_aiNumRefIdx[eRefList]; i++ )
325    {
326      const int iRefPoc = m_aiRefPOCList[ eRefList][i ];
327      const int iRefViewIdx = m_aiRefViewList[ eRefList][i ];
328      if( iRefViewIdx == m_iViewIdx )
329      {
330        for( TComList<TComPic*>::iterator it = rcListPic.begin(); it!=rcListPic.end(); it++)
331        {
332          if((*it)->getPOC() == iRefPoc)
333          {
334            pcRefPic = *it;
335            break;
336          }
337        }
338      }
339      else
340      {
341        // inter-view prediction
342        assert( iRefPoc == m_iPOC );
343        assert( 0 <= iRefViewIdx && iRefViewIdx < rapcSpatRefPics.size() );
344        pcRefPic = rapcSpatRefPics[iRefViewIdx];
345      }
346      if( pcRefPic )
347      {
348        m_apcRefPicList[eRefList][i] = pcRefPic;
349        pcRefPic->getPicYuvRec()->extendPicBorder();
350      }
351      else
352      {
353        printf("\n inconsistence in gop string!") ; // gop string inconsistent
354        assert(0) ;
355      }
356    }
357  }
358}
359
360Void TComSlice::initEqualRef()
361{
362  for (Int iDir = 0; iDir < 2; iDir++)
363  {
364    for (Int iRefIdx1 = 0; iRefIdx1 < MAX_NUM_REF; iRefIdx1++)
365    {
366      for (Int iRefIdx2 = iRefIdx1; iRefIdx2 < MAX_NUM_REF; iRefIdx2++)
367      {
368        m_abEqualRef[iDir][iRefIdx1][iRefIdx2] = m_abEqualRef[iDir][iRefIdx2][iRefIdx1] = (iRefIdx1 == iRefIdx2? true : false);
369      }
370    }
371  }
372}
373
374Void TComSlice::initMultiviewSlice( Int** aaiScale, Int** aaiOffset )
375{
376  if( m_pcSPS->hasCamParInSliceHeader() )
377  {
378    UInt uiViewId = m_pcSPS->getViewId();
379    for( UInt uiBaseViewId = 0; uiBaseViewId < uiViewId; uiBaseViewId++ )
380    {
381      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aaiScale [ uiBaseViewId ][     uiViewId ];
382      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aaiScale [     uiViewId ][ uiBaseViewId ];
383      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aaiOffset[ uiBaseViewId ][     uiViewId ];
384      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aaiOffset[     uiViewId ][ uiBaseViewId ];
385    }
386  }
387}
388
389
390#if DCM_DECODING_REFRESH
391/** Function for marking the reference pictures when an IDR and CDR is encountered.
392 * \param uiPOCCDR POC of the CDR picture
393 * \param bRefreshPending flag indicating if a deferred decoding refresh is pending
394 * \param rcListPic reference to the reference picture list
395 * This function marks the reference pictures as "unused for reference" in the following conditions.
396 * If the nal_unit_type is IDR all pictures in the reference picture list 
397 * is marked as "unused for reference"
398 * Otherwise do for the CDR case (non CDR case has no effect since both if conditions below will not be true)
399 *    If the bRefreshPending flag is true (a deferred decoding refresh is pending) and the current
400 *    temporal reference is greater than the temporal reference of the latest CDR picture (uiPOCCDR),
401 *    mark all reference pictures except the latest CDR picture as "unused for reference" and set
402 *    the bRefreshPending flag to false.
403 *    If the nal_unit_type is CDR, set the bRefreshPending flag to true and iPOCCDR to the temporal
404 *    reference of the current picture.
405 * Note that the current picture is already placed in the reference list and its marking is not changed.
406 * If the current picture has a nal_ref_idc that is not 0, it will remain marked as "used for reference".
407 */
408Void TComSlice::decodingRefreshMarking(UInt& uiPOCCDR, Bool& bRefreshPending, TComList<TComPic*>& rcListPic)
409{
410  TComPic*                 rpcPic;
411  UInt uiPOCCurr = getPOC(); 
412
413  if (getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR)  // IDR
414  {
415    // mark all pictures as not used for reference
416    TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
417    while (iterPic != rcListPic.end())
418    {
419      rpcPic = *(iterPic);
420      rpcPic->setCurrSliceIdx(0);
421      if (rpcPic->getPOC() != uiPOCCurr) rpcPic->getSlice(0)->setReferenced(false);
422      iterPic++;
423    }
424  }
425  else // CDR or No DR
426  {
427    if (bRefreshPending==true && uiPOCCurr > uiPOCCDR) // CDR reference marking pending
428    {
429      TComList<TComPic*>::iterator        iterPic       = rcListPic.begin();
430      while (iterPic != rcListPic.end())
431      {
432        rpcPic = *(iterPic);
433        if (rpcPic->getPOC() != uiPOCCurr && rpcPic->getPOC() != uiPOCCDR) rpcPic->getSlice(0)->setReferenced(false);
434        iterPic++;
435      }
436      bRefreshPending = false; 
437    }
438    if (getNalUnitType() == NAL_UNIT_CODED_SLICE_CDR) // CDR picture found
439    {
440      bRefreshPending = true; 
441      uiPOCCDR = uiPOCCurr;
442    }
443  }
444}
445#endif
446
447Void TComSlice::copySliceInfo(TComSlice *pSrc)
448{
449  assert( pSrc != NULL );
450
451  Int i, j, k;
452
453  m_iPOC                 = pSrc->m_iPOC;
454  m_iViewIdx             = pSrc->m_iViewIdx;
455#if SONY_COLPIC_AVAILABILITY
456  m_iViewOrderIdx        = pSrc->m_iViewOrderIdx;
457#endif
458#if DCM_DECODING_REFRESH
459  m_eNalUnitType         = pSrc->m_eNalUnitType;
460#endif 
461  m_eSliceType           = pSrc->m_eSliceType;
462  m_iSliceQp             = pSrc->m_iSliceQp;
463  m_iSymbolMode          = pSrc->m_iSymbolMode;
464  m_bLoopFilterDisable   = pSrc->m_bLoopFilterDisable;
465 
466#if DCM_COMB_LIST 
467  for (i = 0; i < 3; i++)
468  {
469    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
470  }
471
472  for (i = 0; i < 2; i++)
473  {
474    for (j = 0; j < MAX_NUM_REF_LC; j++)
475    {
476       m_iRefIdxOfLC[i][j]  = pSrc->m_iRefIdxOfLC[i][j];
477    }
478  }
479  for (i = 0; i < MAX_NUM_REF_LC; i++)
480  {
481    m_eListIdFromIdxOfLC[i] = pSrc->m_eListIdFromIdxOfLC[i];
482    m_iRefIdxFromIdxOfLC[i] = pSrc->m_iRefIdxFromIdxOfLC[i];
483    m_iRefIdxOfL1FromRefIdxOfL0[i] = pSrc->m_iRefIdxOfL1FromRefIdxOfL0[i];
484    m_iRefIdxOfL0FromRefIdxOfL1[i] = pSrc->m_iRefIdxOfL0FromRefIdxOfL1[i];
485  }
486  m_bRefPicListModificationFlagLC = pSrc->m_bRefPicListModificationFlagLC;
487  m_bRefPicListCombinationFlag    = pSrc->m_bRefPicListCombinationFlag;
488#else
489  for (i = 0; i < 2; i++)
490  {
491    m_aiNumRefIdx[i]     = pSrc->m_aiNumRefIdx[i];
492  }
493#endif 
494
495  m_iSliceQpDelta        = pSrc->m_iSliceQpDelta;
496  for (i = 0; i < 2; i++)
497  {
498    for (j = 0; j < MAX_NUM_REF; j++)
499    {
500      m_apcRefPicList[i][j]  = pSrc->m_apcRefPicList[i][j];
501      m_aiRefPOCList[i][j]   = pSrc->m_aiRefPOCList[i][j];
502      m_aiRefViewList[i][j]  = pSrc->m_aiRefViewList[i][j];
503    }
504  } 
505  m_iDepth               = pSrc->m_iDepth;
506
507  // referenced slice
508  m_bRefenced            = pSrc->m_bRefenced;
509#ifdef ROUNDING_CONTROL_BIPRED
510  m_bRounding            = pSrc->m_bRounding;
511#endif
512
513  // access channel
514  m_pcSPS                = pSrc->m_pcSPS;
515  m_pcPPS                = pSrc->m_pcPPS;
516  m_uiPPSId              = pSrc->m_uiPPSId;
517  m_pcPic                = pSrc->m_pcPic;
518
519  m_uiColDir             = pSrc->m_uiColDir;
520  m_dLambda              = pSrc->m_dLambda;
521  for (i = 0; i < 2; i++)
522  {
523    for (j = 0; j < MAX_NUM_REF; j++)
524    {
525      for (k =0; k < MAX_NUM_REF; k++)
526      {
527        m_abEqualRef[i][j][k] = pSrc->m_abEqualRef[i][j][k];
528      }
529    }
530  }
531
532  m_bNoBackPredFlag      = pSrc->m_bNoBackPredFlag;
533#if MS_LCEC_LOOKUP_TABLE_EXCEPTION
534  m_bRefIdxCombineCoding = pSrc->m_bRefIdxCombineCoding;
535#endif
536  m_uiSliceMode                   = pSrc->m_uiSliceMode;
537  m_uiSliceArgument               = pSrc->m_uiSliceArgument;
538  m_uiSliceCurStartCUAddr         = pSrc->m_uiSliceCurStartCUAddr;
539  m_uiSliceCurEndCUAddr           = pSrc->m_uiSliceCurEndCUAddr;
540  m_uiSliceIdx                    = pSrc->m_uiSliceIdx;
541  m_uiEntropySliceMode            = pSrc->m_uiEntropySliceMode;
542  m_uiEntropySliceArgument        = pSrc->m_uiEntropySliceArgument; 
543  m_uiEntropySliceCurStartCUAddr  = pSrc->m_uiEntropySliceCurStartCUAddr;
544  m_uiEntropySliceCurEndCUAddr    = pSrc->m_uiEntropySliceCurEndCUAddr;
545  m_bNextSlice                    = pSrc->m_bNextSlice;
546  m_bNextEntropySlice             = pSrc->m_bNextEntropySlice;
547#ifdef WEIGHT_PRED
548  for ( int e=0 ; e<2 ; e++ )
549  for ( int n=0 ; n<MAX_NUM_REF ; n++ )
550    memcpy(m_weightPredTable[e][n], pSrc->m_weightPredTable[e][n], sizeof(wpScalingParam)*3 );
551#endif
552}
553
554#ifdef WEIGHT_PRED
555Void  TComSlice::getWpScaling( RefPicList e, Int iRefIdx, wpScalingParam *&wp )
556{
557  wp = m_weightPredTable[e][iRefIdx];
558}
559
560Void  TComSlice::displayWpScaling()
561{
562  Bool  bFound = false;
563  for ( int e=0 ; e<2 ; e++ ) {
564    for ( int i=0 ; i<MAX_NUM_REF ; i++ )
565    for ( int yuv=0 ; yuv<3 ; yuv++ )
566      if ( m_weightPredTable[e][i][yuv].bPresentFlag ) {
567        if ( !bFound ) {
568          printf("\tluma_log2_weight_denom = %d\n",   m_weightPredTable[0][0][0].uiLog2WeightDenom);
569          printf("\tchroma_log2_weight_denom = %d\n", m_weightPredTable[0][0][1].uiLog2WeightDenom);
570          bFound = true;
571        }
572        Double  weight = (Double)m_weightPredTable[e][i][yuv].iWeight / (Double)(1<<m_weightPredTable[0][0][0].uiLog2WeightDenom);
573        if ( yuv == 0 ) {
574          printf("\tluma_weight_l%d_flag = 1\n", e);
575          printf("\t luma_weight_l%d[%d] = %d => w = %g\n", e, i, m_weightPredTable[e][i][yuv].iWeight, weight);
576          printf("\t luma_offset_l%d[%d] = %d\n", e, i, m_weightPredTable[e][i][yuv].iOffset);
577        }
578        else {
579          if ( yuv == 1 ) printf("\tchroma_weight_l%d_flag = 1\n", e);
580          printf("\t chroma_weight_l%d[%d][%d] = %d => w = %g\n", e, i, yuv-1, m_weightPredTable[e][i][yuv].iWeight, weight);
581          printf("\t chroma_offset_l%d[%d][%d] = %d\n", e, i, yuv-1, m_weightPredTable[e][i][yuv].iOffset);
582        }
583      }
584  }
585}
586
587// Default WP values settings : no weight.
588Void  TComSlice::resetWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
589{
590  for ( int e=0 ; e<2 ; e++ ) {
591    for ( int i=0 ; i<MAX_NUM_REF ; i++ )
592      for ( int yuv=0 ; yuv<3 ; yuv++ ) {
593        wpScalingParam  *pwp = &(wp[e][i][yuv]);
594        pwp->bPresentFlag      = false;
595        pwp->uiLog2WeightDenom = 0;
596        pwp->uiLog2WeightDenom = 0;
597        pwp->iWeight           = 1;
598        pwp->iOffset           = 0;
599      }
600  }
601}
602
603Void  TComSlice::initWpScaling()
604{
605  initWpScaling(m_weightPredTable);
606}
607
608Void  TComSlice::initWpScaling(wpScalingParam  wp[2][MAX_NUM_REF][3])
609{
610  for ( int e=0 ; e<2 ; e++ ) {
611    for ( int i=0 ; i<MAX_NUM_REF ; i++ )
612      for ( int yuv=0 ; yuv<3 ; yuv++ ) {
613        wpScalingParam  *pwp = &(wp[e][i][yuv]);
614        if ( !pwp->bPresentFlag ) {
615          // Inferring values not present :
616          pwp->iWeight = (1 << pwp->uiLog2WeightDenom);
617          pwp->iOffset = 0;
618        }
619
620        pwp->w      = pwp->iWeight;
621        pwp->o      = pwp->iOffset * (1 << (g_uiBitDepth-8));
622        pwp->shift  = pwp->uiLog2WeightDenom;
623        pwp->round  = (pwp->uiLog2WeightDenom>=1) ? (1 << (pwp->uiLog2WeightDenom-1)) : (0);
624      }
625  }
626}
627#endif
628
629#ifdef WEIGHT_PRED
630Void  TComSlice::getWpAcDcParam(wpACDCParam *&wp)
631{
632  wp = m_weightACDCParam;
633}
634
635Void  TComSlice::initWpAcDcParam()
636{
637  for(Int iComp = 0; iComp < 3; iComp++ )
638  {
639    m_weightACDCParam[iComp].iAC = 0;
640    m_weightACDCParam[iComp].iDC = 0;
641  }
642}
643#endif
644
645// ------------------------------------------------------------------------------------------------
646// Sequence parameter set (SPS)
647// ------------------------------------------------------------------------------------------------
648
649TComSPS::TComSPS()
650{
651  // Structure
652  m_uiSPSId       = 0;
653  m_uiWidth       = 352;
654  m_uiHeight      = 288;
655  m_uiMaxCUWidth  = 32;
656  m_uiMaxCUHeight = 32;
657  m_uiMaxCUDepth  = 3;
658  m_uiMinTrDepth  = 0;
659  m_uiMaxTrDepth  = 1;
660  m_uiMaxTrSize   = 32;
661 
662  // Tool list
663  m_bUseALF       = false;
664  m_bUseDQP       = false;
665 
666  m_bUseMRG      = false; // SOPH:
667#if HHI_MPI
668  m_bUseMVI = false;
669#endif
670 
671  m_uiViewId              = 0;
672  m_iViewOrderIdx         = 0;
673  m_bDepth                = false;
674  m_uiCamParPrecision     = 0;
675  m_bCamParInSliceHeader  = false;
676  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
677  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
678
679#if DEPTH_MAP_GENERATION
680  m_uiPredDepthMapGeneration = 0;
681  m_uiPdmPrecision           = 0;
682  ::memset( m_aiPdmScaleNomDelta, 0x00, sizeof( m_aiPdmScaleNomDelta  ) );
683  ::memset( m_aiPdmOffset,        0x00, sizeof( m_aiPdmOffset         ) );
684#endif
685#if HHI_INTER_VIEW_MOTION_PRED
686  m_uiMultiviewMvPredMode    = 0;
687#endif
688#if HHI_INTER_VIEW_RESIDUAL_PRED
689  m_uiMultiviewResPredMode   = 0;
690#endif
691
692#if POZNAN_DBMP
693  m_uiDBMP = 0;
694#endif
695
696#if POZNAN_ENCODE_ONLY_DISOCCLUDED_CU
697  m_uiUseCUSkip = 0;
698#endif
699
700
701  // AMVP parameter
702  ::memset( m_aeAMVPMode, 0, sizeof( m_aeAMVPMode ) );
703
704#if ( HHI_DMM_WEDGE_INTRA || HHI_DMM_PRED_TEX )
705  m_bUseDMM = false;
706#endif
707#if HHI_DMM_PRED_TEX && FLEX_CODING_ORDER
708  m_bUseDMM34 = false;
709#endif
710}
711
712TComSPS::~TComSPS()
713{
714}
715
716TComPPS::TComPPS()
717{
718#if CONSTRAINED_INTRA_PRED
719  m_bConstrainedIntraPred = false;
720#endif
721  m_uiSPSId = 0;
722  m_uiPPSId = 0;
723}
724
725TComPPS::~TComPPS()
726{
727}
728
729Void
730TComSPS::initMultiviewSPS( UInt uiViewId, Int iViewOrderIdx, UInt uiCamParPrecision, Bool bCamParSlice, Int** aaiScale, Int** aaiOffset )
731{
732  AOT( uiViewId == 0 && iViewOrderIdx != 0 );
733  AOT( uiViewId != 0 && iViewOrderIdx == 0 );
734  AOT( uiViewId != 0 && !bCamParSlice && ( aaiScale == 0 || aaiOffset == 0 ) );
735
736  m_uiViewId              = uiViewId;
737  m_iViewOrderIdx         = iViewOrderIdx;
738  m_bDepth                = false;
739  m_uiCamParPrecision     = ( m_uiViewId ? uiCamParPrecision : 0 );
740  m_bCamParInSliceHeader  = ( m_uiViewId ? bCamParSlice  : false );
741  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
742  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
743  if( !m_bCamParInSliceHeader )
744  {
745    for( UInt uiBaseViewId = 0; uiBaseViewId < m_uiViewId; uiBaseViewId++ )
746    {
747      m_aaiCodedScale [ 0 ][ uiBaseViewId ] = aaiScale [ uiBaseViewId ][   m_uiViewId ];
748      m_aaiCodedScale [ 1 ][ uiBaseViewId ] = aaiScale [   m_uiViewId ][ uiBaseViewId ];
749      m_aaiCodedOffset[ 0 ][ uiBaseViewId ] = aaiOffset[ uiBaseViewId ][   m_uiViewId ];
750      m_aaiCodedOffset[ 1 ][ uiBaseViewId ] = aaiOffset[   m_uiViewId ][ uiBaseViewId ];
751    }
752  }
753#if POZNAN_NONLINEAR_DEPTH
754  m_cNonlinearDepthModel.Clear();
755#endif
756#if POZNAN_TEXTURE_TU_DELTA_QP_ACCORDING_TO_DEPTH
757  m_bUseTexDqpAccordingToDepth = false;
758#endif
759}
760
761Void
762TComSPS::initMultiviewSPSDepth( UInt uiViewId, Int iViewOrderIdx )
763{
764  AOT( uiViewId == 0 && iViewOrderIdx != 0 );
765  AOT( uiViewId != 0 && iViewOrderIdx == 0 );
766
767  m_uiViewId              = uiViewId;
768  m_iViewOrderIdx         = iViewOrderIdx;
769  m_bDepth                = true;
770  m_uiCamParPrecision     = 0;
771  m_bCamParInSliceHeader  = false;
772  ::memset( m_aaiCodedScale,  0x00, sizeof( m_aaiCodedScale  ) );
773  ::memset( m_aaiCodedOffset, 0x00, sizeof( m_aaiCodedOffset ) );
774#if POZNAN_NONLINEAR_DEPTH
775  m_cNonlinearDepthModel.Clear();
776#endif
777}
778
779
780#if DEPTH_MAP_GENERATION
781Void
782TComSPS::setPredDepthMapGeneration( UInt uiViewId, Bool bIsDepth, UInt uiPdmGenMode, UInt uiPdmMvPredMode, UInt uiPdmPrec, Int** aaiPdmScaleNomDelta, Int** aaiPdmOffset )
783{ 
784  AOF( m_uiViewId == uiViewId );
785  AOF( m_bDepth   == bIsDepth );
786  AOT( ( uiViewId == 0 || bIsDepth ) && uiPdmGenMode );
787  AOT( uiPdmGenMode && ( aaiPdmScaleNomDelta == 0 || aaiPdmOffset == 0 ) );
788  AOT( uiPdmMvPredMode && uiPdmGenMode == 0 );
789 
790  m_uiPredDepthMapGeneration = uiPdmGenMode;
791#if HHI_INTER_VIEW_MOTION_PRED
792  m_uiMultiviewMvPredMode    = uiPdmMvPredMode;
793#endif
794  m_uiPdmPrecision           = ( m_uiPredDepthMapGeneration ? uiPdmPrec : 0 );
795  ::memset( m_aiPdmScaleNomDelta, 0x00, sizeof( m_aiPdmScaleNomDelta  ) );
796  ::memset( m_aiPdmOffset,        0x00, sizeof( m_aiPdmOffset         ) );
797  if( m_uiPredDepthMapGeneration )
798  {
799    for( UInt uiBaseId = 0; uiBaseId < m_uiViewId; uiBaseId++ )
800    {
801      m_aiPdmScaleNomDelta[ uiBaseId ]  = aaiPdmScaleNomDelta[ m_uiViewId ][ uiBaseId ];
802      m_aiPdmOffset       [ uiBaseId ]  = aaiPdmOffset       [ m_uiViewId ][ uiBaseId ];
803    }
804  }
805}
806#endif
Note: See TracBrowser for help on using the repository browser.