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 */ 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 */ 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 */ 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 */ 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 -= 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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
