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 TEncBinCoderCABAC.cpp
35 \brief binary entropy encoder of CABAC
36 */
37
38 #include "TEncBinCoderCABAC.h"
39 #include "TLibCommon/TComRom.h"
40 #include "TLibCommon/Debug.h"
41
42 //! \ingroup TLibEncoder
43 //! \{
44
45
TEncBinCABAC()46 TEncBinCABAC::TEncBinCABAC()
47 : m_pcTComBitIf( 0 )
48 , m_binCountIncrement( 0 )
49 #if FAST_BIT_EST
50 , m_fracBits( 0 )
51 #endif
52 {
53 }
54
~TEncBinCABAC()55 TEncBinCABAC::~TEncBinCABAC()
56 {
57 }
58
init(TComBitIf * pcTComBitIf)59 Void TEncBinCABAC::init( TComBitIf* pcTComBitIf )
60 {
61 m_pcTComBitIf = pcTComBitIf;
62 }
63
uninit()64 Void TEncBinCABAC::uninit()
65 {
66 m_pcTComBitIf = 0;
67 }
68
start()69 Void TEncBinCABAC::start()
70 {
71 m_uiLow = 0;
72 m_uiRange = 510;
73 m_bitsLeft = 23;
74 m_numBufferedBytes = 0;
75 m_bufferedByte = 0xff;
76 #if FAST_BIT_EST
77 m_fracBits = 0;
78 #endif
79 }
80
finish()81 Void TEncBinCABAC::finish()
82 {
83 if ( m_uiLow >> ( 32 - m_bitsLeft ) )
84 {
85 //assert( m_numBufferedBytes > 0 );
86 //assert( m_bufferedByte != 0xff );
87 m_pcTComBitIf->write( m_bufferedByte + 1, 8 );
88 while ( m_numBufferedBytes > 1 )
89 {
90 m_pcTComBitIf->write( 0x00, 8 );
91 m_numBufferedBytes--;
92 }
93 m_uiLow -= 1 << ( 32 - m_bitsLeft );
94 }
95 else
96 {
97 if ( m_numBufferedBytes > 0 )
98 {
99 m_pcTComBitIf->write( m_bufferedByte, 8 );
100 }
101 while ( m_numBufferedBytes > 1 )
102 {
103 m_pcTComBitIf->write( 0xff, 8 );
104 m_numBufferedBytes--;
105 }
106 }
107 m_pcTComBitIf->write( m_uiLow >> 8, 24 - m_bitsLeft );
108 }
109
flush()110 Void TEncBinCABAC::flush()
111 {
112 encodeBinTrm(1);
113 finish();
114 m_pcTComBitIf->write(1, 1);
115 m_pcTComBitIf->writeAlignZero();
116
117 start();
118 }
119
120 /** Reset BAC register and counter values.
121 * \returns Void
122 */
resetBac()123 Void TEncBinCABAC::resetBac()
124 {
125 start();
126 }
127
128 /** Encode PCM alignment zero bits.
129 * \returns Void
130 */
encodePCMAlignBits()131 Void TEncBinCABAC::encodePCMAlignBits()
132 {
133 finish();
134 m_pcTComBitIf->write(1, 1);
135 m_pcTComBitIf->writeAlignZero(); // pcm align zero
136 }
137
138 /** Write a PCM code.
139 * \param uiCode code value
140 * \param uiLength code bit-depth
141 * \returns Void
142 */
xWritePCMCode(UInt uiCode,UInt uiLength)143 Void TEncBinCABAC::xWritePCMCode(UInt uiCode, UInt uiLength)
144 {
145 m_pcTComBitIf->write(uiCode, uiLength);
146 }
147
copyState(const TEncBinIf * pcTEncBinIf)148 Void TEncBinCABAC::copyState( const TEncBinIf* pcTEncBinIf )
149 {
150 const TEncBinCABAC* pcTEncBinCABAC = pcTEncBinIf->getTEncBinCABAC();
151 m_uiLow = pcTEncBinCABAC->m_uiLow;
152 m_uiRange = pcTEncBinCABAC->m_uiRange;
153 m_bitsLeft = pcTEncBinCABAC->m_bitsLeft;
154 m_bufferedByte = pcTEncBinCABAC->m_bufferedByte;
155 m_numBufferedBytes = pcTEncBinCABAC->m_numBufferedBytes;
156 #if FAST_BIT_EST
157 m_fracBits = pcTEncBinCABAC->m_fracBits;
158 #endif
159 }
160
resetBits()161 Void TEncBinCABAC::resetBits()
162 {
163 m_uiLow = 0;
164 m_bitsLeft = 23;
165 m_numBufferedBytes = 0;
166 m_bufferedByte = 0xff;
167 if ( m_binCountIncrement )
168 {
169 m_uiBinsCoded = 0;
170 }
171 #if FAST_BIT_EST
172 m_fracBits &= 32767;
173 #endif
174 }
175
getNumWrittenBits()176 UInt TEncBinCABAC::getNumWrittenBits()
177 {
178 return m_pcTComBitIf->getNumberOfWrittenBits() + 8 * m_numBufferedBytes + 23 - m_bitsLeft;
179 }
180
181 /**
182 * \brief Encode bin
183 *
184 * \param binValue bin value
185 * \param rcCtxModel context model
186 */
encodeBin(UInt binValue,ContextModel & rcCtxModel)187 Void TEncBinCABAC::encodeBin( UInt binValue, ContextModel &rcCtxModel )
188 {
189 //{
190 // DTRACE_CABAC_VL( g_nSymbolCounter++ )
191 // DTRACE_CABAC_T( "\tstate=" )
192 // DTRACE_CABAC_V( ( rcCtxModel.getState() << 1 ) + rcCtxModel.getMps() )
193 // DTRACE_CABAC_T( "\tsymbol=" )
194 // DTRACE_CABAC_V( binValue )
195 // DTRACE_CABAC_T( "\n" )
196 //}
197
198 #ifdef DEBUG_CABAC_BINS
199 const UInt startingRange = m_uiRange;
200 #endif
201
202 m_uiBinsCoded += m_binCountIncrement;
203 rcCtxModel.setBinsCoded( 1 );
204
205 UInt uiLPS = TComCABACTables::sm_aucLPSTable[ rcCtxModel.getState() ][ ( m_uiRange >> 6 ) & 3 ];
206 m_uiRange -= uiLPS;
207
208 if( binValue != rcCtxModel.getMps() )
209 {
210 Int numBits = TComCABACTables::sm_aucRenormTable[ uiLPS >> 3 ];
211 m_uiLow = ( m_uiLow + m_uiRange ) << numBits;
212 m_uiRange = uiLPS << numBits;
213 rcCtxModel.updateLPS();
214 m_bitsLeft -= numBits;
215 testAndWriteOut();
216 }
217 else
218 {
219 rcCtxModel.updateMPS();
220
221 if ( m_uiRange < 256 )
222 {
223 m_uiLow <<= 1;
224 m_uiRange <<= 1;
225 m_bitsLeft--;
226 testAndWriteOut();
227 }
228 }
229
230 #ifdef DEBUG_CABAC_BINS
231 if ((g_debugCounter + debugCabacBinWindow) >= debugCabacBinTargetLine)
232 std::cout << g_debugCounter << ": coding bin value " << binValue << ", range = [" << startingRange << "->" << m_uiRange << "]\n";
233
234 if (g_debugCounter >= debugCabacBinTargetLine)
235 {
236 Char breakPointThis;
237 breakPointThis = 7;
238 }
239 if (g_debugCounter >= (debugCabacBinTargetLine + debugCabacBinWindow)) exit(0);
240 g_debugCounter++;
241 #endif
242 }
243
244 /**
245 * \brief Encode equiprobable bin
246 *
247 * \param binValue bin value
248 */
encodeBinEP(UInt binValue)249 Void TEncBinCABAC::encodeBinEP( UInt binValue )
250 {
251 if (false)
252 {
253 DTRACE_CABAC_VL( g_nSymbolCounter++ )
254 DTRACE_CABAC_T( "\tEPsymbol=" )
255 DTRACE_CABAC_V( binValue )
256 DTRACE_CABAC_T( "\n" )
257 }
258
259 m_uiBinsCoded += m_binCountIncrement;
260
261 if (m_uiRange == 256)
262 {
263 encodeAlignedBinsEP(binValue, 1);
264 return;
265 }
266
267 m_uiLow <<= 1;
268 if( binValue )
269 {
270 m_uiLow += m_uiRange;
271 }
272 m_bitsLeft--;
273
274 testAndWriteOut();
275 }
276
277 /**
278 * \brief Encode equiprobable bins
279 *
280 * \param binValues bin values
281 * \param numBins number of bins
282 */
encodeBinsEP(UInt binValues,Int numBins)283 Void TEncBinCABAC::encodeBinsEP( UInt binValues, Int numBins )
284 {
285 m_uiBinsCoded += numBins & -m_binCountIncrement;
286
287 if (false)
288 {
289 for ( Int i = 0; i < numBins; i++ )
290 {
291 DTRACE_CABAC_VL( g_nSymbolCounter++ )
292 DTRACE_CABAC_T( "\tEPsymbol=" )
293 DTRACE_CABAC_V( ( binValues >> ( numBins - 1 - i ) ) & 1 )
294 DTRACE_CABAC_T( "\n" )
295 }
296 }
297
298 if (m_uiRange == 256)
299 {
300 encodeAlignedBinsEP(binValues, numBins);
301 return;
302 }
303
304 while ( numBins > 8 )
305 {
306 numBins -= 8;
307 UInt pattern = binValues >> numBins;
308 m_uiLow <<= 8;
309 m_uiLow += m_uiRange * pattern;
310 binValues -= pattern << numBins;
311 m_bitsLeft -= 8;
312
313 testAndWriteOut();
314 }
315
316 m_uiLow <<= numBins;
317 m_uiLow += m_uiRange * binValues;
318 m_bitsLeft -= numBins;
319
320 testAndWriteOut();
321 }
322
align()323 Void TEncBinCABAC::align()
324 {
325 m_uiRange = 256;
326 }
327
encodeAlignedBinsEP(UInt binValues,Int numBins)328 Void TEncBinCABAC::encodeAlignedBinsEP( UInt binValues, Int numBins )
329 {
330 Int binsRemaining = numBins;
331
332 assert(m_uiRange == 256); //aligned encode only works when range = 256
333
334 while (binsRemaining > 0)
335 {
336 const UInt binsToCode = std::min<UInt>(binsRemaining, 8); //code bytes if able to take advantage of the system's byte-write function
337 const UInt binMask = (1 << binsToCode) - 1;
338
339 const UInt newBins = (binValues >> (binsRemaining - binsToCode)) & binMask;
340
341 //The process of encoding an EP bin is the same as that of coding a normal
342 //bin where the symbol ranges for 1 and 0 are both half the range:
343 //
344 // low = (low + range/2) << 1 (to encode a 1)
345 // low = low << 1 (to encode a 0)
346 //
347 // i.e.
348 // low = (low + (bin * range/2)) << 1
349 //
350 // which is equivalent to:
351 //
352 // low = (low << 1) + (bin * range)
353 //
354 // this can be generalised for multiple bins, producing the following expression:
355 //
356 m_uiLow = (m_uiLow << binsToCode) + (newBins << 8); //range is known to be 256
357
358 binsRemaining -= binsToCode;
359 m_bitsLeft -= binsToCode;
360
361 testAndWriteOut();
362 }
363 }
364
365 /**
366 * \brief Encode terminating bin
367 *
368 * \param binValue bin value
369 */
encodeBinTrm(UInt binValue)370 Void TEncBinCABAC::encodeBinTrm( UInt binValue )
371 {
372 m_uiBinsCoded += m_binCountIncrement;
373 m_uiRange -= 2;
374 if( binValue )
375 {
376 m_uiLow += m_uiRange;
377 m_uiLow <<= 7;
378 m_uiRange = 2 << 7;
379 m_bitsLeft -= 7;
380 }
381 else if ( m_uiRange >= 256 )
382 {
383 return;
384 }
385 else
386 {
387 m_uiLow <<= 1;
388 m_uiRange <<= 1;
389 m_bitsLeft--;
390 }
391
392 testAndWriteOut();
393 }
394
testAndWriteOut()395 Void TEncBinCABAC::testAndWriteOut()
396 {
397 if ( m_bitsLeft < 12 )
398 {
399 writeOut();
400 }
401 }
402
403 /**
404 * \brief Move bits from register into bitstream
405 */
writeOut()406 Void TEncBinCABAC::writeOut()
407 {
408 UInt leadByte = m_uiLow >> (24 - m_bitsLeft);
409 m_bitsLeft += 8;
410 m_uiLow &= 0xffffffffu >> m_bitsLeft;
411
412 if ( leadByte == 0xff )
413 {
414 m_numBufferedBytes++;
415 }
416 else
417 {
418 if ( m_numBufferedBytes > 0 )
419 {
420 UInt carry = leadByte >> 8;
421 UInt byte = m_bufferedByte + carry;
422 m_bufferedByte = leadByte & 0xff;
423 m_pcTComBitIf->write( byte, 8 );
424
425 byte = ( 0xff + carry ) & 0xff;
426 while ( m_numBufferedBytes > 1 )
427 {
428 m_pcTComBitIf->write( byte, 8 );
429 m_numBufferedBytes--;
430 }
431 }
432 else
433 {
434 m_numBufferedBytes = 1;
435 m_bufferedByte = leadByte;
436 }
437 }
438 }
439
440 //! \}
441