You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
348 lines
13 KiB
348 lines
13 KiB
4 months ago
|
/******************************************************************************
|
||
|
|
*
|
||
|
|
* 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)
|
||
|
|
*******************************************************************************/
|
||
|
|
INLINE 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
|
||
|
|
*******************************************************************************/
|
||
|
|
INLINE 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.
|
||
|
|
*******************************************************************************/
|
||
|
|
INLINE 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.
|
||
|
|
*******************************************************************************/
|
||
|
|
INLINE 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.
|
||
|
|
*******************************************************************************/
|
||
|
|
|
||
|
|
INLINE 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.
|
||
|
|
*******************************************************************************/
|
||
|
|
INLINE 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);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|