source: 3DVCSoftware/branches/HTM-11.1-dev0/source/Lib/TLibEncoder/TEncEntropy.cpp @ 967

Last change on this file since 967 was 967, checked in by tech, 10 years ago

Cleanup part 1.

  • Property svn:eol-style set to native
File size: 23.1 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     TEncEntropy.cpp
35    \brief    entropy encoder class
36*/
37
38#include "TEncEntropy.h"
39#include "TLibCommon/TypeDef.h"
40#include "TLibCommon/TComSampleAdaptiveOffset.h"
41
42//! \ingroup TLibEncoder
43//! \{
44
45Void TEncEntropy::setEntropyCoder ( TEncEntropyIf* e, TComSlice* pcSlice )
46{
47  m_pcEntropyCoderIf = e;
48  m_pcEntropyCoderIf->setSlice ( pcSlice );
49}
50
51Void TEncEntropy::encodeSliceHeader ( TComSlice* pcSlice )
52{
53  m_pcEntropyCoderIf->codeSliceHeader( pcSlice );
54  return;
55}
56
57Void  TEncEntropy::encodeTilesWPPEntryPoint( TComSlice* pSlice )
58{
59  m_pcEntropyCoderIf->codeTilesWPPEntryPoint( pSlice );
60}
61
62Void TEncEntropy::encodeTerminatingBit      ( UInt uiIsLast )
63{
64  m_pcEntropyCoderIf->codeTerminatingBit( uiIsLast );
65 
66  return;
67}
68
69Void TEncEntropy::encodeSliceFinish()
70{
71  m_pcEntropyCoderIf->codeSliceFinish();
72}
73
74Void TEncEntropy::encodePPS( TComPPS* pcPPS )
75{
76  m_pcEntropyCoderIf->codePPS( pcPPS );
77  return;
78}
79
80#if H_3D
81Void TEncEntropy::encodeSPS( TComSPS* pcSPS, Int viewIndex, Bool depthFlag )
82{
83  m_pcEntropyCoderIf->codeSPS( pcSPS, viewIndex, depthFlag );
84  return;
85}
86#else
87Void TEncEntropy::encodeSPS( TComSPS* pcSPS )
88{
89  m_pcEntropyCoderIf->codeSPS( pcSPS );
90  return;
91}
92#endif
93
94Void TEncEntropy::encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
95{
96  if( bRD )
97  {
98    uiAbsPartIdx = 0;
99  }
100  m_pcEntropyCoderIf->codeCUTransquantBypassFlag( pcCU, uiAbsPartIdx );
101}
102
103Void TEncEntropy::encodeVPS( TComVPS* pcVPS )
104{
105  m_pcEntropyCoderIf->codeVPS( pcVPS );
106  return;
107}
108
109Void TEncEntropy::encodeSkipFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
110{
111  if ( pcCU->getSlice()->isIntra() )
112  {
113    return;
114  }
115  if( bRD )
116  {
117    uiAbsPartIdx = 0;
118  }
119  m_pcEntropyCoderIf->codeSkipFlag( pcCU, uiAbsPartIdx );
120}
121
122/** encode merge flag
123 * \param pcCU
124 * \param uiAbsPartIdx
125 * \returns Void
126 */
127Void TEncEntropy::encodeMergeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx )
128{ 
129  // at least one merge candidate exists
130  m_pcEntropyCoderIf->codeMergeFlag( pcCU, uiAbsPartIdx );
131}
132
133/** encode merge index
134 * \param pcCU
135 * \param uiAbsPartIdx
136 * \param uiPUIdx
137 * \param bRD
138 * \returns Void
139 */
140Void TEncEntropy::encodeMergeIndex( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
141{
142  if( bRD )
143  {
144    uiAbsPartIdx = 0;
145    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
146  }
147  m_pcEntropyCoderIf->codeMergeIndex( pcCU, uiAbsPartIdx );
148}
149
150#if H_3D_IC
151Void TEncEntropy::encodeICFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
152{
153  if ( pcCU->isIntra( uiAbsPartIdx ) || ( pcCU->getSlice()->getViewIndex() == 0 ) || pcCU->getSlice()->getIsDepth() || pcCU->getARPW( uiAbsPartIdx ) > 0 )
154  {
155    return;
156  }
157
158  if( !pcCU->getSlice()->getApplyIC() )
159    return;
160
161  if( bRD )
162  {
163    uiAbsPartIdx = 0;
164  }
165#if MTK_LOW_LATENCY_IC_ENCODING_H0086
166  else
167  {
168    g_aICEnableCANDIDATE[pcCU->getSlice()->getDepth()]++;
169    if(pcCU->getICFlag(uiAbsPartIdx))
170    {
171      g_aICEnableNUM[pcCU->getSlice()->getDepth()]++;
172    }
173  }
174#endif
175  if( pcCU->isICFlagRequired( uiAbsPartIdx ) )
176    m_pcEntropyCoderIf->codeICFlag( pcCU, uiAbsPartIdx );
177}
178#endif
179
180#if H_3D_ARP
181Void TEncEntropy::encodeARPW( TComDataCU* pcCU, UInt uiAbsPartIdx )
182{
183  if( !pcCU->getSlice()->getARPStepNum() || pcCU->isIntra( uiAbsPartIdx ) ) 
184  {
185    return;
186  }
187
188  if ( pcCU->getPartitionSize(uiAbsPartIdx)!=SIZE_2Nx2N )
189  {
190    assert(pcCU->getARPW (uiAbsPartIdx) == 0);
191  }
192  else
193  {
194    m_pcEntropyCoderIf->codeARPW( pcCU, uiAbsPartIdx );
195  }
196}
197#endif
198
199/** encode prediction mode
200 * \param pcCU
201 * \param uiAbsPartIdx
202 * \param bRD
203 * \returns Void
204 */
205Void TEncEntropy::encodePredMode( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
206{
207  if( bRD )
208  {
209    uiAbsPartIdx = 0;
210  }
211  if ( pcCU->getSlice()->isIntra() )
212  {
213    return;
214  }
215
216  m_pcEntropyCoderIf->codePredMode( pcCU, uiAbsPartIdx );
217}
218
219// Split mode
220Void TEncEntropy::encodeSplitFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD )
221{
222  if( bRD )
223  {
224    uiAbsPartIdx = 0;
225  }
226  m_pcEntropyCoderIf->codeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
227}
228
229/** encode partition size
230 * \param pcCU
231 * \param uiAbsPartIdx
232 * \param uiDepth
233 * \param bRD
234 * \returns Void
235 */
236Void TEncEntropy::encodePartSize( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD )
237{
238  if( bRD )
239  {
240    uiAbsPartIdx = 0;
241  }
242 
243#if H_3D_DBBP
244  PartSize eVirtualPartSize = pcCU->getPartitionSize(uiAbsPartIdx);
245  if( pcCU->getDBBPFlag(uiAbsPartIdx) )
246  {
247    AOF( pcCU->getSlice()->getVPS()->getUseDBBP(pcCU->getSlice()->getLayerIdInVps()) );
248   
249    // temporarily change partition size for DBBP blocks
250    pcCU->setPartSizeSubParts(RWTH_DBBP_PACK_MODE, uiAbsPartIdx, uiDepth);
251  }
252#endif
253 
254  m_pcEntropyCoderIf->codePartSize( pcCU, uiAbsPartIdx, uiDepth );
255 
256#if H_3D_DBBP
257  if( pcCU->getSlice()->getVPS()->getUseDBBP(pcCU->getSlice()->getLayerIdInVps()) )
258  {
259    encodeDBBPFlag(pcCU, uiAbsPartIdx, bRD);
260   
261    if( pcCU->getDBBPFlag(uiAbsPartIdx) )
262    {
263      // restore virtual partition size for DBBP blocks
264      pcCU->setPartSizeSubParts(eVirtualPartSize, uiAbsPartIdx, uiDepth);
265    }
266  }
267#endif
268}
269
270/** Encode I_PCM information.
271 * \param pcCU pointer to CU
272 * \param uiAbsPartIdx CU index
273 * \param bRD flag indicating estimation or encoding
274 * \returns Void
275 */
276Void TEncEntropy::encodeIPCMInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
277{
278  if(!pcCU->getSlice()->getSPS()->getUsePCM()
279    || pcCU->getWidth(uiAbsPartIdx) > (1<<pcCU->getSlice()->getSPS()->getPCMLog2MaxSize())
280    || pcCU->getWidth(uiAbsPartIdx) < (1<<pcCU->getSlice()->getSPS()->getPCMLog2MinSize()))
281  {
282    return;
283  }
284#if !MTK_SDC_FLAG_FIX_H0095
285#if H_3D_DIM_SDC
286  if( pcCU->getSDCFlag(uiAbsPartIdx) )
287  {
288    return;
289  }
290#endif
291#endif
292 
293  if( bRD )
294  {
295    uiAbsPartIdx = 0;
296  }
297 
298  m_pcEntropyCoderIf->codeIPCMInfo ( pcCU, uiAbsPartIdx );
299}
300
301Void TEncEntropy::xEncodeTransform( TComDataCU* pcCU,UInt offsetLuma, UInt offsetChroma, UInt uiAbsPartIdx, UInt uiDepth, UInt width, UInt height, UInt uiTrIdx, Bool& bCodeDQP )
302{
303  const UInt uiSubdiv = pcCU->getTransformIdx( uiAbsPartIdx ) + pcCU->getDepth( uiAbsPartIdx ) > uiDepth;
304  const UInt uiLog2TrafoSize = g_aucConvertToBit[pcCU->getSlice()->getSPS()->getMaxCUWidth()]+2 - uiDepth;
305  UInt cbfY = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA    , uiTrIdx );
306  UInt cbfU = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
307  UInt cbfV = pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
308
309  if(uiTrIdx==0)
310  {
311    m_bakAbsPartIdxCU = uiAbsPartIdx;
312  }
313  if( uiLog2TrafoSize == 2 )
314  {
315    UInt partNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
316    if( ( uiAbsPartIdx % partNum ) == 0 )
317    {
318      m_uiBakAbsPartIdx   = uiAbsPartIdx;
319      m_uiBakChromaOffset = offsetChroma;
320    }
321    else if( ( uiAbsPartIdx % partNum ) == (partNum - 1) )
322    {
323      cbfU = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_U, uiTrIdx );
324      cbfV = pcCU->getCbf( m_uiBakAbsPartIdx, TEXT_CHROMA_V, uiTrIdx );
325    }
326  }
327 
328  if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTRA && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_NxN && uiDepth == pcCU->getDepth(uiAbsPartIdx) )
329  {
330    assert( uiSubdiv );
331  }
332  else if( pcCU->getPredictionMode(uiAbsPartIdx) == MODE_INTER && (pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N) && uiDepth == pcCU->getDepth(uiAbsPartIdx) &&  (pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) )
333  {
334    if ( uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
335    {
336      assert( uiSubdiv );
337    }
338    else
339    {
340      assert(!uiSubdiv );
341    }
342  }
343  else if( uiLog2TrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
344  {
345    assert( uiSubdiv );
346  }
347  else if( uiLog2TrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
348  {
349    assert( !uiSubdiv );
350  }
351  else if( uiLog2TrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
352  {
353    assert( !uiSubdiv );
354  }
355  else
356  {
357    assert( uiLog2TrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
358    m_pcEntropyCoderIf->codeTransformSubdivFlag( uiSubdiv, 5 - uiLog2TrafoSize );
359  }
360
361  const UInt uiTrDepthCurr = uiDepth - pcCU->getDepth( uiAbsPartIdx );
362  const Bool bFirstCbfOfCU = uiTrDepthCurr == 0;
363  if( bFirstCbfOfCU || uiLog2TrafoSize > 2 )
364  {
365    if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr - 1 ) )
366    {
367      m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr );
368    }
369    if( bFirstCbfOfCU || pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr - 1 ) )
370    {
371      m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr );
372    }
373  }
374  else if( uiLog2TrafoSize == 2 )
375  {
376    assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, uiTrDepthCurr - 1 ) );
377    assert( pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr ) == pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, uiTrDepthCurr - 1 ) );
378  }
379 
380  if( uiSubdiv )
381  {
382    UInt size;
383    width  >>= 1;
384    height >>= 1;
385    size = width*height;
386    uiTrIdx++;
387    ++uiDepth;
388    const UInt partNum = pcCU->getPic()->getNumPartInCU() >> (uiDepth << 1);
389   
390    xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP );
391
392    uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
393    xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP );
394
395    uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
396    xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP );
397
398    uiAbsPartIdx += partNum;  offsetLuma += size;  offsetChroma += (size>>2);
399    xEncodeTransform( pcCU, offsetLuma, offsetChroma, uiAbsPartIdx, uiDepth, width, height, uiTrIdx, bCodeDQP );
400  }
401  else
402  {
403#if !H_MV_ENC_DEC_TRAC
404    {
405      DTRACE_CABAC_VL( g_nSymbolCounter++ );
406      DTRACE_CABAC_T( "\tTrIdx: abspart=" );
407      DTRACE_CABAC_V( uiAbsPartIdx );
408      DTRACE_CABAC_T( "\tdepth=" );
409      DTRACE_CABAC_V( uiDepth );
410      DTRACE_CABAC_T( "\ttrdepth=" );
411      DTRACE_CABAC_V( pcCU->getTransformIdx( uiAbsPartIdx ) );
412      DTRACE_CABAC_T( "\n" );
413    }
414#endif
415   
416    if( pcCU->getPredictionMode(uiAbsPartIdx) != MODE_INTRA && uiDepth == pcCU->getDepth( uiAbsPartIdx ) && !pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_U, 0 ) && !pcCU->getCbf( uiAbsPartIdx, TEXT_CHROMA_V, 0 ) )
417    {
418      assert( pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, 0 ) );
419      //      printf( "saved one bin! " );
420    }
421    else
422    {
423      m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, TEXT_LUMA, pcCU->getTransformIdx( uiAbsPartIdx ) );
424    }
425
426
427    if ( cbfY || cbfU || cbfV )
428    {
429      // dQP: only for LCU once
430      if ( pcCU->getSlice()->getPPS()->getUseDQP() )
431      {
432        if ( bCodeDQP )
433        {
434          encodeQP( pcCU, m_bakAbsPartIdxCU );
435          bCodeDQP = false;
436        }
437      }
438    }
439    if( cbfY )
440    {
441      Int trWidth = width;
442      Int trHeight = height;
443      m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffY()+offsetLuma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_LUMA );
444    }
445    if( uiLog2TrafoSize > 2 )
446    {
447      Int trWidth = width >> 1;
448      Int trHeight = height >> 1;
449      if( cbfU )
450      {
451        m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCb()+offsetChroma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
452      }
453      if( cbfV )
454      {
455        m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCr()+offsetChroma), uiAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
456      }
457    }
458    else
459    {
460      UInt partNum = pcCU->getPic()->getNumPartInCU() >> ( ( uiDepth - 1 ) << 1 );
461      if( ( uiAbsPartIdx % partNum ) == (partNum - 1) )
462      {
463        Int trWidth = width;
464        Int trHeight = height;
465        if( cbfU )
466        {
467          m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCb()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_U );
468        }
469        if( cbfV )
470        {
471          m_pcEntropyCoderIf->codeCoeffNxN( pcCU, (pcCU->getCoeffCr()+m_uiBakChromaOffset), m_uiBakAbsPartIdx, trWidth, trHeight, uiDepth, TEXT_CHROMA_V );
472        }
473      }
474    }
475  }
476}
477
478// Intra direction for Luma
479Void TEncEntropy::encodeIntraDirModeLuma  ( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiplePU )
480{
481  m_pcEntropyCoderIf->codeIntraDirLumaAng( pcCU, absPartIdx , isMultiplePU);
482}
483
484// Intra direction for Chroma
485Void TEncEntropy::encodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
486{
487  if( bRD )
488  {
489    uiAbsPartIdx = 0;
490  }
491 
492  m_pcEntropyCoderIf->codeIntraDirChroma( pcCU, uiAbsPartIdx );
493}
494
495Void TEncEntropy::encodePredInfo( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
496{
497  if( bRD )
498  {
499    uiAbsPartIdx = 0;
500  }
501  if( pcCU->isIntra( uiAbsPartIdx ) )                                 // If it is Intra mode, encode intra prediction mode.
502  {
503    encodeIntraDirModeLuma  ( pcCU, uiAbsPartIdx,true );
504#if H_3D_DIM_SDC
505    if(!pcCU->getSDCFlag(uiAbsPartIdx))
506#endif
507    encodeIntraDirModeChroma( pcCU, uiAbsPartIdx, bRD );
508  }
509  else                                                                // if it is Inter mode, encode motion vector and reference index
510  {
511    encodePUWise( pcCU, uiAbsPartIdx, bRD );
512  }
513}
514
515/** encode motion information for every PU block
516 * \param pcCU
517 * \param uiAbsPartIdx
518 * \param bRD
519 * \returns Void
520 */
521Void TEncEntropy::encodePUWise( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
522{
523  if ( bRD )
524  {
525    uiAbsPartIdx = 0;
526  }
527 
528  PartSize ePartSize = pcCU->getPartitionSize( uiAbsPartIdx );
529  UInt uiNumPU = ( ePartSize == SIZE_2Nx2N ? 1 : ( ePartSize == SIZE_NxN ? 4 : 2 ) );
530  UInt uiDepth = pcCU->getDepth( uiAbsPartIdx );
531  UInt uiPUOffset = ( g_auiPUOffset[UInt( ePartSize )] << ( ( pcCU->getSlice()->getSPS()->getMaxCUDepth() - uiDepth ) << 1 ) ) >> 4;
532
533  for ( UInt uiPartIdx = 0, uiSubPartIdx = uiAbsPartIdx; uiPartIdx < uiNumPU; uiPartIdx++, uiSubPartIdx += uiPUOffset )
534  {
535#if H_MV_ENC_DEC_TRAC
536    DTRACE_PU_S("=========== prediction_unit ===========\n")
537       //Todo:
538      //DTRACE_PU("x0", uiLPelX)
539      //DTRACE_PU("x1", uiTPelY)
540#endif
541    encodeMergeFlag( pcCU, uiSubPartIdx );
542    if ( pcCU->getMergeFlag( uiSubPartIdx ) )
543    {
544      encodeMergeIndex( pcCU, uiSubPartIdx );
545    }
546    else
547    {
548      encodeInterDirPU( pcCU, uiSubPartIdx );
549      for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
550      {
551        if ( pcCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
552        {
553          encodeRefFrmIdxPU ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
554          encodeMvdPU       ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
555          encodeMVPIdxPU    ( pcCU, uiSubPartIdx, RefPicList( uiRefListIdx ) );
556        }
557      }
558    }
559  }
560
561  return;
562}
563
564Void TEncEntropy::encodeInterDirPU( TComDataCU* pcCU, UInt uiAbsPartIdx )
565{
566  if ( !pcCU->getSlice()->isInterB() )
567  {
568    return;
569  }
570
571  m_pcEntropyCoderIf->codeInterDir( pcCU, uiAbsPartIdx );
572  return;
573}
574
575/** encode reference frame index for a PU block
576 * \param pcCU
577 * \param uiAbsPartIdx
578 * \param eRefList
579 * \returns Void
580 */
581Void TEncEntropy::encodeRefFrmIdxPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
582{
583  assert( !pcCU->isIntra( uiAbsPartIdx ) );
584  {
585    if ( ( pcCU->getSlice()->getNumRefIdx( eRefList ) == 1 ) )
586    {
587      return;
588    }
589
590    if ( pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList ) )
591    {
592      m_pcEntropyCoderIf->codeRefFrmIdx( pcCU, uiAbsPartIdx, eRefList );
593    }
594  }
595
596  return;
597}
598
599/** encode motion vector difference for a PU block
600 * \param pcCU
601 * \param uiAbsPartIdx
602 * \param eRefList
603 * \returns Void
604 */
605Void TEncEntropy::encodeMvdPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
606{
607  assert( !pcCU->isIntra( uiAbsPartIdx ) );
608
609  if ( pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList ) )
610  {
611    m_pcEntropyCoderIf->codeMvd( pcCU, uiAbsPartIdx, eRefList );
612  }
613  return;
614}
615
616Void TEncEntropy::encodeMVPIdxPU( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )
617{
618  if ( (pcCU->getInterDir( uiAbsPartIdx ) & ( 1 << eRefList )) )
619  {
620    m_pcEntropyCoderIf->codeMVPIdx( pcCU, uiAbsPartIdx, eRefList );
621  }
622
623  return;
624}
625
626Void TEncEntropy::encodeQtCbf( TComDataCU* pcCU, UInt uiAbsPartIdx, TextType eType, UInt uiTrDepth )
627{
628  m_pcEntropyCoderIf->codeQtCbf( pcCU, uiAbsPartIdx, eType, uiTrDepth );
629}
630
631Void TEncEntropy::encodeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx )
632{
633  m_pcEntropyCoderIf->codeTransformSubdivFlag( uiSymbol, uiCtx );
634}
635
636Void TEncEntropy::encodeQtRootCbf( TComDataCU* pcCU, UInt uiAbsPartIdx )
637{
638  m_pcEntropyCoderIf->codeQtRootCbf( pcCU, uiAbsPartIdx );
639}
640
641Void TEncEntropy::encodeQtCbfZero( TComDataCU* pcCU, TextType eType, UInt uiTrDepth )
642{
643  m_pcEntropyCoderIf->codeQtCbfZero( pcCU, eType, uiTrDepth );
644}
645Void TEncEntropy::encodeQtRootCbfZero( TComDataCU* pcCU )
646{
647  m_pcEntropyCoderIf->codeQtRootCbfZero( pcCU );
648}
649
650// dQP
651Void TEncEntropy::encodeQP( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
652{
653  if( bRD )
654  {
655    uiAbsPartIdx = 0;
656  }
657 
658  if ( pcCU->getSlice()->getPPS()->getUseDQP() )
659  {
660    m_pcEntropyCoderIf->codeDeltaQP( pcCU, uiAbsPartIdx );
661  }
662}
663
664
665// texture
666/** encode coefficients
667 * \param pcCU
668 * \param uiAbsPartIdx
669 * \param uiDepth
670 * \param uiWidth
671 * \param uiHeight
672 */
673Void TEncEntropy::encodeCoeff( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, Bool& bCodeDQP )
674{
675  UInt uiMinCoeffSize = pcCU->getPic()->getMinCUWidth()*pcCU->getPic()->getMinCUHeight();
676  UInt uiLumaOffset   = uiMinCoeffSize*uiAbsPartIdx;
677  UInt uiChromaOffset = uiLumaOffset>>2;
678#if H_3D_DIM_SDC
679  if( pcCU->getSDCFlag( uiAbsPartIdx ) && pcCU->isIntra( uiAbsPartIdx ) )
680  {
681    assert( pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N );
682    assert( pcCU->getTransformIdx(uiAbsPartIdx) == 0 );
683    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_LUMA) == 1 );
684    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_U) == 1 );
685    assert( pcCU->getCbf(uiAbsPartIdx, TEXT_CHROMA_V) == 1 );
686  }
687
688  if( pcCU->getSDCFlag( uiAbsPartIdx ) && !pcCU->isIntra( uiAbsPartIdx ) )
689  {
690    assert( !pcCU->isSkipped( uiAbsPartIdx ) );
691    assert( !pcCU->isIntra( uiAbsPartIdx) );
692    assert( pcCU->getSlice()->getIsDepth() );
693  }
694
695  if( pcCU->getSlice()->getIsDepth() && ( pcCU->getSDCFlag( uiAbsPartIdx ) || pcCU->isIntra( uiAbsPartIdx ) ) )
696  {
697    Int iPartNum = ( pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_NxN ) ? 4 : 1;
698    UInt uiPartOffset = ( pcCU->getPic()->getNumPartInCU() >> ( pcCU->getDepth( uiAbsPartIdx ) << 1 ) ) >> 2;
699   
700    if( !pcCU->getSDCFlag( uiAbsPartIdx ) )
701    {
702      for( Int iPart = 0; iPart < iPartNum; iPart++ )
703      {
704        if( getDimType( pcCU->getLumaIntraDir( uiAbsPartIdx + uiPartOffset*iPart ) ) < DIM_NUM_TYPE ) 
705        {
706          m_pcEntropyCoderIf->codeDeltaDC( pcCU, uiAbsPartIdx + uiPartOffset*iPart );
707        }
708      }
709    }
710    else
711    {
712      m_pcEntropyCoderIf->codeDeltaDC( pcCU, uiAbsPartIdx );
713      return;
714    }
715  }
716#endif
717
718  if( pcCU->isIntra(uiAbsPartIdx) )
719  {
720#if !H_MV
721    DTRACE_CABAC_VL( g_nSymbolCounter++ )
722    DTRACE_CABAC_T( "\tdecodeTransformIdx()\tCUDepth=" )
723    DTRACE_CABAC_V( uiDepth )
724    DTRACE_CABAC_T( "\n" )
725#endif
726  }
727  else
728  {
729    if( !(pcCU->getMergeFlag( uiAbsPartIdx ) && pcCU->getPartitionSize(uiAbsPartIdx) == SIZE_2Nx2N ) )
730    {
731      m_pcEntropyCoderIf->codeQtRootCbf( pcCU, uiAbsPartIdx );
732    }
733    if ( !pcCU->getQtRootCbf( uiAbsPartIdx ) )
734    {
735      return;
736    }
737  }
738 
739  xEncodeTransform( pcCU, uiLumaOffset, uiChromaOffset, uiAbsPartIdx, uiDepth, uiWidth, uiHeight, 0, bCodeDQP);
740}
741
742Void TEncEntropy::encodeCoeffNxN( TComDataCU* pcCU, TCoeff* pcCoeff, UInt uiAbsPartIdx, UInt uiTrWidth, UInt uiTrHeight, UInt uiDepth, TextType eType )
743{
744  // This is for Transform unit processing. This may be used at mode selection stage for Inter.
745  m_pcEntropyCoderIf->codeCoeffNxN( pcCU, pcCoeff, uiAbsPartIdx, uiTrWidth, uiTrHeight, uiDepth, eType );
746}
747
748Void TEncEntropy::estimateBit (estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, TextType eTType)
749{ 
750  eTType = eTType == TEXT_LUMA ? TEXT_LUMA : TEXT_CHROMA;
751 
752  m_pcEntropyCoderIf->estBit ( pcEstBitsSbac, width, height, eTType );
753}
754
755Int TEncEntropy::countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize )
756{
757  Int count = 0;
758 
759  for ( Int i = 0; i < uiSize; i++ )
760  {
761    count += pcCoef[i] != 0;
762  }
763 
764  return count;
765}
766
767/** encode quantization matrix
768 * \param scalingList quantization matrix information
769 */
770Void TEncEntropy::encodeScalingList( TComScalingList* scalingList )
771{
772  m_pcEntropyCoderIf->codeScalingList( scalingList );
773}
774
775#if H_3D_INTER_SDC
776Void TEncEntropy::encodeDeltaDC  ( TComDataCU* pcCU, UInt absPartIdx )
777{
778  m_pcEntropyCoderIf->codeDeltaDC( pcCU, absPartIdx );
779}
780
781Void TEncEntropy::encodeSDCFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
782{
783  if( ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->getSlice()->getVPS()->getInterSDCFlag( pcCU->getSlice()->getLayerIdInVps() ) ) || 
784    ( pcCU->isIntra( uiAbsPartIdx ) && !pcCU->getSlice()->getVPS()->getVpsDepthModesFlag( pcCU->getSlice()->getLayerIdInVps() ) ) )
785  {
786    return;
787  }
788
789  if( !pcCU->getSlice()->getIsDepth() || pcCU->getPartitionSize( uiAbsPartIdx ) != SIZE_2Nx2N || pcCU->isSkipped( uiAbsPartIdx ) )
790  {
791    return;
792  }
793
794  assert( pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N || ( !pcCU->isIntra( uiAbsPartIdx ) && !pcCU->isSkipped( uiAbsPartIdx ) ) );
795
796  if( bRD )
797  {
798    uiAbsPartIdx = 0;
799  }
800
801  m_pcEntropyCoderIf->codeSDCFlag( pcCU, uiAbsPartIdx );
802}
803
804#endif
805#if H_3D_DBBP
806Void TEncEntropy::encodeDBBPFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD )
807{
808  if( bRD )
809  {
810    uiAbsPartIdx = 0;
811  }
812  m_pcEntropyCoderIf->codeDBBPFlag( pcCU, uiAbsPartIdx );
813}
814#endif
815//! \}
Note: See TracBrowser for help on using the repository browser.