| /****************************************************************************** |
| * |
| * 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 Name : impeg2d_bitstream.c */ |
| /* */ |
| /* Description : This file contains all the necessary examples to */ |
| /* establish a consistent use of Ittiam C coding */ |
| /* standards (based on Indian Hill C Standards) */ |
| /* */ |
| /* List of Functions : <List the functions defined in this file> */ |
| /* */ |
| /* Issues / Problems : None */ |
| /* */ |
| /* Revision History : */ |
| /* */ |
| /* DD MM YYYY Author(s) Changes (Describe the changes made) */ |
| /* 10 01 2005 Ittiam Draft */ |
| /* */ |
| /*****************************************************************************/ |
| #include <stdlib.h> |
| |
| #include "iv_datatypedef.h" |
| #include "impeg2_defs.h" |
| #include "impeg2_platform_macros.h" |
| #include "impeg2_macros.h" |
| #include "impeg2d_bitstream.h" |
| |
| #define BIT(val,bit) (UWORD16)(((val) >> (bit)) & 0x1) |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_init |
| * |
| * Description : This is a Bitstream initialising function. |
| * Arguments : |
| * stream : Pointer to the Bitstream. |
| * byteBuf : Address of the buffer |
| * size : Size of the buffer in bytes |
| * |
| * Values Returned : None |
| *******************************************************************************/ |
| void impeg2d_bit_stream_init(stream_t *ps_stream, |
| UWORD8 *pu1_byte_buf, |
| UWORD32 u4_max_offset) |
| { |
| UWORD8 *pu1_byte_buff; |
| UWORD32 *pu4_word_buf; |
| size_t u4_byte_addr; |
| UWORD32 u4_temp1,u4_temp2; |
| |
| /* Set parameters of the stream structure.Associate the structure with |
| the file */ |
| ps_stream->pv_bs_buf = pu1_byte_buf; |
| ps_stream->u4_offset = 0; |
| |
| /* Take care of unaligned address and create |
| nearest greater aligned address */ |
| pu1_byte_buff = (UWORD8 *)pu1_byte_buf; |
| u4_byte_addr = (size_t)pu1_byte_buff; |
| |
| if((u4_byte_addr & 3) == 1) |
| { |
| u4_temp1 = ((UWORD32)(*pu1_byte_buff++)) << 8; |
| u4_temp1 += ((UWORD32)(*pu1_byte_buff++)) << 16; |
| u4_temp1 += ((UWORD32)(*pu1_byte_buff++)) << 24; |
| |
| pu4_word_buf = (UWORD32 *)pu1_byte_buff; |
| |
| ps_stream->u4_offset = 8; |
| } |
| else if((u4_byte_addr & 3) == 2) |
| { |
| u4_temp1 = ((UWORD32)(*pu1_byte_buff++)) << 16; |
| u4_temp1 += ((UWORD32)(*pu1_byte_buff++)) << 24; |
| |
| pu4_word_buf = (UWORD32 *)pu1_byte_buff; |
| |
| ps_stream->u4_offset = 16; |
| } |
| else if((u4_byte_addr & 3) == 3) |
| { |
| u4_temp1 = (((UWORD32)(*pu1_byte_buff++)) << 24); |
| |
| pu4_word_buf = (UWORD32 *)pu1_byte_buff; |
| |
| ps_stream->u4_offset = 24; |
| } |
| else |
| { |
| pu4_word_buf = (UWORD32 *)pu1_byte_buff; |
| |
| u4_temp1 = *pu4_word_buf++; |
| ps_stream->u4_offset = 0; |
| } |
| |
| /* convert the endian ness from Little endian to Big endian so that bits |
| are in proper order from MSB to LSB */ |
| CONV_LE_TO_BE(u4_temp2,u4_temp1) |
| |
| /* Read One more word for buf nxt */ |
| u4_temp1 = *pu4_word_buf++; |
| ps_stream->u4_buf = u4_temp2; |
| |
| CONV_LE_TO_BE(u4_temp2,u4_temp1) |
| |
| ps_stream->u4_buf_nxt = u4_temp2; |
| |
| ps_stream->pu4_buf_aligned = pu4_word_buf; |
| |
| |
| ps_stream->u4_max_offset = (u4_max_offset << 3) + ps_stream->u4_offset; |
| |
| return; |
| } |
| |
| |
| |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_get_bit |
| * |
| * Description : This is a Bitstream processing function. It reads the |
| * bit currently pointed by the bit pointer in the buffer and |
| * advances the pointer by one. |
| * Arguments : |
| * stream : Pointer to the Bitstream. |
| * |
| * Values Returned : The bit read(0/1) |
| *******************************************************************************/ |
| UWORD8 impeg2d_bit_stream_get_bit(stream_t *ps_stream) |
| { |
| UWORD32 u4_bit,u4_offset,u4_temp; |
| UWORD32 u4_curr_bit; |
| |
| u4_offset = ps_stream->u4_offset; |
| u4_curr_bit = u4_offset & 0x1F; |
| u4_bit = ps_stream->u4_buf; |
| |
| /* Move the current bit read from the current word to the |
| least significant bit positions of 'c'.*/ |
| u4_bit >>= BITS_IN_INT - u4_curr_bit - 1; |
| |
| u4_offset++; |
| |
| /* If the last bit of the last word of the buffer has been read update |
| the currrent buf with next, and read next buf from bit stream buffer */ |
| if (u4_curr_bit == 31) |
| { |
| ps_stream->u4_buf = ps_stream->u4_buf_nxt; |
| |
| if (ps_stream->u4_offset < ps_stream->u4_max_offset) |
| { |
| u4_temp = *(ps_stream->pu4_buf_aligned)++; |
| CONV_LE_TO_BE(ps_stream->u4_buf_nxt,u4_temp) |
| } |
| } |
| ps_stream->u4_offset = u4_offset; |
| |
| return (u4_bit & 0x1); |
| } |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_flush |
| * |
| * Description : This is a Bitstream processing function. It |
| * advances the bit and byte pointers appropriately |
| * |
| * Arguments : |
| * ctxt : Pointer to the Bitstream. |
| * numBits : No of bits to be read |
| * |
| * Values Returned : None |
| *******************************************************************************/ |
| void impeg2d_bit_stream_flush(void* pv_ctxt, UWORD32 u4_no_of_bits) |
| { |
| stream_t *ps_stream = (stream_t *)pv_ctxt; |
| |
| |
| if (ps_stream->u4_offset <= ps_stream->u4_max_offset) |
| { |
| /* We have to flush the bytes even if the offset is equal to the maximum |
| * offset. This will ensure that a stream with an error exactly at the |
| * offset will not get stuck in an infinite loop - If we do not flush |
| * these bytes, then we keep feeding the erroneous bits. |
| */ |
| FLUSH_BITS(ps_stream->u4_offset,ps_stream->u4_buf,ps_stream->u4_buf_nxt,u4_no_of_bits,ps_stream->pu4_buf_aligned) |
| } |
| return; |
| } |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_flush_to_byte_boundary |
| * |
| * Description : This is a Bitstream processing function.It advances |
| * the bit and byte pointers to next byte boundary |
| * |
| * Arguments : |
| * stream : Pointer to the Bitstream. |
| * NoOfBits : No of bits to be read |
| * |
| * Values Returned : The bits read (upto 32 bits maximum) starting from the |
| * least significant bit and going towards most significant |
| * bit in the order of their occurence. |
| *******************************************************************************/ |
| void impeg2d_bit_stream_flush_to_byte_boundary(void* pv_ctxt) |
| { |
| UWORD8 u1_bit_offset; |
| stream_t *ps_stream = (stream_t *)pv_ctxt; |
| |
| u1_bit_offset = (ps_stream->u4_offset) & 0x7; |
| |
| |
| /* if it is not byte aligned make it byte aligned*/ |
| if(u1_bit_offset != 0) |
| { |
| impeg2d_bit_stream_flush(ps_stream,(8 - u1_bit_offset)); |
| } |
| |
| |
| |
| } |
| |
| |
| /****************************************************************************** |
| * |
| * Function Name : ibits_next |
| * |
| * Description : This is a Bitstream processing function.It gets the |
| * specified number of bits from the buffer without |
| * altering the current pointers. It is used mainly to |
| * check for some specific pattern of bits like start |
| * code. This is equivalent to next_bits() function |
| * defined in MPEG-4 Visual Standard Definition of functions |
| * |
| * Arguments : |
| * ctxt : Pointer to the Bitstream. |
| * numBits : No of bits to be read |
| * |
| * Values Returned : The bits read (upto 32 bits maximum) starting from the |
| * least significant bit and going towards most significant |
| * bit in the order of their occurence. |
| *******************************************************************************/ |
| UWORD32 impeg2d_bit_stream_nxt( stream_t *ps_stream, WORD32 i4_no_of_bits) |
| { |
| UWORD32 u4_bits,u4_offset,u4_temp; |
| UWORD8 u4_bit_ptr; |
| |
| ASSERT(i4_no_of_bits > 0); |
| |
| u4_offset = ps_stream->u4_offset; |
| u4_bit_ptr = u4_offset & 0x1F; |
| u4_bits = ps_stream->u4_buf << u4_bit_ptr; |
| |
| u4_bit_ptr += i4_no_of_bits; |
| if(32 < u4_bit_ptr) |
| { |
| /* Read bits from the next word if necessary */ |
| u4_temp = ps_stream->u4_buf_nxt; |
| u4_bit_ptr &= (BITS_IN_INT - 1); |
| |
| u4_temp = (u4_temp >> (BITS_IN_INT - u4_bit_ptr)); |
| |
| /* u4_temp consists of bits,if any that had to be read from the next word |
| of the buffer.The bits read from both the words are concatenated and |
| moved to the least significant positions of 'u4_bits'*/ |
| u4_bits = (u4_bits >> (32 - i4_no_of_bits)) | u4_temp; |
| } |
| else |
| { |
| u4_bits = (u4_bits >> (32 - i4_no_of_bits)); |
| } |
| |
| return (u4_bits); |
| } |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_get |
| * |
| * Description : This is a Bitstream processing function. It reads a |
| * specified number of bits from the current bit |
| * position and advances the bit and byte pointers |
| * appropriately |
| * Arguments : |
| * ctxt : Pointer to the Bitstream. |
| * numBits : No of bits to be read |
| * |
| * Values Returned : The bits read (upto 32 bits maximum) starting from the |
| * least significant bit and going towards most significant |
| * bit in the order of their occurence. |
| *******************************************************************************/ |
| |
| UWORD32 impeg2d_bit_stream_get(void* pv_ctxt, UWORD32 u4_num_bits) |
| { |
| UWORD32 u4_next_bits = impeg2d_bit_stream_nxt(pv_ctxt, u4_num_bits); |
| impeg2d_bit_stream_flush(pv_ctxt, u4_num_bits); |
| return(u4_next_bits); |
| } |
| |
| |
| |
| /****************************************************************************** |
| * |
| * Function Name : impeg2d_bit_stream_num_bits_read |
| * |
| * Description : This is a Bitstream processing function. It reads a |
| * specified number of bits from the current bit |
| * position and advances the bit and byte pointers |
| * appropriately |
| * Arguments : |
| * ctxt : Pointer to the Bitstream. |
| * numBits : No of bits to be read |
| * |
| * Values Returned : The bits read (upto 16 bits maximum) starting from the |
| * least significant bit and going towards most significant |
| * bit in the order of their occurence. |
| *******************************************************************************/ |
| UWORD32 impeg2d_bit_stream_num_bits_read(void* pv_ctxt) |
| { |
| stream_t *u4_no_of_bitsstream = (stream_t *)pv_ctxt; |
| size_t u4_temp; |
| UWORD32 u4_bits_read; |
| u4_temp = (size_t)(u4_no_of_bitsstream->pv_bs_buf); |
| u4_temp &= 0x3; |
| u4_bits_read = (u4_no_of_bitsstream->u4_offset - (u4_temp << 3)); |
| |
| return(u4_bits_read); |
| |
| } |
| |
| |
