/* ------------------------------------------------------------------ * Copyright (C) 1998-2009 PacketVideo * * 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. * ------------------------------------------------------------------- */ /* Pathname: get_adts_header.c ------------------------------------------------------------------------------ REVISION HISTORY Description: Remove default_config variable Description: change enter_mc_info to set_mc_info Description: (1) add error checking for channel_config > 2 (2) eliminated call to check_mc_info (3) use (profile + 1) when calling set_mc_info (4) use winmap when calling set_mc_info Who: Date: Description: ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: pVars = Pointer to structure that holds file-scope variables. [ tDec_Int_File * ] pSyncword = Pointer to variable that holds the 28-bit fixed header upon the exit of this function. [ UInt32 * ] pInvoke = Pointer to variable that keeps track of how many "short" (14 bit) headers have been successfully parsed from the bitstream. [ Int * ] Local Stores/Buffers/Pointers Needed: None Global Stores/Buffers/Pointers Needed: None Outputs: Status = SUCCESS or ERROR CODE Pointers and Buffers Modified: pVars->prog_config Updated with program information data as read from the ADTS header. pSyncword Value pointed to is updated with the contents of the 28-bit fixed header. pInvoke Value pointed to is updated to reflect the number of successful "short" (14 bit) headers that have been successfully parsed from the bitstream. Local Stores Modified: None Global Stores Modified: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION Acronym Definitions ADTS Audio Data Transport Stream CRC Cyclic Redundancy Code This function calls find_adts_syncword to find the next ADTS header. Until three consistent headers have been read, the syncword used for detection consists of the 12-bit syncword and the 2-bit Layer. After three consistent headers are read, the entire fixed header is used for a robust 28-bit syncword. Configuration information is then extracted from the bitstream. The bitstream information is packed as follows. Comments about the correct interpretation of these bits are contained within the code. CRC_absent sampling_rate_idx \ / \ \ / \ \ Profile / \ UNUSED \ / \ / \ / |00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25| \ _______________ / | \ / \ / \-------|0xFFF syncword |-------/ | Layer == '00' for AAC \ / \-------------/ | \ / | \/ ID == '1' for MPEG-2 AAC channel_config copyright_id_bit == '0' for MPEG-4 AAC / home / / / |26|27|28|29|30|31|32|33|34|35|36|37|38|39|40|41|42| | \ \ _____________ / | \ \--------|frame length |---------/ orig_copy \ \-----------/ \ ______________________________ copyright_id_start | TOTAL HEADER LENGTH: 56 bits| |-----------------------------| |43|44|45|46|47|48|49|50|51|52|53|54|55| | FIXED HEADER BITS 00-27 | \ _______________ / | | | VARIABLE HEADER BITS 28-55 | \-----|buffer_fullness|----/ \ / |_____________________________| \-------------/ | headerless_frames In addition to the bits displayed above, if the value CRC_absent is '0' an additional 16 bits corresponding to a CRC word are read from the bitstream, following the header. ------------------------------------------------------------------------------ REQUIREMENTS After the ADTS syncword is detected, this function shall parse the information residing behind the syncword in the bitstream. ------------------------------------------------------------------------------ REFERENCES (1) ISO/IEC 13818-7:1997(E) Part 7 Subpart 6.2 (Audio_Data_Transport_Stream frame, ADTS) (2) ISO/IEC 11172-3:1993(E) Part 3 Subpart 2.4.3 The audio decoding process (3) MPEG-2 NBC Audio Decoder "This software module was originally developed by AT&T, Dolby Laboratories, Fraunhofer Gesellschaft IIS in the course of development of the MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7, 14496-1,2 and 3. This software module is an implementation of a part of one or more MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4 Audio standard. ISO/IEC gives users of the MPEG-2 NBC/MPEG-4 Audio standards free license to this software module or modifications thereof for use in hardware or software products claiming conformance to the MPEG-2 NBC/MPEG-4 Audio standards. Those UIntending to use this software module in hardware or software products are advised that this use may infringe existing patents. The original developer of this software module and his/her company, the subsequent editors and their companies, and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. Copyright is not released for non MPEG-2 NBC/MPEG-4 Audio conforming products.The original developer retains full right to use the code for his/her own purpose, assign or donate the code to a third party and to inhibit third party from using the code for non MPEG-2 NBC/MPEG-4 Audio conforming products. This copyright notice must be included in all copies or derivative works." Copyright(c)1996. ------------------------------------------------------------------------------ PSEUDO-CODE IF (*(pInvoke) > 3) CALL find_adts_syncword( pSyncword, &(pVars->inputStream), LENGTH_FIXED_HEADER, MASK_28BITS); RETURNING status ELSE *(pSyncword) = SYNCWORD_15BITS; CALL find_adts_syncword( pSyncword, &(pVars->inputStream), LENGTH_SYNCWORD, ID_BIT_FILTER); MODIFYING *(pSyncword) = 28-bit fixed header (long syncword) RETURNING status CALL getbits( (LENGTH_FIXED_HEADER - LENGTH_SYNCWORD), &(pVars->inputStream)); MODIFYING pVars->inputStream RETURNING adts_header = remaining bits in the fixed header *(pSyncword) <<= 13; *(pSyncword) = *(pSyncword) OR adts_header; pVars->prog_config.CRC_absent = ((UInt)(adts_header >> 12)) AND 0x0001; lower_16 = (UInt)adts_header; pVars->prog_config.profile = (lower_16 >> 10) AND 0x3; pVars->prog_config.sampling_rate_idx = (lower_16 >> 6) AND 0xF; channel_configuration = (lower_16 >> 2) AND 0x7; channel_configuration = channel_configuration - 1; pVars->prog_config.front.ele_is_cpe[0] = channel_configuration; pVars->prog_config.front.num_ele = 1; pVars->prog_config.front.ele_tag[0] = 0; pVars->prog_config.mono_mix.present = 0; pVars->prog_config.stereo_mix.present = 0; pVars->prog_config.matrix_mix.present = 0; CALL set_mc_info( &(pVars->mc_info), &(pVars->savedMCInfo), &(pVars->prog_config), pVars->pWinSeqInfo, pVars->SFBWidth128); MODIFYING pVars->mc_info = multi-channel configuration information RETURNING status = SUCCESS/FAILURE IF ( (*pInvoke) != 0) CALL check_mc_info( &(pVars->mc_info), &(pVars->savedMCInfo), FALSE); RETURNING status = SUCCESS/FAILURE ELSE CALL check_mc_info( &(pVars->mc_info), &(pVars->savedMCInfo), TRUE); MODIFYING pVars->savedMCInfo = pVars->mc_info RETURNING status = SUCCESS/FAILURE ENDIF IF (status == SUCCESS) (*pInvoke) = (*pInvoke) + 1; ELSE (*pInvoke) = 0; ENDIF ENDIF CALL getbits( LENGTH_VARIABLE_HEADER, &(pVars->inputStream)); RETURNING adts_header = 28-bits (the contents of the variable header.) pVars->prog_config.frame_length = ((UInt)(adts_header >> 13)) AND 0x1FFF; lower_16 = (UInt)adts_header; pVars->prog_config.buffer_fullness = (lower_16 >> 2) AND 0x7FF; pVars->prog_config.headerless_frames = (lower_16 AND 0x0003); IF (pVars->prog_config.CRC_absent == 0) CALL getbits( LENGTH_CRC, &(pVars->inputStream) ); RETURNING pVars->prog_config.CRC_check = 16-bit CRC ENDIF pVars->default_config = 0; IF (byte_align_offset > 7) status = 1; ENDIF return (status); ------------------------------------------------------------------------------ RESOURCES USED When the code is written for a specific target processor the the resources used should be documented below. STACK USAGE: [stack count for this module] + [variable to represent stack usage for each subroutine called] where: [stack usage variable] = stack usage for [subroutine name] (see [filename].ext) DATA MEMORY USED: x words PROGRAM MEMORY USED: x words CLOCK CYCLES: [cycle count equation for this module] + [variable used to represent cycle count for each subroutine called] where: [cycle count variable] = cycle count for [subroutine name] (see [filename].ext) ------------------------------------------------------------------------------ */ /*---------------------------------------------------------------------------- ; INCLUDES ----------------------------------------------------------------------------*/ #include "pv_audio_type_defs.h" #include "s_bits.h" #include "s_tdec_int_file.h" #include "ibstream.h" #include "set_mc_info.h" #include "find_adts_syncword.h" #include "get_adts_header.h" /*---------------------------------------------------------------------------- ; MACROS ; Define module specific macros here ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; DEFINES ; Include all pre-processor statements here. Include conditional ; compile variables also. ----------------------------------------------------------------------------*/ #define LENGTH_VARIABLE_HEADER 28 #define LENGTH_FIXED_HEADER 28 #define LENGTH_SYNCWORD 15 #define LENGTH_CRC 16 #define ID_BIT_FILTER 0x7FFB #define SYNCWORD_15BITS 0x7FF8 #define MASK_28BITS 0x0FFFFFFFL /*---------------------------------------------------------------------------- ; LOCAL FUNCTION DEFINITIONS ; Function Prototype declaration ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL STORE/BUFFER/POINTER DEFINITIONS ; Variable declaration - defined here and used outside this module ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; EXTERNAL FUNCTION REFERENCES ; Declare functions defined elsewhere and referenced in this module ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES ; Declare variables used in this module but defined elsewhere ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; FUNCTION CODE ----------------------------------------------------------------------------*/ Int get_adts_header( tDec_Int_File *pVars, UInt32 *pSyncword, Int *pInvoke, Int CorrectlyReadFramesCount) { UInt32 adts_header; UInt lower_16; Int status = SUCCESS; UInt channel_configuration; /* * Search for the LONG ADTS syncword (comprised of the entire fixed header) * if the number of CorrectlyReadFrames is > CorrectlyReadFramesCount * * Otherwise, search for just the short syncword. */ if (*(pInvoke) > CorrectlyReadFramesCount) { /* * Find the long ADTS syncword * (comprised of the entire ADTS fixed header) */ status = find_adts_syncword(pSyncword, &(pVars->inputStream), LENGTH_FIXED_HEADER, MASK_28BITS); } else { *(pSyncword) = SYNCWORD_15BITS; status = find_adts_syncword(pSyncword, &(pVars->inputStream), LENGTH_SYNCWORD, ID_BIT_FILTER); /* * Extract the data from the header following the syncword */ adts_header = getbits((LENGTH_FIXED_HEADER - LENGTH_SYNCWORD), &(pVars->inputStream)); *(pSyncword) <<= (LENGTH_FIXED_HEADER - LENGTH_SYNCWORD); *(pSyncword) |= adts_header; /* Denotes whether a CRC check should be performed */ pVars->prog_config.CRC_absent = ((UInt)(adts_header >> 12)) & 0x0001; /* * All the unread bits in adts_header reside in the lower * 16-bits at this point. Perform a typecast for faster * execution on 16-bit processors. */ lower_16 = (UInt)adts_header; /* * Profile consists of 2 bits, which indicate * the profile used. * * '00' AAC_MAIN profile * '01' AAC_LC (Low Complexity) profile * '10' AAC_SSR (Scaleable Sampling Rate) profile * '11' AAC_LTP (Long Term Prediction) profile */ pVars->prog_config.profile = (lower_16 >> 10) & 0x3; if (pVars->prog_config.profile == MP4AUDIO_AAC_SSR) { status = 1; /* Not supported */ } /* * Sampling_rate_idx consists of 4 bits * see Ref #1 for their interpretation. */ pVars->prog_config.sampling_rate_idx = (lower_16 >> 6) & 0xF; /* * private_bit is a bit for private use. ISO/IEC will not make * use of this bit in the future. * * We currently make no use of it, but parsing the information * from the bitstream could be easily implemented with the * following instruction... * * private_bit = (lower_16 & 0x0400) >> 10; */ /* * These 3 bits indicate the channel configuration used. * * If '0' then the channel configuration is unspecified here, * and must be given by a program configuration element in * the raw data block. * * If '1' then the channel configuration is MONO. * If '2' then the channel configuration is STEREO * * 3-7 represent channel configurations which this library * will not support in the forseeable future. */ channel_configuration = (lower_16 >> 2) & 0x7; /* do not support more than 2 channels */ if (channel_configuration > 2) { status = 1; } /* * The following 2 bits encode copyright information. * original_copy is '0' if there is no copyright in the bitstream. * '1' if the bitstream is copyright protected. * * home is '0' for a copy, '1' for an original. * * PacketVideo currently does nothing with this information, * however, parsing the data from the bitstream could be easily * implemented with the following instructions... * * original_copy = (lower_16 >> 1) & 0x1; * * home = (lower_16 & 0x1); * */ /* Set up based on information extracted from the ADTS FIXED header */ /* This equals 1 for STEREO, 0 for MONO */ if (channel_configuration) { channel_configuration--; } pVars->prog_config.front.ele_is_cpe[0] = channel_configuration; /* This value is constant for both MONO and STEREO */ pVars->prog_config.front.num_ele = 1; /* ADTS does not specify this tag value - do we even use it? */ pVars->prog_config.front.ele_tag[0] = 0; /* Disable all mix related variables */ pVars->prog_config.mono_mix.present = 0; pVars->prog_config.stereo_mix.present = 0; pVars->prog_config.matrix_mix.present = 0; /* enter configuration into MC_Info structure */ if (status == SUCCESS) { /* profile + 1 == audioObjectType */ status = set_mc_info( &(pVars->mc_info), (tMP4AudioObjectType)(pVars->prog_config.profile + 1), pVars->prog_config.sampling_rate_idx, pVars->prog_config.front.ele_tag[0], pVars->prog_config.front.ele_is_cpe[0], pVars->winmap, /* changed from pVars->pWinSeqInfo, */ pVars->SFBWidth128); } /* if (status == SUCCESS) */ #ifdef AAC_PLUS /* * For implicit signalling, no hint that sbr or ps is used, so we need to * check the sampling frequency of the aac content, if lesser or equal to * 24 KHz, by defualt upsample, otherwise, do nothing */ if ((pVars->prog_config.sampling_rate_idx >= 6) && (pVars->aacPlusEnabled == TRUE)) { pVars->mc_info.upsamplingFactor = 2; pVars->prog_config.sampling_rate_idx -= 3; pVars->mc_info.sbrPresentFlag = 1; pVars->sbrDecoderData.SbrChannel[0].syncState = SBR_ACTIVE; pVars->sbrDecoderData.SbrChannel[1].syncState = SBR_ACTIVE; } #endif /* * The tag and is_cpe will be checked in huffdecode, * remove this check routine. */ /*if (status == SUCCESS) *{ * if ( (*pInvoke) != 0) * { * status = * check_mc_info( * &(pVars->mc_info), * &(pVars->savedMCInfo), * FALSE); * } * else * { * status = * check_mc_info( * &(pVars->mc_info), * &(pVars->savedMCInfo), * TRUE); * } * *}*/ /* if (status == SUCCESS) */ /* * This keeps track of how many headers have been read in the file. * After the three successful headers with the same configuration * are read in, the entire ADTS fixed header is used as the syncword * for a more robust 28-bit long syncword */ if (status == SUCCESS) { (*pInvoke)++; } else { (*pInvoke) = 0; } } /* END if (*(pInvoke) > 3) */ /* Grab the bits in the ADTS variable header */ adts_header = getbits( LENGTH_VARIABLE_HEADER, &(pVars->inputStream)); /* * copyright_identification bit is a single bit of the 72-bit * copyright_id field. This consists of a 8-bit copyright identifier * and a 64-bit copyright_number. 72 headers must be decoded * to reconstruct the entire copyright_id field. * * copyright_identification_start is a single bit flagging * the beginning bit of the copyright_id field. '1' for start of * copyright_id, '0' otherwise. * * * PacketVideo currently does nothing with this information, * however, parsing the data from the bitstream could be easily * implemented with the following instructions... * * copyright_id_bit = ((UInt)(adts_header >> 27)) & 0x1; * * copyright_id_start = ((UInt)(adts_header >> 26)) & 0x1; */ /* * frame_length is a 13-bit field which indicates the length, * in bytes, of the frame including error_check and headers. * This information can theoretically be used to help verify syncwords. */ pVars->prog_config.frame_length = ((UInt)(adts_header >> 13)) & 0x1FFF; /* * All the unread bits in adts_header reside in the lower * 16-bits at this point. Perform a typecast for faster * execution on 16-bit processors. */ lower_16 = (UInt)adts_header; /* * Indicates the number of 32-bit words remaining in the * encoder buffer after the encoding of the first raw * data block. This value is 0x7ff for variable bit * rate encoders, since buffer fullness does not apply * to Variable Bit Rate (VBR) encoders. */ pVars->prog_config.buffer_fullness = (lower_16 >> 2) & 0x7FF; /* * headerless_frames indicates the number of * frames with no headers to be processed before the reading * in of the next header. * * In ADTS, up to 4 "no header frames" can exist between * syncwords. * * EXAMPLES: * * Legend: (Sync words denoted by X, frames * deonted by FRAME_#) * * Example(1): The ADTS sequence below packs 5 * frames per header. * Here, headerless_frames would always be read in as "4" * * |X||FRAME_0||FRAME_1||FRAME_2||FRAME_3||FRAME_4||X||FRAME_0| * * Example(2): The ADTS sequence below packs 1 frame per header. * Here, headerless_frames would always be read in as "0" * * |X||FRAME_0||X||FRAME_1||X||FRAME_2| * */ pVars->prog_config.headerless_frames = (lower_16 & 0x0003); if (pVars->prog_config.CRC_absent == 0) { pVars->prog_config.CRC_check = (UInt)getbits( LENGTH_CRC, &(pVars->inputStream)); } /* pVars->current_program = 0; */ /* shall be set after PCE is read */ return (status); } /* END get_adts_header */