Hamsalekha S | 8d3d303 | 2015-03-13 21:24:58 +0530 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * Copyright (C) 2015 The Android Open Source Project |
| 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 | * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| 19 | */ |
| 20 | |
| 21 | /** |
| 22 | ****************************************************************************** |
| 23 | * @file |
| 24 | * ih264e_bitstream.c |
| 25 | * |
| 26 | * @brief |
| 27 | * This file contains function definitions related to bitstream generation |
| 28 | * |
| 29 | * @author |
| 30 | * ittiam |
| 31 | * |
| 32 | * @par List of Functions: |
| 33 | * - ih264e_bitstrm_init() |
| 34 | * - ih264e_put_bits() |
| 35 | * - ih264e_put_bit() |
| 36 | * - ih264e_put_rbsp_trailing_bits() |
| 37 | * - ih264e_put_uev() |
| 38 | * - ih264e_put_sev() |
| 39 | * - ih264e_put_nal_start_code_prefix() |
| 40 | * |
| 41 | ****************************************************************************** |
| 42 | */ |
| 43 | |
| 44 | /*****************************************************************************/ |
| 45 | /* File Includes */ |
| 46 | /*****************************************************************************/ |
| 47 | |
| 48 | /* System include files */ |
| 49 | #include <stdio.h> |
| 50 | #include <string.h> |
| 51 | #include <stdlib.h> |
| 52 | #include <assert.h> |
| 53 | #include <stdarg.h> |
| 54 | #include <math.h> |
| 55 | |
| 56 | /* User include files */ |
| 57 | #include "ih264e_config.h" |
| 58 | #include "ih264_typedefs.h" |
| 59 | #include "ih264_platform_macros.h" |
| 60 | #include "ih264_debug.h" |
| 61 | #include "ih264e_error.h" |
| 62 | #include "ih264e_bitstream.h" |
| 63 | #include "ih264_defs.h" |
| 64 | #include "ih264_macros.h" |
| 65 | |
| 66 | |
| 67 | /*****************************************************************************/ |
| 68 | /* Function Definitions */ |
| 69 | /*****************************************************************************/ |
| 70 | |
| 71 | /** |
| 72 | ****************************************************************************** |
| 73 | * |
| 74 | * @brief Initializes the encoder bitstream engine |
| 75 | * |
| 76 | * @par Description |
| 77 | * This routine needs to be called at start of slice/frame encode |
| 78 | * |
| 79 | * @param[in] ps_bitstrm |
| 80 | * pointer to bitstream context (handle) |
| 81 | * |
| 82 | * @param[in] p1_bitstrm_buf |
| 83 | * bitstream buffer pointer where the encoded stream is generated in byte order |
| 84 | * |
| 85 | * @param[in] u4_max_bitstrm_size |
| 86 | * indicates maximum bitstream buffer size. (in bytes) |
| 87 | * If actual stream size exceeds the maximum size, encoder should |
| 88 | * 1. Not corrupt data beyond u4_max_bitstrm_size bytes |
| 89 | * 2. Report an error back to application indicating overflow |
| 90 | * |
| 91 | * @return success or failure error code |
| 92 | * |
| 93 | ****************************************************************************** |
| 94 | */ |
| 95 | IH264E_ERROR_T ih264e_bitstrm_init(bitstrm_t *ps_bitstrm, |
| 96 | UWORD8 *pu1_bitstrm_buf, |
| 97 | UWORD32 u4_max_bitstrm_size) |
| 98 | { |
| 99 | ps_bitstrm->pu1_strm_buffer = pu1_bitstrm_buf; |
Harinarayanan K K | d2d469e | 2015-06-19 14:45:44 +0530 | [diff] [blame] | 100 | ps_bitstrm->u4_max_strm_size = u4_max_bitstrm_size; |
Hamsalekha S | 8d3d303 | 2015-03-13 21:24:58 +0530 | [diff] [blame] | 101 | |
| 102 | /* Default init values for other members of bitstream context */ |
| 103 | ps_bitstrm->u4_strm_buf_offset = 0; |
| 104 | ps_bitstrm->u4_cur_word = 0; |
| 105 | ps_bitstrm->i4_bits_left_in_cw = WORD_SIZE; |
| 106 | ps_bitstrm->i4_zero_bytes_run = 0; |
| 107 | |
| 108 | return(IH264E_SUCCESS); |
| 109 | } |
| 110 | |
| 111 | /** |
| 112 | ****************************************************************************** |
| 113 | * |
| 114 | * @brief puts a code with specified number of bits into the bitstream |
| 115 | * |
| 116 | * @par Description |
| 117 | * inserts code_len number of bits from lsb of code_val into the |
| 118 | * bitstream. updates context members like u4_cur_word, u4_strm_buf_offset and |
| 119 | * i4_bits_left_in_cw. If the total words (u4_strm_buf_offset) exceeds max |
| 120 | * available size (u4_max_strm_size), returns error without corrupting data |
| 121 | * beyond it |
| 122 | * |
| 123 | * @param[in] ps_bitstrm |
| 124 | * pointer to bitstream context (handle) |
| 125 | * |
| 126 | * @param[in] u4_code_val |
| 127 | * code value that needs to be inserted in the stream. |
| 128 | * |
| 129 | * @param[in] code_len |
| 130 | * indicates code length (in bits) of code_val that would be inserted in |
| 131 | * bitstream buffer size. Range of length[1:WORD_SIZE] |
| 132 | * |
| 133 | * @remarks Assumptions: all bits from bit position code_len to msb of |
| 134 | * code_val shall be zero |
| 135 | * |
| 136 | * @return success or failure error code |
| 137 | * |
| 138 | ****************************************************************************** |
| 139 | */ |
| 140 | IH264E_ERROR_T ih264e_put_bits(bitstrm_t *ps_bitstrm, |
| 141 | UWORD32 u4_code_val, |
| 142 | WORD32 code_len) |
| 143 | { |
| 144 | UWORD32 u4_cur_word = ps_bitstrm->u4_cur_word; |
| 145 | WORD32 bits_left_in_cw = ps_bitstrm->i4_bits_left_in_cw; |
| 146 | |
| 147 | |
| 148 | /* check assumptions made in the module */ |
| 149 | ASSERT(code_len > 0 && code_len <= WORD_SIZE); |
| 150 | |
| 151 | if(code_len < WORD_SIZE) |
| 152 | ASSERT((u4_code_val >> code_len) == 0); |
| 153 | |
Hamsalekha S | 8d3d303 | 2015-03-13 21:24:58 +0530 | [diff] [blame] | 154 | /* sanity check on the bitstream engine state */ |
| 155 | ASSERT(bits_left_in_cw > 0 && bits_left_in_cw <= WORD_SIZE); |
| 156 | |
| 157 | ASSERT(ps_bitstrm->i4_zero_bytes_run <= EPB_ZERO_BYTES); |
| 158 | |
| 159 | ASSERT(ps_bitstrm->pu1_strm_buffer != NULL); |
| 160 | |
| 161 | |
| 162 | if(bits_left_in_cw > code_len) |
| 163 | { |
| 164 | /*******************************************************************/ |
| 165 | /* insert the code in local bitstream word and return */ |
| 166 | /* code is inserted in position of bits left (post decrement) */ |
| 167 | /*******************************************************************/ |
| 168 | bits_left_in_cw -= code_len; |
| 169 | u4_cur_word |= (u4_code_val << bits_left_in_cw); |
| 170 | |
| 171 | ps_bitstrm->u4_cur_word = u4_cur_word; |
| 172 | ps_bitstrm->i4_bits_left_in_cw = bits_left_in_cw; |
| 173 | |
| 174 | return(IH264E_SUCCESS); |
| 175 | } |
| 176 | else |
| 177 | { |
| 178 | /********************************************************************/ |
| 179 | /* 1. insert partial code corresponding to bits left in cur word */ |
| 180 | /* 2. flush all the bits of cur word to bitstream */ |
| 181 | /* 3. insert emulation prevention bytes while flushing the bits */ |
| 182 | /* 4. insert remaining bits of code starting from msb of cur word */ |
| 183 | /* 5. update bitsleft in current word and stream buffer offset */ |
| 184 | /********************************************************************/ |
| 185 | UWORD32 u4_strm_buf_offset = ps_bitstrm->u4_strm_buf_offset; |
| 186 | |
| 187 | UWORD32 u4_max_strm_size = ps_bitstrm->u4_max_strm_size; |
| 188 | |
| 189 | WORD32 zero_run = ps_bitstrm->i4_zero_bytes_run; |
| 190 | |
| 191 | UWORD8* pu1_strm_buf = ps_bitstrm->pu1_strm_buffer; |
| 192 | |
| 193 | WORD32 i, rem_bits = (code_len - bits_left_in_cw); |
| 194 | |
| 195 | |
| 196 | /*********************************************************************/ |
| 197 | /* Bitstream overflow check */ |
| 198 | /* NOTE: corner case of epb bytes (max 2 for 32bit word) not handled */ |
| 199 | /*********************************************************************/ |
| 200 | if((u4_strm_buf_offset + (WORD_SIZE>>3)) >= u4_max_strm_size) |
| 201 | { |
| 202 | /* return without corrupting the buffer beyond its size */ |
| 203 | return(IH264E_BITSTREAM_BUFFER_OVERFLOW); |
| 204 | } |
| 205 | |
| 206 | /* insert parital code corresponding to bits left in cur word */ |
| 207 | u4_cur_word |= u4_code_val >> rem_bits; |
| 208 | |
| 209 | for(i = WORD_SIZE; i > 0; i -= 8) |
| 210 | { |
| 211 | /* flush the bits in cur word byte by byte and copy to stream */ |
| 212 | UWORD8 u1_next_byte = (u4_cur_word >> (i-8)) & 0xFF; |
| 213 | |
| 214 | PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_next_byte, zero_run); |
| 215 | } |
| 216 | |
| 217 | /* insert the remaining bits from code val into current word */ |
| 218 | u4_cur_word = rem_bits ? (u4_code_val << (WORD_SIZE - rem_bits)) : 0; |
| 219 | |
| 220 | /* update the state variables and return success */ |
| 221 | ps_bitstrm->u4_cur_word = u4_cur_word; |
| 222 | ps_bitstrm->i4_bits_left_in_cw = WORD_SIZE - rem_bits; |
| 223 | ps_bitstrm->i4_zero_bytes_run = zero_run; |
| 224 | ps_bitstrm->u4_strm_buf_offset = u4_strm_buf_offset; |
| 225 | return (IH264E_SUCCESS); |
| 226 | } |
| 227 | } |
| 228 | |
| 229 | /** |
| 230 | ****************************************************************************** |
| 231 | * |
| 232 | * @brief inserts a 1-bit code into the bitstream |
| 233 | * |
| 234 | * @par Description |
| 235 | * inserts 1bit lsb of code_val into the bitstream |
| 236 | * updates context members like u4_cur_word, u4_strm_buf_offset and |
| 237 | * i4_bits_left_in_cw. If the total words (u4_strm_buf_offset) exceeds max |
| 238 | * available size (u4_max_strm_size), returns error without corrupting data |
| 239 | * beyond it |
| 240 | * |
| 241 | * @param[in] ps_bitstrm |
| 242 | * pointer to bitstream context (handle) |
| 243 | * |
| 244 | * @param[in] u4_code_val |
| 245 | * code value that needs to be inserted in the stream. |
| 246 | * |
| 247 | * @remarks Assumptions: all bits from bit position 1 to msb of code_val |
| 248 | * shall be zero |
| 249 | * |
| 250 | * @return success or failure error code |
| 251 | * |
| 252 | ****************************************************************************** |
| 253 | */ |
| 254 | IH264E_ERROR_T ih264e_put_bit(bitstrm_t *ps_bitstrm, UWORD32 u4_code_val) |
| 255 | { |
| 256 | /* call the put bits function for 1 bit and return */ |
| 257 | return(ih264e_put_bits(ps_bitstrm, u4_code_val, 1)); |
| 258 | } |
| 259 | |
| 260 | /** |
| 261 | ****************************************************************************** |
| 262 | * |
| 263 | * @brief inserts rbsp trailing bits at the end of stream buffer (NAL) |
| 264 | * |
| 265 | * @par Description |
| 266 | * inserts rbsp trailing bits, updates context members like u4_cur_word and |
| 267 | * i4_bits_left_in_cw and flushes the same in the bitstream buffer. If the |
| 268 | * total words (u4_strm_buf_offset) exceeds max available size |
| 269 | * (u4_max_strm_size), returns error without corrupting data beyond it |
| 270 | * |
| 271 | * @param[in] ps_bitstrm |
| 272 | * pointer to bitstream context (handle) |
| 273 | * |
| 274 | * @return success or failure error code |
| 275 | * |
| 276 | ****************************************************************************** |
| 277 | */ |
| 278 | IH264E_ERROR_T ih264e_put_rbsp_trailing_bits(bitstrm_t *ps_bitstrm) |
| 279 | { |
| 280 | WORD32 i; |
| 281 | UWORD32 u4_cur_word = ps_bitstrm->u4_cur_word; |
| 282 | WORD32 bits_left_in_cw = ps_bitstrm->i4_bits_left_in_cw; |
| 283 | WORD32 bytes_left_in_cw = (bits_left_in_cw - 1) >> 3; |
| 284 | |
| 285 | UWORD32 u4_strm_buf_offset = ps_bitstrm->u4_strm_buf_offset; |
| 286 | UWORD32 u4_max_strm_size = ps_bitstrm->u4_max_strm_size; |
| 287 | WORD32 zero_run = ps_bitstrm->i4_zero_bytes_run; |
| 288 | UWORD8* pu1_strm_buf = ps_bitstrm->pu1_strm_buffer; |
| 289 | |
| 290 | /*********************************************************************/ |
| 291 | /* Bitstream overflow check */ |
| 292 | /* NOTE: corner case of epb bytes (max 2 for 32bit word) not handled */ |
| 293 | /*********************************************************************/ |
| 294 | if((u4_strm_buf_offset + (WORD_SIZE>>3) - bytes_left_in_cw) >= |
| 295 | u4_max_strm_size) |
| 296 | { |
| 297 | /* return without corrupting the buffer beyond its size */ |
| 298 | return(IH264E_BITSTREAM_BUFFER_OVERFLOW); |
| 299 | } |
| 300 | |
| 301 | /* insert a 1 at the end of current word and flush all the bits */ |
| 302 | u4_cur_word |= (1 << (bits_left_in_cw - 1)); |
| 303 | |
| 304 | /* get the bits to be inserted in msbdb of the word */ |
| 305 | //u4_cur_word <<= (WORD_SIZE - bytes_left_in_cw + 1); |
| 306 | |
| 307 | for(i = WORD_SIZE; i > (bytes_left_in_cw*8); i -= 8) |
| 308 | { |
| 309 | /* flush the bits in cur word byte by byte and copy to stream */ |
| 310 | UWORD8 u1_next_byte = (u4_cur_word >> (i-8)) & 0xFF; |
| 311 | |
| 312 | PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_next_byte, zero_run); |
| 313 | } |
| 314 | |
| 315 | /* update the stream offset */ |
| 316 | ps_bitstrm->u4_strm_buf_offset = u4_strm_buf_offset; |
| 317 | |
| 318 | /* Default init values for scratch variables of bitstream context */ |
| 319 | ps_bitstrm->u4_cur_word = 0; |
| 320 | ps_bitstrm->i4_bits_left_in_cw = WORD_SIZE; |
| 321 | ps_bitstrm->i4_zero_bytes_run = 0; |
| 322 | |
| 323 | return (IH264E_SUCCESS); |
| 324 | } |
| 325 | |
| 326 | /** |
| 327 | ****************************************************************************** |
| 328 | * |
| 329 | * @brief puts exponential golomb code of a unsigned integer into bitstream |
| 330 | * |
| 331 | * @par Description |
| 332 | * computes uev code for given syntax element and inserts the same into |
| 333 | * bitstream by calling ih264e_put_bits() interface. |
| 334 | * |
| 335 | * @param[in] ps_bitstrm |
| 336 | * pointer to bitstream context (handle) |
| 337 | * |
| 338 | * @param[in] u4_code_num |
| 339 | * unsigned integer input whose golomb code is written in stream |
| 340 | * |
| 341 | * @remarks Assumptions: code value can be represented in less than 16bits |
| 342 | * |
| 343 | * @return success or failure error code |
| 344 | * |
| 345 | ****************************************************************************** |
| 346 | */ |
| 347 | IH264E_ERROR_T ih264e_put_uev(bitstrm_t *ps_bitstrm, UWORD32 u4_code_num) |
| 348 | { |
| 349 | UWORD32 u4_bit_str, u4_range; |
| 350 | IH264E_ERROR_T e_error; |
| 351 | |
| 352 | /* convert the codenum to exp-golomb bit code: Table 9-2 JCTVC-J1003_d7 */ |
| 353 | u4_bit_str = u4_code_num + 1; |
| 354 | |
| 355 | /* get range of the bit string and put using put_bits() */ |
| 356 | GETRANGE(u4_range, u4_bit_str); |
| 357 | |
| 358 | e_error = ih264e_put_bits(ps_bitstrm, u4_bit_str, (2 * u4_range - 1)); |
| 359 | |
| 360 | return(e_error); |
| 361 | } |
| 362 | |
| 363 | /** |
| 364 | ****************************************************************************** |
| 365 | * |
| 366 | * @brief puts exponential golomb code of a signed integer into bitstream |
| 367 | * |
| 368 | * @par Description |
| 369 | * computes sev code for given syntax element and inserts the same into |
| 370 | * bitstream by calling ih264e_put_bits() interface. |
| 371 | * |
| 372 | * @param[in] ps_bitstrm |
| 373 | * pointer to bitstream context (handle) |
| 374 | * |
| 375 | * @param[in] syntax_elem |
| 376 | * signed integer input whose golomb code is written in stream |
| 377 | * |
| 378 | * @remarks Assumptions: code value can be represented in less than 16bits |
| 379 | * |
| 380 | * @return success or failure error code |
| 381 | * |
| 382 | ****************************************************************************** |
| 383 | */ |
| 384 | IH264E_ERROR_T ih264e_put_sev(bitstrm_t *ps_bitstrm, WORD32 syntax_elem) |
| 385 | { |
| 386 | UWORD32 u4_code_num, u4_bit_str, u4_range; |
| 387 | IH264E_ERROR_T e_error; |
| 388 | |
| 389 | /************************************************************************/ |
| 390 | /* convert the codenum to exp-golomb bit code for signed syntax element */ |
| 391 | /* See Table9-2 and Table 9-3 of standard JCTVC-J1003_d7 */ |
| 392 | /************************************************************************/ |
| 393 | if(syntax_elem <= 0) |
| 394 | { |
| 395 | /* codeNum for non-positive integer = 2*abs(x) : Table9-3 */ |
| 396 | u4_code_num = ((-syntax_elem) << 1); |
| 397 | } |
| 398 | else |
| 399 | { |
| 400 | /* codeNum for positive integer = 2x-1 : Table9-3 */ |
| 401 | u4_code_num = (syntax_elem << 1) - 1; |
| 402 | } |
| 403 | |
| 404 | /* convert the codenum to exp-golomb bit code: Table 9-2 JCTVC-J1003_d7 */ |
| 405 | u4_bit_str = u4_code_num + 1; |
| 406 | |
| 407 | /* get range of the bit string and put using put_bits() */ |
| 408 | GETRANGE(u4_range, u4_bit_str); |
| 409 | |
| 410 | e_error = ih264e_put_bits(ps_bitstrm, u4_bit_str, (2 * u4_range - 1)); |
| 411 | |
| 412 | return(e_error); |
| 413 | } |
| 414 | |
| 415 | /** |
| 416 | ****************************************************************************** |
| 417 | * |
| 418 | * @brief insert NAL start code prefix (0x000001) into bitstream with an option |
| 419 | * of inserting leading_zero_8bits (which makes startcode prefix as 0x00000001) |
| 420 | * |
| 421 | * @par Description |
| 422 | * Although start code prefix could have been put by calling ih264e_put_bits(), |
| 423 | * ih264e_put_nal_start_code_prefix() is specially added to make sure emulation |
| 424 | * prevention insertion is not done for the NAL start code prefix which will |
| 425 | * surely happen otherwise by calling ih264e_put_bits() interface. |
| 426 | * |
| 427 | * @param[in] ps_bitstrm |
| 428 | * pointer to bitstream context (handle) |
| 429 | * |
| 430 | * @param[in] insert_leading_zero_8bits |
| 431 | * flag indicating if one more zero bytes needs to prefixed before start code |
| 432 | * |
| 433 | * @return success or failure error code |
| 434 | * |
| 435 | ****************************************************************************** |
| 436 | */ |
| 437 | IH264E_ERROR_T ih264e_put_nal_start_code_prefix(bitstrm_t *ps_bitstrm, |
| 438 | WORD32 insert_leading_zero_8bits) |
| 439 | { |
| 440 | UWORD32 u4_strm_buf_offset = ps_bitstrm->u4_strm_buf_offset; |
| 441 | UWORD8* pu1_strm_buf = ps_bitstrm->pu1_strm_buffer; |
| 442 | |
| 443 | /* Bitstream buffer overflow check assuming worst case of 4 bytes */ |
| 444 | if((u4_strm_buf_offset + 4) >= ps_bitstrm->u4_max_strm_size) |
| 445 | { |
| 446 | return(IH264E_BITSTREAM_BUFFER_OVERFLOW); |
| 447 | } |
| 448 | |
| 449 | /* Insert leading zero 8 bits conditionally */ |
| 450 | if(insert_leading_zero_8bits) |
| 451 | { |
| 452 | pu1_strm_buf[u4_strm_buf_offset] = 0x00; |
| 453 | u4_strm_buf_offset++; |
| 454 | } |
| 455 | |
| 456 | /* Insert NAL start code prefix 0x00 00 01 */ |
| 457 | pu1_strm_buf[u4_strm_buf_offset] = 0x00; |
| 458 | u4_strm_buf_offset++; |
| 459 | |
| 460 | pu1_strm_buf[u4_strm_buf_offset] = 0x00; |
| 461 | u4_strm_buf_offset++; |
| 462 | |
| 463 | pu1_strm_buf[u4_strm_buf_offset] = 0x01; |
| 464 | u4_strm_buf_offset++; |
| 465 | |
| 466 | /* update the stream offset */ |
| 467 | ps_bitstrm->u4_strm_buf_offset = u4_strm_buf_offset; |
| 468 | |
| 469 | return (IH264E_SUCCESS); |
| 470 | } |
| 471 | |