decoder/ih264d_nal.c

/******************************************************************************
 *
 * 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   ih264d_nal.c
 *
 *  \brief  NAL parsing routines
 *
 *  Detailed_description
 *
 *  \author
 *         - AI  19 11 2002  Creation
 **************************************************************************
 */
#include "ih264d_bitstrm.h"
#include "ih264d_defs.h"
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_defs.h"
#define NUM_OF_ZERO_BYTES_BEFORE_START_CODE 2
#define EMULATION_PREVENTION_BYTE           0x03

#define NAL_FIRST_BYTE_SIZE 1

/*!
 **************************************************************************
 * \if Function name : ih264d_find_start_code \endif
 *
 * \brief
 *    This function searches for the Start Code Prefix.
 *
 * \param pu1_buf : Pointer to char buffer which contains bitstream.
 * \param u4_cur_pos : Current position in the buffer.
 * \param u4_max_ofst : Number of bytes in Buffer.
 * \param pu4_length_of_start_code  : Poiter to length of Start Code.
 *
 * \return
 *    Returns 0 on success and -1 on error.
 *
 **************************************************************************
 */
#define START_CODE_NOT_FOUND    -1
#define END_OF_STREAM_BUFFER    -2
#define END_OF_STREAM           -1

void ih264d_check_if_aud(UWORD8 *pu1_buf,
                         UWORD32 u4_cur_pos,
                         UWORD32 u4_max_ofst,
                         UWORD32 *pu4_next_is_aud)
{
    UWORD8 u1_first_byte, u1_nal_unit_type;
    if(u4_cur_pos + 1 < u4_max_ofst)
    {
        u1_first_byte = pu1_buf[u4_cur_pos + 1];
        u1_nal_unit_type = NAL_UNIT_TYPE(u1_first_byte);

        if(u1_nal_unit_type == ACCESS_UNIT_DELIMITER_RBSP)
        {
            *pu4_next_is_aud = 1;
        }
    }

}
WORD32 ih264d_find_start_code(UWORD8 *pu1_buf,
                              UWORD32 u4_cur_pos,
                              UWORD32 u4_max_ofst,
                              UWORD32 *pu4_length_of_start_code,
                              UWORD32 *pu4_next_is_aud)
{
    WORD32 zero_byte_cnt = 0;
    UWORD32 ui_curPosTemp;

    *pu4_length_of_start_code = 0;
    /*Find first start code */
    while(u4_cur_pos < u4_max_ofst)
    {
        if(pu1_buf[u4_cur_pos] == 0)
            zero_byte_cnt++;
        else if(pu1_buf[u4_cur_pos]
                        == 0x01 && zero_byte_cnt >= NUM_OF_ZERO_BYTES_BEFORE_START_CODE)
        {
            /* Found the start code */
            u4_cur_pos++;
            break;
        }
        else
        {
            zero_byte_cnt = 0;
        }
        u4_cur_pos++;
    }
    /*Find Next Start Code */
    *pu4_length_of_start_code = u4_cur_pos;
    zero_byte_cnt = 0;
    ui_curPosTemp = u4_cur_pos;
    while(u4_cur_pos < u4_max_ofst)
    {

        if(pu1_buf[u4_cur_pos] == 0)
            zero_byte_cnt++;
        else if(pu1_buf[u4_cur_pos]
                        == 0x01 && zero_byte_cnt >= NUM_OF_ZERO_BYTES_BEFORE_START_CODE)
        {
            /* Found the start code */
            ih264d_check_if_aud(pu1_buf, u4_cur_pos, u4_max_ofst,
                                pu4_next_is_aud);
            return (u4_cur_pos - zero_byte_cnt - ui_curPosTemp);
        }
        else
        {
            zero_byte_cnt = 0;
        }
        u4_cur_pos++;
    }

    return (u4_cur_pos - zero_byte_cnt - ui_curPosTemp); //(START_CODE_NOT_FOUND);
}

