| /****************************************************************************** |
| * |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| |
| /** |
| ******************************************************************************* |
| * @file |
| * ih264e_bitstream.h |
| * |
| * @brief |
| * This file contains encoder bitstream engine related structures and |
| * interface prototypes |
| * |
| * @author |
| * ittiam |
| * |
| * @remarks |
| * none |
| * |
| ******************************************************************************* |
| */ |
| |
| #ifndef IH264E_BITSTREAM_H_ |
| #define IH264E_BITSTREAM_H_ |
| |
| /*****************************************************************************/ |
| /* Constant Macros */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * @brief defines the maximum number of bits in a bitstream word |
| ****************************************************************************** |
| */ |
| #define WORD_SIZE 32 |
| |
| /** |
| ****************************************************************************** |
| * @brief The number of consecutive zero bytes for emulation prevention check |
| ****************************************************************************** |
| */ |
| #define EPB_ZERO_BYTES 2 |
| |
| /** |
| ****************************************************************************** |
| * @brief Emulation prevention insertion byte |
| ****************************************************************************** |
| */ |
| #define EPB_BYTE 0x03 |
| |
| |
| /** |
| ****************************************************************************** |
| * @brief Stream buffer allocated per frame should be atleast MIN_STREAM_SIZE |
| ****************************************************************************** |
| */ |
| #define MIN_STREAM_SIZE 0x800 |
| |
| |
| /*****************************************************************************/ |
| /* Function Macros */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * @brief Macro to check if emulation prevention byte insertion is required |
| ****************************************************************************** |
| */ |
| #define INSERT_EPB(zero_run, next_byte) \ |
| ((zero_run) == EPB_ZERO_BYTES) && (0 == ((next_byte) & 0xFC)) |
| |
| /** |
| ****************************************************************************** |
| * @brief returns the bit position of a leading 1 (msb) in a code value |
| ****************************************************************************** |
| */ |
| #if !MSVC |
| #define GETRANGE(r,value) \ |
| { \ |
| r = 0; \ |
| if(0 == value) \ |
| r = 1; \ |
| else \ |
| { \ |
| r = 32-CLZ(value); \ |
| }\ |
| } |
| #else |
| #define GETRANGE(r,value) \ |
| { \ |
| unsigned long msb_one_bit = 0; \ |
| r = _BitScanReverse(&msb_one_bit, value) ? (UWORD32)(msb_one_bit + 1) : 1 ; \ |
| } |
| #endif |
| |
| /** |
| ****************************************************************************** |
| * @brief returns bits required to code a value |
| ****************************************************************************** |
| */ |
| #define UE_LENGTH(bits,x) \ |
| { \ |
| UWORD32 r_bit; \ |
| GETRANGE(r_bit,x+1) \ |
| bits =(((r_bit - 1) << 1)+1);\ |
| } \ |
| |
| /** |
| ****************************************************************************** |
| * @brief Inserts 1 byte and Emulation Prevention Byte(if any) into bitstream |
| * Increments the stream offset and zero run correspondingly |
| ****************************************************************************** |
| */ |
| #define PUTBYTE_EPB(ptr,off,byte,zero_run) \ |
| { \ |
| if( INSERT_EPB(zero_run, byte) ) \ |
| { \ |
| ptr[off] = EPB_BYTE; \ |
| off++; \ |
| zero_run = 0; \ |
| } \ |
| \ |
| ptr[off] = byte; \ |
| off++; \ |
| zero_run = byte ? 0 : zero_run+1; \ |
| } \ |
| |
| /** |
| ****************************************************************************** |
| * @brief Ensures Byte alignment of the slice header |
| ****************************************************************************** |
| */ |
| #define BYTE_ALIGNMENT(ps_bitstrm) ih264e_put_rbsp_trailing_bits(ps_bitstrm) |
| |
| /** |
| ****************************************************************************** |
| * @brief Gets number of bits coded |
| ****************************************************************************** |
| */ |
| |
| #define GET_NUM_BITS(ps_bitstream) ((ps_bitstream->u4_strm_buf_offset << 3) \ |
| + 32 - ps_bitstream->i4_bits_left_in_cw); |
| |
| |
| |
| /** |
| ****************************************************************************** |
| * @macro Align bitstream to byte - Remainig bits are filled with '1' |
| ****************************************************************************** |
| */ |
| #define BITSTREAM_BYTE_ALIGN(ps_bitstrm) \ |
| if (ps_bitstrm->i4_bits_left_in_cw & 0x07) \ |
| { \ |
| const WORD32 len = (WORD32)((ps_bitstrm->i4_bits_left_in_cw) & 0x07);\ |
| ih264e_put_bits(ps_bitstrm, (UWORD32)((1 << len) - 1), len); \ |
| } |
| |
| |
| /** |
| ****************************************************************************** |
| * flush the bits in cur word byte by byte and copy to stream * |
| * (current word is assumed to be byte aligned) * |
| ****************************************************************************** |
| */ |
| #define BITSTREAM_FLUSH(ps_bitstrm) \ |
| { \ |
| WORD32 i; \ |
| for (i = WORD_SIZE; i > ps_bitstrm->i4_bits_left_in_cw; i -= 8) \ |
| { \ |
| UWORD8 u1_next_byte = (ps_bitstrm->u4_cur_word >> (i - 8)) & 0xFF; \ |
| PUTBYTE_EPB(ps_bitstrm->pu1_strm_buffer, ps_bitstrm->u4_strm_buf_offset,\ |
| u1_next_byte, ps_bitstrm->i4_zero_bytes_run); \ |
| } \ |
| ps_bitstrm->u4_cur_word = 0; \ |
| ps_bitstrm->i4_bits_left_in_cw = WORD_SIZE; \ |
| } \ |
| |
| |
| |
| |
| /*****************************************************************************/ |
| /* Structures */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * @brief Bitstream context for encoder |
| ****************************************************************************** |
| */ |
| typedef struct bitstrm |
| { |
| /** points to start of stream buffer. */ |
| UWORD8 *pu1_strm_buffer; |
| |
| /** |
| * max bitstream size (in bytes). |
| * Encoded stream shall not exceed this size. |
| */ |
| UWORD32 u4_max_strm_size; |
| |
| /** |
| * byte offset (w.r.t pu1_strm_buffer) where next byte would be written |
| * Bitstream engine makes sure it would not corrupt data beyond |
| * u4_max_strm_size bytes |
| */ |
| UWORD32 u4_strm_buf_offset; |
| |
| /** |
| * current bitstream word; It is a scratch word containing max of |
| * WORD_SIZE bits. Will be copied to stream buffer when the word is |
| * full |
| */ |
| UWORD32 u4_cur_word; |
| |
| /** |
| * signifies number of bits available in u4_cur_word |
| * bits from msb to i4_bits_left_in_cw of u4_cur_word have already been |
| * inserted next bits would be inserted from pos [i4_bits_left_in_cw-1] |
| * Range of this variable [1 : WORD_SIZE] |
| */ |
| WORD32 i4_bits_left_in_cw; |
| |
| /** |
| * signifies the number of consecutive zero bytes propogated from previous |
| * word. It is used for emulation prevention byte insertion in the stream |
| */ |
| WORD32 i4_zero_bytes_run; |
| |
| } bitstrm_t; |
| |
| |
| /*****************************************************************************/ |
| /* Extern Function Declarations */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Initializes the encoder bitstream engine |
| * |
| * @par Description |
| * This routine needs to be called at start of slice/frame encode |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] p1_bitstrm_buf |
| * bitstream buffer pointer where the encoded stream is generated in byte order |
| * |
| * @param[in] u4_max_bitstrm_size |
| * indicates maximum bitstream buffer size. (in bytes) |
| * If actual stream size exceeds the maximum size, encoder should |
| * 1. Not corrupt data beyond u4_max_bitstrm_size bytes |
| * 2. Report an error back to application indicating overflow |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_bitstrm_init |
| ( |
| bitstrm_t *ps_bitstrm, |
| UWORD8 *pu1_bitstrm_buf, |
| UWORD32 u4_max_bitstrm_size |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief puts a code with specified number of bits into the bitstream |
| * |
| * @par Description |
| * inserts code_len number of bits from lsb of code_val into the |
| * bitstream. If the total bytes (u4_strm_buf_offset) exceeds max |
| * available size (u4_max_strm_size), returns error without corrupting data |
| * beyond it |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] u4_code_val |
| * code value that needs to be inserted in the stream. |
| * |
| * @param[in] code_len |
| * indicates code length (in bits) of code_val that would be inserted in |
| * bitstream buffer size. |
| * |
| * @remarks Assumptions: all bits from bit position code_len to msb of |
| * code_val shall be zero |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_bits |
| ( |
| bitstrm_t *ps_bitstrm, |
| UWORD32 u4_code_val, |
| WORD32 code_len |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief inserts a 1-bit code into the bitstream |
| * |
| * @par Description |
| * inserts 1bit lsb of code_val into the bitstream |
| * updates context members like u4_cur_word, u4_strm_buf_offset and |
| * i4_bits_left_in_cw. If the total words (u4_strm_buf_offset) exceeds max |
| * available size (u4_max_strm_size), returns error without corrupting data |
| * beyond it |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] u4_code_val |
| * code value that needs to be inserted in the stream. |
| * |
| * @remarks Assumptions: all bits from bit position 1 to msb of code_val |
| * shall be zero |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_bit |
| ( |
| bitstrm_t *ps_bitstrm, |
| UWORD32 u4_code_val |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief inserts rbsp trailing bits at the end of stream buffer (NAL) |
| * |
| * @par Description |
| * inserts rbsp trailing bits, updates context members like u4_cur_word and |
| * i4_bits_left_in_cw and flushes the same in the bitstream buffer. If the |
| * total words (u4_strm_buf_offset) exceeds max available size |
| * (u4_max_strm_size), returns error without corrupting data beyond it |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_rbsp_trailing_bits |
| ( |
| bitstrm_t *ps_bitstrm |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief puts exponential golomb code of a unsigned integer into bitstream |
| * |
| * @par Description |
| * computes uev code for given syntax element and inserts the same into |
| * bitstream by calling ih264e_put_bits() interface. |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] u4_code_num |
| * unsigned integer input whose golomb code is written in stream |
| * |
| * @remarks Assumptions: code value can be represented in less than 16bits |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_uev |
| ( |
| bitstrm_t *ps_bitstrm, |
| UWORD32 u4_code_num |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief puts exponential golomb code of a signed integer into bitstream |
| * |
| * @par Description |
| * computes sev code for given syntax element and inserts the same into |
| * bitstream by calling ih264e_put_bits() interface. |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] syntax_elem |
| * signed integer input whose golomb code is written in stream |
| * |
| * @remarks Assumptions: code value can be represented in less than 16bits |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_sev |
| ( |
| bitstrm_t *ps_bitstrm, |
| WORD32 syntax_elem |
| ); |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief insert NAL start code prefix (0x000001) into bitstream with an option |
| * of inserting leading_zero_8bits (which makes startcode prefix as 0x00000001) |
| * |
| * @par Description |
| * Although start code prefix could have been put by calling ih264e_put_bits(), |
| * ih264e_put_nal_start_code_prefix() is specially added to make sure emulation |
| * prevention insertion is not done for the NAL start code prefix which will |
| * surely happen otherwise by calling ih264e_put_bits() interface. |
| * |
| * @param[in] ps_bitstrm |
| * pointer to bitstream context (handle) |
| * |
| * @param[in] insert_leading_zero_8bits |
| * flag indicating if one more zero bytes needs to prefixed before start code |
| * |
| * @return success or failure error code |
| * |
| ****************************************************************************** |
| */ |
| IH264E_ERROR_T ih264e_put_nal_start_code_prefix |
| ( |
| bitstrm_t *ps_bitstrm, |
| WORD32 insert_leading_zero_8bits |
| ); |
| |
| #endif /* IH264E_BITSTREAM_H_ */ |
