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 */
ihevcd_bits_init(bitstrm_t * ps_bitstrm,UWORD8 * pu1_buf,UWORD32 u4_numbytes)105 void 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 */
ihevcd_bits_flush(bitstrm_t * ps_bitstrm,UWORD32 u4_numbits)155 void 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 */
ihevcd_bits_flush_to_byte_boundary(bitstrm_t * ps_bitstrm)187 void 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 */
ihevcd_bits_seek(bitstrm_t * ps_bitstrm,WORD32 numbits)227 void 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 += 32;
251 ps_bitstrm->u4_bit_ofst -= abs_numbits;
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 */
ihevcd_bits_nxt(bitstrm_t * ps_bitstrm,UWORD32 u4_numbits)298 UWORD32 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 */
ihevcd_bits_nxt32(bitstrm_t * ps_bitstrm,UWORD32 u4_numbits)334 UWORD32 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 */
ihevcd_bits_get(bitstrm_t * ps_bitstrm,UWORD32 u4_numbits)370 UWORD32 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 */
ihevcd_bits_num_bits_remaining(bitstrm_t * ps_bitstrm)405 UWORD32 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) - 8;
418 u4_size_in_bits <<= 3;
419 if(u4_size_in_bits > u4_bits_consumed)
420 {
421 return (u4_size_in_bits - u4_bits_consumed);
422 }
423 else
424 {
425 return 0;
426 }
427 }
428
429 /**
430 *******************************************************************************
431 *
432 * @brief
433 * Returns the number of bits consumed in the bitstream
434 *
435 * @par Description:
436 * Compute number of bits consumed based on current pointer and buffer base
437 * and current offset. Since 8 bytes are read at the start into cur_word and
438 * nxt_word and are not consumed, 8 has to be subtracted
439 *
440 * @param[in] ps_bitstrm
441 * Pointer to bitstream structure
442 *
443 * @returns Total number of bits bits consumed
444 *
445 * @remarks
446 *
447 *
448 *******************************************************************************
449 */
ihevcd_bits_num_bits_consumed(bitstrm_t * ps_bitstrm)450 UWORD32 ihevcd_bits_num_bits_consumed(bitstrm_t *ps_bitstrm)
451 {
452 UWORD32 u4_bits_consumed;
453 /* 8 bytes are read in cur_word and nxt_word at the start. Hence */
454 /* subtract 8 bytes */
455
456 u4_bits_consumed = (UWORD32)(((UWORD8 *)ps_bitstrm->pu4_buf -
457 (UWORD8 *)ps_bitstrm->pu1_buf_base - 8) <<
458 3) + ps_bitstrm->u4_bit_ofst;
459 return u4_bits_consumed;
460 }
461
462 /**
463 *******************************************************************************
464 *
465 * @brief
466 * Reads unsigned integer 0-th order exp-golomb-coded syntax element from
467 * the bitstream Section: 9.2
468 *
469 * @par Description:
470 * Extract required number of bits from cur_word & nxt_word return these
471 * bits
472 *
473 * @param[in] ps_bitstrm
474 * Pointer to bitstream structure
475 *
476 * @returns UEV decoded syntax element
477 *
478 * @remarks
479 *
480 *
481 *******************************************************************************
482 */
ihevcd_uev(bitstrm_t * ps_bitstrm)483 UWORD32 ihevcd_uev(bitstrm_t *ps_bitstrm)
484 {
485 UWORD32 u4_bits_read;
486 UWORD32 u4_clz;
487
488
489 /***************************************************************/
490 /* Find leading zeros in next 32 bits */
491 /***************************************************************/
492 BITS_NXT32(u4_bits_read,
493 ps_bitstrm->pu4_buf,
494 ps_bitstrm->u4_bit_ofst,
495 ps_bitstrm->u4_cur_word,
496 ps_bitstrm->u4_nxt_word);
497
498
499 u4_clz = CLZ(u4_bits_read);
500
501 BITS_FLUSH(ps_bitstrm->pu4_buf,
502 ps_bitstrm->u4_bit_ofst,
503 ps_bitstrm->u4_cur_word,
504 ps_bitstrm->u4_nxt_word,
505 (u4_clz + 1));
506
507 u4_bits_read = 0;
508 if(u4_clz)
509 {
510 BITS_GET(u4_bits_read,
511 ps_bitstrm->pu4_buf,
512 ps_bitstrm->u4_bit_ofst,
513 ps_bitstrm->u4_cur_word,
514 ps_bitstrm->u4_nxt_word,
515 u4_clz);
516 }
517 return ((1 << u4_clz) + u4_bits_read - 1);
518
519 }
520
521 /**
522 *******************************************************************************
523 *
524 * @brief
525 * Reads signed integer 0-th order exp-golomb-coded syntax element from the
526 * bitstream. Function similar to get_uev Section: 9.2.1
527 *
528 * @par Description:
529 * Extract required number of bits from cur_word & nxt_word return these
530 * bits
531 *
532 * @param[in] ps_bitstrm
533 * Pointer to bitstream structure
534 *
535 * @returns UEV decoded syntax element
536 *
537 * @remarks
538 *
539 *
540 *******************************************************************************
541 */
ihevcd_sev(bitstrm_t * ps_bitstrm)542 WORD32 ihevcd_sev(bitstrm_t *ps_bitstrm)
543 {
544 UWORD32 u4_bits_read;
545 UWORD32 u4_clz;
546 UWORD32 u4_abs_val;
547
548
549 /***************************************************************/
550 /* Find leading zeros in next 32 bits */
551 /***************************************************************/
552 BITS_NXT32(u4_bits_read,
553 ps_bitstrm->pu4_buf,
554 ps_bitstrm->u4_bit_ofst,
555 ps_bitstrm->u4_cur_word,
556 ps_bitstrm->u4_nxt_word);
557
558
559 u4_clz = CLZ(u4_bits_read);
560
561 BITS_FLUSH(ps_bitstrm->pu4_buf,
562 ps_bitstrm->u4_bit_ofst,
563 ps_bitstrm->u4_cur_word,
564 ps_bitstrm->u4_nxt_word,
565 (u4_clz + 1));
566
567 u4_bits_read = 0;
568 if(u4_clz)
569 {
570 BITS_GET(u4_bits_read,
571 ps_bitstrm->pu4_buf,
572 ps_bitstrm->u4_bit_ofst,
573 ps_bitstrm->u4_cur_word,
574 ps_bitstrm->u4_nxt_word,
575 u4_clz);
576 }
577 u4_abs_val = ((1 << u4_clz) + u4_bits_read) >> 1;
578 if(u4_bits_read & 0x1)
579 return (-(WORD32)u4_abs_val);
580 else
581 return (u4_abs_val);
582 }
583
584
585
586
587
588
589