/*!
 **************************************************************************
 * \if Function name : ih264d_get_next_nal_unit \endif
 *
 * \brief
 *    This function reads one NAl unit.
 *
 * \param ps_nalStream : Poiter to NalUnitStream structure.
 * \param ps_nalUnit : Pointer to NalUnit.
 *
 * \return
 *    Returns 0 on success and -1 on error.
 *
 **************************************************************************
 */
WORD32 ih264d_get_next_nal_unit(UWORD8 *pu1_buf,
                                UWORD32 u4_cur_pos,
                                UWORD32 u4_max_ofst,
                                UWORD32 *pu4_length_of_start_code)
{

    WORD32 i_length_of_nal_unit = 0;
    UWORD32 u4_next_is_aud;

    /* NAL Thread starts */

    ih264d_find_start_code(pu1_buf, u4_cur_pos, u4_max_ofst,
                           pu4_length_of_start_code, &u4_next_is_aud);

    return (i_length_of_nal_unit);
}

/*!
 **************************************************************************
 * \if Function name : ih264d_process_nal_unit \endif
 *
 * \brief
 *    This function removes emulation byte "0x03" from bitstream (EBSP to RBSP).
 *    It also converts bytestream format into 32 bit little-endian format.
 *
 * \param ps_bitstrm : Poiter to dec_bit_stream_t structure.
 * \param pu1_nal_unit  : Pointer to char buffer of NalUnit.
 * \param u4_numbytes_in_nal_unit : Number bytes in NalUnit buffer.
 *
 * \return
 *    Returns number of bytes in RBSP ps_bitstrm.
 *
 * \note
 *    This function is same as nal_unit() of 7.3.1. Apart from nal_unit()
 *    implementation it converts char buffer into 32 bit Buffer. This
 *    facilitates efficient access of bitstream. This has been done taking
 *    into account present processor architectures.
 *
 **************************************************************************
 */
