xref: /aosp_15_r20/external/libavc/decoder/svc/isvcd_nal.c (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)

/******************************************************************************
 *
 * Copyright (C) 2022 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 isvcd_nal.c
 *
 * \brief
 *    Contains routines that resample for SVC resampling
 *
 * Detailed_description
 *
 * \date
 *
 *
 * \author : Kishore
 **************************************************************************
 */

/******************************************************************************
 *
 * Copyright (C) 2022 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         : isvcd_nal.c                                          */
/*                                                                           */
/*  Description       : Contains fucntions which help in NAL extraction from */
/*                      the bitstream                                        */
/*                                                                           */
/*  List of Functions : isvcd_nal_find_start_code,                           */
/*                      isvcd_get_annex_b_nal_unit,                          */
/*                      isvcd_get_rfc_nal_unit,                              */
/*                      isvcd_nal_rbsp_to_sodb,                              */
/*                      isvcd_reset_emulation_ctxt,                          */
/*                      isvcd_nal_byte_swap_emulation,                       */
/*                      isvcd_set_default_nal_header_prms,                   */
/*                      isvcd_dec_nal_hdr,                                   */
/*                      isvcd_parse_part_slice_hdr,                          */
/*                      isvcd_get_int_tgt_lyr_attr,                          */
/*                      isvcd_discard_nal                                    */
/*                                                                           */
/*  Issues / Problems : None                                                 */
/*                                                                           */
/*  Revision History:                                                        */
/*          DD MM YYYY   Author(s)       Changes                             */
/*          14 09 2021   Kishore         Draft                               */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System include files */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stddef.h>
#include <assert.h>

/* standard interface include files */
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_tables.h"
#include "iv.h"
#include "ivd.h"
#include "ih264d_defs.h"
#include "ih264_debug.h"
#include "ih264d_parse_cavlc.h"
#include "ih264d_inter_pred.h"
#include "isvcd_structs.h"
#include "ih264d_nal.h"
#include "ih264d_error_handler.h"
#include "ih264d_defs.h"

/*****************************************************************************/
/*Extern Variable Declarations                                               */
/*****************************************************************************/

/*****************************************************************************/
/* Global Variable Definitions                                               */
/*****************************************************************************/

/*****************************************************************************/
/* Static Global Variable Definitions                                        */
/*****************************************************************************/

