source: 3DVCSoftware/trunk/source/Lib/TLibEncoder/TEncSampleAdaptiveOffset.cpp

Last change on this file was 1413, checked in by tech, 6 years ago

Merged HTM-16.2-dev@1412

File size: 45.9 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2017, 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/**
35 \file     TEncSampleAdaptiveOffset.cpp
36 \brief       estimation part of sample adaptive offset class
37 */
38#include "TEncSampleAdaptiveOffset.h"
39#include <string.h>
40#include <stdlib.h>
41#include <stdio.h>
42#include <math.h>
43
44//! \ingroup TLibEncoder
45//! \{
46
47
48//! rounding with IBDI
49inline Double xRoundIbdi2(Int bitDepth, Double x)
50{
51  return ((x)>0) ? (Int)(((Int)(x)+(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))) : ((Int)(((Int)(x)-(1<<(bitDepth-8-1)))/(1<<(bitDepth-8))));
52}
53
54inline Double xRoundIbdi(Int bitDepth, Double x)
55{
56  return (bitDepth > 8 ? xRoundIbdi2(bitDepth, (x)) : ((x)>=0 ? ((Int)((x)+0.5)) : ((Int)((x)-0.5)))) ;
57}
58
59
60TEncSampleAdaptiveOffset::TEncSampleAdaptiveOffset()
61{
62  m_pppcRDSbacCoder = NULL;
63  m_pcRDGoOnSbacCoder = NULL;
64  m_pppcBinCoderCABAC = NULL;
65  m_statData = NULL;
66  m_preDBFstatData = NULL;
67}
68
69TEncSampleAdaptiveOffset::~TEncSampleAdaptiveOffset()
70{
71  destroyEncData();
72}
73
74Void TEncSampleAdaptiveOffset::createEncData(Bool isPreDBFSamplesUsed)
75{
76
77  //cabac coder for RDO
78  m_pppcRDSbacCoder = new TEncSbac* [NUM_SAO_CABACSTATE_LABELS];
79#if FAST_BIT_EST
80  m_pppcBinCoderCABAC = new TEncBinCABACCounter* [NUM_SAO_CABACSTATE_LABELS];
81#else
82  m_pppcBinCoderCABAC = new TEncBinCABAC* [NUM_SAO_CABACSTATE_LABELS];
83#endif
84
85  for(Int cs=0; cs < NUM_SAO_CABACSTATE_LABELS; cs++)
86  {
87    m_pppcRDSbacCoder[cs] = new TEncSbac;
88#if FAST_BIT_EST
89    m_pppcBinCoderCABAC[cs] = new TEncBinCABACCounter;
90#else
91    m_pppcBinCoderCABAC[cs] = new TEncBinCABAC;
92#endif
93    m_pppcRDSbacCoder   [cs]->init( m_pppcBinCoderCABAC [cs] );
94  }
95
96
97  //statistics
98  m_statData = new SAOStatData**[m_numCTUsPic];
99  for(Int i=0; i< m_numCTUsPic; i++)
100  {
101    m_statData[i] = new SAOStatData*[MAX_NUM_COMPONENT];
102    for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
103    {
104      m_statData[i][compIdx] = new SAOStatData[NUM_SAO_NEW_TYPES];
105    }
106  }
107  if(isPreDBFSamplesUsed)
108  {
109    m_preDBFstatData = new SAOStatData**[m_numCTUsPic];
110    for(Int i=0; i< m_numCTUsPic; i++)
111    {
112      m_preDBFstatData[i] = new SAOStatData*[MAX_NUM_COMPONENT];
113      for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
114      {
115        m_preDBFstatData[i][compIdx] = new SAOStatData[NUM_SAO_NEW_TYPES];
116      }
117    }
118
119  }
120
121  ::memset(m_saoDisabledRate, 0, sizeof(m_saoDisabledRate));
122  m_lastIRAPPoc = MAX_INT;
123
124  for(Int typeIdc=0; typeIdc < NUM_SAO_NEW_TYPES; typeIdc++)
125  {
126    m_skipLinesR[COMPONENT_Y ][typeIdc]= 5;
127    m_skipLinesR[COMPONENT_Cb][typeIdc]= m_skipLinesR[COMPONENT_Cr][typeIdc]= 3;
128
129    m_skipLinesB[COMPONENT_Y ][typeIdc]= 4;
130    m_skipLinesB[COMPONENT_Cb][typeIdc]= m_skipLinesB[COMPONENT_Cr][typeIdc]= 2;
131
132    if(isPreDBFSamplesUsed)
133    {
134      switch(typeIdc)
135      {
136      case SAO_TYPE_EO_0:
137        {
138          m_skipLinesR[COMPONENT_Y ][typeIdc]= 5;
139          m_skipLinesR[COMPONENT_Cb][typeIdc]= m_skipLinesR[COMPONENT_Cr][typeIdc]= 3;
140
141          m_skipLinesB[COMPONENT_Y ][typeIdc]= 3;
142          m_skipLinesB[COMPONENT_Cb][typeIdc]= m_skipLinesB[COMPONENT_Cr][typeIdc]= 1;
143        }
144        break;
145      case SAO_TYPE_EO_90:
146        {
147          m_skipLinesR[COMPONENT_Y ][typeIdc]= 4;
148          m_skipLinesR[COMPONENT_Cb][typeIdc]= m_skipLinesR[COMPONENT_Cr][typeIdc]= 2;
149
150          m_skipLinesB[COMPONENT_Y ][typeIdc]= 4;
151          m_skipLinesB[COMPONENT_Cb][typeIdc]= m_skipLinesB[COMPONENT_Cr][typeIdc]= 2;
152        }
153        break;
154      case SAO_TYPE_EO_135:
155      case SAO_TYPE_EO_45:
156        {
157          m_skipLinesR[COMPONENT_Y ][typeIdc]= 5;
158          m_skipLinesR[COMPONENT_Cb][typeIdc]= m_skipLinesR[COMPONENT_Cr][typeIdc]= 3;
159
160          m_skipLinesB[COMPONENT_Y ][typeIdc]= 4;
161          m_skipLinesB[COMPONENT_Cb][typeIdc]= m_skipLinesB[COMPONENT_Cr][typeIdc]= 2;
162        }
163        break;
164      case SAO_TYPE_BO:
165        {
166          m_skipLinesR[COMPONENT_Y ][typeIdc]= 4;
167          m_skipLinesR[COMPONENT_Cb][typeIdc]= m_skipLinesR[COMPONENT_Cr][typeIdc]= 2;
168
169          m_skipLinesB[COMPONENT_Y ][typeIdc]= 3;
170          m_skipLinesB[COMPONENT_Cb][typeIdc]= m_skipLinesB[COMPONENT_Cr][typeIdc]= 1;
171        }
172        break;
173      default:
174        {
175          printf("Not a supported type");
176          assert(0);
177          exit(-1);
178        }
179      }
180    }
181  }
182
183}
184
185Void TEncSampleAdaptiveOffset::destroyEncData()
186{
187  if(m_pppcRDSbacCoder != NULL)
188  {
189    for (Int cs = 0; cs < NUM_SAO_CABACSTATE_LABELS; cs ++ )
190    {
191      delete m_pppcRDSbacCoder[cs];
192    }
193    delete[] m_pppcRDSbacCoder; m_pppcRDSbacCoder = NULL;
194  }
195
196  if(m_pppcBinCoderCABAC != NULL)
197  {
198    for (Int cs = 0; cs < NUM_SAO_CABACSTATE_LABELS; cs ++ )
199    {
200      delete m_pppcBinCoderCABAC[cs];
201    }
202    delete[] m_pppcBinCoderCABAC; m_pppcBinCoderCABAC = NULL;
203  }
204
205  if(m_statData != NULL)
206  {
207    for(Int i=0; i< m_numCTUsPic; i++)
208    {
209      for(Int compIdx=0; compIdx< MAX_NUM_COMPONENT; compIdx++)
210      {
211        delete[] m_statData[i][compIdx];
212      }
213      delete[] m_statData[i];
214    }
215    delete[] m_statData; m_statData = NULL;
216  }
217  if(m_preDBFstatData != NULL)
218  {
219    for(Int i=0; i< m_numCTUsPic; i++)
220    {
221      for(Int compIdx=0; compIdx< MAX_NUM_COMPONENT; compIdx++)
222      {
223        delete[] m_preDBFstatData[i][compIdx];
224      }
225      delete[] m_preDBFstatData[i];
226    }
227    delete[] m_preDBFstatData; m_preDBFstatData = NULL;
228  }
229}
230
231Void TEncSampleAdaptiveOffset::initRDOCabacCoder(TEncSbac* pcRDGoOnSbacCoder, TComSlice* pcSlice)
232{
233  m_pcRDGoOnSbacCoder = pcRDGoOnSbacCoder;
234  m_pcRDGoOnSbacCoder->resetEntropy(pcSlice);
235  m_pcRDGoOnSbacCoder->resetBits();
236
237  m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[SAO_CABACSTATE_PIC_INIT]);
238}
239
240
241
242Void TEncSampleAdaptiveOffset::SAOProcess(TComPic* pPic, Bool* sliceEnabled, const Double *lambdas, const Bool bTestSAODisableAtPictureLevel, const Double saoEncodingRate, const Double saoEncodingRateChroma, const Bool isPreDBFSamplesUsed, const Bool bResetStateAfterIRAP )
243{
244  TComPicYuv* orgYuv= pPic->getPicYuvOrg();
245  TComPicYuv* resYuv= pPic->getPicYuvRec();
246  memcpy(m_lambda, lambdas, sizeof(m_lambda));
247  TComPicYuv* srcYuv = m_tempPicYuv;
248  resYuv->copyToPic(srcYuv);
249  srcYuv->setBorderExtension(false);
250  srcYuv->extendPicBorder();
251
252  //collect statistics
253  getStatistics(m_statData, orgYuv, srcYuv, pPic);
254  if(isPreDBFSamplesUsed)
255  {
256    addPreDBFStatistics(m_statData);
257  }
258  //slice on/off
259  decidePicParams(sliceEnabled, pPic, saoEncodingRate, saoEncodingRateChroma, bResetStateAfterIRAP);
260
261  //block on/off
262  SAOBlkParam* reconParams = new SAOBlkParam[m_numCTUsPic]; //temporary parameter buffer for storing reconstructed SAO parameters
263  decideBlkParams(pPic, sliceEnabled, m_statData, srcYuv, resYuv, reconParams, pPic->getPicSym()->getSAOBlkParam(), bTestSAODisableAtPictureLevel, saoEncodingRate, saoEncodingRateChroma);
264  delete[] reconParams;
265}
266
267Void TEncSampleAdaptiveOffset::getPreDBFStatistics(TComPic* pPic)
268{
269  getStatistics(m_preDBFstatData, pPic->getPicYuvOrg(), pPic->getPicYuvRec(), pPic, true);
270}
271
272Void TEncSampleAdaptiveOffset::addPreDBFStatistics(SAOStatData*** blkStats)
273{
274  for(Int n=0; n< m_numCTUsPic; n++)
275  {
276    for(Int compIdx=0; compIdx < MAX_NUM_COMPONENT; compIdx++)
277    {
278      for(Int typeIdc=0; typeIdc < NUM_SAO_NEW_TYPES; typeIdc++)
279      {
280        blkStats[n][compIdx][typeIdc] += m_preDBFstatData[n][compIdx][typeIdc];
281      }
282    }
283  }
284}
285
286Void TEncSampleAdaptiveOffset::getStatistics(SAOStatData*** blkStats, TComPicYuv* orgYuv, TComPicYuv* srcYuv, TComPic* pPic, Bool isCalculatePreDeblockSamples)
287{
288  Bool isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail;
289
290  const Int numberOfComponents = getNumberValidComponents(m_chromaFormatIDC);
291
292  for(Int ctuRsAddr= 0; ctuRsAddr < m_numCTUsPic; ctuRsAddr++)
293  {
294    Int yPos   = (ctuRsAddr / m_numCTUInWidth)*m_maxCUHeight;
295    Int xPos   = (ctuRsAddr % m_numCTUInWidth)*m_maxCUWidth;
296    Int height = (yPos + m_maxCUHeight > m_picHeight)?(m_picHeight- yPos):m_maxCUHeight;
297    Int width  = (xPos + m_maxCUWidth  > m_picWidth )?(m_picWidth - xPos):m_maxCUWidth;
298
299    pPic->getPicSym()->deriveLoopFilterBoundaryAvailibility(ctuRsAddr, isLeftAvail,isRightAvail,isAboveAvail,isBelowAvail,isAboveLeftAvail,isAboveRightAvail,isBelowLeftAvail,isBelowRightAvail);
300
301    //NOTE: The number of skipped lines during gathering CTU statistics depends on the slice boundary availabilities.
302    //For simplicity, here only picture boundaries are considered.
303
304    isRightAvail      = (xPos + m_maxCUWidth  < m_picWidth );
305    isBelowAvail      = (yPos + m_maxCUHeight < m_picHeight);
306    isBelowRightAvail = (isRightAvail && isBelowAvail);
307    isBelowLeftAvail  = ((xPos > 0) && (isBelowAvail));
308    isAboveRightAvail = ((yPos > 0) && (isRightAvail));
309
310    for(Int compIdx = 0; compIdx < numberOfComponents; compIdx++)
311    {
312      const ComponentID component = ComponentID(compIdx);
313
314      const UInt componentScaleX = getComponentScaleX(component, pPic->getChromaFormat());
315      const UInt componentScaleY = getComponentScaleY(component, pPic->getChromaFormat());
316
317      Int  srcStride  = srcYuv->getStride(component);
318      Pel* srcBlk     = srcYuv->getAddr(component) + ((yPos >> componentScaleY) * srcStride) + (xPos >> componentScaleX);
319
320      Int  orgStride  = orgYuv->getStride(component);
321      Pel* orgBlk     = orgYuv->getAddr(component) + ((yPos >> componentScaleY) * orgStride) + (xPos >> componentScaleX);
322
323      getBlkStats(component, pPic->getPicSym()->getSPS().getBitDepth(toChannelType(component)), blkStats[ctuRsAddr][component]
324                , srcBlk, orgBlk, srcStride, orgStride, (width  >> componentScaleX), (height >> componentScaleY)
325                , isLeftAvail,  isRightAvail, isAboveAvail, isBelowAvail, isAboveLeftAvail, isAboveRightAvail
326                , isCalculatePreDeblockSamples
327                );
328
329    }
330  }
331}
332
333Void TEncSampleAdaptiveOffset::decidePicParams(Bool* sliceEnabled, const TComPic* pic, const Double saoEncodingRate, const Double saoEncodingRateChroma, const Bool bResetStateAfterIRAP)
334{
335  if (pic->getSlice(0)->isIRAP())
336  {
337    m_lastIRAPPoc = pic->getSlice(0)->getPOC();
338  }
339  if (bResetStateAfterIRAP && pic->getSlice(0)->getPOC() > m_lastIRAPPoc)
340  { // reset
341    for (Int compIdx = 0; compIdx < MAX_NUM_COMPONENT; compIdx++)
342{
343      for (Int tempLayer = 1; tempLayer < MAX_TLAYER; tempLayer++)
344      {
345        m_saoDisabledRate[compIdx][tempLayer] = 0.0;
346      }
347    }
348    m_lastIRAPPoc = MAX_INT;
349  }
350  const Int picTempLayer = pic->getSlice(0)->getDepth();
351
352  //decide sliceEnabled[compIdx]
353  const Int numberOfComponents = getNumberValidComponents(m_chromaFormatIDC);
354  for (Int compIdx = 0; compIdx < MAX_NUM_COMPONENT; compIdx++)
355  {
356    sliceEnabled[compIdx] = false;
357  }
358
359  for (Int compIdx = 0; compIdx < numberOfComponents; compIdx++)
360  {
361    // reset flags & counters
362    sliceEnabled[compIdx] = true;
363
364    if (saoEncodingRate>0.0)
365    {
366      if (saoEncodingRateChroma>0.0)
367      {
368    // decide slice-level on/off based on previous results
369    if( (picTempLayer > 0)
370          && (m_saoDisabledRate[compIdx][picTempLayer-1] > ((compIdx==COMPONENT_Y) ? saoEncodingRate : saoEncodingRateChroma)) )
371    {
372      sliceEnabled[compIdx] = false;
373    }
374      }
375      else
376      {
377    // decide slice-level on/off based on previous results
378    if( (picTempLayer > 0)
379          && (m_saoDisabledRate[COMPONENT_Y][0] > saoEncodingRate) )
380    {
381      sliceEnabled[compIdx] = false;
382    }
383      }
384    }
385  }
386}
387
388Int64 TEncSampleAdaptiveOffset::getDistortion(const Int channelBitDepth, Int typeIdc, Int typeAuxInfo, Int* invQuantOffset, SAOStatData& statData)
389{
390  Int64 dist        = 0;
391  Int shift         = 2 * DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth - 8);
392
393  switch(typeIdc)
394  {
395    case SAO_TYPE_EO_0:
396    case SAO_TYPE_EO_90:
397    case SAO_TYPE_EO_135:
398    case SAO_TYPE_EO_45:
399      {
400        for (Int offsetIdx=0; offsetIdx<NUM_SAO_EO_CLASSES; offsetIdx++)
401        {
402          dist += estSaoDist( statData.count[offsetIdx], invQuantOffset[offsetIdx], statData.diff[offsetIdx], shift);
403        }
404      }
405      break;
406    case SAO_TYPE_BO:
407      {
408        for (Int offsetIdx=typeAuxInfo; offsetIdx<typeAuxInfo+4; offsetIdx++)
409        {
410          Int bandIdx = offsetIdx % NUM_SAO_BO_CLASSES ;
411          dist += estSaoDist( statData.count[bandIdx], invQuantOffset[bandIdx], statData.diff[bandIdx], shift);
412        }
413      }
414      break;
415    default:
416      {
417        printf("Not a supported type");
418        assert(0);
419        exit(-1);
420      }
421  }
422
423  return dist;
424}
425
426inline Int64 TEncSampleAdaptiveOffset::estSaoDist(Int64 count, Int64 offset, Int64 diffSum, Int shift)
427{
428  return (( count*offset*offset-diffSum*offset*2 ) >> shift);
429}
430
431
432inline Int TEncSampleAdaptiveOffset::estIterOffset(Int typeIdx, Double lambda, Int offsetInput, Int64 count, Int64 diffSum, Int shift, Int bitIncrease, Int64& bestDist, Double& bestCost, Int offsetTh )
433{
434  Int iterOffset, tempOffset;
435  Int64 tempDist, tempRate;
436  Double tempCost, tempMinCost;
437  Int offsetOutput = 0;
438  iterOffset = offsetInput;
439  // Assuming sending quantized value 0 results in zero offset and sending the value zero needs 1 bit. entropy coder can be used to measure the exact rate here.
440  tempMinCost = lambda;
441  while (iterOffset != 0)
442  {
443    // Calculate the bits required for signaling the offset
444    tempRate = (typeIdx == SAO_TYPE_BO) ? (abs((Int)iterOffset)+2) : (abs((Int)iterOffset)+1);
445    if (abs((Int)iterOffset)==offsetTh) //inclusive
446    {
447      tempRate --;
448    }
449    // Do the dequantization before distortion calculation
450    tempOffset  = iterOffset << bitIncrease;
451    tempDist    = estSaoDist( count, tempOffset, diffSum, shift);
452    tempCost    = ((Double)tempDist + lambda * (Double) tempRate);
453    if(tempCost < tempMinCost)
454    {
455      tempMinCost = tempCost;
456      offsetOutput = iterOffset;
457      bestDist = tempDist;
458      bestCost = tempCost;
459    }
460    iterOffset = (iterOffset > 0) ? (iterOffset-1):(iterOffset+1);
461  }
462  return offsetOutput;
463}
464
465Void TEncSampleAdaptiveOffset::deriveOffsets(ComponentID compIdx, const Int channelBitDepth, Int typeIdc, SAOStatData& statData, Int* quantOffsets, Int& typeAuxInfo)
466{
467  Int bitDepth = channelBitDepth;
468  Int shift    = 2 * DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8);
469  Int offsetTh = TComSampleAdaptiveOffset::getMaxOffsetQVal(channelBitDepth);  //inclusive
470
471  ::memset(quantOffsets, 0, sizeof(Int)*MAX_NUM_SAO_CLASSES);
472
473  //derive initial offsets
474  Int numClasses = (typeIdc == SAO_TYPE_BO)?((Int)NUM_SAO_BO_CLASSES):((Int)NUM_SAO_EO_CLASSES);
475  for(Int classIdx=0; classIdx< numClasses; classIdx++)
476  {
477    if( (typeIdc != SAO_TYPE_BO) && (classIdx==SAO_CLASS_EO_PLAIN)  )
478    {
479      continue; //offset will be zero
480    }
481
482    if(statData.count[classIdx] == 0)
483    {
484      continue; //offset will be zero
485    }
486
487    quantOffsets[classIdx] = (Int) xRoundIbdi(bitDepth, (Double)( statData.diff[classIdx]<<(bitDepth-8))
488                                                                  /
489                                                          (Double)( statData.count[classIdx]<< m_offsetStepLog2[compIdx])
490                                               );
491    quantOffsets[classIdx] = Clip3(-offsetTh, offsetTh, quantOffsets[classIdx]);
492  }
493
494  // adjust offsets
495  switch(typeIdc)
496  {
497    case SAO_TYPE_EO_0:
498    case SAO_TYPE_EO_90:
499    case SAO_TYPE_EO_135:
500    case SAO_TYPE_EO_45:
501      {
502        Int64 classDist;
503        Double classCost;
504        for(Int classIdx=0; classIdx<NUM_SAO_EO_CLASSES; classIdx++)
505        {
506          if(classIdx==SAO_CLASS_EO_FULL_VALLEY && quantOffsets[classIdx] < 0)
507          {
508            quantOffsets[classIdx] =0;
509          }
510          if(classIdx==SAO_CLASS_EO_HALF_VALLEY && quantOffsets[classIdx] < 0)
511          {
512            quantOffsets[classIdx] =0;
513          }
514          if(classIdx==SAO_CLASS_EO_HALF_PEAK   && quantOffsets[classIdx] > 0)
515          {
516            quantOffsets[classIdx] =0;
517          }
518          if(classIdx==SAO_CLASS_EO_FULL_PEAK   && quantOffsets[classIdx] > 0)
519          {
520            quantOffsets[classIdx] =0;
521          }
522
523          if( quantOffsets[classIdx] != 0 ) //iterative adjustment only when derived offset is not zero
524          {
525            quantOffsets[classIdx] = estIterOffset( typeIdc, m_lambda[compIdx], quantOffsets[classIdx], statData.count[classIdx], statData.diff[classIdx], shift, m_offsetStepLog2[compIdx], classDist , classCost , offsetTh );
526          }
527        }
528
529        typeAuxInfo =0;
530      }
531      break;
532    case SAO_TYPE_BO:
533      {
534        Int64  distBOClasses[NUM_SAO_BO_CLASSES];
535        Double costBOClasses[NUM_SAO_BO_CLASSES];
536        ::memset(distBOClasses, 0, sizeof(Int64)*NUM_SAO_BO_CLASSES);
537        for(Int classIdx=0; classIdx< NUM_SAO_BO_CLASSES; classIdx++)
538        {
539          costBOClasses[classIdx]= m_lambda[compIdx];
540          if( quantOffsets[classIdx] != 0 ) //iterative adjustment only when derived offset is not zero
541          {
542            quantOffsets[classIdx] = estIterOffset( typeIdc, m_lambda[compIdx], quantOffsets[classIdx], statData.count[classIdx], statData.diff[classIdx], shift, m_offsetStepLog2[compIdx], distBOClasses[classIdx], costBOClasses[classIdx], offsetTh );
543          }
544        }
545
546        //decide the starting band index
547        Double minCost = MAX_DOUBLE, cost;
548        for(Int band=0; band< NUM_SAO_BO_CLASSES- 4+ 1; band++)
549        {
550          cost  = costBOClasses[band  ];
551          cost += costBOClasses[band+1];
552          cost += costBOClasses[band+2];
553          cost += costBOClasses[band+3];
554
555          if(cost < minCost)
556          {
557            minCost = cost;
558            typeAuxInfo = band;
559          }
560        }
561        //clear those unused classes
562        Int clearQuantOffset[NUM_SAO_BO_CLASSES];
563        ::memset(clearQuantOffset, 0, sizeof(Int)*NUM_SAO_BO_CLASSES);
564        for(Int i=0; i< 4; i++)
565        {
566          Int band = (typeAuxInfo+i)%NUM_SAO_BO_CLASSES;
567          clearQuantOffset[band] = quantOffsets[band];
568        }
569        ::memcpy(quantOffsets, clearQuantOffset, sizeof(Int)*NUM_SAO_BO_CLASSES);
570      }
571      break;
572    default:
573      {
574        printf("Not a supported type");
575        assert(0);
576        exit(-1);
577      }
578
579  }
580
581
582}
583
584Void TEncSampleAdaptiveOffset::deriveModeNewRDO(const BitDepths &bitDepths, Int ctuRsAddr, SAOBlkParam* mergeList[NUM_SAO_MERGE_TYPES], Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel)
585{
586  Double minCost, cost;
587  UInt previousWrittenBits;
588  const Int numberOfComponents = getNumberValidComponents(m_chromaFormatIDC);
589
590  Int64 dist[MAX_NUM_COMPONENT], modeDist[MAX_NUM_COMPONENT];
591  SAOOffset testOffset[MAX_NUM_COMPONENT];
592  Int invQuantOffset[MAX_NUM_SAO_CLASSES];
593  for(Int comp=0; comp < MAX_NUM_COMPONENT; comp++)
594  {
595    modeDist[comp] = 0;
596  }
597
598  //pre-encode merge flags
599  modeParam[COMPONENT_Y].modeIdc = SAO_MODE_OFF;
600  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
601  m_pcRDGoOnSbacCoder->codeSAOBlkParam(modeParam, bitDepths, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), true);
602  m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
603
604    //------ luma --------//
605  {
606    const ComponentID compIdx = COMPONENT_Y;
607    //"off" case as initial cost
608    modeParam[compIdx].modeIdc = SAO_MODE_OFF;
609    m_pcRDGoOnSbacCoder->resetBits();
610    m_pcRDGoOnSbacCoder->codeSAOOffsetParam(compIdx, modeParam[compIdx], sliceEnabled[compIdx], bitDepths.recon[CHANNEL_TYPE_LUMA]);
611    modeDist[compIdx] = 0;
612    minCost= m_lambda[compIdx]*((Double)m_pcRDGoOnSbacCoder->getNumberOfWrittenBits());
613    m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
614    if(sliceEnabled[compIdx])
615    {
616      for(Int typeIdc=0; typeIdc< NUM_SAO_NEW_TYPES; typeIdc++)
617      {
618        testOffset[compIdx].modeIdc = SAO_MODE_NEW;
619        testOffset[compIdx].typeIdc = typeIdc;
620
621        //derive coded offset
622        deriveOffsets(compIdx, bitDepths.recon[CHANNEL_TYPE_LUMA], typeIdc, blkStats[ctuRsAddr][compIdx][typeIdc], testOffset[compIdx].offset, testOffset[compIdx].typeAuxInfo);
623
624        //inversed quantized offsets
625        invertQuantOffsets(compIdx, typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, testOffset[compIdx].offset);
626
627        //get distortion
628        dist[compIdx] = getDistortion(bitDepths.recon[CHANNEL_TYPE_LUMA], testOffset[compIdx].typeIdc, testOffset[compIdx].typeAuxInfo, invQuantOffset, blkStats[ctuRsAddr][compIdx][typeIdc]);
629
630        //get rate
631        m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
632        m_pcRDGoOnSbacCoder->resetBits();
633        m_pcRDGoOnSbacCoder->codeSAOOffsetParam(compIdx, testOffset[compIdx], sliceEnabled[compIdx], bitDepths.recon[CHANNEL_TYPE_LUMA]);
634        Int rate = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
635        cost = (Double)dist[compIdx] + m_lambda[compIdx]*((Double)rate);
636        if(cost < minCost)
637        {
638          minCost = cost;
639          modeDist[compIdx] = dist[compIdx];
640          modeParam[compIdx]= testOffset[compIdx];
641          m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
642        }
643      }
644    }
645    m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
646    m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
647  }
648
649  //------ chroma --------//
650//"off" case as initial cost
651  cost = 0;
652  previousWrittenBits = 0;
653  m_pcRDGoOnSbacCoder->resetBits();
654  for(UInt componentIndex = COMPONENT_Cb; componentIndex < numberOfComponents; componentIndex++)
655  {
656    const ComponentID component = ComponentID(componentIndex);
657
658    modeParam[component].modeIdc = SAO_MODE_OFF;
659    modeDist [component]         = 0;
660    m_pcRDGoOnSbacCoder->codeSAOOffsetParam(component, modeParam[component], sliceEnabled[component], bitDepths.recon[CHANNEL_TYPE_CHROMA]);
661   
662    const UInt currentWrittenBits = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
663    cost += m_lambda[component] * (currentWrittenBits - previousWrittenBits);
664    previousWrittenBits = currentWrittenBits;
665  }
666
667  minCost = cost;
668
669  //doesn't need to store cabac status here since the whole CTU parameters will be re-encoded at the end of this function
670
671  for(Int typeIdc=0; typeIdc< NUM_SAO_NEW_TYPES; typeIdc++)
672  {
673    m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_MID]);
674    m_pcRDGoOnSbacCoder->resetBits();
675    previousWrittenBits = 0;
676    cost = 0;
677
678    for(UInt componentIndex = COMPONENT_Cb; componentIndex < numberOfComponents; componentIndex++)
679    {
680      const ComponentID component = ComponentID(componentIndex);
681      if(!sliceEnabled[component])
682      {
683        testOffset[component].modeIdc = SAO_MODE_OFF;
684        dist[component]= 0;
685        continue;
686      }
687      testOffset[component].modeIdc = SAO_MODE_NEW;
688      testOffset[component].typeIdc = typeIdc;
689
690      //derive offset & get distortion
691      deriveOffsets(component, bitDepths.recon[CHANNEL_TYPE_CHROMA], typeIdc, blkStats[ctuRsAddr][component][typeIdc], testOffset[component].offset, testOffset[component].typeAuxInfo);
692      invertQuantOffsets(component, typeIdc, testOffset[component].typeAuxInfo, invQuantOffset, testOffset[component].offset);
693      dist[component] = getDistortion(bitDepths.recon[CHANNEL_TYPE_CHROMA], typeIdc, testOffset[component].typeAuxInfo, invQuantOffset, blkStats[ctuRsAddr][component][typeIdc]);
694
695      m_pcRDGoOnSbacCoder->codeSAOOffsetParam(component, testOffset[component], sliceEnabled[component], bitDepths.recon[CHANNEL_TYPE_CHROMA]);
696
697      const UInt currentWrittenBits = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
698      cost += dist[component] + (m_lambda[component] * (currentWrittenBits - previousWrittenBits));
699      previousWrittenBits = currentWrittenBits;
700    }
701
702    if(cost < minCost)
703    {
704      minCost = cost;
705      for(UInt componentIndex = COMPONENT_Cb; componentIndex < numberOfComponents; componentIndex++)
706      {
707        modeDist[componentIndex]  = dist[componentIndex];
708        modeParam[componentIndex] = testOffset[componentIndex];
709      }
710    }
711
712  } // SAO_TYPE loop
713
714  //----- re-gen rate & normalized cost----//
715  modeNormCost = 0;
716  for(UInt componentIndex = COMPONENT_Y; componentIndex < numberOfComponents; componentIndex++)
717  {
718    modeNormCost += (Double)modeDist[componentIndex] / m_lambda[componentIndex];
719  }
720
721  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
722  m_pcRDGoOnSbacCoder->resetBits();
723  m_pcRDGoOnSbacCoder->codeSAOBlkParam(modeParam, bitDepths, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), false);
724  modeNormCost += (Double)m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
725}
726
727Void TEncSampleAdaptiveOffset::deriveModeMergeRDO(const BitDepths &bitDepths, Int ctuRsAddr, SAOBlkParam* mergeList[NUM_SAO_MERGE_TYPES], Bool* sliceEnabled, SAOStatData*** blkStats, SAOBlkParam& modeParam, Double& modeNormCost, TEncSbac** cabacCoderRDO, Int inCabacLabel)
728{
729  modeNormCost = MAX_DOUBLE;
730
731  Double cost;
732  SAOBlkParam testBlkParam;
733  const Int numberOfComponents = getNumberValidComponents(m_chromaFormatIDC);
734
735  for(Int mergeType=0; mergeType< NUM_SAO_MERGE_TYPES; mergeType++)
736  {
737    if(mergeList[mergeType] == NULL)
738    {
739      continue;
740    }
741
742    testBlkParam = *(mergeList[mergeType]);
743    //normalized distortion
744    Double normDist=0;
745    for(Int compIdx = 0; compIdx < numberOfComponents; compIdx++)
746    {
747      testBlkParam[compIdx].modeIdc = SAO_MODE_MERGE;
748      testBlkParam[compIdx].typeIdc = mergeType;
749
750      SAOOffset& mergedOffsetParam = (*(mergeList[mergeType]))[compIdx];
751
752      if( mergedOffsetParam.modeIdc != SAO_MODE_OFF)
753      {
754        //offsets have been reconstructed. Don't call inversed quantization function.
755        normDist += (((Double)getDistortion(bitDepths.recon[toChannelType(ComponentID(compIdx))], mergedOffsetParam.typeIdc, mergedOffsetParam.typeAuxInfo, mergedOffsetParam.offset, blkStats[ctuRsAddr][compIdx][mergedOffsetParam.typeIdc]))
756                       /m_lambda[compIdx]
757                    );
758      }
759
760    }
761
762    //rate
763    m_pcRDGoOnSbacCoder->load(cabacCoderRDO[inCabacLabel]);
764    m_pcRDGoOnSbacCoder->resetBits();
765    m_pcRDGoOnSbacCoder->codeSAOBlkParam(testBlkParam, bitDepths, sliceEnabled, (mergeList[SAO_MERGE_LEFT]!= NULL), (mergeList[SAO_MERGE_ABOVE]!= NULL), false);
766    Int rate = m_pcRDGoOnSbacCoder->getNumberOfWrittenBits();
767
768    cost = normDist+(Double)rate;
769
770    if(cost < modeNormCost)
771    {
772      modeNormCost = cost;
773      modeParam    = testBlkParam;
774      m_pcRDGoOnSbacCoder->store(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
775    }
776  }
777
778  m_pcRDGoOnSbacCoder->load(cabacCoderRDO[SAO_CABACSTATE_BLK_TEMP]);
779}
780
781Void TEncSampleAdaptiveOffset::decideBlkParams(TComPic* pic, Bool* sliceEnabled, SAOStatData*** blkStats, TComPicYuv* srcYuv, TComPicYuv* resYuv,
782                                               SAOBlkParam* reconParams, SAOBlkParam* codedParams, const Bool bTestSAODisableAtPictureLevel,
783                                               const Double saoEncodingRate, const Double saoEncodingRateChroma)
784{
785  Bool allBlksDisabled = true;
786  const Int numberOfComponents = getNumberValidComponents(m_chromaFormatIDC);
787  for(Int compId = COMPONENT_Y; compId < numberOfComponents; compId++)
788  {
789    if (sliceEnabled[compId])
790    {
791      allBlksDisabled = false;
792    }
793  }
794
795  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[ SAO_CABACSTATE_PIC_INIT ]);
796
797  SAOBlkParam modeParam;
798  Double minCost, modeCost;
799
800
801  Double totalCost = 0; // Used if bTestSAODisableAtPictureLevel==true
802
803  for(Int ctuRsAddr=0; ctuRsAddr< m_numCTUsPic; ctuRsAddr++)
804  {
805    if(allBlksDisabled)
806    {
807      codedParams[ctuRsAddr].reset();
808      continue;
809    }
810
811    m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_CUR ]);
812
813    //get merge list
814    SAOBlkParam* mergeList[NUM_SAO_MERGE_TYPES] = { NULL };
815    getMergeList(pic, ctuRsAddr, reconParams, mergeList);
816
817    minCost = MAX_DOUBLE;
818    for(Int mode=0; mode < NUM_SAO_MODES; mode++)
819    {
820      switch(mode)
821      {
822      case SAO_MODE_OFF:
823        {
824          continue; //not necessary, since all-off case will be tested in SAO_MODE_NEW case.
825        }
826        break;
827      case SAO_MODE_NEW:
828        {
829          deriveModeNewRDO(pic->getPicSym()->getSPS().getBitDepths(), ctuRsAddr, mergeList, sliceEnabled, blkStats, modeParam, modeCost, m_pppcRDSbacCoder, SAO_CABACSTATE_BLK_CUR);
830
831        }
832        break;
833      case SAO_MODE_MERGE:
834        {
835          deriveModeMergeRDO(pic->getPicSym()->getSPS().getBitDepths(), ctuRsAddr, mergeList, sliceEnabled, blkStats , modeParam, modeCost, m_pppcRDSbacCoder, SAO_CABACSTATE_BLK_CUR);
836        }
837        break;
838      default:
839        {
840          printf("Not a supported SAO mode\n");
841          assert(0);
842          exit(-1);
843        }
844      }
845
846#if NH_MV
847      D_PRINT_INDENT( g_traceSAOCost, "SAO mode " + n2s( mode ) + " Cost:  " + n2s( modeCost) );
848#endif
849      if(modeCost < minCost)
850      {
851        minCost = modeCost;
852        codedParams[ctuRsAddr] = modeParam;
853        m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_NEXT ]);
854      }
855    } //mode
856
857    totalCost += minCost;
858
859    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[ SAO_CABACSTATE_BLK_NEXT ]);
860
861    //apply reconstructed offsets
862    reconParams[ctuRsAddr] = codedParams[ctuRsAddr];
863    reconstructBlkSAOParam(reconParams[ctuRsAddr], mergeList);
864    offsetCTU(ctuRsAddr, srcYuv, resYuv, reconParams[ctuRsAddr], pic);
865  } //ctuRsAddr
866
867  if (!allBlksDisabled && (totalCost >= 0) && bTestSAODisableAtPictureLevel) //SAO has not beneficial in this case - disable it
868  {
869    for(Int ctuRsAddr = 0; ctuRsAddr < m_numCTUsPic; ctuRsAddr++)
870    {
871      codedParams[ctuRsAddr].reset();
872    }
873
874    for (UInt componentIndex = 0; componentIndex < MAX_NUM_COMPONENT; componentIndex++)
875    {
876      sliceEnabled[componentIndex] = false;
877    }
878
879    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[ SAO_CABACSTATE_PIC_INIT ]);
880  }
881
882  if (saoEncodingRate > 0.0)
883  {
884  Int picTempLayer = pic->getSlice(0)->getDepth();
885  Int numCtusForSAOOff[MAX_NUM_COMPONENT];
886
887  for (Int compIdx = 0; compIdx < numberOfComponents; compIdx++)
888  {
889    numCtusForSAOOff[compIdx] = 0;
890    for(Int ctuRsAddr=0; ctuRsAddr< m_numCTUsPic; ctuRsAddr++)
891    {
892      if( reconParams[ctuRsAddr][compIdx].modeIdc == SAO_MODE_OFF)
893      {
894        numCtusForSAOOff[compIdx]++;
895      }
896    }
897  }
898    if (saoEncodingRateChroma > 0.0)
899    {
900  for (Int compIdx = 0; compIdx < numberOfComponents; compIdx++)
901  {
902    m_saoDisabledRate[compIdx][picTempLayer] = (Double)numCtusForSAOOff[compIdx]/(Double)m_numCTUsPic;
903  }
904    }
905    else if (picTempLayer == 0)
906  {
907    m_saoDisabledRate[COMPONENT_Y][0] = (Double)(numCtusForSAOOff[COMPONENT_Y]+numCtusForSAOOff[COMPONENT_Cb]+numCtusForSAOOff[COMPONENT_Cr])/(Double)(m_numCTUsPic*3);
908  }
909  }
910}
911
912
913Void TEncSampleAdaptiveOffset::getBlkStats(const ComponentID compIdx, const Int channelBitDepth, SAOStatData* statsDataTypes
914                        , Pel* srcBlk, Pel* orgBlk, Int srcStride, Int orgStride, Int width, Int height
915                        , Bool isLeftAvail,  Bool isRightAvail, Bool isAboveAvail, Bool isBelowAvail, Bool isAboveLeftAvail, Bool isAboveRightAvail
916                        , Bool isCalculatePreDeblockSamples
917                        )
918{
919  if(m_lineBufWidth != m_maxCUWidth)
920  {
921    m_lineBufWidth = m_maxCUWidth;
922
923    if (m_signLineBuf1)
924    {
925      delete[] m_signLineBuf1;
926      m_signLineBuf1 = NULL;
927    }
928    m_signLineBuf1 = new SChar[m_lineBufWidth+1];
929
930    if (m_signLineBuf2)
931    {
932      delete[] m_signLineBuf2;
933      m_signLineBuf2 = NULL;
934    }
935    m_signLineBuf2 = new SChar[m_lineBufWidth+1];
936  }
937
938  Int x,y, startX, startY, endX, endY, edgeType, firstLineStartX, firstLineEndX;
939  SChar signLeft, signRight, signDown;
940  Int64 *diff, *count;
941  Pel *srcLine, *orgLine;
942  Int* skipLinesR = m_skipLinesR[compIdx];
943  Int* skipLinesB = m_skipLinesB[compIdx];
944
945  for(Int typeIdx=0; typeIdx< NUM_SAO_NEW_TYPES; typeIdx++)
946  {
947    SAOStatData& statsData= statsDataTypes[typeIdx];
948    statsData.reset();
949
950    srcLine = srcBlk;
951    orgLine = orgBlk;
952    diff    = statsData.diff;
953    count   = statsData.count;
954    switch(typeIdx)
955    {
956    case SAO_TYPE_EO_0:
957      {
958        diff +=2;
959        count+=2;
960        endY   = (isBelowAvail) ? (height - skipLinesB[typeIdx]) : height;
961        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
962                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
963                                                 ;
964        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
965                                                 : (isRightAvail ? width : (width - 1))
966                                                 ;
967        for (y=0; y<endY; y++)
968        {
969          signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
970          for (x=startX; x<endX; x++)
971          {
972            signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
973            edgeType  =  signRight + signLeft;
974            signLeft  = -signRight;
975
976            diff [edgeType] += (orgLine[x] - srcLine[x]);
977            count[edgeType] ++;
978          }
979          srcLine  += srcStride;
980          orgLine  += orgStride;
981        }
982        if(isCalculatePreDeblockSamples)
983        {
984          if(isBelowAvail)
985          {
986            startX = isLeftAvail  ? 0 : 1;
987            endX   = isRightAvail ? width : (width -1);
988
989            for(y=0; y<skipLinesB[typeIdx]; y++)
990            {
991              signLeft = (SChar)sgn(srcLine[startX] - srcLine[startX-1]);
992              for (x=startX; x<endX; x++)
993              {
994                signRight =  (SChar)sgn(srcLine[x] - srcLine[x+1]);
995                edgeType  =  signRight + signLeft;
996                signLeft  = -signRight;
997
998                diff [edgeType] += (orgLine[x] - srcLine[x]);
999                count[edgeType] ++;
1000              }
1001              srcLine  += srcStride;
1002              orgLine  += orgStride;
1003            }
1004          }
1005        }
1006      }
1007      break;
1008    case SAO_TYPE_EO_90:
1009      {
1010        diff +=2;
1011        count+=2;
1012        SChar *signUpLine = m_signLineBuf1;
1013
1014        startX = (!isCalculatePreDeblockSamples) ? 0
1015                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : width)
1016                                                 ;
1017        startY = isAboveAvail ? 0 : 1;
1018        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : width)
1019                                                 : width
1020                                                 ;
1021        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
1022        if (!isAboveAvail)
1023        {
1024          srcLine += srcStride;
1025          orgLine += orgStride;
1026        }
1027
1028        Pel* srcLineAbove = srcLine - srcStride;
1029        for (x=startX; x<endX; x++)
1030        {
1031          signUpLine[x] = (SChar)sgn(srcLine[x] - srcLineAbove[x]);
1032        }
1033
1034        Pel* srcLineBelow;
1035        for (y=startY; y<endY; y++)
1036        {
1037          srcLineBelow = srcLine + srcStride;
1038
1039          for (x=startX; x<endX; x++)
1040          {
1041            signDown  = (SChar)sgn(srcLine[x] - srcLineBelow[x]);
1042            edgeType  = signDown + signUpLine[x];
1043            signUpLine[x]= -signDown;
1044
1045            diff [edgeType] += (orgLine[x] - srcLine[x]);
1046            count[edgeType] ++;
1047          }
1048          srcLine += srcStride;
1049          orgLine += orgStride;
1050        }
1051        if(isCalculatePreDeblockSamples)
1052        {
1053          if(isBelowAvail)
1054          {
1055            startX = 0;
1056            endX   = width;
1057
1058            for(y=0; y<skipLinesB[typeIdx]; y++)
1059            {
1060              srcLineBelow = srcLine + srcStride;
1061              srcLineAbove = srcLine - srcStride;
1062
1063              for (x=startX; x<endX; x++)
1064              {
1065                edgeType = sgn(srcLine[x] - srcLineBelow[x]) + sgn(srcLine[x] - srcLineAbove[x]);
1066                diff [edgeType] += (orgLine[x] - srcLine[x]);
1067                count[edgeType] ++;
1068              }
1069              srcLine  += srcStride;
1070              orgLine  += orgStride;
1071            }
1072          }
1073        }
1074
1075      }
1076      break;
1077    case SAO_TYPE_EO_135:
1078      {
1079        diff +=2;
1080        count+=2;
1081        SChar *signUpLine, *signDownLine, *signTmpLine;
1082
1083        signUpLine  = m_signLineBuf1;
1084        signDownLine= m_signLineBuf2;
1085
1086        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
1087                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
1088                                                 ;
1089
1090        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]): (width - 1))
1091                                                 : (isRightAvail ? width : (width - 1))
1092                                                 ;
1093        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
1094
1095        //prepare 2nd line's upper sign
1096        Pel* srcLineBelow = srcLine + srcStride;
1097        for (x=startX; x<endX+1; x++)
1098        {
1099          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x-1]);
1100        }
1101
1102        //1st line
1103        Pel* srcLineAbove = srcLine - srcStride;
1104        firstLineStartX = (!isCalculatePreDeblockSamples) ? (isAboveLeftAvail ? 0    : 1) : startX;
1105        firstLineEndX   = (!isCalculatePreDeblockSamples) ? (isAboveAvail     ? endX : 1) : endX;
1106        for(x=firstLineStartX; x<firstLineEndX; x++)
1107        {
1108          edgeType = sgn(srcLine[x] - srcLineAbove[x-1]) - signUpLine[x+1];
1109          diff [edgeType] += (orgLine[x] - srcLine[x]);
1110          count[edgeType] ++;
1111        }
1112        srcLine  += srcStride;
1113        orgLine  += orgStride;
1114
1115
1116        //middle lines
1117        for (y=1; y<endY; y++)
1118        {
1119          srcLineBelow = srcLine + srcStride;
1120
1121          for (x=startX; x<endX; x++)
1122          {
1123            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x+1]);
1124            edgeType = signDown + signUpLine[x];
1125            diff [edgeType] += (orgLine[x] - srcLine[x]);
1126            count[edgeType] ++;
1127
1128            signDownLine[x+1] = -signDown;
1129          }
1130          signDownLine[startX] = (SChar)sgn(srcLineBelow[startX] - srcLine[startX-1]);
1131
1132          signTmpLine  = signUpLine;
1133          signUpLine   = signDownLine;
1134          signDownLine = signTmpLine;
1135
1136          srcLine += srcStride;
1137          orgLine += orgStride;
1138        }
1139        if(isCalculatePreDeblockSamples)
1140        {
1141          if(isBelowAvail)
1142          {
1143            startX = isLeftAvail  ? 0     : 1 ;
1144            endX   = isRightAvail ? width : (width -1);
1145
1146            for(y=0; y<skipLinesB[typeIdx]; y++)
1147            {
1148              srcLineBelow = srcLine + srcStride;
1149              srcLineAbove = srcLine - srcStride;
1150
1151              for (x=startX; x< endX; x++)
1152              {
1153                edgeType = sgn(srcLine[x] - srcLineBelow[x+1]) + sgn(srcLine[x] - srcLineAbove[x-1]);
1154                diff [edgeType] += (orgLine[x] - srcLine[x]);
1155                count[edgeType] ++;
1156              }
1157              srcLine  += srcStride;
1158              orgLine  += orgStride;
1159            }
1160          }
1161        }
1162      }
1163      break;
1164    case SAO_TYPE_EO_45:
1165      {
1166        diff +=2;
1167        count+=2;
1168        SChar *signUpLine = m_signLineBuf1+1;
1169
1170        startX = (!isCalculatePreDeblockSamples) ? (isLeftAvail  ? 0 : 1)
1171                                                 : (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
1172                                                 ;
1173        endX   = (!isCalculatePreDeblockSamples) ? (isRightAvail ? (width - skipLinesR[typeIdx]) : (width - 1))
1174                                                 : (isRightAvail ? width : (width - 1))
1175                                                 ;
1176        endY   = isBelowAvail ? (height - skipLinesB[typeIdx]) : (height - 1);
1177
1178        //prepare 2nd line upper sign
1179        Pel* srcLineBelow = srcLine + srcStride;
1180        for (x=startX-1; x<endX; x++)
1181        {
1182          signUpLine[x] = (SChar)sgn(srcLineBelow[x] - srcLine[x+1]);
1183        }
1184
1185
1186        //first line
1187        Pel* srcLineAbove = srcLine - srcStride;
1188        firstLineStartX = (!isCalculatePreDeblockSamples) ? (isAboveAvail ? startX : endX)
1189                                                          : startX
1190                                                          ;
1191        firstLineEndX   = (!isCalculatePreDeblockSamples) ? ((!isRightAvail && isAboveRightAvail) ? width : endX)
1192                                                          : endX
1193                                                          ;
1194        for(x=firstLineStartX; x<firstLineEndX; x++)
1195        {
1196          edgeType = sgn(srcLine[x] - srcLineAbove[x+1]) - signUpLine[x-1];
1197          diff [edgeType] += (orgLine[x] - srcLine[x]);
1198          count[edgeType] ++;
1199        }
1200
1201        srcLine += srcStride;
1202        orgLine += orgStride;
1203
1204        //middle lines
1205        for (y=1; y<endY; y++)
1206        {
1207          srcLineBelow = srcLine + srcStride;
1208
1209          for(x=startX; x<endX; x++)
1210          {
1211            signDown = (SChar)sgn(srcLine[x] - srcLineBelow[x-1]);
1212            edgeType = signDown + signUpLine[x];
1213
1214            diff [edgeType] += (orgLine[x] - srcLine[x]);
1215            count[edgeType] ++;
1216
1217            signUpLine[x-1] = -signDown;
1218          }
1219          signUpLine[endX-1] = (SChar)sgn(srcLineBelow[endX-1] - srcLine[endX]);
1220          srcLine  += srcStride;
1221          orgLine  += orgStride;
1222        }
1223        if(isCalculatePreDeblockSamples)
1224        {
1225          if(isBelowAvail)
1226          {
1227            startX = isLeftAvail  ? 0     : 1 ;
1228            endX   = isRightAvail ? width : (width -1);
1229
1230            for(y=0; y<skipLinesB[typeIdx]; y++)
1231            {
1232              srcLineBelow = srcLine + srcStride;
1233              srcLineAbove = srcLine - srcStride;
1234
1235              for (x=startX; x<endX; x++)
1236              {
1237                edgeType = sgn(srcLine[x] - srcLineBelow[x-1]) + sgn(srcLine[x] - srcLineAbove[x+1]);
1238                diff [edgeType] += (orgLine[x] - srcLine[x]);
1239                count[edgeType] ++;
1240              }
1241              srcLine  += srcStride;
1242              orgLine  += orgStride;
1243            }
1244          }
1245        }
1246      }
1247      break;
1248    case SAO_TYPE_BO:
1249      {
1250        startX = (!isCalculatePreDeblockSamples)?0
1251                                                :( isRightAvail?(width- skipLinesR[typeIdx]):width)
1252                                                ;
1253        endX   = (!isCalculatePreDeblockSamples)?(isRightAvail ? (width - skipLinesR[typeIdx]) : width )
1254                                                :width
1255                                                ;
1256        endY = isBelowAvail ? (height- skipLinesB[typeIdx]) : height;
1257        Int shiftBits = channelBitDepth - NUM_SAO_BO_CLASSES_LOG2;
1258        for (y=0; y< endY; y++)
1259        {
1260          for (x=startX; x< endX; x++)
1261          {
1262
1263            Int bandIdx= srcLine[x] >> shiftBits;
1264            diff [bandIdx] += (orgLine[x] - srcLine[x]);
1265            count[bandIdx] ++;
1266          }
1267          srcLine += srcStride;
1268          orgLine += orgStride;
1269        }
1270        if(isCalculatePreDeblockSamples)
1271        {
1272          if(isBelowAvail)
1273          {
1274            startX = 0;
1275            endX   = width;
1276
1277            for(y= 0; y< skipLinesB[typeIdx]; y++)
1278            {
1279              for (x=startX; x< endX; x++)
1280              {
1281                Int bandIdx= srcLine[x] >> shiftBits;
1282                diff [bandIdx] += (orgLine[x] - srcLine[x]);
1283                count[bandIdx] ++;
1284              }
1285              srcLine  += srcStride;
1286              orgLine  += orgStride;
1287
1288            }
1289
1290          }
1291        }
1292      }
1293      break;
1294    default:
1295      {
1296        printf("Not a supported SAO types\n");
1297        assert(0);
1298        exit(-1);
1299      }
1300    }
1301  }
1302}
1303
1304
1305//! \}
Note: See TracBrowser for help on using the repository browser.