source: 3DVCSoftware/trunk/source/Lib/TLibEncoder/TEncEntropy.cpp @ 296

Last change on this file since 296 was 296, checked in by tech, 11 years ago

Reintegrated branch 5.1-dev0 rev. 295.

  • Property svn:eol-style set to native
File size: 51.0 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-2012, 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     TEncEntropy.cpp
35    \brief    entropy encoder class
36*/
37
38#include "TEncEntropy.h"
39#include "TLibCommon/TypeDef.h"
40#include "TLibCommon/TComAdaptiveLoopFilter.h"
41#include "TLibCommon/TComSampleAdaptiveOffset.h"
42
43//! \ingroup TLibEncoder
44//! \{
45
46Void TEncEntropy::setEntropyCoder ( TEncEntropyIf* e, TComSlice* pcSlice )
47{
48  m_pcEntropyCoderIf = e;
49  m_pcEntropyCoderIf->setSlice ( pcSlice );
50}
51
52Void TEncEntropy::encodeSliceHeader ( TComSlice* pcSlice )
53{
54  if (pcSlice->getSPS()->getUseSAO())
55  {
56    pcSlice->setSaoInterleavingFlag(pcSlice->getAPS()->getSaoInterleavingFlag());
57    pcSlice->setSaoEnabledFlag     (pcSlice->getAPS()->getSaoParam()->bSaoFlag[0]);
58    if (pcSlice->getAPS()->getSaoInterleavingFlag())
59    {
60      pcSlice->setSaoEnabledFlagCb   (pcSlice->getAPS()->getSaoParam()->bSaoFlag[1]);
61      pcSlice->setSaoEnabledFlagCr   (pcSlice->getAPS()->getSaoParam()->bSaoFlag[2]);
62    }
63    else
64    {
65      pcSlice->setSaoEnabledFlagCb   (0);
66      pcSlice->setSaoEnabledFlagCr   (0);
67    }
68  }
69
70  m_pcEntropyCoderIf->codeSliceHeader( pcSlice );
71  return;
72}
73
74Void  TEncEntropy::encodeTilesWPPEntryPoint( TComSlice* pSlice )
75{
76  m_pcEntropyCoderIf->codeTilesWPPEntryPoint( pSlice );
77}
78
79Void TEncEntropy::encodeTerminatingBit      ( UInt uiIsLast )
80{
81  m_pcEntropyCoderIf->codeTerminatingBit( uiIsLast );
82 
83  return;
84}
85
86Void TEncEntropy::encodeSliceFinish()
87{
88  m_pcEntropyCoderIf->codeSliceFinish();
89}
90
91Void TEncEntropy::encodeFlush()
92{
93  m_pcEntropyCoderIf->codeFlush();
94}
95Void TEncEntropy::encodeStart()
96{
97  m_pcEntropyCoderIf->encodeStart();
98}
99
100Void TEncEntropy::encodeSEI(const SEI& sei)
101{
102  m_pcEntropyCoderIf->codeSEI(sei);
103  return;
104}
105
106Void TEncEntropy::encodePPS( TComPPS* pcPPS )
107{
108  m_pcEntropyCoderIf->codePPS( pcPPS );
109  return;
110}
111
112#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
113Void TEncEntropy::encodeVPS( TComVPS* pcVPS )
114{
115  m_pcEntropyCoderIf->codeVPS( pcVPS );
116  return;
117}
118#endif
119
120#if VIDYO_VPS_INTEGRATION|QC_MVHEVC_B0046
121Void  codeVPS                 ( TComVPS* pcVPS );
122#endif
123
124#if HHI_MPI || OL_QTLIMIT_PREDCODING_B0068
125Void TEncEntropy::encodeSPS( TComSPS* pcSPS, Bool bIsDepth )
126{
127  m_pcEntropyCoderIf->codeSPS( pcSPS, bIsDepth );
128  return;
129}
130#else
131Void TEncEntropy::encodeSPS( TComSPS* pcSPS )
132{
133  m_pcEntropyCoderIf->codeSPS( pcSPS );
134  return;
135}
136#endif
137
138Void TEncEntropy::encodeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
139{
140  if ( pcCU->getSlice()->isIntra() )
141  {
142    return;
143  }
144  if( bRD )
145  {
146    uiAbsPartIdx = 0;
147  }
148  if( !bRD )
149  {
150    if( pcCU->getLastCUSucIPCMFlag() && pcCU->getIPCMFlag(uiAbsPartIdx) )
151    {
152      return;
153    }
154  }
155  m_pcEntropyCoderIf->codeSkipFlag( pcCU, uiAbsPartIdx );
156}
157
158#if LGE_ILLUCOMP_B0045
159Void TEncEntropy::encodeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD
160#if LGE_ILLUCOMP_DEPTH_C0046
161    , UInt uiDepth
162#endif
163    )
164{
165  if (pcCU->isIntra(uiAbsPartIdx) || (pcCU->getSlice()->getViewId() == 0)
166#if !LGE_ILLUCOMP_DEPTH_C0046
167      || pcCU->getSlice()->getSPS()->isDepth()
168#endif
169      )
170  {
171    return;
172  }
173
174  if(!pcCU->getSlice()->getApplyIC())
175    return;
176
177  if( bRD )
178  {
179    uiAbsPartIdx = 0;
180  }
181
182  if(pcCU->isICFlagRequired(uiAbsPartIdx
183#if LGE_ILLUCOMP_DEPTH_C0046
184      , uiDepth //This modification is not needed after integrating JCT3V-C0137
185#endif
186      ))
187    m_pcEntropyCoderIf->codeICFlag( pcCU, uiAbsPartIdx );
188}
189#endif
190
191Void TEncEntropy::codeFiltCountBit(ALFParam* pAlfParam, Int64* ruiRate)
192{
193  resetEntropy();
194  resetBits();
195  codeFilt(pAlfParam);
196  *ruiRate = getNumberOfWrittenBits();
197  resetEntropy();
198  resetBits();
199}
200
201Void TEncEntropy::codeAuxCountBit(ALFParam* pAlfParam, Int64* ruiRate)
202{
203  resetEntropy();
204  resetBits();
205  codeAux(pAlfParam);
206  *ruiRate = getNumberOfWrittenBits();
207  resetEntropy();
208  resetBits();
209}
210
211Void TEncEntropy::codeAux(ALFParam* pAlfParam)
212{
213  //  m_pcEntropyCoderIf->codeAlfUvlc(pAlfParam->realfiltNo);
214
215  Int noFilters = min(pAlfParam->filters_per_group-1, 2);
216  m_pcEntropyCoderIf->codeAlfUvlc(noFilters);
217
218  if(noFilters == 1)
219  {
220    m_pcEntropyCoderIf->codeAlfUvlc(pAlfParam->startSecondFilter);
221  }
222  else if (noFilters == 2)
223  {
224    Int numMergeFlags = 16;
225    for (Int i=1; i<numMergeFlags; i++) 
226    {
227      m_pcEntropyCoderIf->codeAlfFlag (pAlfParam->filterPattern[i]);
228    }
229  }
230}
231
232Int TEncEntropy::lengthGolomb(int coeffVal, int k)
233{
234  int m = 2 << (k - 1);
235  int q = coeffVal / m;
236  if(coeffVal != 0)
237  {
238    return(q + 2 + k);
239  }
240  else
241  {
242    return(q + 1 + k);
243  }
244}
245
246Int TEncEntropy::codeFilterCoeff(ALFParam* ALFp)
247{
248  Int filters_per_group = ALFp->filters_per_group;
249  int sqrFiltLength = ALFp->num_coeff;
250  int i, k, kMin, kStart, minBits, ind, scanPos, maxScanVal, coeffVal, len = 0,
251    *pDepthInt=NULL, kMinTab[MAX_SCAN_VAL], bitsCoeffScan[MAX_SCAN_VAL][MAX_EXP_GOLOMB],
252    minKStart, minBitsKStart, bitsKStart;
253 
254  pDepthInt = pDepthIntTabShapes[ALFp->filter_shape];
255  maxScanVal = 0;
256  int minScanVal = MIN_SCAN_POS_CROSS;
257
258  for(i = 0; i < sqrFiltLength; i++)
259  {
260    maxScanVal = max(maxScanVal, pDepthInt[i]);
261  }
262 
263  // vlc for all
264  memset(bitsCoeffScan, 0, MAX_SCAN_VAL * MAX_EXP_GOLOMB * sizeof(int));
265  for(ind=0; ind<filters_per_group; ++ind)
266  {
267    for(i = 0; i < sqrFiltLength; i++)
268    {
269      scanPos=pDepthInt[i]-1;
270      coeffVal=abs(ALFp->coeffmulti[ind][i]);
271      for (k=1; k<15; k++)
272      {
273        bitsCoeffScan[scanPos][k]+=lengthGolomb(coeffVal, k);
274      }
275    }
276  }
277 
278  minBitsKStart = 0;
279  minKStart = -1;
280  for(k = 1; k < 8; k++)
281  { 
282    bitsKStart = 0; 
283    kStart = k;
284    for(scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
285    {
286      kMin = kStart; 
287      minBits = bitsCoeffScan[scanPos][kMin];
288     
289      if(bitsCoeffScan[scanPos][kStart+1] < minBits)
290      {
291        kMin = kStart + 1; 
292        minBits = bitsCoeffScan[scanPos][kMin];
293      }
294      kStart = kMin;
295      bitsKStart += minBits;
296    }
297    if((bitsKStart < minBitsKStart) || (k == 1))
298    {
299      minBitsKStart = bitsKStart;
300      minKStart = k;
301    }
302  }
303 
304  kStart = minKStart; 
305  for(scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
306  {
307    kMin = kStart; 
308    minBits = bitsCoeffScan[scanPos][kMin];
309   
310    if(bitsCoeffScan[scanPos][kStart+1] < minBits)
311    {
312      kMin = kStart + 1; 
313      minBits = bitsCoeffScan[scanPos][kMin];
314    }
315   
316    kMinTab[scanPos] = kMin;
317    kStart = kMin;
318  }
319 
320  // Coding parameters
321  ALFp->minKStart = minKStart;
322  for(scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
323  {
324    ALFp->kMinTab[scanPos] = kMinTab[scanPos];
325  }
326
327  if (ALFp->filters_per_group == 1)
328  {
329    len += writeFilterCoeffs(sqrFiltLength, filters_per_group, pDepthInt, ALFp->coeffmulti, kTableTabShapes[ALF_CROSS9x7_SQUARE3x3]);
330  }
331  else
332  {
333  len += writeFilterCodingParams(minKStart, minScanVal, maxScanVal, kMinTab);
334
335  // Filter coefficients
336  len += writeFilterCoeffs(sqrFiltLength, filters_per_group, pDepthInt, ALFp->coeffmulti, kMinTab);
337  }
338 
339  return len;
340}
341
342Int TEncEntropy::writeFilterCodingParams(int minKStart, int minScanVal, int maxScanVal, int kMinTab[])
343{
344  int scanPos;
345  int golombIndexBit;
346  int kMin;
347
348  // Golomb parameters
349  m_pcEntropyCoderIf->codeAlfUvlc(minKStart - 1);
350 
351  kMin = minKStart; 
352  for(scanPos = minScanVal; scanPos < maxScanVal; scanPos++)
353  {
354    golombIndexBit = (kMinTab[scanPos] != kMin)? 1: 0;
355   
356    assert(kMinTab[scanPos] <= kMin + 1);
357   
358    m_pcEntropyCoderIf->codeAlfFlag(golombIndexBit);
359    kMin = kMinTab[scanPos];
360  }   
361 
362  return 0;
363}
364
365Int TEncEntropy::writeFilterCoeffs(int sqrFiltLength, int filters_per_group, int pDepthInt[], 
366                                   int **FilterCoeff, int kMinTab[])
367{
368  int ind, scanPos, i;
369 
370  for(ind = 0; ind < filters_per_group; ++ind)
371  {
372    for(i = 0; i < sqrFiltLength; i++)
373    {
374      scanPos = pDepthInt[i] - 1;
375      Int k = (filters_per_group == 1) ? kMinTab[i] : kMinTab[scanPos];
376      golombEncode(FilterCoeff[ind][i], k);
377    }
378  }
379  return 0;
380}
381
382Int TEncEntropy::golombEncode(int coeff, int k)
383{
384  int q, i;
385  int symbol = abs(coeff);
386 
387  q = symbol >> k;
388 
389  for (i = 0; i < q; i++)
390  {
391    m_pcEntropyCoderIf->codeAlfFlag(1);
392  }
393  m_pcEntropyCoderIf->codeAlfFlag(0);
394  // write one zero
395 
396  for(i = 0; i < k; i++)
397  {
398    m_pcEntropyCoderIf->codeAlfFlag(symbol & 0x01);
399    symbol >>= 1;
400  }
401 
402  if(coeff != 0)
403  {
404    int sign = (coeff > 0)? 1: 0;
405    m_pcEntropyCoderIf->codeAlfFlag(sign);
406  }
407  return 0;
408}
409
410Void TEncEntropy::codeFilt(ALFParam* pAlfParam)
411{
412  if(pAlfParam->filters_per_group > 1)
413  {
414    m_pcEntropyCoderIf->codeAlfFlag (pAlfParam->predMethod);
415  }
416  for(Int ind = 0; ind < pAlfParam->filters_per_group; ++ind)
417  {
418    m_pcEntropyCoderIf->codeAlfFlag (pAlfParam->nbSPred[ind]);
419  }
420  codeFilterCoeff (pAlfParam);
421}
422
423/** encode merge flag
424 * \param pcCU
425 * \param uiAbsPartIdx
426 * \param uiPUIdx
427 * \returns Void
428 */
429Void TEncEntropy::encodeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPUIdx )
430{ 
431  // at least one merge candidate exists
432  m_pcEntropyCoderIf->codeMergeFlag( pcCU, uiAbsPartIdx );
433}
434
435/** encode merge index
436 * \param pcCU
437 * \param uiAbsPartIdx
438 * \param uiPUIdx
439 * \param bRD
440 * \returns Void
441 */
442Void TEncEntropy::encodeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPUIdx, Bool bRD )
443{
444  if( bRD )
445  {
446    uiAbsPartIdx = 0;
447    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
448  }
449
450  UInt uiNumCand = MRG_MAX_NUM_CANDS;
451  if ( uiNumCand > 1 )
452  {
453    m_pcEntropyCoderIf->codeMergeIndex( pcCU, uiAbsPartIdx );
454  }
455}
456
457#if H3D_IVRP && !MTK_MDIVRP_C0138
458Void
459TEncEntropy::encodeResPredFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiPUIdx, Bool bRD )
460{
461  if( bRD )
462  {
463    uiAbsPartIdx = 0;
464  }
465
466  // check whether flag is coded
467  ROTVS( pcCU->getSlice()->getSPS()->isDepth                () );
468  ROFVS( pcCU->getSlice()->getSPS()->getViewId              () );
469  ROFVS( pcCU->getSlice()->getSPS()->getMultiviewResPredMode() );
470  ROTVS( pcCU->isIntra           ( uiAbsPartIdx )              );
471  ROFVS( pcCU->getResPredAvail   ( uiAbsPartIdx )              );
472#if LG_RESTRICTEDRESPRED_M24766
473  Int iPUResiPredShift[4];
474  pcCU->getPUResiPredShift(iPUResiPredShift, uiAbsPartIdx);
475  if(iPUResiPredShift[0] >= 0 || iPUResiPredShift[1] >= 0  || iPUResiPredShift[2] >= 0  || iPUResiPredShift[3] >= 0 )
476#endif
477  // encode flag
478  m_pcEntropyCoderIf->codeResPredFlag( pcCU, uiAbsPartIdx );
479}
480#endif
481
482/** parse the fixed length code (smaller than one max value) in ALF
483 * \param run: coded value
484 * \param rx: cur addr
485 * \param numLCUInWidth: # of LCU in one LCU
486 * \returns Void
487 */
488Void TEncEntropy::encodeAlfFixedLengthRun(UInt run, UInt rx, UInt numLCUInWidth)
489{
490  assert(numLCUInWidth > rx);
491  UInt maxValue = numLCUInWidth - rx - 1;
492  m_pcEntropyCoderIf->codeAlfFixedLengthIdx(run, maxValue);
493}
494
495/** parse the fixed length code (smaller than one max value) in ALF
496 * \param idx: coded value
497 * \param numFilterSetsInBuffer: max value
498 * \returns Void
499 */
500Void TEncEntropy::encodeAlfStoredFilterSetIdx(UInt idx, UInt numFilterSetsInBuffer)
501{
502  assert(numFilterSetsInBuffer > 0);
503  UInt maxValue = numFilterSetsInBuffer - 1;
504  m_pcEntropyCoderIf->codeAlfFixedLengthIdx(idx, maxValue);
505}
506
507Void TEncEntropy::encodeAlfParam(AlfParamSet* pAlfParamSet, Bool bSentInAPS, Int firstLCUAddr, Bool alfAcrossSlice)
508{
509  Bool isEnabled[NUM_ALF_COMPONENT];
510  Bool isUniParam[NUM_ALF_COMPONENT];
511
512  isEnabled[ALF_Y] = true;
513  isEnabled[ALF_Cb]= pAlfParamSet->isEnabled[ALF_Cb];
514  isEnabled[ALF_Cr]= pAlfParamSet->isEnabled[ALF_Cr];
515
516  isUniParam[ALF_Y]= pAlfParamSet->isUniParam[ALF_Y];
517  isUniParam[ALF_Cb]= pAlfParamSet->isUniParam[ALF_Cb];
518  isUniParam[ALF_Cr]= pAlfParamSet->isUniParam[ALF_Cr]; 
519
520
521  //alf_cb_enable_flag
522  m_pcEntropyCoderIf->codeAlfFlag(isEnabled[ALF_Cb]?1:0);
523  //alf_cr_enable_flag
524  m_pcEntropyCoderIf->codeAlfFlag(isEnabled[ALF_Cr]?1:0); 
525
526  for(Int compIdx = 0; compIdx< NUM_ALF_COMPONENT; compIdx++)
527  {
528    if(isEnabled[compIdx])
529    {
530      //alf_one_{luma, cb, cr}_unit_per_slice_flag
531      m_pcEntropyCoderIf->codeAlfFlag(isUniParam[compIdx]?1:0);
532    }
533  }
534  if(bSentInAPS)
535  {
536    //alf_num_lcu_in_width_minus1
537    m_pcEntropyCoderIf->codeAlfUvlc(pAlfParamSet->numLCUInWidth-1);
538    //alf_num_lcu_in_height_minus1
539    m_pcEntropyCoderIf->codeAlfUvlc(pAlfParamSet->numLCUInHeight-1);
540  }
541  else //sent in slice header
542  {
543    //alf_num_lcu_in_slice_minus1
544    m_pcEntropyCoderIf->codeAlfUvlc(pAlfParamSet->numLCU-1);
545  }
546
547
548  encodeAlfParamSet(pAlfParamSet, pAlfParamSet->numLCUInWidth, pAlfParamSet->numLCU, firstLCUAddr, alfAcrossSlice, 0, (Int)NUM_ALF_COMPONENT-1);
549
550}
551
552Bool TEncEntropy::getAlfRepeatRowFlag(Int compIdx, AlfParamSet* pAlfParamSet
553                                    , Int lcuIdxInSlice, Int lcuPos
554                                    , Int startlcuPosX, Int endlcuPosX
555                                    , Int numLCUInWidth
556                                    )
557{
558  assert(startlcuPosX == 0); //only the beginning of one LCU row needs to send repeat_row_flag
559 
560  Int len = endlcuPosX - startlcuPosX +1;
561  Bool isRepeatRow = true;
562  Int curPos;
563
564  for(Int i= 0; i < len; i++)
565  {
566    curPos = lcuIdxInSlice +i;
567    AlfUnitParam& alfUnitParam = pAlfParamSet->alfUnitParam[compIdx][curPos];
568    AlfUnitParam& alfUpUnitParam = pAlfParamSet->alfUnitParam[compIdx][curPos-numLCUInWidth];
569
570    if ( !(alfUnitParam == alfUpUnitParam) )
571    {
572      isRepeatRow = false;
573      break;
574    }
575  }
576
577  return isRepeatRow;
578}
579
580
581Int TEncEntropy::getAlfRun(Int compIdx, AlfParamSet* pAlfParamSet
582                          , Int lcuIdxInSlice, Int lcuPos
583                          , Int startlcuPosX, Int endlcuPosX
584                          )
585{
586  Int alfRun = 0;
587  Int len = endlcuPosX - startlcuPosX +1;
588  AlfUnitParam& alfLeftUnitParam = pAlfParamSet->alfUnitParam[compIdx][lcuIdxInSlice];
589
590
591
592  for(Int i= 1; i < len; i++)
593  {
594    AlfUnitParam& alfUnitParam = pAlfParamSet->alfUnitParam[compIdx][lcuIdxInSlice+ i];
595
596    if (alfUnitParam == alfLeftUnitParam)
597    {
598      alfRun++;
599    }
600    else
601    {
602      break;
603    }
604  }
605
606  return alfRun;
607
608}
609
610
611
612Void TEncEntropy::encodeAlfParamSet(AlfParamSet* pAlfParamSet, Int numLCUInWidth, Int numLCU, Int firstLCUAddr, Bool alfAcrossSlice, Int startCompIdx, Int endCompIdx)
613{
614  Int endLCUY       = (numLCU -1 + firstLCUAddr)/numLCUInWidth;
615  Int endLCUX       = (numLCU -1 + firstLCUAddr)%numLCUInWidth;
616
617  static Bool isRepeatedRow   [NUM_ALF_COMPONENT];
618  static Int  numStoredFilters[NUM_ALF_COMPONENT];
619  static Int* run             [NUM_ALF_COMPONENT];
620
621  for(Int compIdx =startCompIdx; compIdx <= endCompIdx; compIdx++)
622  {
623    isRepeatedRow[compIdx]    = false;
624    numStoredFilters[compIdx] = 0;
625
626    run[compIdx] = new Int[numLCU+1];
627    run[compIdx][0] = -1; 
628  }
629
630  Int  ry, rx, addrUp, endrX, lcuPos;
631
632  for(Int i=0; i< numLCU; i++)
633  {
634    lcuPos= firstLCUAddr+ i;
635    rx    = lcuPos% numLCUInWidth;
636    ry    = lcuPos/ numLCUInWidth;
637    endrX = ( ry == endLCUY)?( endLCUX ):(numLCUInWidth-1);
638
639    for(Int compIdx =startCompIdx; compIdx <= endCompIdx; compIdx++)
640    {
641      AlfUnitParam& alfUnitParam = pAlfParamSet->alfUnitParam[compIdx][i];
642      if(pAlfParamSet->isEnabled[compIdx])
643      {
644        if(!pAlfParamSet->isUniParam[compIdx])
645        {
646          addrUp = i-numLCUInWidth;
647          if(rx ==0 && addrUp >=0)
648          {
649            isRepeatedRow[compIdx] = getAlfRepeatRowFlag(compIdx, pAlfParamSet, i, lcuPos, rx, endrX, numLCUInWidth);
650
651            //alf_repeat_row_flag
652            m_pcEntropyCoderIf->codeAlfFlag(isRepeatedRow[compIdx]?1:0);
653          }
654
655          if(isRepeatedRow[compIdx])
656          {
657            assert(addrUp >=0);
658            run[compIdx][i] = run[compIdx][addrUp];
659          }
660          else
661          {
662            if(rx == 0 || run[compIdx][i] < 0)
663            {             
664              run[compIdx][i] = getAlfRun(compIdx, pAlfParamSet, i, lcuPos, rx, endrX);
665
666              if(addrUp < 0)
667              {
668                //alf_run_diff u(v)
669                encodeAlfFixedLengthRun(run[compIdx][i], rx, numLCUInWidth);               
670              }
671              else
672              {
673                //alf_run_diff s(v)
674                m_pcEntropyCoderIf->codeAlfSvlc(run[compIdx][i]- run[compIdx][addrUp]);
675
676              }
677
678              if(ry > 0 && (addrUp >=0 || alfAcrossSlice))
679              {
680                //alf_merge_up_flag
681                m_pcEntropyCoderIf->codeAlfFlag(  (alfUnitParam.mergeType == ALF_MERGE_UP)?1:0   ); 
682              }
683
684              if(alfUnitParam.mergeType != ALF_MERGE_UP)
685              {
686                assert(alfUnitParam.mergeType == ALF_MERGE_DISABLED);
687
688                //alf_lcu_enable_flag
689                m_pcEntropyCoderIf->codeAlfFlag(alfUnitParam.isEnabled ? 1 : 0);
690
691                if(alfUnitParam.isEnabled)
692                {
693                  if(numStoredFilters[compIdx] > 0)
694                  {
695                    //alf_new_filter_set_flag
696                    m_pcEntropyCoderIf->codeAlfFlag(alfUnitParam.isNewFilt ? 1:0);
697
698                    if(!alfUnitParam.isNewFilt)
699                    {
700                      //alf_stored_filter_set_idx
701                      encodeAlfStoredFilterSetIdx(alfUnitParam.storedFiltIdx, numStoredFilters[compIdx]);
702
703                    }
704                  }
705                  else
706                  {
707                    assert(alfUnitParam.isNewFilt);
708                  }
709
710                  if(alfUnitParam.isNewFilt)
711                  {
712                    assert(alfUnitParam.alfFiltParam->alf_flag == 1);
713                    encodeAlfParam(alfUnitParam.alfFiltParam);
714                    numStoredFilters[compIdx]++;
715                  }
716                }
717
718              }
719            }
720
721            run[compIdx][i+1] = run[compIdx][i] -1;
722          }
723
724        }
725        else // uni-param
726        {
727          if(i == 0)
728          {
729            //alf_lcu_enable_flag
730            m_pcEntropyCoderIf->codeAlfFlag(alfUnitParam.isEnabled?1:0);
731            if(alfUnitParam.isEnabled)
732            {
733              encodeAlfParam(alfUnitParam.alfFiltParam);
734            }
735          }
736        }
737      } // component enabled/disable
738    } //comp
739
740  }
741
742  for(Int compIdx =startCompIdx; compIdx <= endCompIdx; compIdx++)
743  {
744    delete[] run[compIdx];
745  }
746
747}
748
749
750Void TEncEntropy::encodeAlfParam(ALFParam* pAlfParam)
751{
752  const Int numCoeff = (Int)ALF_MAX_NUM_COEF;
753
754  switch(pAlfParam->componentID)
755  {
756  case ALF_Cb:
757  case ALF_Cr:
758    {
759      for(Int pos=0; pos< numCoeff; pos++)
760      {
761        m_pcEntropyCoderIf->codeAlfSvlc(  pAlfParam->coeffmulti[0][pos]);
762
763      }
764    }
765    break;
766  case ALF_Y:
767    {
768      codeAux(pAlfParam);
769      codeFilt(pAlfParam);
770    }
771    break;
772  default:
773    {
774      printf("Not a legal component ID\n");
775      assert(0);
776      exit(-1);
777    }
778  }
779}
780
781Void TEncEntropy::encodeAlfCtrlFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
782{
783  if( bRD )
784  {
785    uiAbsPartIdx = 0;
786  }
787  m_pcEntropyCoderIf->codeAlfCtrlFlag( pcCU, uiAbsPartIdx );
788}
789
790
791/** Encode ALF CU control flag
792 * \param uiFlag ALF CU control flag: 0 or 1
793 */
794Void TEncEntropy::encodeAlfCtrlFlag(UInt uiFlag)
795{
796  assert(uiFlag == 0 || uiFlag == 1);
797  m_pcEntropyCoderIf->codeAlfCtrlFlag( uiFlag );
798}
799
800
801/** Encode ALF CU control flag parameters
802 * \param pAlfParam ALF parameters
803 */
804Void TEncEntropy::encodeAlfCtrlParam(AlfCUCtrlInfo& cAlfParam, Int iNumCUsInPic)
805{
806  // region control parameters for luma
807  m_pcEntropyCoderIf->codeAlfFlag(cAlfParam.cu_control_flag);
808
809  if (cAlfParam.cu_control_flag == 0)
810  { 
811    return;
812  }
813
814  m_pcEntropyCoderIf->codeAlfCtrlDepth();
815
816  Int iSymbol    = ((Int)cAlfParam.num_alf_cu_flag - iNumCUsInPic);
817  m_pcEntropyCoderIf->codeAlfSvlc(iSymbol);
818
819  for(UInt i=0; i< cAlfParam.num_alf_cu_flag; i++)
820  {
821    m_pcEntropyCoderIf->codeAlfCtrlFlag( cAlfParam.alf_cu_flag[i] );
822  }
823}
824
825/** encode prediction mode
826 * \param pcCU
827 * \param uiAbsPartIdx
828 * \param bRD
829 * \returns Void
830 */
831Void TEncEntropy::encodePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
832{
833  if( bRD )
834  {
835    uiAbsPartIdx = 0;
836  }
837  if( !bRD )
838  {
839    if( pcCU->getLastCUSucIPCMFlag() && pcCU->getIPCMFlag(uiAbsPartIdx) )
840    {
841      return;
842    }
843  }
844
845#if !RWTH_SDC_DLT_B0036
846  if ( pcCU->getSlice()->isIntra() )
847  {
848    return;
849  }
850#endif
851
852  m_pcEntropyCoderIf->codePredMode( pcCU, uiAbsPartIdx );
853 
854#if RWTH_SDC_DLT_B0036
855  // if B-Slice, code SDC flag later
856  if( !pcCU->getSlice()->isInterB() && pcCU->getSlice()->getSPS()->isDepth() && pcCU->isIntra(uiAbsPartIdx) )
857  {
858    // encode SDC flag
859    encodeSDCFlag(pcCU, uiAbsPartIdx, bRD);
860  }
861#endif
862}
863
864// Split mode
865Void TEncEntropy::encodeSplitFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD )
866{
867  if( bRD )
868  {
869    uiAbsPartIdx = 0;
870  }
871  if( !bRD )
872  {
873    if( pcCU->getLastCUSucIPCMFlag() && pcCU->getIPCMFlag(uiAbsPartIdx) )
874    {
875      return;
876    }
877  }
878
879  m_pcEntropyCoderIf->codeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
880}
881
882/** encode partition size
883 * \param pcCU
884 * \param uiAbsPartIdx
885 * \param uiDepth
886 * \param bRD
887 * \returns Void
888 */
889Void TEncEntropy::encodePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD )
890{
891  if( bRD )
892  {
893    uiAbsPartIdx = 0;
894  }
895  if( !bRD )
896  {
897    if( pcCU->getLastCUSucIPCMFlag() && pcCU->getIPCMFlag(uiAbsPartIdx) )
898    {
899      return;
900    }
901  }
902#if RWTH_SDC_DLT_B0036
903  if( !pcCU->getSlice()->isInterB() && pcCU->isIntra(uiAbsPartIdx) && pcCU->getSDCFlag(uiAbsPartIdx)  )
904  {
905    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
906    return;
907  }
908#endif
909 
910  m_pcEntropyCoderIf->codePartSize( pcCU, uiAbsPartIdx, uiDepth );
911 
912#if RWTH_SDC_DLT_B0036
913  // code SDC flag now!
914  if( pcCU->getSlice()->isInterB() && pcCU->isIntra(uiAbsPartIdx) && pcCU->getSlice()->getSPS()->isDepth() )
915  {
916    // encode SDC flag
917    encodeSDCFlag(pcCU, uiAbsPartIdx, bRD);
918   
919    if( pcCU->getSDCFlag(uiAbsPartIdx) )
920    {
921      // part size is also known for SDC intra
922      assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
923    }
924  }
925#endif
926}
927
928/** Encode I_PCM information.
929 * \param pcCU pointer to CU
930 * \param uiAbsPartIdx CU index
931 * \param bRD flag indicating estimation or encoding
932 * \returns Void
933 */
934Void TEncEntropy::encodeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
935{
936  if(!pcCU->getSlice()->getSPS()->getUsePCM()
937    || pcCU->getWidth(uiAbsPartIdx) > (1<<pcCU->getSlice()->getSPS()->getPCMLog2MaxSize())
938    || pcCU->getWidth(uiAbsPartIdx) < (1<<pcCU->getSlice()->getSPS()->getPCMLog2MinSize()))
939  {
940    return;
941  }
942 
943#if RWTH_SDC_DLT_B0036
944  if( pcCU->getSDCFlag(uiAbsPartIdx) )
945  {
946    return;
947  }
948#endif
949 
950  if( bRD )
951  {
952    uiAbsPartIdx = 0;
953  }
954 
955  Int numIPCM = 0;
956  Bool firstIPCMFlag = false;
957
958  if( pcCU->getIPCMFlag(uiAbsPartIdx) )
959  {
960    numIPCM = 1;
961    firstIPCMFlag = true;
962
963    if( !bRD )
964    {
965      numIPCM = pcCU->getNumSucIPCM();
966      firstIPCMFlag = !pcCU->getLastCUSucIPCMFlag();
967    }
968  }
969  m_pcEntropyCoderIf->codeIPCMInfo ( pcCU, uiAbsPartIdx, numIPCM, firstIPCMFlag);
970
971}
972
973Void TEncEntropy::xEncodeTransform( TComDataCU* pcCU,UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt absTUPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, UInt uiInnerQuadIdx, UInt& uiYCbfFront3, UInt& uiUCbfFront3, UInt& uiVCbfFront3, Bool& bCodeDQP )
974{
975  const UInt uiSubdiv = pcCU->getTransformIdx( uiAbsPartIdx ) + pcCU->getDepth( uiAbsPartIdx ) > uiDepth;
976  const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
977  UInt cbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA    , uiTrIdx );
978  UInt cbfU = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
979  UInt cbfV = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
980
981  if(uiTrIdx==0)
982  {
983    m_bakAbsPartIdxCU = uiAbsPartIdx;
984  }
985  if( uiLog2TrafoSize == 2 )
986  {
987    UInt partNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
988    if( ( uiAbsPartIdx % partNum ) == 0 )
989    {
990      m_uiBakAbsPartIdx   = uiAbsPartIdx;
991      m_uiBakChromaOffset = offsetChroma;
992    }
993    else if( ( uiAbsPartIdx % partNum ) == (partNum - 1) )
994    {
995      cbfU = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
996      cbfV = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
997    }
998  }
999  {//CABAC
1000    if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
1001    {
1002      assert( uiSubdiv );
1003    }
1004    else if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER && (pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N) && uiDepth == pcCU->getDepth(uiAbsPartIdx) &&  (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) )
1005    {
1006      if ( uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
1007      {
1008        assert( uiSubdiv );
1009      }
1010      else
1011      {
1012        assert(!uiSubdiv );
1013      }
1014    }
1015    else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
1016    {
1017      assert( uiSubdiv );
1018    }
1019    else if( uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
1020    {
1021      assert( !uiSubdiv );
1022    }
1023    else if( uiLog2TrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
1024    {
1025      assert( !uiSubdiv );
1026    }
1027    else
1028    {
1029      assert( uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
1030      m_pcEntropyCoderIf->codeTransformSubdivFlag( uiSubdiv, uiDepth );
1031    }
1032  }
1033
1034  {
1035    if( uiLog2TrafoSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
1036    {
1037      const UInt uiTrDepthCurr = uiDepth - pcCU->getDepth( uiAbsPartIdx );
1038      const Bool bFirstCbfOfCU = uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() || uiTrDepthCurr == 0;
1039      if( bFirstCbfOfCU || uiLog2TrafoSize > 2 )
1040      {
1041        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr - 1 ) )
1042        {
1043          if ( uiInnerQuadIdx == 3 && uiUCbfFront3 == 0 && uiLog2TrafoSize < pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
1044          {
1045            uiUCbfFront3++;
1046          }
1047          else
1048          {
1049            m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr );
1050            uiUCbfFront3 += pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr );
1051          }
1052        }
1053        if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr - 1 ) )
1054        {
1055          if ( uiInnerQuadIdx == 3 && uiVCbfFront3 == 0 && uiLog2TrafoSize < pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize()  )
1056          {
1057            uiVCbfFront3++;
1058          }
1059          else
1060          {
1061            m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr );
1062            uiVCbfFront3 += pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr );
1063          }
1064        }
1065      }
1066      else if( uiLog2TrafoSize == 2 )
1067      {
1068        assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr - 1 ) );
1069        assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr - 1 ) );
1070       
1071        uiUCbfFront3 += pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr );
1072        uiVCbfFront3 += pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr );
1073      }
1074    }
1075   
1076    if( uiSubdiv )
1077    {
1078      UInt size;
1079      width  >>= 1;
1080      height >>= 1;
1081      size = width*height;
1082      uiTrIdx++;
1083      ++uiDepth;
1084      const UInt partNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
1085     
1086      UInt uiCurrentCbfY = 0;
1087      UInt uiCurrentCbfU = 0;
1088      UInt uiCurrentCbfV = 0;
1089     
1090      UInt nsAddr = 0;
1091      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, 0, uiDepth - pcCU->getDepth( uiAbsPartIdx ) );
1092      xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, 0, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );
1093
1094      uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
1095      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, 1, uiDepth - pcCU->getDepth( uiAbsPartIdx ) );
1096      xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, 1, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );
1097
1098      uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
1099      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, 2, uiDepth - pcCU->getDepth( uiAbsPartIdx ) );
1100      xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, 2, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );
1101
1102      uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
1103      nsAddr = pcCU->getNSAbsPartIdx( uiLog2TrafoSize-1, uiAbsPartIdx, absTUPartIdx, 3, uiDepth - pcCU->getDepth( uiAbsPartIdx ) );
1104      xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, nsAddr, uiDepth, width, height, uiTrIdx, 3, uiCurrentCbfY, uiCurrentCbfU, uiCurrentCbfV, bCodeDQP );     
1105     
1106      uiYCbfFront3 += uiCurrentCbfY;
1107      uiUCbfFront3 += uiCurrentCbfU;
1108      uiVCbfFront3 += uiCurrentCbfV;
1109    }
1110    else
1111    {
1112      {
1113        DTRACE_CABAC_VL( g_nSymbolCounter++ );
1114        DTRACE_CABAC_T( "\tTrIdx: abspart=" );
1115        DTRACE_CABAC_V( uiAbsPartIdx );
1116        DTRACE_CABAC_T( "\tdepth=" );
1117        DTRACE_CABAC_V( uiDepth );
1118        DTRACE_CABAC_T( "\ttrdepth=" );
1119        DTRACE_CABAC_V( pcCU->getTransformIdx( uiAbsPartIdx ) );
1120        DTRACE_CABAC_T( "\n" );
1121      }
1122      UInt uiLumaTrMode, uiChromaTrMode;
1123      pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx( uiAbsPartIdx ), uiLumaTrMode, uiChromaTrMode );
1124      if(pcCU->getPredictionMode( uiAbsPartIdx ) == MODE_INTER && pcCU->useNonSquarePU( uiAbsPartIdx ) )
1125      {
1126        pcCU->setNSQTIdxSubParts( uiLog2TrafoSize, uiAbsPartIdx, absTUPartIdx, uiLumaTrMode );
1127      }
1128      if( pcCU->getPredictionMode(uiAbsPartIdx) != MODE_INTRA && uiDepth == pcCU->getDepth( uiAbsPartIdx ) && !pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, 0 ) && !pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, 0 ) )
1129      {
1130        assert( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, 0 ) );
1131        //      printf( "saved one bin! " );
1132      }
1133      else
1134      {
1135        const UInt uiLog2CUSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()] + 2 - pcCU->getDepth( uiAbsPartIdx );
1136        if ( pcCU->getPredictionMode( uiAbsPartIdx ) != MODE_INTRA && uiInnerQuadIdx == 3 && uiYCbfFront3 == 0 && uiUCbfFront3 == 0 && uiVCbfFront3 == 0
1137            && ( uiLog2CUSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() + 1 || uiLog2TrafoSize < pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() ) )
1138        {     
1139          uiYCbfFront3++;
1140        }   
1141        else
1142        {
1143          m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA, uiLumaTrMode );
1144          uiYCbfFront3 += pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiLumaTrMode );
1145        }
1146      }
1147     
1148      if ( cbfY || cbfU || cbfV )
1149      {
1150        // dQP: only for LCU once
1151        if ( pcCU->getSlice()->getPPS()->getUseDQP() )
1152        {
1153          if ( bCodeDQP )
1154          {
1155            encodeQP( pcCU, m_bakAbsPartIdxCU );
1156            bCodeDQP = false;
1157          }
1158        }
1159      }
1160      if( cbfY )
1161      {
1162        Int trWidth = width;
1163        Int trHeight = height;
1164        pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
1165        m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffY()+offsetLuma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_LUMA );
1166      }
1167      if( uiLog2TrafoSize > 2 )
1168      {
1169        Int trWidth = width >> 1;
1170        Int trHeight = height >> 1;
1171        pcCU->getNSQTSize( uiTrIdx, uiAbsPartIdx, trWidth, trHeight );
1172        if( cbfU )
1173        {
1174          m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCb()+offsetChroma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
1175        }
1176        if( cbfV )
1177        {
1178          m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCr()+offsetChroma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
1179        }
1180      }
1181      else
1182      {
1183        UInt partNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
1184        if( ( uiAbsPartIdx % partNum ) == (partNum - 1) )
1185        {
1186          Int trWidth = width;
1187          Int trHeight = height;
1188          pcCU->getNSQTSize( uiTrIdx - 1, uiAbsPartIdx, trWidth, trHeight );
1189          if( cbfU )
1190          {
1191            m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCb()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
1192          }
1193          if( cbfV )
1194          {
1195            m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCr()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
1196          }
1197        }
1198      }
1199    }
1200  }
1201}
1202
1203
1204// Intra direction for Luma
1205Void TEncEntropy::encodeIntraDirModeLuma  ( TComDataCU* pcCU, UInt uiAbsPartIdx )
1206{
1207  m_pcEntropyCoderIf->codeIntraDirLumaAng( pcCU, uiAbsPartIdx );
1208}
1209
1210// Intra direction for Chroma
1211Void TEncEntropy::encodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1212{
1213  if( bRD )
1214  {
1215    uiAbsPartIdx = 0;
1216  }
1217 
1218  m_pcEntropyCoderIf->codeIntraDirChroma( pcCU, uiAbsPartIdx );
1219}
1220
1221Void TEncEntropy::encodePredInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1222{
1223  if( bRD )
1224  {
1225    uiAbsPartIdx = 0;
1226  }
1227
1228#if RWTH_SDC_DLT_B0036
1229  if( pcCU->getSDCFlag(uiAbsPartIdx) )
1230  {
1231    encodeSDCPredMode(pcCU, uiAbsPartIdx, bRD);
1232    return;
1233  }
1234#endif
1235
1236  PartSize eSize = pcCU->getPartitionSize( uiAbsPartIdx );
1237 
1238  if( pcCU->isIntra( uiAbsPartIdx ) )                                 // If it is Intra mode, encode intra prediction mode.
1239  {
1240    if( eSize == SIZE_NxN )                                         // if it is NxN size, encode 4 intra directions.
1241    {
1242      UInt uiPartOffset = ( pcCU->getPic()->getNumPartInCU() >> ( pcCU->getDepth(uiAbsPartIdx) << 1 ) ) >> 2;
1243      // if it is NxN size, this size might be the smallest partition size.
1244      encodeIntraDirModeLuma( pcCU, uiAbsPartIdx                  );
1245      encodeIntraDirModeLuma( pcCU, uiAbsPartIdx + uiPartOffset   );
1246      encodeIntraDirModeLuma( pcCU, uiAbsPartIdx + uiPartOffset*2 );
1247      encodeIntraDirModeLuma( pcCU, uiAbsPartIdx + uiPartOffset*3 );
1248      encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
1249    }
1250    else                                                              // if it is not NxN size, encode 1 intra directions
1251    {
1252      encodeIntraDirModeLuma  ( pcCU, uiAbsPartIdx );
1253      encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
1254    }
1255  }
1256  else                                                                // if it is Inter mode, encode motion vector and reference index
1257  {
1258    encodePUWise( pcCU, uiAbsPartIdx, bRD );
1259  }
1260}
1261
1262/** encode motion information for every PU block
1263 * \param pcCU
1264 * \param uiAbsPartIdx
1265 * \param bRD
1266 * \returns Void
1267 */
1268Void TEncEntropy::encodePUWise( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1269{
1270  if ( bRD )
1271  {
1272    uiAbsPartIdx = 0;
1273  }
1274 
1275  PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
1276  UInt uiNumPU = ( ePartSize == SIZE_2Nx2N ? 1 : ( ePartSize == SIZE_NxN ? 4 : 2 ) );
1277  UInt uiDepth = pcCU->getDepth( uiAbsPartIdx );
1278  UInt uiPUOffset = ( g_auiPUOffset[UInt( ePartSize )] << ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() - uiDepth ) << 1 ) ) >> 4;
1279
1280  for ( UInt uiPartIdx = 0, uiSubPartIdx = uiAbsPartIdx; uiPartIdx < uiNumPU; uiPartIdx++, uiSubPartIdx += uiPUOffset )
1281  {
1282    encodeMergeFlag( pcCU, uiSubPartIdx, uiPartIdx );
1283    if ( pcCU->getMergeFlag( uiSubPartIdx ) )
1284    {
1285      encodeMergeIndex( pcCU, uiSubPartIdx, uiPartIdx );
1286    }
1287    else
1288    {
1289      encodeInterDirPU( pcCU, uiSubPartIdx );
1290      for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
1291      {
1292        if ( pcCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
1293        {
1294          encodeRefFrmIdxPU ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
1295          encodeMvdPU       ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
1296          encodeMVPIdxPU    ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
1297        }
1298      }
1299    }
1300  }
1301
1302  return;
1303}
1304
1305Void TEncEntropy::encodeInterDirPU( TComDataCU* pcCU, UInt uiAbsPartIdx )
1306{
1307  if ( !pcCU->getSlice()->isInterB() )
1308  {
1309    return;
1310  }
1311
1312  m_pcEntropyCoderIf->codeInterDir( pcCU, uiAbsPartIdx );
1313  return;
1314}
1315
1316/** encode reference frame index for a PU block
1317 * \param pcCU
1318 * \param uiAbsPartIdx
1319 * \param eRefList
1320 * \returns Void
1321 */
1322Void TEncEntropy::encodeRefFrmIdxPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1323{
1324  assert( !pcCU->isIntra( uiAbsPartIdx ) );
1325
1326  if(pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_C)>0 && pcCU->getInterDir( uiAbsPartIdx ) != 3)
1327  {
1328    if ((eRefList== REF_PIC_LIST_1) || ( pcCU->getSlice()->getNumRefIdx( REF_PIC_LIST_C ) == 1 ) )
1329    {
1330      return;
1331    }
1332
1333    if ( pcCU->getSlice()->getNumRefIdx ( REF_PIC_LIST_C ) > 1 )
1334    {
1335      m_pcEntropyCoderIf->codeRefFrmIdx( pcCU, uiAbsPartIdx, RefPicList(pcCU->getInterDir( uiAbsPartIdx )-1) );
1336    }
1337
1338  }
1339  else
1340  {
1341    if ( ( pcCU->getSlice()->getNumRefIdx( eRefList ) == 1 ) )
1342    {
1343      return;
1344    }
1345
1346    if ( pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList ) )
1347    {
1348      m_pcEntropyCoderIf->codeRefFrmIdx( pcCU, uiAbsPartIdx, eRefList );
1349    }
1350  }
1351
1352  return;
1353}
1354
1355/** encode motion vector difference for a PU block
1356 * \param pcCU
1357 * \param uiAbsPartIdx
1358 * \param eRefList
1359 * \returns Void
1360 */
1361Void TEncEntropy::encodeMvdPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1362{
1363  assert( !pcCU->isIntra( uiAbsPartIdx ) );
1364
1365  if ( pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList ) )
1366  {
1367    m_pcEntropyCoderIf->codeMvd( pcCU, uiAbsPartIdx, eRefList );
1368  }
1369  return;
1370}
1371
1372Void TEncEntropy::encodeMVPIdxPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
1373{
1374  if ( (pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList )) && (pcCU->getAMVPMode(uiAbsPartIdx) == AM_EXPL) )
1375  {
1376#if H3D_IVMP
1377    const Int iNumCands = AMVP_MAX_NUM_CANDS + ( pcCU->getSlice()->getSPS()->getMultiviewMvPredMode() ? 1 : 0 );
1378    m_pcEntropyCoderIf->codeMVPIdx( pcCU, uiAbsPartIdx, eRefList, iNumCands );
1379#else
1380    m_pcEntropyCoderIf->codeMVPIdx( pcCU, uiAbsPartIdx, eRefList );
1381#endif
1382  }
1383
1384  return;
1385}
1386
1387Void TEncEntropy::encodeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
1388{
1389  m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, eType, uiTrDepth );
1390}
1391
1392Void TEncEntropy::encodeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
1393{
1394  m_pcEntropyCoderIf->codeTransformSubdivFlag( uiSymbol, uiCtx );
1395}
1396
1397Void TEncEntropy::encodeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
1398{
1399  m_pcEntropyCoderIf->codeQtRootCbf( pcCU, uiAbsPartIdx );
1400}
1401
1402// dQP
1403Void TEncEntropy::encodeQP( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1404{
1405  if( bRD )
1406  {
1407    uiAbsPartIdx = 0;
1408  }
1409 
1410  if ( pcCU->getSlice()->getPPS()->getUseDQP() )
1411  {
1412    m_pcEntropyCoderIf->codeDeltaQP( pcCU, uiAbsPartIdx );
1413  }
1414}
1415
1416
1417// texture
1418
1419/** encode coefficients
1420 * \param pcCU
1421 * \param uiAbsPartIdx
1422 * \param uiDepth
1423 * \param uiWidth
1424 * \param uiHeight
1425 */
1426Void TEncEntropy::encodeCoeff( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, Bool& bCodeDQP )
1427{
1428  UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
1429  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
1430  UInt uiChromaOffset = uiLumaOffset>>2;
1431 
1432  UInt uiLumaTrMode, uiChromaTrMode;
1433  pcCU->convertTransIdx( uiAbsPartIdx, pcCU->getTransformIdx(uiAbsPartIdx), uiLumaTrMode, uiChromaTrMode );
1434 
1435#if RWTH_SDC_DLT_B0036
1436  if( pcCU->getSDCFlag( uiAbsPartIdx ) )
1437  {
1438    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
1439    assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
1440    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
1441    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
1442    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
1443   
1444    encodeSDCResidualData(pcCU, uiAbsPartIdx);
1445    return;
1446  }
1447#endif
1448 
1449  if( pcCU->isIntra(uiAbsPartIdx) )
1450  {
1451    DTRACE_CABAC_VL( g_nSymbolCounter++ )
1452    DTRACE_CABAC_T( "\tdecodeTransformIdx()\tCUDepth=" )
1453    DTRACE_CABAC_V( uiDepth )
1454    DTRACE_CABAC_T( "\n" )
1455  }
1456  else
1457  {
1458    {
1459#if HHI_MPI
1460      if( !(pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N &&
1461            ( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 || uiDepth == pcCU->getTextureModeDepth( uiAbsPartIdx ) ) ) )
1462#else
1463      if( !(pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N ) )
1464#endif
1465      {
1466        m_pcEntropyCoderIf->codeQtRootCbf( pcCU, uiAbsPartIdx );
1467      }
1468      if ( !pcCU->getQtRootCbf( uiAbsPartIdx ) )
1469      {
1470#if 1 // MW Bug Fix
1471        pcCU->setCbfSubParts( 0, 0, 0, uiAbsPartIdx, uiDepth );
1472        pcCU->setTrIdxSubParts( 0 , uiAbsPartIdx, uiDepth );
1473#endif
1474        pcCU->setNSQTIdxSubParts( uiAbsPartIdx, uiDepth );
1475        return;
1476      }
1477    }
1478  }
1479 
1480#if FIX_MPI_B0065
1481  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER && pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getMergeIndex( uiAbsPartIdx ) == 0 && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N && pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1 )
1482  {
1483    TComDataCU *pcTextureCU = pcCU->getSlice()->getTexturePic()->getCU( pcCU->getAddr() );
1484    if( uiDepth == pcTextureCU->getDepth(uiAbsPartIdx))
1485    {
1486      PartSize partSize = pcTextureCU->getPartitionSize(uiAbsPartIdx);
1487      pcCU->setPartSizeSubParts( partSize, uiAbsPartIdx, uiDepth );
1488    }
1489    else
1490    {
1491      pcCU->setPartSizeSubParts( SIZE_NxN, uiAbsPartIdx, uiDepth );
1492    }
1493  }
1494#endif
1495
1496  UInt temp = 0;
1497  UInt temp1 = 0;
1498  UInt temp2 = 0;
1499  xEncodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, 0, temp, temp1, temp2, bCodeDQP );
1500
1501#if FIX_MPI_B0065
1502  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER && pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getMergeIndex( uiAbsPartIdx ) == 0 && pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N &&  pcCU->getTextureModeDepth( uiAbsPartIdx ) != -1 )
1503  {
1504    pcCU->setPartSizeSubParts( SIZE_2Nx2N, uiAbsPartIdx, uiDepth ); 
1505  }
1506#endif
1507}
1508
1509Void TEncEntropy::encodeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoeff, UInt uiAbsPartIdx, UInt uiTrWidth, UInt uiTrHeight, UInt uiDepth, TextType eType )
1510{ // This is for Transform unit processing. This may be used at mode selection stage for Inter.
1511  m_pcEntropyCoderIf->codeCoeffNxN( pcCU, pcCoeff, uiAbsPartIdx, uiTrWidth, uiTrHeight, uiDepth, eType );
1512}
1513
1514Void TEncEntropy::estimateBit (estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType)
1515{ 
1516  eTType = eTType == TEXT_LUMA ? TEXT_LUMA : TEXT_CHROMA;
1517 
1518  m_pcEntropyCoderIf->estBit ( pcEstBitsSbac, width, height, eTType );
1519}
1520
1521/** Encode SAO Offset
1522 * \param  saoLcuParam SAO LCU paramters
1523 */
1524Void TEncEntropy::encodeSaoOffset(SaoLcuParam* saoLcuParam)
1525{
1526  UInt uiSymbol;
1527  Int i;
1528
1529  uiSymbol = saoLcuParam->typeIdx + 1;
1530  m_pcEntropyCoderIf->codeSaoTypeIdx(uiSymbol);
1531  if (uiSymbol)
1532  {
1533    if( saoLcuParam->typeIdx == SAO_BO )
1534    {
1535      // Code Left Band Index
1536      uiSymbol = (UInt) (saoLcuParam->bandPosition);
1537      m_pcEntropyCoderIf->codeSaoUflc(uiSymbol);
1538      for( i=0; i< saoLcuParam->length; i++)
1539      {
1540        m_pcEntropyCoderIf->codeSaoSvlc(saoLcuParam->offset[i]);
1541      } 
1542    }
1543    else
1544      if( saoLcuParam->typeIdx < 4 )
1545      {
1546        m_pcEntropyCoderIf->codeSaoUvlc( saoLcuParam->offset[0]);
1547        m_pcEntropyCoderIf->codeSaoUvlc( saoLcuParam->offset[1]);
1548        m_pcEntropyCoderIf->codeSaoUvlc(-saoLcuParam->offset[2]);
1549        m_pcEntropyCoderIf->codeSaoUvlc(-saoLcuParam->offset[3]);
1550      }
1551  }
1552}
1553/** Encode SAO unit
1554* \param  rx
1555* \param  ry
1556* \param  iCompIdx
1557* \param  pSaoParam
1558* \param  bRepeatedRow
1559 */
1560Void TEncEntropy::encodeSaoUnit(Int rx, Int ry, Int compIdx, SAOParam* saoParam, Int repeatedRow )
1561{
1562  int addr, addrLeft; 
1563  int numCuInWidth  = saoParam->numCuInWidth;
1564  SaoLcuParam* saoOneLcu;
1565  Int runLeft;
1566
1567  addr      =  rx + ry*numCuInWidth;
1568  addrLeft  =  (addr%numCuInWidth == 0) ? -1 : addr - 1;
1569
1570  if (!repeatedRow)
1571  {
1572    saoOneLcu = &(saoParam->saoLcuParam[compIdx][addr]);   
1573    runLeft = (addrLeft>=0 ) ? saoParam->saoLcuParam[compIdx][addrLeft].run : -1;
1574    if (rx == 0 || runLeft==0)
1575    {
1576      if (ry == 0)
1577      {
1578        m_pcEntropyCoderIf->codeSaoRun(saoOneLcu->runDiff, numCuInWidth-rx-1); 
1579        saoOneLcu->mergeUpFlag = 0;
1580      }
1581      else 
1582      {
1583        m_pcEntropyCoderIf->codeSaoSvlc(saoOneLcu->runDiff); 
1584        m_pcEntropyCoderIf->codeSaoFlag(saoOneLcu->mergeUpFlag); 
1585      }
1586      if (!saoOneLcu->mergeUpFlag)
1587      {
1588        encodeSaoOffset(saoOneLcu);
1589      }
1590    }
1591  }
1592}
1593
1594/** Encode SAO unit interleaving
1595* \param  rx
1596* \param  ry
1597* \param  pSaoParam
1598* \param  pcCU
1599* \param  iCUAddrInSlice
1600* \param  iCUAddrUpInSlice
1601* \param  bLFCrossSliceBoundaryFlag
1602 */
1603Void TEncEntropy::encodeSaoUnitInterleaving(Int rx, Int ry, SAOParam* saoParam, TComDataCU* cu, Int cuAddrInSlice, Int cuAddrUpInSlice, Bool lfCrossSliceBoundaryFlag)
1604{
1605  Int addr = cu->getAddr();
1606  for (Int compIdx=0; compIdx<3; compIdx++)
1607  {
1608    if (saoParam->bSaoFlag[compIdx])
1609    {
1610      if (rx>0 && cuAddrInSlice!=0)
1611      {
1612      m_pcEntropyCoderIf->codeSaoMergeLeft(saoParam->saoLcuParam[compIdx][addr].mergeLeftFlag,compIdx);
1613      }
1614      else
1615      {
1616        saoParam->saoLcuParam[compIdx][addr].mergeLeftFlag = 0;
1617      }
1618      if (saoParam->saoLcuParam[compIdx][addr].mergeLeftFlag == 0)
1619      {
1620        if ( (ry > 0) && (cuAddrUpInSlice>0||lfCrossSliceBoundaryFlag))
1621        {
1622          m_pcEntropyCoderIf->codeSaoMergeUp(saoParam->saoLcuParam[compIdx][addr].mergeUpFlag);
1623        }
1624        else
1625        {
1626          saoParam->saoLcuParam[compIdx][addr].mergeUpFlag = 0;
1627        }
1628        if (!saoParam->saoLcuParam[compIdx][addr].mergeUpFlag)
1629        {
1630          encodeSaoOffset(&(saoParam->saoLcuParam[compIdx][addr]));
1631        }
1632      }
1633    }
1634  }
1635}
1636
1637/** Encode SAO parameter
1638* \param  pcAPS
1639 */
1640Void TEncEntropy::encodeSaoParam(TComAPS* aps)
1641{
1642  SaoLcuParam* psSaoOneLcu;
1643  int i,j,k, compIdx; 
1644  int numCuInWidth  ;
1645  int numCuInHeight ;
1646  Bool repeatedRow[3];
1647  Int addr;
1648  m_pcEntropyCoderIf->codeSaoFlag(aps->getSaoInterleavingFlag()); 
1649  if(!aps->getSaoInterleavingFlag())
1650  {
1651    m_pcEntropyCoderIf->codeSaoFlag(aps->getSaoEnabled()); 
1652    if (aps->getSaoEnabled())
1653    {
1654      SAOParam* pSaoParam = aps->getSaoParam();
1655      numCuInWidth  = pSaoParam->numCuInWidth;
1656      numCuInHeight = pSaoParam->numCuInHeight;
1657      m_pcEntropyCoderIf->codeSaoFlag(pSaoParam->bSaoFlag[1]); 
1658      m_pcEntropyCoderIf->codeSaoFlag(pSaoParam->bSaoFlag[2]); 
1659      m_pcEntropyCoderIf->codeSaoUvlc(numCuInWidth-1); 
1660      m_pcEntropyCoderIf->codeSaoUvlc(numCuInHeight-1); 
1661      for (compIdx=0;compIdx<3;compIdx++)
1662      {
1663        if (pSaoParam->bSaoFlag[compIdx])
1664        {
1665          m_pcEntropyCoderIf->codeSaoFlag(pSaoParam->oneUnitFlag[compIdx]); 
1666          if (pSaoParam->oneUnitFlag[compIdx])
1667          {
1668            psSaoOneLcu = &(pSaoParam->saoLcuParam[compIdx][0]);   
1669            encodeSaoOffset(psSaoOneLcu);
1670          }
1671        }
1672      }
1673
1674      for (j=0;j<numCuInHeight;j++)
1675      {
1676        for (compIdx=0; compIdx<3; compIdx++)
1677        {
1678          repeatedRow[compIdx] = true;
1679          for (k=0;k<numCuInWidth;k++)
1680          {
1681            addr       =  k + j*numCuInWidth;
1682            psSaoOneLcu = &(pSaoParam->saoLcuParam[compIdx][addr]);   
1683            if (!psSaoOneLcu->mergeUpFlag || psSaoOneLcu->runDiff)
1684            {
1685              repeatedRow[compIdx] = false;
1686              break;
1687            }
1688          }
1689        }
1690        for (i=0;i<numCuInWidth;i++)
1691        {
1692          for (compIdx=0; compIdx<3; compIdx++)
1693          {
1694            if (pSaoParam->bSaoFlag[compIdx]  && !pSaoParam->oneUnitFlag[compIdx]) 
1695            {
1696              if (j>0 && i==0) 
1697              {
1698                m_pcEntropyCoderIf->codeSaoFlag(repeatedRow[compIdx]); 
1699              }
1700              encodeSaoUnit (i,j, compIdx, pSaoParam, repeatedRow[compIdx]);
1701            }
1702          }
1703        }
1704      }
1705    }
1706  }
1707}
1708
1709Int TEncEntropy::countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize )
1710{
1711  Int count = 0;
1712 
1713  for ( Int i = 0; i < uiSize; i++ )
1714  {
1715    count += pcCoef[i] != 0;
1716  }
1717 
1718  return count;
1719}
1720
1721/** encode quantization matrix
1722 * \param scalingList quantization matrix information
1723 */
1724Void TEncEntropy::encodeScalingList( TComScalingList* scalingList )
1725{
1726  m_pcEntropyCoderIf->codeScalingList( scalingList );
1727}
1728
1729Void TEncEntropy::encodeDFParams(TComAPS* pcAPS)
1730{
1731  m_pcEntropyCoderIf->codeDFFlag(pcAPS->getLoopFilterDisable(), "loop_filter_disable");
1732
1733  if (!pcAPS->getLoopFilterDisable())
1734  {
1735    m_pcEntropyCoderIf->codeDFSvlc(pcAPS->getLoopFilterBetaOffset(), "beta_offset_div2");
1736    m_pcEntropyCoderIf->codeDFSvlc(pcAPS->getLoopFilterTcOffset(), "tc_offset_div2");
1737  }
1738}
1739
1740#if RWTH_SDC_DLT_B0036
1741Void TEncEntropy::encodeSDCPredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1742{
1743  assert( pcCU->getSlice()->getSPS()->isDepth() );
1744 
1745  if( bRD )
1746    uiAbsPartIdx = 0;
1747 
1748  m_pcEntropyCoderIf->codeSDCPredMode(pcCU, uiAbsPartIdx);
1749}
1750
1751Void TEncEntropy::encodeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1752{
1753  assert( pcCU->getSlice()->getSPS()->isDepth() );
1754 
1755  if( bRD )
1756    uiAbsPartIdx = 0;
1757 
1758  m_pcEntropyCoderIf->codeSDCFlag(pcCU, uiAbsPartIdx);
1759}
1760
1761Void TEncEntropy::encodeSDCResidualData( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
1762{
1763  assert( pcCU->getSlice()->getSPS()->isDepth() );
1764  assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
1765  assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
1766  assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
1767  assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
1768 
1769  if( bRD )
1770    uiAbsPartIdx = 0;
1771 
1772  // number of segments depends on prediction mode for INTRA
1773  UInt uiNumSegments = 2;
1774  UInt uiLumaPredMode = pcCU->getLumaIntraDir( uiAbsPartIdx );
1775  if( uiLumaPredMode == DC_IDX || uiLumaPredMode == PLANAR_IDX )
1776    uiNumSegments = 1;
1777 
1778  // encode residual data for each segment
1779  for( UInt uiSeg = 0; uiSeg < uiNumSegments; uiSeg++ )
1780    m_pcEntropyCoderIf->codeSDCResidualData(pcCU, uiAbsPartIdx, uiSeg);
1781}
1782#endif
1783
1784//! \}
Note: See TracBrowser for help on using the repository browser.