WORD32 ih264d_process_nal_unit(dec_bit_stream_t *ps_bitstrm,
                            UWORD8 *pu1_nal_unit,
                            UWORD32 u4_numbytes_in_nal_unit)
{
    UWORD32 u4_num_bytes_in_rbsp;
    UWORD8 u1_cur_byte;
    WORD32 i = 0;
    WORD8 c_count;
    UWORD32 ui_word;
    UWORD32 *puc_bitstream_buffer = (UWORD32*)pu1_nal_unit;
    ps_bitstrm->pu4_buffer = puc_bitstream_buffer;

    /*--------------------------------------------------------------------*/
    /* First Byte of the NAL Unit                                         */
    /*--------------------------------------------------------------------*/

    ui_word = *pu1_nal_unit++;

    /*--------------------------------------------------------------------*/
    /* Convertion of the EBSP to RBSP                                     */
    /* ie Remove the emulation_prevention_byte [equal to 0x03]            */
    /*--------------------------------------------------------------------*/
    u4_num_bytes_in_rbsp = 0;
    c_count = 0;

//first iteration

    u1_cur_byte = *pu1_nal_unit++;

    ui_word = ((ui_word << 8) | u1_cur_byte);

    c_count++;
    if(u1_cur_byte != 0x00)
        c_count = 0;

//second iteration

    u1_cur_byte = *pu1_nal_unit++;

    ui_word = ((ui_word << 8) | u1_cur_byte);
    u4_num_bytes_in_rbsp = 2;

    c_count++;
    if(u1_cur_byte != 0x00)
        c_count = 0;

    if(u4_numbytes_in_nal_unit > 2)
    {
        i = ((u4_numbytes_in_nal_unit - 3));
    }

    for(; i > 8; i -= 4)
    {

// loop 0
        u1_cur_byte = *pu1_nal_unit++;

        if(c_count == NUM_OF_ZERO_BYTES_BEFORE_START_CODE
                        && u1_cur_byte == EMULATION_PREVENTION_BYTE)
        {
            c_count = 0;
            u1_cur_byte = *pu1_nal_unit++;
            i--;
        }

        ui_word = ((ui_word << 8) | u1_cur_byte);
        *puc_bitstream_buffer = ui_word;
        puc_bitstream_buffer++;
        c_count++;
        if(u1_cur_byte != 0x00)
            c_count = 0;

// loop 1
        u1_cur_byte = *pu1_nal_unit++;

        if(c_count == NUM_OF_ZERO_BYTES_BEFORE_START_CODE
                        && u1_cur_byte == EMULATION_PREVENTION_BYTE)
        {
            c_count = 0;
            u1_cur_byte = *pu1_nal_unit++;
            i--;
        }
        ui_word = ((ui_word << 8) | u1_cur_byte);

        c_count++;
        if(u1_cur_byte != 0x00)
            c_count = 0;

// loop 2
        u1_cur_byte = *pu1_nal_unit++;

        if(c_count == NUM_OF_ZERO_BYTES_BEFORE_START_CODE
                        && u1_cur_byte == EMULATION_PREVENTION_BYTE)
        {
            c_count = 0;
            u1_cur_byte = *pu1_nal_unit++;
            i--;
        }

        ui_word = ((ui_word << 8) | u1_cur_byte);

        c_count++;
        if(u1_cur_byte != 0x00)
            c_count = 0;

// loop 3
        u1_cur_byte = *pu1_nal_unit++;

        if(c_count == NUM_OF_ZERO_BYTES_BEFORE_START_CODE
                        && u1_cur_byte == EMULATION_PREVENTION_BYTE)
        {
            c_count = 0;
            u1_cur_byte = *pu1_nal_unit++;
            i--;
        }

        ui_word = ((ui_word << 8) | u1_cur_byte);

        c_count++;
        if(u1_cur_byte != 0x00)
            c_count = 0;

        u4_num_bytes_in_rbsp += 4;

    }

    for(; i > 0; i--)
    {
        u1_cur_byte = *pu1_nal_unit++;

        if(c_count == NUM_OF_ZERO_BYTES_BEFORE_START_CODE
                        && u1_cur_byte == EMULATION_PREVENTION_BYTE)
        {
            c_count = 0;
            i--;
            u1_cur_byte = *pu1_nal_unit++;
        }

        ui_word = ((ui_word << 8) | u1_cur_byte);
        u4_num_bytes_in_rbsp++;

        if((u4_num_bytes_in_rbsp & 0x03) == 0x03)
        {
            *puc_bitstream_buffer = ui_word;
            puc_bitstream_buffer++;
        }
        c_count++;
        if(u1_cur_byte != 0x00)
            c_count = 0;

    }

    *puc_bitstream_buffer = (ui_word
                    << ((3 - (((u4_num_bytes_in_rbsp << 30) >> 30))) << 3));
    ps_bitstrm->u4_ofst = 0;
    ps_bitstrm->u4_max_ofst = ((u4_num_bytes_in_rbsp + NAL_FIRST_BYTE_SIZE) << 3);

    return (u4_num_bytes_in_rbsp);
}


/*!
 **************************************************************************
 * \if Function name : ih264d_rbsp_to_sodb \endif
 *
 * \brief
 *    This function converts RBSP to SODB.
 *
 * \param ps_bitstrm : Poiter to dec_bit_stream_t structure.
 *
 * \return
 *    None.
 *
 **************************************************************************
 */
void ih264d_rbsp_to_sodb(dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 ui_lastWord;
    UWORD32 ui_word;
    UWORD8 uc_lastByte;
    WORD8 i;

    ui_lastWord = (ps_bitstrm->u4_max_ofst >> 5);
    i = (ps_bitstrm->u4_max_ofst >> 3) & 0x03;

    if(i)
    {
        ui_word = ps_bitstrm->pu4_buffer[ui_lastWord];
        uc_lastByte = ((ui_word << ((i - 1) << 3)) >> 24);
    }
    else
    {
        ui_word = ps_bitstrm->pu4_buffer[ui_lastWord - 1];
        uc_lastByte = ((ui_word << 24) >> 24);
    }
    /*--------------------------------------------------------------------*/
    /* Find out the rbsp_stop_bit position in the last byte of rbsp       */
    /*--------------------------------------------------------------------*/
    for(i = 0; (i < 8) && !CHECKBIT(uc_lastByte, i); ++i)
        ;
    ps_bitstrm->u4_max_ofst = ps_bitstrm->u4_max_ofst - (i + 1);
}