1/******************************************************************************
2*
3* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
4*
5* Licensed under the Apache License, Version 2.0 (the "License");
6* you may not use this file except in compliance with the License.
7* You may obtain a copy of the License at:
8*
9* http://www.apache.org/licenses/LICENSE-2.0
10*
11* Unless required by applicable law or agreed to in writing, software
12* distributed under the License is distributed on an "AS IS" BASIS,
13* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14* See the License for the specific language governing permissions and
15* limitations under the License.
16*
17******************************************************************************/
18/**
19*******************************************************************************
20* @file
21*  ihevcd_bitstream.c
22*
23* @brief
24*  Contains functions for bitstream access
25*
26* @author
27*  Harish
28*
29* @par List of Functions:
30* - ihevcd_bits_init()
31* - ihevcd_bits_flush()
32* - ihevcd_bits_flush_to_byte_boundary()
33* - ihevcd_bits_nxt()
34* - ihevcd_bits_nxt32()
35* - ihevcd_bits_get()
36* - ihevcd_bits_num_bits_remaining()
37* - ihevcd_bits_num_bits_consumed()
38* - ihevcd_sev()
39* - ihevcd_uev()
40*
41*
42* @remarks
43*  None
44*
45*******************************************************************************
46*/
47/*****************************************************************************/
48/* File Includes                                                             */
49/*****************************************************************************/
50#include <stdio.h>
51#include <stddef.h>
52#include <stdlib.h>
53#include <string.h>
54#include <assert.h>
55#include "ihevc_typedefs.h"
56#include "iv.h"
57#include "ivd.h"
58#include "ihevcd_cxa.h"
59
60#include "ihevc_defs.h"
61#include "ihevc_debug.h"
62#include "ihevc_structs.h"
63#include "ihevc_macros.h"
64#include "ihevc_platform_macros.h"
65#include "ihevc_cabac_tables.h"
66
67#include "ihevcd_defs.h"
68#include "ihevcd_function_selector.h"
69#include "ihevcd_structs.h"
70#include "ihevcd_error.h"
71#include "ihevcd_bitstream.h"
72
73/*****************************************************************************/
74/* Function Prototypes                                                       */
75/*****************************************************************************/
76
77/**
78*******************************************************************************
79*
80* @brief
81*  Function used for bitstream structure initialization
82*
83* @par Description:
84*  Initialize bitstream structure elements
85*
86* @param[in] ps_bitstrm
87*  Pointer to bitstream structure
88*
89* @param[in] pu1_buf
90*  Pointer to bitstream data
91*
92* @param[in] u4_numbytes
93*  Number of bytes in bitstream
94*
95* @returns  none
96*
97* @remarks
98*  Assumes pu1_buf is aligned to 4 bytes. If not aligned  then all bitstream
99* accesses will be unaligned and hence  costlier. Since this is codec memory
100* that holds emulation prevented data, assumption of aligned to 4 bytes is
101* valid
102*
103*******************************************************************************
104*/
105void ihevcd_bits_init(bitstrm_t *ps_bitstrm,
106                      UWORD8 *pu1_buf,
107                      UWORD32 u4_numbytes)
108{
109    UWORD32 u4_cur_word;
110    UWORD32 u4_nxt_word;
111    UWORD32 u4_temp;
112    UWORD32 *pu4_buf;
113
114    pu4_buf     = (UWORD32 *)pu1_buf;
115    u4_temp = *pu4_buf++;
116    u4_cur_word = ITT_BIG_ENDIAN(u4_temp);
117    u4_temp = *pu4_buf++;
118    u4_nxt_word = ITT_BIG_ENDIAN(u4_temp);
119
120    ps_bitstrm->u4_bit_ofst     = 0;
121    ps_bitstrm->pu1_buf_base    = pu1_buf;
122    ps_bitstrm->pu4_buf         = pu4_buf;
123    ps_bitstrm->u4_cur_word     = u4_cur_word;
124    ps_bitstrm->u4_nxt_word     = u4_nxt_word;
125
126    ps_bitstrm->pu1_buf_max     = pu1_buf + u4_numbytes + 8;
127
128    return;
129}
130
131/**
132*******************************************************************************
133*
134* @brief
135*  Flushes given number of bits. Bits consumed increases by  this number
136*
137* @par Description:
138*  Increment bit offset by numbits. If bit offset increases  beyond 32, then
139* move nxt_word to cur_word, read next  word32 to nxt_word after endian
140* conversion
141*
142* @param[in] ps_bitstrm
143*  Pointer to bitstream structure
144*
145* @param[in] u4_numbits
146*  Number of bits to be flushed
147*
148* @returns  None
149*
150* @remarks
151*
152*
153*******************************************************************************
154*/
155void ihevcd_bits_flush(bitstrm_t *ps_bitstrm, UWORD32 u4_numbits)
156{
157
158    BITS_FLUSH(ps_bitstrm->pu4_buf,
159               ps_bitstrm->u4_bit_ofst,
160               ps_bitstrm->u4_cur_word,
161               ps_bitstrm->u4_nxt_word,
162               u4_numbits);
163
164    return;
165}
166
167/**
168*******************************************************************************
169*
170* @brief
171*  Flushes to next byte boundary.Bits consumed increases by  this number
172*
173* @par Description:
174*  Compute number of bits remaining in the current byte  then call
175* ihevcd_bits_flush() bits with this number
176*
177* @param[in] ps_bitstrm
178*  Pointer to bitstream structure
179*
180* @returns  None
181*
182* @remarks
183*
184*
185*******************************************************************************
186*/
187void ihevcd_bits_flush_to_byte_boundary(bitstrm_t *ps_bitstrm)
188{
189    UWORD32 u4_numbits;
190    u4_numbits = (ps_bitstrm->u4_bit_ofst) & 7;
191
192    u4_numbits = 8 - u4_numbits;
193
194    BITS_FLUSH(ps_bitstrm->pu4_buf,
195               ps_bitstrm->u4_bit_ofst,
196               ps_bitstrm->u4_cur_word,
197               ps_bitstrm->u4_nxt_word,
198               u4_numbits);
199
200    return;
201}
202
203/**
204*******************************************************************************
205*
206* @brief
207*  Seeks by given number of bits in the bitstream from current position
208*
209* @par Description:
210*  Add given number of bits to bitstream offset and update pu4_buf, cur_word and
211*  nxt_word accordingly
212*
213* @param[in] ps_bitstrm
214*  Pointer to bitstream structure
215*
216* @param[in] numbits
217*  Number of bits to seek
218*
219* @returns  None
220*
221* @remarks
222* Assumes emulation prevention has been done before and the buffer does not
223* contain any emulation prevention bytes
224*
225*******************************************************************************
226*/
227void ihevcd_bits_seek(bitstrm_t *ps_bitstrm, WORD32 numbits)
228{
229    WORD32 val;
230    ASSERT(numbits >= -32);
231    ASSERT(numbits <= 32);
232    /* Check if Seeking backwards*/
233    if(numbits < 0)
234    {
235        UWORD32 abs_numbits = -numbits;
236        if(ps_bitstrm->u4_bit_ofst >= abs_numbits)
237        {
238            /* If the current offset is greater than number of bits to seek back,
239             * then subtract abs_numbits from offset and return.
240             */
241            ps_bitstrm->u4_bit_ofst -= abs_numbits;
242            return;
243        }
244        else
245        {
246            /* If the current offset is lesser than number of bits to seek back,
247             * then subtract abs_numbits from offset and add 32 and move cur_word to nxt_word
248             * and load cur_word appropriately and decrement pu4_buf
249             */
250            ps_bitstrm->u4_bit_ofst -= abs_numbits;
251            ps_bitstrm->u4_bit_ofst += 32;
252            ps_bitstrm->pu4_buf--;
253
254            val = *(ps_bitstrm->pu4_buf - 2);
255            ps_bitstrm->u4_nxt_word = ps_bitstrm->u4_cur_word;
256            ps_bitstrm->u4_cur_word = ITT_BIG_ENDIAN(val);
257            return;
258        }
259    }
260    else
261    {
262        /* Not supported/tested currently */
263        ASSERT(1);
264        BITS_FLUSH(ps_bitstrm->pu4_buf,
265                   ps_bitstrm->u4_bit_ofst,
266                   ps_bitstrm->u4_cur_word,
267                   ps_bitstrm->u4_nxt_word,
268                   numbits);
269
270
271    }
272    return;
273}
274/**
275*******************************************************************************
276*
277* @brief
278*  Snoops for next numbits number of bits from the bitstream this does not
279* update the bitstream offset and does not  consume the bits
280*
281* @par Description:
282*  Extract required number of bits from cur_word & nxt_word  return these
283* bits
284*
285* @param[in] ps_bitstrm
286*  Pointer to bitstream structure
287*
288* @param[in] u4_numbits
289*  Number of bits
290*
291* @returns  Next u4_numbits number of bits
292*
293* @remarks
294*
295*
296*******************************************************************************
297*/
298UWORD32 ihevcd_bits_nxt(bitstrm_t *ps_bitstrm, UWORD32 u4_numbits)
299{
300    UWORD32 u4_bits_read;
301
302    BITS_NXT(u4_bits_read,
303             ps_bitstrm->pu4_buf,
304             ps_bitstrm->u4_bit_ofst,
305             ps_bitstrm->u4_cur_word,
306             ps_bitstrm->u4_nxt_word,
307             u4_numbits);
308    return u4_bits_read;
309}
310/**
311*******************************************************************************
312*
313* @brief
314*  Snoops for next 32 bits from the bitstream  this does not update the
315* bitstream offset and does not  consume the bits
316*
317* @par Description:
318*  Extract required number of bits from cur_word & nxt_word  return these
319* bits
320*
321* @param[in] ps_bitstrm
322*  Pointer to bitstream structure
323*
324* @param[in] u4_numbits
325*  Number of bits
326*
327* @returns  Next 32 bits
328*
329* @remarks
330*
331*
332*******************************************************************************
333*/
334UWORD32 ihevcd_bits_nxt32(bitstrm_t *ps_bitstrm, UWORD32 u4_numbits)
335{
336    UWORD32 u4_bits_read;
337    UNUSED(u4_numbits);
338    BITS_NXT32(u4_bits_read,
339               ps_bitstrm->pu4_buf,
340               ps_bitstrm->u4_bit_ofst,
341               ps_bitstrm->u4_cur_word,
342               ps_bitstrm->u4_nxt_word);
343    return u4_bits_read;
344}
345
346/**
347*******************************************************************************
348*
349* @brief
350*  Reads next numbits number of bits from the bitstream  this updates the
351* bitstream offset and consumes the bits
352*
353* @par Description:
354*  Extract required number of bits from cur_word & nxt_word  return these
355* bits
356*
357* @param[in] ps_bitstrm
358*  Pointer to bitstream structure
359*
360* @param[in] u4_numbits
361*  Number of bits
362*
363* @returns  Bits read
364*
365* @remarks
366*
367*
368*******************************************************************************
369*/
370UWORD32 ihevcd_bits_get(bitstrm_t *ps_bitstrm, UWORD32 u4_numbits)
371{
372    UWORD32 u4_bits_read;
373
374    BITS_GET(u4_bits_read,
375             ps_bitstrm->pu4_buf,
376             ps_bitstrm->u4_bit_ofst,
377             ps_bitstrm->u4_cur_word,
378             ps_bitstrm->u4_nxt_word,
379             u4_numbits);
380    return u4_bits_read;
381
382}
383
384/**
385*******************************************************************************
386*
387* @brief
388*  Returns the number of bits remaining in the bitstream
389*
390* @par Description:
391*  Compute number of bits remaining based on current pointer and buffer base
392* and current offset. Since 8 bytes are  read at the start into cur_word and
393* nxt_word and are not  consumed, 8 has to be subtracted
394*
395* @param[in] ps_bitstrm
396*  Pointer to bitstream structure
397*
398* @returns  Total number of bits remaining
399*
400* @remarks
401*
402*
403*******************************************************************************
404*/
405UWORD32  ihevcd_bits_num_bits_remaining(bitstrm_t *ps_bitstrm)
406{
407    UWORD32 u4_bits_consumed;
408    UWORD32 u4_size_in_bits;
409
410    /* 8 bytes are read in cur_word and nxt_word at the start. Hence */
411    /* subtract 8 bytes */
412    u4_bits_consumed = (UWORD32)(((UWORD8 *)ps_bitstrm->pu4_buf -
413                                  (UWORD8 *)ps_bitstrm->pu1_buf_base - 8) <<
414                                 3) + ps_bitstrm->u4_bit_ofst;
415
416    u4_size_in_bits = (UWORD32)(ps_bitstrm->pu1_buf_max -
417                    ps_bitstrm->pu1_buf_base);
418    return (u4_size_in_bits - u4_bits_consumed);
419}
420
421/**
422*******************************************************************************
423*
424* @brief
425*  Returns the number of bits consumed in the bitstream
426*
427* @par Description:
428*  Compute number of bits consumed based on current pointer  and buffer base
429* and current offset. Since 8 bytes are  read at the start into cur_word and
430* nxt_word and are not  consumed, 8 has to be subtracted
431*
432* @param[in] ps_bitstrm
433*  Pointer to bitstream structure
434*
435* @returns  Total number of bits bits consumed
436*
437* @remarks
438*
439*
440*******************************************************************************
441*/
442UWORD32  ihevcd_bits_num_bits_consumed(bitstrm_t *ps_bitstrm)
443{
444    UWORD32 u4_bits_consumed;
445    /* 8 bytes are read in cur_word and nxt_word at the start. Hence */
446    /* subtract 8 bytes */
447
448    u4_bits_consumed = (UWORD32)(((UWORD8 *)ps_bitstrm->pu4_buf -
449                                  (UWORD8 *)ps_bitstrm->pu1_buf_base - 8) <<
450                                 3) + ps_bitstrm->u4_bit_ofst;
451    return u4_bits_consumed;
452}
453
454/**
455*******************************************************************************
456*
457* @brief
458*  Reads unsigned integer 0-th order exp-golomb-coded syntax element from
459* the bitstream  Section: 9.2
460*
461* @par Description:
462*  Extract required number of bits from cur_word & nxt_word  return these
463* bits
464*
465* @param[in] ps_bitstrm
466*  Pointer to bitstream structure
467*
468* @returns  UEV decoded syntax element
469*
470* @remarks
471*
472*
473*******************************************************************************
474*/
475UWORD32 ihevcd_uev(bitstrm_t *ps_bitstrm)
476{
477    UWORD32 u4_bits_read;
478    UWORD32 u4_clz;
479
480
481    /***************************************************************/
482    /* Find leading zeros in next 32 bits                          */
483    /***************************************************************/
484    BITS_NXT32(u4_bits_read,
485               ps_bitstrm->pu4_buf,
486               ps_bitstrm->u4_bit_ofst,
487               ps_bitstrm->u4_cur_word,
488               ps_bitstrm->u4_nxt_word);
489
490
491    u4_clz = CLZ(u4_bits_read);
492
493    BITS_FLUSH(ps_bitstrm->pu4_buf,
494               ps_bitstrm->u4_bit_ofst,
495               ps_bitstrm->u4_cur_word,
496               ps_bitstrm->u4_nxt_word,
497               (u4_clz + 1));
498
499    u4_bits_read = 0;
500    if(u4_clz)
501    {
502        BITS_GET(u4_bits_read,
503                 ps_bitstrm->pu4_buf,
504                 ps_bitstrm->u4_bit_ofst,
505                 ps_bitstrm->u4_cur_word,
506                 ps_bitstrm->u4_nxt_word,
507                 u4_clz);
508    }
509    return ((1 << u4_clz) + u4_bits_read - 1);
510
511}
512
513/**
514*******************************************************************************
515*
516* @brief
517*  Reads signed integer 0-th order exp-golomb-coded syntax  element from the
518* bitstream. Function similar to get_uev  Section: 9.2.1
519*
520* @par Description:
521*  Extract required number of bits from cur_word & nxt_word  return these
522* bits
523*
524* @param[in] ps_bitstrm
525*  Pointer to bitstream structure
526*
527* @returns  UEV decoded syntax element
528*
529* @remarks
530*
531*
532*******************************************************************************
533*/
534WORD32 ihevcd_sev(bitstrm_t *ps_bitstrm)
535{
536    UWORD32 u4_bits_read;
537    UWORD32 u4_clz;
538    UWORD32 u4_abs_val;
539
540
541    /***************************************************************/
542    /* Find leading zeros in next 32 bits                          */
543    /***************************************************************/
544    BITS_NXT32(u4_bits_read,
545               ps_bitstrm->pu4_buf,
546               ps_bitstrm->u4_bit_ofst,
547               ps_bitstrm->u4_cur_word,
548               ps_bitstrm->u4_nxt_word);
549
550
551    u4_clz = CLZ(u4_bits_read);
552
553    BITS_FLUSH(ps_bitstrm->pu4_buf,
554               ps_bitstrm->u4_bit_ofst,
555               ps_bitstrm->u4_cur_word,
556               ps_bitstrm->u4_nxt_word,
557               (u4_clz + 1));
558
559    u4_bits_read = 0;
560    if(u4_clz)
561    {
562        BITS_GET(u4_bits_read,
563                 ps_bitstrm->pu4_buf,
564                 ps_bitstrm->u4_bit_ofst,
565                 ps_bitstrm->u4_cur_word,
566                 ps_bitstrm->u4_nxt_word,
567                 u4_clz);
568    }
569    u4_abs_val = ((1 << u4_clz) + u4_bits_read) >> 1;
570    if(u4_bits_read & 0x1)
571        return (-(WORD32)u4_abs_val);
572    else
573        return (u4_abs_val);
574}
575
576
577
578
579
580
581