| /****************************************************************************** |
| * |
| * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore |
| * |
| * 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. |
| * |
| ******************************************************************************/ |
| /** |
| ******************************************************************************* |
| * @file |
| * ihevcd_nal.c |
| * |
| * @brief |
| * Contains functions for NAL level such as search start code etc |
| * |
| * @author |
| * Harish |
| * |
| * @par List of Functions: |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| #include <stdio.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #include "ihevc_typedefs.h" |
| #include "iv.h" |
| #include "ivd.h" |
| #include "ihevcd_cxa.h" |
| |
| #include "ihevc_defs.h" |
| #include "ihevc_debug.h" |
| #include "ihevc_structs.h" |
| #include "ihevc_macros.h" |
| #include "ihevc_platform_macros.h" |
| #include "ihevc_cabac_tables.h" |
| |
| |
| #include "ihevcd_defs.h" |
| #include "ihevcd_function_selector.h" |
| #include "ihevcd_structs.h" |
| #include "ihevcd_error.h" |
| #include "ihevcd_nal.h" |
| #include "ihevcd_bitstream.h" |
| #include "ihevcd_parse_headers.h" |
| #include "ihevcd_parse_slice.h" |
| #include "ihevcd_debug.h" |
| /*****************************************************************************/ |
| /* Function Prototypes */ |
| /*****************************************************************************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * Search start code from the given buffer pointer |
| * |
| * @par Description: |
| * Search for start code Return the offset of start code if start code is |
| * found If no start code is found till end of given bitstream then treat |
| * it as invalid NAL and return end of buffer as offset |
| * |
| * @param[in] pu1_buf |
| * Pointer to bitstream |
| * |
| * @param[in] bytes_remaining |
| * Number of bytes remaining in the buffer |
| * |
| * @returns Offset to the first byte in NAL after start code |
| * |
| * @remarks |
| * Incomplete start code at the end of input bitstream is not handled. This |
| * has to be taken care outside this func |
| * |
| ******************************************************************************* |
| */ |
| WORD32 ihevcd_nal_search_start_code(UWORD8 *pu1_buf, WORD32 bytes_remaining) |
| { |
| WORD32 ofst; |
| |
| WORD32 zero_byte_cnt; |
| WORD32 start_code_found; |
| |
| ofst = -1; |
| |
| zero_byte_cnt = 0; |
| start_code_found = 0; |
| while(ofst < (bytes_remaining - 1)) |
| { |
| ofst++; |
| if(pu1_buf[ofst] != 0) |
| { |
| zero_byte_cnt = 0; |
| continue; |
| } |
| |
| zero_byte_cnt++; |
| if((pu1_buf[ofst + 1] == START_CODE_PREFIX_BYTE) && |
| (zero_byte_cnt >= NUM_ZEROS_BEFORE_START_CODE)) |
| { |
| /* Found the start code */ |
| ofst++; |
| start_code_found = 1; |
| break; |
| } |
| } |
| if(0 == start_code_found) |
| { |
| if((START_CODE_PREFIX_BYTE == pu1_buf[ofst]) && |
| (zero_byte_cnt >= NUM_ZEROS_BEFORE_START_CODE)) |
| { |
| /* Found a start code at the end*/ |
| ofst++; |
| } |
| } |
| /* Since ofst started at -1, increment it by 1 */ |
| ofst++; |
| |
| return ofst; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * Remove emulation prevention byte present in the bitstream till next start |
| * code is found. Emulation prevention byte removed data is stored in a |
| * different buffer |
| * |
| * @par Description: |
| * Assumption is first start code is already found and pu1_buf is pointing |
| * to a byte after the start code Search for Next NAL's start code Return |
| * if start code is found Remove any emulation prevention byte present Copy |
| * data to new buffer If no start code is found, then treat complete buffer |
| * as one nal. |
| * |
| * @param[in] pu1_src |
| * Pointer to bitstream (excludes the initial the start code) |
| * |
| * @param[in] pu1_dst |
| * Pointer to destination buffer |
| * |
| * @param[in] bytes_remaining |
| * Number of bytes remaining |
| * |
| * @param[out] pi4_nal_len |
| * NAL length (length of bitstream parsed) |
| * |
| * @param[out] pi4_dst_len |
| * Destination bitstream size (length of bitstream parsed with emulation bytes |
| * removed) |
| * |
| * @returns Error code from IHEVCD_ERROR_T |
| * |
| * @remarks |
| * Incomplete start code at the end of input bitstream is not handled. This |
| * has to be taken care outside this func |
| * |
| ******************************************************************************* |
| */ |
| IHEVCD_ERROR_T ihevcd_nal_remv_emuln_bytes(UWORD8 *pu1_src, |
| UWORD8 *pu1_dst, |
| WORD32 bytes_remaining, |
| WORD32 *pi4_nal_len, |
| WORD32 *pi4_dst_len) |
| { |
| WORD32 src_cnt; |
| WORD32 dst_cnt; |
| WORD32 zero_byte_cnt; |
| WORD32 start_code_found; |
| UWORD8 u1_src; |
| IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; |
| |
| src_cnt = 0; |
| dst_cnt = 0; |
| zero_byte_cnt = 0; |
| start_code_found = 0; |
| while(src_cnt < (bytes_remaining - 1)) |
| { |
| u1_src = pu1_src[src_cnt++]; |
| |
| pu1_dst[dst_cnt++] = u1_src; |
| if(u1_src != 0) |
| { |
| zero_byte_cnt = 0; |
| continue; |
| } |
| |
| zero_byte_cnt++; |
| if(zero_byte_cnt >= NUM_ZEROS_BEFORE_START_CODE) |
| { |
| u1_src = pu1_src[src_cnt]; |
| if(START_CODE_PREFIX_BYTE == u1_src) |
| { |
| /* Found the start code */ |
| src_cnt -= zero_byte_cnt; |
| dst_cnt -= zero_byte_cnt; |
| start_code_found = 1; |
| break; |
| } |
| else if(EMULATION_PREVENT_BYTE == u1_src) |
| { |
| /* Found the emulation prevention byte */ |
| src_cnt++; |
| zero_byte_cnt = 0; |
| |
| /* Decrement dst_cnt so that the next byte overwrites |
| * the emulation prevention byte already copied to dst above |
| */ |
| } |
| } |
| |
| } |
| |
| if(0 == start_code_found) |
| { |
| u1_src = pu1_src[src_cnt++]; |
| if(zero_byte_cnt >= NUM_ZEROS_BEFORE_START_CODE) |
| { |
| |
| if(START_CODE_PREFIX_BYTE == u1_src) |
| { |
| /* Found a start code at the end*/ |
| src_cnt -= zero_byte_cnt; |
| } |
| else if(EMULATION_PREVENT_BYTE == u1_src) |
| { |
| /* Found the emulation prevention byte at the end*/ |
| src_cnt++; |
| /* Decrement dst_cnt so that the next byte overwrites |
| * the emulation prevention byte already copied to dst above |
| */ |
| dst_cnt--; |
| } |
| } |
| else |
| { |
| pu1_dst[dst_cnt++] = u1_src; |
| } |
| |
| |
| } |
| *pi4_nal_len = src_cnt; |
| *pi4_dst_len = dst_cnt; |
| return ret; |
| } |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * Decode given NAL unit's header |
| * |
| * @par Description: |
| * Call NAL unit's header decode Section: 7.3.1.2 |
| * |
| * @param[in] ps_bitstrm |
| * Pointer to bitstream context |
| * |
| * @param[out] ps_nal |
| * Pointer to NAL header |
| * |
| * @returns Error code from IHEVCD_ERROR_T |
| * |
| * @remarks |
| * |
| * |
| ******************************************************************************* |
| */ |
| IHEVCD_ERROR_T ihevcd_nal_unit_header(bitstrm_t *ps_bitstrm, nal_header_t *ps_nal) |
| { |
| WORD32 unused; |
| IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; |
| UNUSED(unused); |
| /* Syntax : forbidden_zero_bit */ |
| unused = ihevcd_bits_get(ps_bitstrm, 1); |
| |
| /* Syntax : nal_unit_type */ |
| ps_nal->i1_nal_unit_type = ihevcd_bits_get(ps_bitstrm, 6); |
| |
| /* Syntax : nuh_reserved_zero_6bits */ |
| unused = ihevcd_bits_get(ps_bitstrm, 6); |
| |
| /* Syntax : nuh_temporal_id_plus1 */ |
| ps_nal->i1_nuh_temporal_id = ihevcd_bits_get(ps_bitstrm, 3) - 1; |
| |
| return ret; |
| |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * Decode given NAL |
| * |
| * @par Description: |
| * Based on the NAL type call appropriate decode function Section: 7.3.1.1 |
| * |
| * |
| * @param[in,out] ps_codec |
| * Pointer to codec context (Functions called within will modify contents of |
| * ps_codec) |
| * |
| * @returns Error code from IHEVCD_ERROR_T |
| * |
| * @remarks |
| * |
| * |
| ******************************************************************************* |
| */ |
| IHEVCD_ERROR_T ihevcd_nal_unit(codec_t *ps_codec) |
| { |
| IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS; |
| |
| /* NAL Header */ |
| nal_header_t s_nal; |
| |
| ret = ihevcd_nal_unit_header(&ps_codec->s_parse.s_bitstrm, &s_nal); |
| RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret); |
| |
| if(ps_codec->i4_slice_error) |
| s_nal.i1_nal_unit_type = ps_codec->s_parse.ps_slice_hdr->i1_nal_unit_type; |
| |
| /* Setting RASL Output flag */ |
| switch(s_nal.i1_nal_unit_type) |
| { |
| case NAL_BLA_W_LP : |
| case NAL_BLA_W_DLP : |
| case NAL_BLA_N_LP : |
| ps_codec->i4_rasl_output_flag = 0; |
| break; |
| |
| //TODO: After IDR, there is no case of open GOP |
| //To be fixed appropriately by ignoring RASL only if the |
| // required references are not found |
| case NAL_IDR_W_LP : |
| case NAL_IDR_N_LP : |
| ps_codec->i4_rasl_output_flag = 1; |
| break; |
| |
| case NAL_CRA : |
| ps_codec->i4_rasl_output_flag = (0 != ps_codec->i4_cra_as_first_pic) ? 0 : 1; |
| break; |
| |
| default: |
| break; |
| } |
| |
| switch(s_nal.i1_nal_unit_type) |
| { |
| case NAL_BLA_W_LP : |
| case NAL_BLA_W_DLP : |
| case NAL_BLA_N_LP : |
| case NAL_IDR_W_LP : |
| case NAL_IDR_N_LP : |
| case NAL_CRA : |
| case NAL_TRAIL_N : |
| case NAL_TRAIL_R : |
| case NAL_TSA_N : |
| case NAL_TSA_R : |
| case NAL_STSA_N : |
| case NAL_STSA_R : |
| case NAL_RADL_N : |
| case NAL_RADL_R : |
| case NAL_RASL_N : |
| case NAL_RASL_R : |
| if(ps_codec->i4_header_mode) |
| return IHEVCD_SLICE_IN_HEADER_MODE; |
| |
| if((0 == ps_codec->i4_sps_done) || |
| (0 == ps_codec->i4_pps_done)) |
| { |
| return IHEVCD_INVALID_HEADER; |
| } |
| |
| ps_codec->i4_header_in_slice_mode = 0; |
| ps_codec->i4_cra_as_first_pic = 0; |
| |
| ret = ihevcd_parse_slice_header(ps_codec, &s_nal); |
| DEBUG_PRINT_NAL_INFO(ps_codec, s_nal.i1_nal_unit_type); |
| if(ret == (IHEVCD_ERROR_T)IHEVCD_SUCCESS) |
| { |
| if((s_nal.i1_nal_unit_type != NAL_RASL_N && s_nal.i1_nal_unit_type != NAL_RASL_R) || |
| ps_codec->i4_rasl_output_flag || |
| ps_codec->i4_slice_error) |
| ret = ihevcd_parse_slice_data(ps_codec); |
| } |
| break; |
| |
| case NAL_VPS : |
| // ret = ihevcd_parse_vps(ps_codec); |
| DEBUG_PRINT_NAL_INFO(ps_codec, s_nal.i1_nal_unit_type); |
| break; |
| |
| case NAL_SPS : |
| if(0 == ps_codec->i4_header_mode) |
| { |
| ps_codec->i4_header_in_slice_mode = 1; |
| if(ps_codec->i4_sps_done && |
| ps_codec->i4_pic_present) |
| break; |
| } |
| |
| ret = ihevcd_parse_sps(ps_codec); |
| if(ret == (IHEVCD_ERROR_T)IHEVCD_SUCCESS) |
| { |
| sps_t *ps_sps = ps_codec->ps_sps_base + MAX_SPS_CNT - 1; |
| ihevcd_copy_sps(ps_codec, ps_sps->i1_sps_id, MAX_SPS_CNT - 1); |
| } |
| ps_codec->i4_error_code = ret; |
| |
| DEBUG_PRINT_NAL_INFO(ps_codec, s_nal.i1_nal_unit_type); |
| break; |
| |
| case NAL_PPS : |
| if(0 == ps_codec->i4_header_mode) |
| { |
| ps_codec->i4_header_in_slice_mode = 1; |
| if(ps_codec->i4_pps_done && |
| ps_codec->i4_pic_present) |
| break; |
| } |
| |
| ret = ihevcd_parse_pps(ps_codec); |
| if(ret == (IHEVCD_ERROR_T)IHEVCD_SUCCESS) |
| { |
| pps_t *ps_pps = ps_codec->ps_pps_base + MAX_PPS_CNT - 1; |
| ihevcd_copy_pps(ps_codec, ps_pps->i1_pps_id, MAX_PPS_CNT - 1); |
| } |
| ps_codec->i4_error_code = ret; |
| DEBUG_PRINT_NAL_INFO(ps_codec, s_nal.i1_nal_unit_type); |
| break; |
| |
| case NAL_EOS : |
| ps_codec->i4_cra_as_first_pic = 1; |
| break; |
| |
| default: |
| DEBUG_PRINT_NAL_INFO(ps_codec, s_nal.i1_nal_unit_type); |
| break; |
| } |
| |
| return ret; |
| } |
| |
