/src/libavc/encoder/ih264e_bitstream.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * 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.c
*
* @brief
*  This file contains function definitions related to bitstream generation
*
* @author
*  ittiam
*
* @par List of Functions:
*  - ih264e_bitstrm_init
*  - ih264e_put_bits
*  - ih264e_put_bit
*  - ih264e_put_rbsp_trailing_bits
*  - ih264e_put_uev
*  - ih264e_put_sev
*  - ih264e_put_nal_start_code_prefix
*
******************************************************************************
*/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System Include Files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#include <math.h>

/* User Include Files */
#include "ih264e_config.h"
#include "ih264_typedefs.h"

#include "ih264_debug.h"
#include "ih264_macros.h"
#include "ih264_defs.h"
#include "ih264_platform_macros.h"

#include "ih264e_error.h"
#include "ih264e_bitstream.h"

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/**
******************************************************************************
*
*  @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)
{
    ps_bitstrm->pu1_strm_buffer  = pu1_bitstrm_buf;
    ps_bitstrm->u4_max_strm_size = u4_max_bitstrm_size;

    /* Default init values for other members of bitstream context */
    ps_bitstrm->u4_strm_buf_offset  = 0;
    ps_bitstrm->u4_cur_word         = 0;
    ps_bitstrm->i4_bits_left_in_cw  = WORD_SIZE;
    ps_bitstrm->i4_zero_bytes_run   = 0;

    return(IH264E_SUCCESS);
}

/**
******************************************************************************
*
*  @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. 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.
*
*  @param[in]    code_len
*  indicates code length (in bits) of code_val that would be inserted in
*  bitstream buffer size. Range of length[1:WORD_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)
{
    UWORD32 u4_cur_word = ps_bitstrm->u4_cur_word;
    WORD32  bits_left_in_cw = ps_bitstrm->i4_bits_left_in_cw;


    /* check assumptions made in the module */
    ASSERT(code_len > 0 && code_len <= WORD_SIZE);

    if(code_len < WORD_SIZE)
        ASSERT((u4_code_val >> code_len) == 0);

    /* sanity check on the bitstream engine state */
    ASSERT(bits_left_in_cw > 0 && bits_left_in_cw <= WORD_SIZE);

    ASSERT(ps_bitstrm->i4_zero_bytes_run <= EPB_ZERO_BYTES);

    ASSERT(ps_bitstrm->pu1_strm_buffer != NULL);


    if(bits_left_in_cw > code_len)
    {
        /*******************************************************************/
        /* insert the code in local bitstream word and return              */
        /* code is inserted in position of bits left (post decrement)      */
        /*******************************************************************/
        bits_left_in_cw -= code_len;
        u4_cur_word     |= (u4_code_val << bits_left_in_cw);

        ps_bitstrm->u4_cur_word         = u4_cur_word;
        ps_bitstrm->i4_bits_left_in_cw  = bits_left_in_cw;

        return(IH264E_SUCCESS);
    }
    else
    {
        /********************************************************************/
        /* 1. insert partial code corresponding to bits left in cur word    */
        /* 2. flush all the bits of cur word to bitstream                   */
        /* 3. insert emulation prevention bytes while flushing the bits     */
        /* 4. insert remaining bits of code starting from msb of cur word   */
        /* 5. update bitsleft in current word and stream buffer offset      */
        /********************************************************************/
        WORD32  i, rem_bits = (code_len - bits_left_in_cw);

        /* insert parital code corresponding to bits left in cur word */
        u4_cur_word |= u4_code_val >> rem_bits;

        for(i = WORD_SIZE; i > 0; i -= 8)
        {
            /* flush the bits in cur word byte by byte and copy to stream */
            UWORD8   u1_next_byte = (u4_cur_word >> (i-8)) & 0xFF;

            IH264E_ERROR_T status = ih264e_put_byte_epb(ps_bitstrm, u1_next_byte);
            if (status != IH264E_SUCCESS) return status;
        }

        /* insert the remaining bits from code val into current word */
        u4_cur_word = rem_bits ? (u4_code_val << (WORD_SIZE - rem_bits)) : 0;

        /* update the state variables and return success */
        ps_bitstrm->u4_cur_word         = u4_cur_word;
        ps_bitstrm->i4_bits_left_in_cw  = WORD_SIZE - rem_bits;
        return (IH264E_SUCCESS);

    }
}

/**
******************************************************************************
*
*  @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)
{
    /* call the put bits function for 1 bit and return */
    return(ih264e_put_bits(ps_bitstrm, u4_code_val, 1));
}