/*****************************************************************************/
/* Static function Definitions                                               */
/*****************************************************************************/

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_reset_nal_buf                                      */
/*                                                                           */
/*  Description   : Performs the reset of NAL buffer structure               */
/*  Inputs        : 1. Pointer to NAL buffer structure                       */
/*  Globals       : None                                                     */
/*  Processing    : Updates different fields of the structure                */
/*  Outputs       : None                                                     */
/*  Returns       :                                                          */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay      Draft                                     */
/*                                                                           */
/*****************************************************************************/
void isvcd_nal_buf_reset(void *pv_nal_buf)
{
    nal_buf_t *ps_nal_buf = pv_nal_buf;

    ps_nal_buf->i4_valid_flag = SVCD_FALSE;
    ps_nal_buf->i4_buf_size = 0;
    ps_nal_buf->u4_max_bits = 0;
    ps_nal_buf->pu1_buf = NULL;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name :svcd_nal_find_start_code                                  */
/*                                                                           */
/*  Description   : Finds the position of the start code in the stream       */
/*                                                                           */
/*                                                                           */
/*  Inputs        : 1. Pointer to buffer start                               */
/*                  2. start position                                        */
/*                  3. Maximum number of bytes in the buffer                 */
/*                  4. pointer to zero byte count                            */
/*                  5. pointer to bytes consumed variable                    */
/*  Globals       :                                                          */
/*  Processing    : Searches for the start code in the bitstream and updates */
/*                  consumed variable                                        */
/*                                                                           */
/*  Outputs       : Bytes consumed variable                                  */
/*  Returns       : If start code is found then it returns SC_FOUND otherwise*/
/*                  it returns SC_NOT_FOUND                                  */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay      Draft                                     */
/*                                                                           */
/*****************************************************************************/
WORD32 isvcd_nal_find_start_code(UWORD8 *pu1_buf_start, WORD32 i4_cur_pos, WORD32 i4_max_num_bytes,
                                 WORD32 *pi4_zero_cnt, UWORD32 *pu4_bytes_consumed)
{
    UWORD8 *pu1_buf = pu1_buf_start + i4_cur_pos;
    WORD32 i4_i;

    for(i4_i = 0; i4_i < (i4_max_num_bytes - i4_cur_pos); i4_i++)
    {
        /*-------------------------------------------------------------------*/
        /* If zero increment the zero byte counter                           */
        /*-------------------------------------------------------------------*/
        if(0 == *pu1_buf)
        {
            (*pi4_zero_cnt)++;
        }

        /*-------------------------------------------------------------------*/
        /* If start code found then increment the byte consumed and return   */
        /*-------------------------------------------------------------------*/
        else if(0x01 == *pu1_buf && *pi4_zero_cnt >= NUM_OF_ZERO_BYTES_BEFORE_START_CODE)
        {
            (*pu4_bytes_consumed)++;
            return (SC_FOUND);
        }
        /*-------------------------------------------------------------------*/
        /* If non zero byte and value is not equal to 1 a then reset zero    */
        /* byte counter                                                      */
        /*-------------------------------------------------------------------*/
        else
        {
            *pi4_zero_cnt = 0;
        }

        (*pu4_bytes_consumed)++;
        pu1_buf++;
    }

    return (SC_NOT_FOUND);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_get_first_start_code                               */
/*                                                                           */
/*  Description   : Searches for the first start code in the bitstream       */
/*                                                                           */
/*                                                                           */
/*  Inputs        : 1. input buffer structure                                */
/*                  2. Bytes consumed variable                               */
/*  Globals       : None                                                     */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       : Updates bytes consumed variable                          */
/*  Returns       : Start code is found or not                               */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay      Draft                                     */
/*                                                                           */
/*****************************************************************************/

WORD32 isvcd_get_first_start_code(UWORD8 *pu1_stream_buffer, UWORD32 *pu4_bytes_consumed,
                                  UWORD32 *pu4_num_bytes)
{
    WORD32 i4_zero_cnt = 0, i4_status;
    UWORD32 u4_bytes_consumed_temp = 0;

    i4_status = isvcd_nal_find_start_code(pu1_stream_buffer, 0, *pu4_num_bytes, &i4_zero_cnt,
                                          &u4_bytes_consumed_temp);

    /*-----------------------------------------------------------------------*/
    /* If start code is not found then return and start searching for it     */
    /* again in the next process call. This process is repeated till we      */
    /* get a start code                                                      */
    /*-----------------------------------------------------------------------*/
    if(SC_NOT_FOUND == i4_status)
    {
        *pu4_bytes_consumed += u4_bytes_consumed_temp;
        return (i4_status);
    }
    else
    {
        /*-------------------------------------------------------------------*/
        /* If start code found then proceed with bitstream extraction        */
        /*-------------------------------------------------------------------*/
        *pu4_bytes_consumed += u4_bytes_consumed_temp;
        return (i4_status);
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_get_annex_b_nal_unit                               */
/*                                                                           */
/*  Description   : This function gets one NAL unit from the Annex B based   */
/*                  input bitstream                                          */
/*                                                                           */
/*                                                                           */
/*  Inputs        : 1. Input buffer pointer                                  */
/*                  2. Current position in the input buffer                  */
/*                  3. Input buffer size                                     */
/*                  4. Pointer to state of NAL boundary detection variable   */
/*                  5. Pointer to bytes consumed variable                    */
/*                  6. pointer to nal structure                              */
/*  Globals       :                                                          */
/*  Processing    : This fucntion searches for start code from the current   */
/*                  position and once gets one start code it searches for    */
/*                  another start code to get a NAL unit.                    */
/*                                                                           */
/*  Outputs       : Updates the state of NAL boundary detection logic        */
/*                  Updates the bytes consumed variable from 0 to bytes      */
/*                  consumed in this call                                    */
/*  Returns       : start of nal flag                                        */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay      Draft                                     */
/*                                                                           */
/*****************************************************************************/

WORD32 isvcd_get_annex_b_nal_unit(UWORD8 *pu1_buf_start, WORD32 i4_cur_pos, WORD32 i4_max_num_bytes,
                                  WORD32 *pi4_state, WORD32 *pi4_zero_byte_cnt,
                                  UWORD32 *pu4_bytes_consumed, void *pv_nal_unit,
                                  WORD32 *pi4_more_data_flag)
{
    nal_unit_t *ps_nal_unit = (nal_unit_t *) pv_nal_unit;
    WORD32 i4_status, i4_nal_start_flag = SVCD_FALSE;

    /*-----------------------------------------------------------------------*/
    /* Initialization                                                        */
    /*-----------------------------------------------------------------------*/
    *pu4_bytes_consumed = 0;
    *pi4_more_data_flag = SVCD_TRUE;

    /*------------------------ check ----------------------------------------*/
    /* Assumptions is that this fucntion should not be called with this state*/
    /* hence it is responsibility of the caller to reset the state after the */
    /* NAL_END.                                                              */
    /*-----------------------------------------------------------------------*/
    if(NAL_END == *pi4_state)
    {
        return i4_nal_start_flag;
    }

    /*-----------------------------------------------------------------------*/
    /* ps_nal_unit->apu1_bufs[0] is expected to point to start of buffer of  */
    /* current NAL unit of the current process call. If a NAL unit is frag-  */
    /* -mented across multiple process call then this buffer should point to */
    /* start address of buffers. But when start of NAL is present in the     */
    /* buffer of current process call then ps_nal_unit->apu1_bufs[0] is      */
    /* expected to point to start adress of NAL unit (should be pointing to) */
    /* NAL header)                                                           */
    /*-----------------------------------------------------------------------*/
    ps_nal_unit->pu1_bufs = pu1_buf_start + i4_cur_pos;

    if(NAL_START == *pi4_state)
    {
        if(0 != *pi4_zero_byte_cnt)
        {
            return i4_nal_start_flag;
        }
        i4_nal_start_flag = SVCD_TRUE;
        ps_nal_unit->i4_num_bufs = 1;
        ps_nal_unit->i4_buf_sizes = 0;
        *pi4_state = FIND_NAL_END;
    }

    i4_status = isvcd_nal_find_start_code(pu1_buf_start, i4_cur_pos, i4_max_num_bytes,
                                          pi4_zero_byte_cnt, pu4_bytes_consumed);

    if(SC_NOT_FOUND == i4_status)
    {
        /*-------------------------------------------------------------------*/
        /* If start code is not found then there are 2 possibilities         */
        /* 1. We are in the middle of decoding the start code. This means    */
        /*    that we might have decoded the one or 2 zeroes of the start    */
        /*    code. In such cases, we should not consume these bytes. Though */
        /*    doing so we might encounter spurious cases where 0's are not   */
        /*    actually corresponds to start code but these will not harm us  */
        /* 2. Not of above case. Straightforward one                         */
        /*-------------------------------------------------------------------*/
        ps_nal_unit->i4_buf_sizes = *pu4_bytes_consumed;
        *pi4_more_data_flag = SVCD_FALSE;

        return (i4_nal_start_flag);
    }
    else
    {
        /*-------------------------------------------------------------------*/
        /* If NAL END is found then increment the bytes consumed appropriatly*/
        /* reset the zero byte counter                                       */
        /*-------------------------------------------------------------------*/
        *pi4_state = NAL_END;
        ps_nal_unit->i4_buf_sizes = *pu4_bytes_consumed - 1;
        *pi4_zero_byte_cnt = 0;
        return (i4_nal_start_flag);
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_nal_rbsp_to_sodb                                   */
/*                                                                           */
/*  Description   : Converts the RBSP data to SODB data                      */
/*                                                                           */
/*                                                                           */
/*  Inputs        : 1. Input buffer containing the NAL unit                  */
/*                  2. Length of NAL unit (in bytes)                         */
/*  Globals       : None                                                     */
/*  Processing    : Finds the RBSP stop bit, if present then finds the length*/
/*                  of SODB data                                             */
/*                                                                           */
/*  Outputs       :                                                          */
/*  Returns       : Number of bits in the SODB data                          */
/*                                                                           */
/*  Issues        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay      Draft                                     */
/*                                                                           */
/*****************************************************************************/

UWORD32 isvcd_nal_rbsp_to_sodb(UWORD8 *pu1_buf, WORD32 i4_nal_len_in_bytes, UWORD8 u1_ecd_mode)
{
    UWORD32 u4_last_word_pos;
    UWORD32 u4_word, u4_max_bit_offset;
    UWORD8 i4_num_bits;
    WORD32 i4_i;
    WORD64 i8_nal_len;
    UWORD32 *pu4_buf;

    if(0 >= i4_nal_len_in_bytes)
    {
        return (0);
    }

    /* Get offset in bits */
    i8_nal_len = (WORD64) i4_nal_len_in_bytes << 3;
    u4_max_bit_offset = (UWORD32) i8_nal_len;

    /* If NAL is coded in CABAC then SODB */
    /* length has to account for CABAC    */
    /* ZERO WORDS also                    */
    if(1 == u1_ecd_mode)
    {
        return (u4_max_bit_offset);
    }

    /* Calculate the position of last word */
    u4_last_word_pos = i4_nal_len_in_bytes >> 2;

    /* Load the last word                 */
    i4_i = i4_nal_len_in_bytes & 0x03;
    if(0 != i4_i)
    {
        pu4_buf = (UWORD32 *) pu1_buf;
        pu4_buf += u4_last_word_pos;
        u4_word = *pu4_buf;
        i4_num_bits = i4_i << 3;
        u4_word >>= (32 - i4_num_bits);
    }
    else
    {
        pu4_buf = (UWORD32 *) pu1_buf;
        pu4_buf += (u4_last_word_pos - 1);
        u4_word = *pu4_buf;
        i4_num_bits = 32;
    }

    /* Search for RBSP stop bit          */
    do
    {
        for(i4_i = 0; (i4_i < i4_num_bits) && !CHECKBIT(u4_word, i4_i); i4_i++)
            ;

        u4_max_bit_offset -= i4_i;

        /* RBSP stop bit is found then   */
        /* come out of the loop          */
        if(0 != CHECKBIT(u4_word, i4_i))
        {
            /* Remove RBSP stop bit */
            u4_max_bit_offset -= 1;
            break;
        }

        pu4_buf -= 1;
        u4_word = *pu4_buf;
        i4_num_bits = 32;
    } while(u4_max_bit_offset > 0);

    return (u4_max_bit_offset);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_reset_emulation_ctxt                               */
/*                                                                           */
/*  Description   : Resets the emulation prevention context structure        */
/*                                                                           */
/*  Inputs        : pv_emulation_ctxt - pointer to emulation prevention      */
/*                      context structure                                    */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       : None                                                     */
/*                                                                           */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*          DD MM YYYY   Author(s)       Changes                             */
/*          06 09 2021   Vijay      Draft                                    */
/*                                                                           */
/*****************************************************************************/

void isvcd_reset_emulation_ctxt(void *pv_emulation_ctxt)
{
    emulation_prevent_ctxt_t *ps_emulation_ctxt = (emulation_prevent_ctxt_t *) pv_emulation_ctxt;

    /*! Reset the emulation prevention context */
    ps_emulation_ctxt->i4_state = NOT_STUFFED_BYTE;
    ps_emulation_ctxt->i4_zeroes_cnt = 0;
    ps_emulation_ctxt->u4_bytes_in_word = 0;
    ps_emulation_ctxt->u4_word = 0;
}

/****************************************************************************/
/*                                                                          */
/* Function Name  : isvcd_nal_byte_swap_emulation                           */
/*                                                                          */
/* Description    : This function is does byte swap or emulation or both    */
/*                  in the stream.                                          */
/*                                                                          */
/* Inputs         :  pu4_out_stream : Pointer to bitstream out buffer       */
/*                   pu4_out_len    : Pointer to variable for out len       */
/*                   pu1_in_stream  : Pointer to bitstream in buffer        */
/*                   u4_in_len      : Input bitstream buffer length         */
/*                   u4_prev_0s     : In case of fragemented NAL 0s in last */
/*                                    fragmented unit                       */
/*                   u4_0s_bfr_sc   : Number of zeros before start code     */
/*                   u4_bytes       : Number of bytes in last fragmented    */
/*                                    word                                  */
/*                   u4_word        : Last fragmented word                  */
/*                                                                          */
/* Globals        :  None                                                   */
/*                                                                          */
/* Processing     :  It has three mode of operations                        */
/*                   1. Byte Swap and Emulation for H.264 WMV9 AP DEC       */
/*                      supports both fragmented and non fragmented packets */
/*                      set u4_prev_0s = last valid zeros for this operation*/
/*                   2. Byte Swap only for MPEG2 and MPEG4 WMV9 MP DEC      */
/*                      supports both fragmented and non fragmented packets */
/*                      set u4_prev_0s = 0 and  u4_0s_bfr_sc = u4_in_len    */
/*                   3. Annex B stream                                      */
/*                      only non fragmented                                 */
/*                      set u4_prev_0s = 0 for this operation               */
/* Outputs        :  pu4_out_len output length of the bit stream            */
/*                                                                          */
/* Returns        :  Number of zeros in case of framented start code        */
/*                                                                          */
/* Known Issues   :                                                         */
/*                                                                          */
/* Revision History                                                         */
/*                                                                          */
/*      DD MM YY            Author        Changes                           */
/*      06 09 2021          Vijay                                           */
/****************************************************************************/
UWORD32 isvcd_nal_byte_swap_emulation(UWORD32 *pu4_out_stream, UWORD32 *pu4_out_len,
                                      UWORD8 *pu1_in_stream, UWORD32 u4_in_len, WORD32 i4_0s_bfr_sc,
                                      void *pv_emulation_ctxt)
{
    UWORD32 u4_i, u4_num_bytes, u4_offset;
    UWORD8 u1_cur_byte;
    emulation_prevent_ctxt_t *ps_emulation_ctxt = (emulation_prevent_ctxt_t *) pv_emulation_ctxt;

    u4_offset = ps_emulation_ctxt->u4_bytes_in_word;
    u4_num_bytes = ps_emulation_ctxt->u4_bytes_in_word;

    for(u4_i = 0; u4_i < u4_in_len; u4_i++)
    {
        UWORD8 u1_cur_byte_emu, u1_cur_byte_sc;
        UWORD64 u8_sft_word;

        u1_cur_byte = *pu1_in_stream++;
        u1_cur_byte_emu = (EMULATION_PREVENTION_BYTE == u1_cur_byte);
        u1_cur_byte_sc = (START_CODE_BYTE == u1_cur_byte);

        if((ps_emulation_ctxt->i4_zeroes_cnt >= i4_0s_bfr_sc) & (u1_cur_byte_emu | u1_cur_byte_sc) &
           (NOT_STUFFED_BYTE == ps_emulation_ctxt->i4_state))
        {
            if(u1_cur_byte_sc)
            {
                break;
            }
            ps_emulation_ctxt->i4_zeroes_cnt = 0;
            ps_emulation_ctxt->i4_state = STUFFED_BYTE;
            continue;
        }

        u8_sft_word = (UWORD64) ps_emulation_ctxt->u4_word << 8;
        ps_emulation_ctxt->u4_word = (UWORD32) (u8_sft_word | u1_cur_byte);
        ps_emulation_ctxt->u4_bytes_in_word++;
        u4_num_bytes++;
        ps_emulation_ctxt->i4_zeroes_cnt++;
        if(u1_cur_byte != 0x00)
        {
            ps_emulation_ctxt->i4_zeroes_cnt = 0;
        }

        if((u4_num_bytes & 0x03) == 0x00)
        {
            *pu4_out_stream = ps_emulation_ctxt->u4_word;
            ps_emulation_ctxt->u4_bytes_in_word = 0;
            pu4_out_stream++;
        }

        ps_emulation_ctxt->i4_state = NOT_STUFFED_BYTE;
    }

    if(ps_emulation_ctxt->u4_bytes_in_word)
    {
        UWORD64 temp_out_stream = (UWORD64) ps_emulation_ctxt->u4_word
                                  << ((4 - ps_emulation_ctxt->u4_bytes_in_word) << 3);
        *pu4_out_stream = (UWORD32) temp_out_stream;
    }

    *pu4_out_len = (u4_num_bytes - u4_offset);
    return ((u4_num_bytes & 0xFFFFFFFC));
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_set_default_nal_header_prms                        */
/*                                                                           */
/*  Description   : Sets the members of NAL header structures to default     */
/*                  values                                                   */
/*                                                                           */
/*  Inputs        : pv_nal_prms - pointer nal header prms structure          */
/*                  i4_temp_id - default value of temporal id                */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       : None                                                     */
/*                                                                           */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*          DD MM YYYY   Author(s)       Changes                             */
/*          06 09 2021   Vijay      Draft                                    */
/*                                                                           */
/*****************************************************************************/
void isvcd_set_default_nal_prms(void *pv_nal_prms)
{
    nal_prms_t *ps_nal_prms;
    ps_nal_prms = (nal_prms_t *) pv_nal_prms;

    /* Set default values */
    ps_nal_prms->i4_dependency_id = 0;
    ps_nal_prms->i4_derived_nal_type = 0xFF;
    ps_nal_prms->i4_idr_pic_flag = SVCD_FALSE;
    ps_nal_prms->i4_nal_header_len = 0;
    ps_nal_prms->i4_nal_ref_idc = 0xFF;
    ps_nal_prms->i4_nal_unit_type = 0xFF;
    ps_nal_prms->i4_no_int_lyr_pred = 1;
    ps_nal_prms->i4_priority_id = 0;
    ps_nal_prms->i4_quality_id = 0;
    ps_nal_prms->i4_discard_flag = 0;
    ps_nal_prms->i4_dqid = 0;
    ps_nal_prms->i4_use_ref_base_pic_flag = 0;
    ps_nal_prms->i4_temporal_id = 0;
    ps_nal_prms->i4_idr_pic_num = 0;
    ps_nal_prms->u2_frm_num = 0;
    ps_nal_prms->i4_poc_lsb = 0;
    ps_nal_prms->i4_delta_poc_bot = 0;
    ps_nal_prms->ai4_delta_poc[0] = 0;
    ps_nal_prms->ai4_delta_poc[1] = 0;
    ps_nal_prms->u1_pps_id = 0;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_dec_nal_hdr                                        */
/*                                                                           */
/*  Description   : None                                                     */
/*                                                                           */
/*  Inputs        : pv_buf_ptr - Pointer to buffer constaining start of NAL  */
/*                  pv_nal_header_buf - Temporray working buffer             */
/*                  pv_nal_prms - Pointer to nal header prms                 */
/*                      structure                                            */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       : None                                                     */
/*                                                                           */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*          DD MM YYYY   Author(s)       Changes                             */
/*          06 09 2021   Vijay      Draft                                    */
/*                                                                           */
/*****************************************************************************/
void isvcd_dec_nal_hdr(void *pv_buf_ptr, WORD32 i4_buf_size, void *pv_nal_header_buf,
                       void *pv_nal_prms, void *pv_prefix_nal_buf, void *pv_prefix_nal_prms,
                       UWORD32 *pu4_err_code)
{
    nal_prms_t *ps_nal_prms;
    nal_prms_t *ps_prefix_nal_prms;
    nal_buf_t *ps_prefix_nal_buf;
    dec_bit_stream_t s_stream_ctxt = {0};
    WORD32 i4_forbidden_zero_bit;

    /* byte swapping */
    UWORD8 *pu1_buf = (UWORD8 *) pv_nal_header_buf;
    UWORD8 *pu1_src = (UWORD8 *) pv_buf_ptr;

    ps_nal_prms = (nal_prms_t *) pv_nal_prms;
    ps_prefix_nal_prms = (nal_prms_t *) pv_prefix_nal_prms;
    ps_prefix_nal_buf = (nal_buf_t *) pv_prefix_nal_buf;

    /* The NAL header syntax elements are read through bitstream fucntions.  */
    /* Hence bitstream context structure initializaton is needed before      */
    /* parsing from the bitstream                                            */
    /* Also bitstream fucntions assume the buffer is byteswapped. Hence the  */
    /* byte swapping is also done for 4 bytes                                */
    s_stream_ctxt.u4_ofst = 0;
    s_stream_ctxt.pu4_buffer = pv_nal_header_buf;
    s_stream_ctxt.u4_max_ofst = (i4_buf_size << 3);

    *pu4_err_code = 0;

    /* Check the size of bitstream buffer */
    if(s_stream_ctxt.u4_max_ofst < 8)
    {
        *pu4_err_code = (UWORD32) NAL_INSUFFICIENT_DATA;
        return;
    }

    if(s_stream_ctxt.u4_max_ofst >= 32)
    {
        *pu1_buf++ = *(pu1_src + 3);
        *pu1_buf++ = *(pu1_src + 2);
        *pu1_buf++ = *(pu1_src + 1);
        *pu1_buf++ = *pu1_src;
    }
    else
    {
        *pu1_buf++ = *pu1_src;
    }

    /*-----------------------------------------------------------------------*/
    /*! Parse the NAL header and update the NAL header structure members     */
    /*-----------------------------------------------------------------------*/
    /* Read forbidden 0 bit */
    i4_forbidden_zero_bit = ih264d_get_bit_h264(&s_stream_ctxt);

    if(0 != i4_forbidden_zero_bit)
    {
        *pu4_err_code = (UWORD32) NAL_CORRUPT_DATA;
        return;
    }

    /*---------------- Read NAL ref idc -----------------------------*/
    ps_nal_prms->i4_nal_ref_idc = ih264d_get_bits_h264(&s_stream_ctxt, 2);

    /*----------------- Read NAL type -------------------------------*/
    ps_nal_prms->i4_nal_unit_type = ih264d_get_bits_h264(&s_stream_ctxt, 5);
    if(ps_nal_prms->i4_nal_unit_type > CODED_SLICE_EXTENSION_NAL)
    {
        *pu4_err_code = (UWORD32) NAL_CORRUPT_DATA;
        return;
    }
    if(ACCESS_UNIT_DELIMITER_RBSP == ps_nal_prms->i4_nal_unit_type)
    {
        ps_nal_prms->i4_derived_nal_type = NON_VCL_NAL;
        return;
    }

    /* set idr pic flag */
    if(IDR_SLICE_NAL == ps_nal_prms->i4_nal_unit_type)
    {
        ps_nal_prms->i4_idr_pic_flag = SVCD_TRUE;
    }
    else
    {
        ps_nal_prms->i4_idr_pic_flag = SVCD_FALSE;
    }

    /*----------------- Read SVC extension NAL header ---------------*/
    if(CODED_SLICE_EXTENSION_NAL == ps_nal_prms->i4_nal_unit_type ||
       PREFIX_UNIT_NAL == ps_nal_prms->i4_nal_unit_type)
    {
        WORD32 i4_svc_extension_flag, i4_idr_flag;

        /* check the size of the buffer */
        if(s_stream_ctxt.u4_max_ofst < 32)
        {
            *pu4_err_code = (UWORD32) NAL_INSUFFICIENT_DATA;
            return;
        }

        i4_svc_extension_flag = ih264d_get_bit_h264(&s_stream_ctxt);
        UNUSED(i4_svc_extension_flag);

        i4_idr_flag = ih264d_get_bit_h264(&s_stream_ctxt);

        /* Set idr pic flag based on idr flag */
        if(1 == i4_idr_flag)
        {
            ps_nal_prms->i4_idr_pic_flag = SVCD_TRUE;
        }
        else
        {
            ps_nal_prms->i4_idr_pic_flag = SVCD_FALSE;
        }

        /* parse priorit id */
        ps_nal_prms->i4_priority_id = ih264d_get_bits_h264(&s_stream_ctxt, 6);

        /* parse the no inter layer prediction flag */
        ps_nal_prms->i4_no_int_lyr_pred = ih264d_get_bit_h264(&s_stream_ctxt);

        /* parse dependency id */
        ps_nal_prms->i4_dependency_id = ih264d_get_bits_h264(&s_stream_ctxt, 3);

        /* parse quality id */
        ps_nal_prms->i4_quality_id = ih264d_get_bits_h264(&s_stream_ctxt, 4);

        if((ps_nal_prms->i4_quality_id > 0) || (ps_nal_prms->i4_dependency_id > 2))
        {
            *pu4_err_code = (UWORD32) NAL_CORRUPT_DATA;
            return;
        }
        /* parse temporal id */
        ps_nal_prms->i4_temporal_id = ih264d_get_bits_h264(&s_stream_ctxt, 3);

        /* parse use ref base pic flag */
        ps_nal_prms->i4_use_ref_base_pic_flag = ih264d_get_bit_h264(&s_stream_ctxt);

        if(0 != ps_nal_prms->i4_use_ref_base_pic_flag)
        {
            *pu4_err_code = (UWORD32) NAL_CORRUPT_DATA;
            return;
        }
        /* parse discrad flag */
        ps_nal_prms->i4_discard_flag = ih264d_get_bit_h264(&s_stream_ctxt);

        /* parse the reserved bits */
        ih264d_get_bits_h264(&s_stream_ctxt, 3);
    }

    /* update NAL hedaer length in bytes */
    ps_nal_prms->i4_nal_header_len = s_stream_ctxt.u4_ofst >> 3;

    /*************************************************************************/
    /* PREFIX NAL UNIT ASSOCIATION WITH ASSOCIATED NAL UNIT                  */
    /*************************************************************************/

    /* if current NAL is not a AVC NAL unit then */
    /* discard the prefix NAL unit if present    */
    if(CODED_SLICE_EXTENSION_NAL == ps_nal_prms->i4_nal_unit_type)
    {
        isvcd_nal_buf_reset(ps_prefix_nal_buf);
    }

    if(SVCD_TRUE == ps_prefix_nal_buf->i4_valid_flag)
    {
        /* Copy the required parameters from the prefix NAL unit */
        ps_nal_prms->i4_dependency_id = ps_prefix_nal_prms->i4_dependency_id;
        ps_nal_prms->i4_quality_id = ps_prefix_nal_prms->i4_quality_id;
        ps_nal_prms->i4_priority_id = ps_prefix_nal_prms->i4_priority_id;
        ps_nal_prms->i4_temporal_id = ps_prefix_nal_prms->i4_temporal_id;
        ps_nal_prms->i4_no_int_lyr_pred = ps_prefix_nal_prms->i4_no_int_lyr_pred;
        ps_nal_prms->i4_use_ref_base_pic_flag = ps_prefix_nal_prms->i4_use_ref_base_pic_flag;
        ps_nal_prms->i4_discard_flag = ps_prefix_nal_prms->i4_discard_flag;
    }

    /*-----------------------------------------------------------------------*/
    /* Set the derived NAL unit type and also update the DQID for VCL NAL    */
    /*  units                                                                */
    /*-----------------------------------------------------------------------*/
    if(CODED_SLICE_EXTENSION_NAL == ps_nal_prms->i4_nal_unit_type ||
       SLICE_NAL == ps_nal_prms->i4_nal_unit_type ||
       IDR_SLICE_NAL == ps_nal_prms->i4_nal_unit_type ||
       PREFIX_UNIT_NAL == ps_nal_prms->i4_nal_unit_type)
    {
        ps_nal_prms->i4_derived_nal_type = VCL_NAL;

        /* calculate the DQID and modified DQID */
        ps_nal_prms->i4_dqid = (ps_nal_prms->i4_dependency_id << 4) + ps_nal_prms->i4_quality_id;
    }
    else
    {
        ps_nal_prms->i4_derived_nal_type = NON_VCL_NAL;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_parse_part_slice_hdr                                */
/*                                                                           */
/*  Description   : This routine parses the slice till POC parameters        */
/*                                                                           */
/*  Inputs        : 1. Pointer to input bitstream                            */
/*                  2. Temporary input buffer                                */
/*                  3. PPS start buffer                                      */
/*                  4. SPS start buffer                                      */
/*                  5. Pointer to NAL paramter structure                     */
/*                  6. Place holder for error code                           */
/*  Globals       : None                                                     */
/*  Processing    : Parses the slice header                                  */
/*                                                                           */
/*  Outputs       : Updated NAL prms structure                               */
/*                  Updated error code                                       */
/*  Returns       : status                                                   */
/*                                                                           */
/*  Issues        : Does not support interlaced content                      */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay           Draft                                */
/*                                                                           */
/*****************************************************************************/
WORD32 isvcd_parse_part_slice_hdr(UWORD8 *pu1_input_buf, WORD32 i4_input_buf_size,
                                  UWORD8 *pu1_temp_buf, void *pv_sps, void *pv_pps,
                                  nal_prms_t *ps_nal_prms, UWORD32 *pu4_err_code,
                                  WORD32 *pi4_sps_pps_status)
{
    UWORD32 u4_slice_type;
    dec_seq_params_t *ps_sps = (dec_seq_params_t *) pv_sps;
    dec_pic_params_t *ps_pps = (dec_pic_params_t *) pv_pps;
    dec_bit_stream_t s_stream_ctxt = {0};
    dec_bit_stream_t *ps_stream_ctxt;
    UWORD32 *pu4_bitstrm_buf;
    UWORD32 *pu4_bitstrm_ofst;

    *pi4_sps_pps_status = NAL_CORRUPT_DATA;
    /* Perform the emulation prevention and byte swap */
    {
        emulation_prevent_ctxt_t s_emulation_ctxt = {0};
        WORD32 i4_size, i4_temp;

        isvcd_reset_emulation_ctxt((void *) &s_emulation_ctxt);
        i4_size = MIN(i4_input_buf_size, HEADER_BUFFER_LEN_BEFORE_EP);

        isvcd_nal_byte_swap_emulation((UWORD32 *) pu1_temp_buf, (UWORD32 *) &i4_temp, pu1_input_buf,
                                      (UWORD32) i4_size, NUM_OF_ZERO_BYTES_BEFORE_START_CODE,
                                      &s_emulation_ctxt);

        /* Initialize the stream context structure */
        s_stream_ctxt.pu4_buffer = (UWORD32 *) pu1_temp_buf;
        s_stream_ctxt.u4_ofst = 0;
        s_stream_ctxt.u4_max_ofst = (i4_size << 3);
    }

    ps_stream_ctxt = &s_stream_ctxt;

    /* Parse the first mb address in slice */
    pu4_bitstrm_buf = ps_stream_ctxt->pu4_buffer;
    pu4_bitstrm_ofst = &ps_stream_ctxt->u4_ofst;
    ps_nal_prms->u4_first_mb_addr = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
    if(ps_nal_prms->u4_first_mb_addr >= (MAX_MBS_LEVEL_51))
    {
        return ERROR_CORRUPTED_SLICE;
    }
    /* Parse slice type */
    u4_slice_type = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);

    if(u4_slice_type > 9) return ERROR_INV_SLC_TYPE_T;

    /* Check the validity of slice prms */
    switch(u4_slice_type)
    {
        case 0:
        case 5:
            u4_slice_type = P_SLICE;
            /* P slice */
            break;
        case 1:
        case 6:
            u4_slice_type = B_SLICE;
            /* B slice */
            break;
        case 2:
        case 7:
            /* I slice */
            u4_slice_type = I_SLICE;
            break;
        default:
            break;
    }

    /* Parse the pps id */
    ps_nal_prms->u1_pps_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
    if(ps_nal_prms->u1_pps_id & MASK_ERR_PIC_SET_ID) return ERROR_INV_SLICE_HDR_T;

    /* validate pps id */
    ps_pps += ps_nal_prms->u1_pps_id;
    if(0 == ps_pps->u1_is_valid)
    {
        return NOT_OK;
    }
    /* Derive sps id */
    ps_sps = ps_pps->ps_sps;

    ps_nal_prms->u1_sps_id = ps_sps->u1_seq_parameter_set_id;
    if(CODED_SLICE_EXTENSION_NAL == ps_nal_prms->i4_nal_unit_type)
    {
        ps_sps += MAX_NUM_SEQ_PARAMS;
        ps_nal_prms->u1_sps_id = ps_sps->u1_seq_parameter_set_id;
        ps_nal_prms->u1_sps_id += MAX_NUM_SEQ_PARAMS;
    }

    if(NULL == ps_sps)
    {
        return NOT_OK;
    }
    if(FALSE == ps_sps->u1_is_valid)
    {
        return ERROR_INV_SLICE_HDR_T;
    }
    if(ps_nal_prms->u4_first_mb_addr > (ps_sps->u2_frm_ht_in_mbs * ps_sps->u2_frm_wd_in_mbs))
    {
        return ERROR_CORRUPTED_SLICE;
    }
    *pi4_sps_pps_status = 0;

    /* Parse frame number */
    ps_nal_prms->u2_frm_num = ih264d_get_bits_h264(ps_stream_ctxt, ps_sps->u1_bits_in_frm_num);

    /* IDR picture number */
    if(SVCD_TRUE == ps_nal_prms->i4_idr_pic_flag)
    {
        ps_nal_prms->i4_idr_pic_num = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);

        if(ps_nal_prms->i4_idr_pic_num > 65535) return ERROR_INV_SLICE_HDR_T;
    }

    /* Poc lsb */
    if(0 == ps_sps->u1_pic_order_cnt_type)
    {
        ps_nal_prms->i4_poc_lsb =
            ih264d_get_bits_h264(ps_stream_ctxt, ps_sps->u1_log2_max_pic_order_cnt_lsb_minus);

        if(ps_nal_prms->i4_poc_lsb < 0 ||
           ps_nal_prms->i4_poc_lsb >= ps_sps->i4_max_pic_order_cntLsb)
            return ERROR_INV_SLICE_HDR_T;
        if(SVCD_TRUE == ps_pps->u1_pic_order_present_flag)
        {
            ps_nal_prms->i4_delta_poc_bot = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
        }
    }
    else if((1 == ps_sps->u1_pic_order_cnt_type) && (!ps_sps->u1_delta_pic_order_always_zero_flag))
    {
        ps_nal_prms->ai4_delta_poc[0] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);

        if(SVCD_TRUE == ps_pps->u1_pic_order_present_flag)
        {
            ps_nal_prms->ai4_delta_poc[1] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
        }
    }

    *pu4_err_code = 0;
    return (OK);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_get_int_tgt_lyr_attr                                */
/*                                                                           */
/*  Description   : This routine returns the target layer attributes         */
/*                  (dependency id, temporal id and quality id)              */
/*                                                                           */
/*  Inputs        : 1. Application attributes                                */
/*                  2. Internal attributes (input and output)                */
/*                  3. Nal prms structure                                    */
/*  Globals       : None                                                     */
/*  Processing    :                                                          */
/*                                                                           */
/*  Outputs       : Updated internal target layer attributes                 */
/*  Returns       : status                                                   */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         06 09 2021   Vijay           Draft                                */
/*                                                                           */
/*****************************************************************************/
WORD32 isvcd_get_int_tgt_lyr_attr(target_lyr_attr_t *ps_app_attr, target_lyr_attr_t *ps_int_attr,
                                  nal_prms_t *ps_nal_prms)
{
    WORD32 i4_dep_id;
    WORD32 i4_quality_id;
    WORD32 i4_temp_id;
    WORD32 i4_prior_id;

    /* sanity checks */
    if((NULL == ps_app_attr) || (NULL == ps_int_attr) || (NULL == ps_nal_prms))
    {
        return NOT_OK;
    }

    i4_dep_id = ps_int_attr->i4_dependency_id;
    i4_quality_id = ps_int_attr->i4_quality_id;
    i4_temp_id = ps_int_attr->i4_temporal_id;
    i4_prior_id = ps_int_attr->i4_priority_id;

    /* check for idr pic flag                                  */
    /* dependency & temporal id is updated only for IDR picture */
    if(SVCD_TRUE == ps_nal_prms->i4_idr_pic_flag)
    {
        if(ps_int_attr->i4_dependency_id < ps_app_attr->i4_dependency_id)
        {
            /* update the internal attributes only if             */
            /* current dep_id -1 == highest dep id decoded so far */
            /* and quality id is equal to 0                       */
            if((ps_nal_prms->i4_dependency_id - 1 == ps_int_attr->i4_dependency_id) &&
               (0 == ps_nal_prms->i4_quality_id))
            {
                /* Set revised target dependency id */
                i4_dep_id = ps_nal_prms->i4_dependency_id;
                i4_temp_id = ps_app_attr->i4_temporal_id;
                i4_prior_id = ps_app_attr->i4_priority_id;
            }
        }
        else
        {
            /* cases when the curr dep is greater than or equal to app dep */
            i4_dep_id = ps_app_attr->i4_dependency_id;
            i4_temp_id = ps_app_attr->i4_temporal_id;
            i4_prior_id = ps_app_attr->i4_priority_id;
        }
    }

    /* Set quality id */
    if(i4_dep_id == ps_app_attr->i4_dependency_id)
    {
        i4_quality_id = ps_app_attr->i4_quality_id;
    }
    else
    {
        i4_quality_id = MAX_QUALITY_ID;
    }

    /* Update the internal attributes */
    ps_int_attr->i4_dependency_id = i4_dep_id;
    ps_int_attr->i4_quality_id = i4_quality_id;
    ps_int_attr->i4_temporal_id = i4_temp_id;
    ps_int_attr->i4_priority_id = i4_prior_id;

    return (OK);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : isvcd_discard_nal                                         */
/*                                                                           */
/*  Description   : Determines whether current NAL unit has to be discarded  */
/*                  or not                                                   */
/*                                                                           */
/*  Inputs        : pv_nal_prms - Pointer to NAL header prms                 */
/*                      structure                                            */
/*                  pv_app_lyr_attr - Pointer to application target layer    */
/*                      attributes  structure                                */
/*                  pv_app_lyr_attr - Pointer to internal target layer       */
/*                      attributes  structure                                */
/*                  i4_update_flag - This flag indicates whether the internal*/
/*                      target attrbutes should be updated or not            */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : None                                                     */
/*                                                                           */
/*  Outputs       : None                                                     */
/*                                                                           */
/*  Returns       : None                                                     */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*          DD MM YYYY   Author(s)       Changes                             */
/*          06 09 2021   Vijay           Draft                               */
/*                                                                           */
/*****************************************************************************/
WORD32 isvcd_discard_nal(void *pv_nal_prms, void *pv_app_attr, void *pv_int_attr,
                         WORD32 i4_update_flag)
{
    WORD32 i4_discard_nal_flag;
    nal_prms_t *ps_nal_prms;
    target_lyr_attr_t *ps_app_attr;
    target_lyr_attr_t *ps_int_attr;
    WORD32 i4_status;

    ps_nal_prms = (nal_prms_t *) pv_nal_prms;
    ps_app_attr = (target_lyr_attr_t *) pv_app_attr;
    ps_int_attr = (target_lyr_attr_t *) pv_int_attr;

    /* Get the updated target layer attributes */
    if(SVCD_TRUE == i4_update_flag)
    {
        i4_status = isvcd_get_int_tgt_lyr_attr(ps_app_attr, ps_int_attr, ps_nal_prms);
        if(OK != i4_status)
        {
            return NOT_OK;
        }
    }

    i4_discard_nal_flag = SVCD_FALSE;

    if(VCL_NAL == ps_nal_prms->i4_derived_nal_type)
    {
        /*-------------------------------------------------------------------*/
        /*!Discard VCL NAL if any of following is true                       */
        /*! - Dependency id is greater than target dependency id             */
        /*! - Dependency id is equal to target dependency id but quality id  */
        /*!   is greater than target quality id                              */
        /*! - priority id is greater than target priority id                 */
        /*! - Temporal id is greater than target temporal id                 */
        /*! - If dependency id is greater than a NAL unit for which discard  */
        /*!   flag of the NAL header is set                                  */
        /*-------------------------------------------------------------------*/
        if(PREFIX_UNIT_NAL != ps_nal_prms->i4_nal_unit_type)
        {
            if(ps_nal_prms->i4_dependency_id > ps_int_attr->i4_dependency_id)
            {
                i4_discard_nal_flag = SVCD_TRUE;
            }

            if(ps_nal_prms->i4_dependency_id == ps_int_attr->i4_dependency_id &&
               ps_nal_prms->i4_quality_id > ps_int_attr->i4_quality_id)
            {
                i4_discard_nal_flag = SVCD_TRUE;
            }

            if(ps_nal_prms->i4_temporal_id > ps_int_attr->i4_temporal_id)
            {
                i4_discard_nal_flag = SVCD_TRUE;
            }

            if(ps_nal_prms->i4_priority_id > ps_int_attr->i4_priority_id)
            {
                i4_discard_nal_flag = SVCD_TRUE;
            }
        }
        else
        {
            if(0 == ps_int_attr->i4_quality_id && 0 == ps_int_attr->i4_dependency_id)
            {
                i4_discard_nal_flag = SVCD_TRUE;
            }
        }
    }

    return (i4_discard_nal_flag);
}