/**
******************************************************************************
*
*  @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)
{
    WORD32 i;
    UWORD32 u4_cur_word = ps_bitstrm->u4_cur_word;
    WORD32  bits_left_in_cw = ps_bitstrm->i4_bits_left_in_cw;
    WORD32  bytes_left_in_cw = (bits_left_in_cw - 1) >> 3;

    /* insert a 1 at the end of current word and flush all the bits */
    u4_cur_word |= (1 << (bits_left_in_cw - 1));

    /* get the bits to be inserted in msbdb of the word */
    //u4_cur_word <<= (WORD_SIZE - bytes_left_in_cw + 1);

    for(i = WORD_SIZE; i > (bytes_left_in_cw*8); i -= 8)
    {
        /* flush the bits in cur word byte by byte  and copy to stream */
        UWORD8   u1_next_byte = (u4_cur_word >> (i-8)) & 0xFF;

        IH264E_ERROR_T status = ih264e_put_byte_epb(ps_bitstrm, u1_next_byte);
        if (status != IH264E_SUCCESS) return status;
    }

    /* Default init values for scratch variables of bitstream context */
    ps_bitstrm->u4_cur_word         = 0;
    ps_bitstrm->i4_bits_left_in_cw  = WORD_SIZE;
    ps_bitstrm->i4_zero_bytes_run   = 0;

    return (IH264E_SUCCESS);
}

/**
******************************************************************************
*
*  @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)
{
    UWORD32 u4_bit_str, u4_range;
    IH264E_ERROR_T e_error;

    /* convert the codenum to exp-golomb bit code: Table 9-2 JCTVC-J1003_d7 */
    u4_bit_str = u4_code_num + 1;

    /* get range of the bit string and put using put_bits()                 */
    GETRANGE(u4_range, u4_bit_str);

    e_error = ih264e_put_bits(ps_bitstrm, u4_bit_str, (2 * u4_range - 1));

    return(e_error);
}

/**
******************************************************************************
*
*  @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)
{
    UWORD32 u4_code_num, u4_bit_str, u4_range;
    IH264E_ERROR_T e_error;

    /************************************************************************/
    /* convert the codenum to exp-golomb bit code for signed syntax element */
    /* See Table9-2 and Table 9-3 of standard JCTVC-J1003_d7                */
    /************************************************************************/
    if(syntax_elem <= 0)
    {
        /* codeNum for non-positive integer =  2*abs(x) : Table9-3  */
        u4_code_num = ((-syntax_elem) << 1);
    }
    else
    {
        /* codeNum for positive integer     =  2x-1     : Table9-3  */
        u4_code_num = (syntax_elem << 1) - 1;
    }

    /* convert the codenum to exp-golomb bit code: Table 9-2 JCTVC-J1003_d7 */
    u4_bit_str = u4_code_num + 1;

    /* get range of the bit string and put using put_bits()                 */
    GETRANGE(u4_range, u4_bit_str);

    e_error = ih264e_put_bits(ps_bitstrm, u4_bit_str, (2 * u4_range - 1));

    return(e_error);
}

/**
******************************************************************************
*
*  @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)
{
    UWORD32 u4_strm_buf_offset  = ps_bitstrm->u4_strm_buf_offset;
    UWORD8* pu1_strm_buf        = ps_bitstrm->pu1_strm_buffer;

    /* Bitstream buffer overflow check assuming worst case of 4 bytes */
    if((u4_strm_buf_offset + 4) >= ps_bitstrm->u4_max_strm_size)
    {
        return(IH264E_BITSTREAM_BUFFER_OVERFLOW);
    }

    /* Insert leading zero 8 bits conditionally */
    if(insert_leading_zero_8bits)
    {
        pu1_strm_buf[u4_strm_buf_offset] = 0x00;
        u4_strm_buf_offset++;
    }

    /* Insert NAL start code prefix 0x00 00 01 */
    pu1_strm_buf[u4_strm_buf_offset] = 0x00;
    u4_strm_buf_offset++;

    pu1_strm_buf[u4_strm_buf_offset] = 0x00;
    u4_strm_buf_offset++;

    pu1_strm_buf[u4_strm_buf_offset] = 0x01;
    u4_strm_buf_offset++;

    /* update the stream offset */
    ps_bitstrm->u4_strm_buf_offset = u4_strm_buf_offset;

    return (IH264E_SUCCESS);
}


Coverage Report

Created: 2025-07-23 06:18

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