/* ------------------------------------------------------------------ * 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: pvmp4audiodecodeframe ------------------------------------------------------------------------------ REVISION HISTORY Description: Modified from original shareware code Description: Pulled in loop structure from console.c, so that this function now decodes all frames in the file. Original program used several global variables. These have been eliminated, except for situations in which the global variables could be converted into const types. Otherwise, they are passed by reference through the functions. Description: Begin mods for file I/O removal Description: Merged trans4m_freq_2_time, trans4m_time_2_freq, etc. Description: Removing commented out sections of code. This includes the removal of unneeded functions init_lt_pred, reset_mc_info, Description: Copied from aac_decode_frame.c and renamed file, Made many changes. Description: Prepare for code review Description: Update per review comments: 1) Add comment about leaveGetLoop 2) Remove inverseTNSCoef array 3) fix wnd_shape_this_bk to wnd_shape_prev_bk in F to T 4) Clean up comments 5) Change call to long_term_synthesis Description: Remove division for calculation of bitrate. Description: Remove update of LTP buffers if not LTP audio object type. Description: Add hasmask to call to right_ch_sfb_tools_ms Description: Modified to call ltp related routines on the left channel before intensity is called on the right channel. The previous version was causing a problem when IS was used on the right channel and LTP on the left channel for the same scalefactor band. This fix required creating a new function, apply_ms_synt, deleting another function (right_ch_sfb_tools_noms.c), and modifying the calling order of the other functions. Description: Made changes per review comments. Description: Changed name of right_ch_sfb_tools_ms to pns_intensity_right Description: Added cast, since pVars->inputStream.usedBits is UInt, and pExt->remainderBits is Int. pExt->remainderBits = (Int)(pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK); Description: Modified to pass a pointer to scratch memory into tns_setup_filter.c Description: Removed include of "s_TNSInfo.h" Description: Removed call to "tns_setup_filter" which has been eliminated by merging its functionality into "get_tns" Description: Passing in a pointer to a q-format array, rather than the address of a single q-format, for the inverse filter case for apply_tns. Description: (1) Added #include of "e_ElementId.h" Previously, this function was relying on another include file to include "e_ElementId.h" (2) Updated the copyright header. Description: Per review comments, declared two temporary variables pChLeftShare = pChVars[LEFT]->pShareWfxpCoef; pChRightShare = pChVars[RIGHT]->pShareWfxpCoef; Description: long_term_synthesis should have been invoked with max_sfb as the 2nd parameter, rather than pFrameInfo->sfb_per_win[0]. Old long_term_synthesis( pChVars[ch]->wnd, pFrameInfo->sfb_per_win[0] ... Correction long_term_synthesis( pChVars[ch]->wnd, pChVars[ch]->pShareWfxpCoef->max_sfb ... This problem caused long_term_synthesis to read memory which was not initialized in get_ics_info.c Description: (1) Utilize scratch memory for the scratch Prog_Config. Description: (1) Modified to decode ID_END syntactic element after header Description: (1) Reconfigured LTP buffer as a circular buffer. This saves 2048 Int16->Int16 copies per frame. Description: Updated so ltp buffers are not used as a wasteful intermediate buffer for LC streams. Data is transferred directly from the filterbank to the output stream. Description: Decode ADIF header if frame count is zero. The AudioSpecificConfig is decoded by a separate API. Description: Added comments explaining how the ltp_buffer_state variable is updated. Description: Modified code to take advantage of new trans4m_freq_2_time_fxp, which writes the output directly into a 16-bit output buffer. This improvement allows faster operation by reducing the amount of memory transfers. Speed can be further improved on most platforms via use of a DMA transfer in the function write_output.c Description: perChan[] is an array of structures in tDec_Int_File. Made corresponding changes. Description: Included changes in interface for q_normalize() and trans4m_freq_2_time_fxp. Description: Included changes in interface for long_term_prediction. Description: Added support for DSE (Data Streaming Channel). Added function get_dse() and included file get_dse.h Description: Added support for the ill-case when a raw data block contains only a terminator . This is illegal but is added for convinience Description: Added support for empty audio frames, such the one containing only DSE or FILL elements. A trap was added to stop processing when no audio information was sent. Description: Added support for adts format files. Added saturation to floating point version of aac+ decoding Description: ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: pExt = pointer to the external interface structure. See the file PVMP4AudioDecoder_API.h for a description of each field. Data type of pointer to a tPVMP4AudioDecoderExternal structure. pMem = void pointer to hide the internal implementation of the library It is cast back to a tDec_Int_File structure. This structure contains information that needs to persist between calls to this function, or is too big to be placed on the stack, even though the data is only needed during execution of this function Data type void pointer, internally pointer to a tDec_Int_File structure. Local Stores/Buffers/Pointers Needed: None (The memory set aside in pMem performs this task) Global Stores/Buffers/Pointers Needed: None Outputs: status = 0 if no error occurred MP4AUDEC_NONRECOVERABLE if a non-recoverable error occurred MP4AUDEC_RECOVERABLE if a recoverable error occurred. Presently a recoverable error does not exist, but this was a requirement. Pointers and Buffers Modified: pMem contents are modified. pExt: (more detail in the file PVMP4AudioDecoder_API.h) inputBufferUsedLength - number of array elements used up by the stream. remainderBits - remaining bits in the next UInt32 buffer samplingRate - sampling rate in samples per sec bitRate - bit rate in bits per second, varies frame to frame. encodedChannels - channels found on the file (informative) frameLength - length of the frame Local Stores Modified: None. Global Stores Modified: None. ------------------------------------------------------------------------------ FUNCTION DESCRIPTION Decodes one frame of an MPEG-2/MPEG-4 encoded audio bitstream. This function calls the various components of the decoder in the proper order. Left Channel Right Channel | | | | | | \|/ \|/ #1 ____________________ #2 ____________________ | | | | | Huffman Decoding | | Huffman Decoding | |__________________| |__________________| | | | | | | \|/ | #3 ____________________ | | | | | PNS LEFT | | |__________________| | | | | | | | \|/ \|/ #4 ______________________________________________________________________ | | | Apply MS_Synt | |____________________________________________________________________| | | | | \|/ | #5 ____________________ | | | W | LTP | A |__________________| I | T | | | F \|/ O #6 ____________________ R | | | | Time -> Freq | L |__________________| E | F | T | | \|/ C #7 ____________________ H | | A | TNS Inverse | N |__________________| N | E | L | | \|/ | #8 ____________________ | | | | | Long Term Synth | | |__________________| | | | | \|/ | #9 ____________________ | | | |--DATA ON LEFT CHANNEL MAY BE USED----->| PNS/Intensity Rt | | |__________________| | | | | | \|/ | #10 ____________________ W | | A | LTP | I |__________________| T | | | F | O \|/ R #11 ____________________ | | | R | Time -> Freq | I |__________________| G | H | T | | \|/ C #12 ____________________ H | | A | TNS Inverse | N |__________________| N | E | L | | \|/ | #13 ____________________ | | | | | Long Term Synth | | |__________________| | | | | | | \|/ \|/ #14 ____________________ #18 ____________________ | | | | | TNS | | TNS | |__________________| |__________________| | | | | | | \|/ \|/ #15 ____________________ #19 ____________________ | | | | | qFormatNorm | | qFormatNorm | |__________________| |__________________| | | | | | | \|/ \|/ #16 ____________________ #20 ____________________ | | | | | Freq / Time | | Freq / Time | |__________________| |__________________| | | | | | | \|/ \|/ #17 ____________________ #21 ____________________ | | | | | Limit Buffer | | Limit Buffer | |__________________| |__________________| | | | | | | \|/ \|/ #22 ______________________________________________________________________ | | | Write Output | |____________________________________________________________________| ------------------------------------------------------------------------------ REQUIREMENTS PacketVideo Document # CCC-AUD-AAC-ERS-0003 ------------------------------------------------------------------------------ REFERENCES (1) 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 intending 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. ------------------------------------------------------------------------------ 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_tdec_int_chan.h" #include "s_tdec_int_file.h" #include "aac_mem_funcs.h" #include "sfb.h" /* Where samp_rate_info[] is declared */ #include "e_tmp4audioobjecttype.h" #include "e_elementid.h" #include "get_adif_header.h" #include "get_adts_header.h" #include "get_audio_specific_config.h" #include "ibstream.h" /* where getbits is declared */ #include "huffman.h" /* where huffdecode is declared */ #include "get_prog_config.h" #include "getfill.h" #include "pns_left.h" #include "apply_ms_synt.h" #include "pns_intensity_right.h" #include "q_normalize.h" #include "long_term_prediction.h" #include "long_term_synthesis.h" #include "ltp_common_internal.h" #include "apply_tns.h" #include "window_block_fxp.h" #include "write_output.h" #include "pvmp4audiodecoder_api.h" /* Where this function is declared */ #include "get_dse.h" #include "sbr_applied.h" #include "sbr_open.h" #include "get_sbr_bitstream.h" #include "e_sbr_element_id.h" /*---------------------------------------------------------------------------- ; MACROS ; Define module specific macros here ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; DEFINES ; Include all pre-processor statements here. Include conditional ; compile variables also. ----------------------------------------------------------------------------*/ #define LEFT (0) #define RIGHT (1) /*---------------------------------------------------------------------------- ; 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 ----------------------------------------------------------------------------*/ void InitSbrSynFilterbank(bool bDownSampleSBR); /*---------------------------------------------------------------------------- ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES ; Declare variables used in this module but defined elsewhere ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; FUNCTION CODE ----------------------------------------------------------------------------*/ OSCL_EXPORT_REF Int PVMP4AudioDecodeFrame( tPVMP4AudioDecoderExternal *pExt, void *pMem) { Int frameLength; /* Helper variable */ Int ch; Int id_syn_ele; UInt initialUsedBits; /* Unsigned for C55x */ Int qFormatNorm; Int qPredictedSamples; Bool leaveGetLoop; MC_Info *pMC_Info; /* Helper pointer */ FrameInfo *pFrameInfo; /* Helper pointer */ tDec_Int_File *pVars; /* Helper pointer */ tDec_Int_Chan *pChVars[Chans]; /* Helper pointer */ per_chan_share_w_fxpCoef *pChLeftShare; /* Helper pointer */ per_chan_share_w_fxpCoef *pChRightShare; /* Helper pointer */ Int status = MP4AUDEC_SUCCESS; Bool empty_frame; #ifdef AAC_PLUS SBRDECODER_DATA *sbrDecoderData; SBR_DEC *sbrDec; SBRBITSTREAM *sbrBitStream; #endif /* * Initialize "helper" pointers to existing memory. */ pVars = (tDec_Int_File *)pMem; pMC_Info = &pVars->mc_info; pChVars[LEFT] = &pVars->perChan[LEFT]; pChVars[RIGHT] = &pVars->perChan[RIGHT]; pChLeftShare = pChVars[LEFT]->pShareWfxpCoef; pChRightShare = pChVars[RIGHT]->pShareWfxpCoef; #ifdef AAC_PLUS sbrDecoderData = (SBRDECODER_DATA *) & pVars->sbrDecoderData; sbrDec = (SBR_DEC *) & pVars->sbrDec; sbrBitStream = (SBRBITSTREAM *) & pVars->sbrBitStr; #ifdef PARAMETRICSTEREO sbrDecoderData->hParametricStereoDec = (HANDLE_PS_DEC) & pVars->sbrDecoderData.ParametricStereoDec; #endif #endif /* * Translate input buffer variables. */ pVars->inputStream.pBuffer = pExt->pInputBuffer; pVars->inputStream.inputBufferCurrentLength = (UInt)pExt->inputBufferCurrentLength; pVars->inputStream.availableBits = (UInt)(pExt->inputBufferCurrentLength << INBUF_ARRAY_INDEX_SHIFT); initialUsedBits = (UInt)((pExt->inputBufferUsedLength << INBUF_ARRAY_INDEX_SHIFT) + pExt->remainderBits); pVars->inputStream.usedBits = initialUsedBits; if (initialUsedBits > pVars->inputStream.availableBits) { status = MP4AUDEC_INVALID_FRAME; } else if (pVars->bno == 0) { /* * Attempt to read in ADIF format first because it is easily identified. * If its not an ADIF bitstream, get_adif_header rewinds the "pointer" * (actually usedBits). */ status = get_adif_header( pVars, &(pVars->scratch.scratch_prog_config)); byte_align(&pVars->inputStream); if (status == SUCCESS) { pVars->prog_config.file_is_adts = FALSE; } else /* we've tried simple audio config, adif, then it should be adts */ { pVars->prog_config.file_is_adts = TRUE; } } else if ((pVars->bno == 1) && (pVars->prog_config.file_is_adts == FALSE)) { /* * There might be an ID_END element following immediately after the * AudioSpecificConfig header. This syntactic element should be read * and byte_aligned before proceeds to decode "real" AAC raw data. */ id_syn_ele = (Int)getbits(LEN_SE_ID, &pVars->inputStream) ; if (id_syn_ele == ID_END) { byte_align(&pVars->inputStream); pExt->inputBufferUsedLength = pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; pExt->remainderBits = pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK; pVars->bno++; return(status); } else { /* * Rewind bitstream pointer so that the syntactic element can be * read when decoding raw bitstream */ pVars->inputStream.usedBits -= LEN_SE_ID; } } if (pVars->prog_config.file_is_adts == TRUE) { /* * If file is adts format, let the decoder handle only on data raw * block at the time, once the last (or only) data block has been * processed, then synch on the next header */ if (pVars->prog_config.headerless_frames) { pVars->prog_config.headerless_frames--; /* raw data block counter */ } else { status = get_adts_header(pVars, &(pVars->syncword), &(pVars->invoke), 3); /* CorrectlyReadFramesCount */ if (status != SUCCESS) { status = MP4AUDEC_LOST_FRAME_SYNC; /* we lost track of header */ } } } else { byte_align(&pVars->inputStream); } #ifdef AAC_PLUS sbrBitStream->NrElements = 0; sbrBitStream->NrElementsCore = 0; #endif /* * The variable leaveGetLoop is used to signal that the following * loop can be left, which retrieves audio syntatic elements until * an ID_END is found, or an error occurs. */ leaveGetLoop = FALSE; empty_frame = TRUE; while ((leaveGetLoop == FALSE) && (status == SUCCESS)) { /* get audio syntactic element */ id_syn_ele = (Int)get9_n_lessbits(LEN_SE_ID, &pVars->inputStream); /* * As fractional frames are a possible input, check that parsing does not * go beyond the available bits before parsing the syntax. */ if (pVars->inputStream.usedBits > pVars->inputStream.availableBits) { status = MP4AUDEC_INCOMPLETE_FRAME; /* possible EOF or fractional frame */ id_syn_ele = ID_END; /* quit while-loop */ } switch (id_syn_ele) { case ID_END: /* terminator field */ leaveGetLoop = TRUE; break; case ID_SCE: /* single channel */ case ID_CPE: /* channel pair */ empty_frame = FALSE; status = huffdecode( id_syn_ele, &(pVars->inputStream), pVars, pChVars); #ifdef AAC_PLUS if (id_syn_ele == ID_SCE) { sbrBitStream->sbrElement[sbrBitStream->NrElements].ElementID = SBR_ID_SCE; } else if (id_syn_ele == ID_CPE) { sbrBitStream->sbrElement[sbrBitStream->NrElements].ElementID = SBR_ID_CPE; } sbrBitStream->NrElementsCore++; #endif break; case ID_PCE: /* program config element */ /* * PCE are not accepted in the middle of a * raw_data_block. If found, a possible error may happen * If a PCE is encountered during the first 2 frames, * it will be read and accepted * if its tag matches the first, with no error checking * (inside of get_prog_config) */ if (pVars->bno <= 1) { status = get_prog_config(pVars, &(pVars->scratch.scratch_prog_config)); } else { status = MP4AUDEC_INVALID_FRAME; } break; case ID_FIL: /* fill element */ #ifdef AAC_PLUS get_sbr_bitstream(sbrBitStream, &pVars->inputStream); #else getfill(&pVars->inputStream); #endif break; case ID_DSE: /* Data Streaming element */ get_dse(pVars->share.data_stream_bytes, &pVars->inputStream); break; default: /* Unsupported element, including ID_LFE */ status = -1; /* ERROR CODE needs to be updated */ break; } /* end switch() */ } /* end while() */ byte_align(&pVars->inputStream); /* * After parsing the first frame ( bno=0 (adif), bno=1 (raw)) * verify if implicit signalling is forcing to upsample AAC with * no AAC+/eAAC+ content. If so, disable upsampling */ #ifdef AAC_PLUS if (pVars->bno <= 1) { if ((pVars->mc_info.ExtendedAudioObjectType == MP4AUDIO_AAC_LC) && (!sbrBitStream->NrElements)) { PVMP4AudioDecoderDisableAacPlus(pExt, pMem); } } #endif /* * There might be an empty raw data block with only a * ID_END element or non audio ID_DSE, ID_FIL * This is an "illegal" condition but this trap * avoids any further processing */ if (empty_frame == TRUE) { pExt->inputBufferUsedLength = pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; pExt->remainderBits = pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK; pVars->bno++; return(status); } #ifdef AAC_PLUS if (sbrBitStream->NrElements) { /* for every core SCE or CPE there must be an SBR element, otherwise sths. wrong */ if (sbrBitStream->NrElements != sbrBitStream->NrElementsCore) { status = MP4AUDEC_INVALID_FRAME; } if (pExt->aacPlusEnabled == false) { sbrBitStream->NrElements = 0; /* disable aac processing */ } } else { /* * This is AAC, but if aac+/eaac+ was declared in the stream, and there is not sbr content * something is wrong */ if (pMC_Info->sbrPresentFlag || pMC_Info->psPresentFlag) { status = MP4AUDEC_INVALID_FRAME; } } #endif /* * Signal processing section. */ frameLength = pVars->frameLength; if (status == SUCCESS) { /* * PNS and INTENSITY STEREO and MS */ pFrameInfo = pVars->winmap[pChVars[LEFT]->wnd]; pns_left( pFrameInfo, pChLeftShare->group, pChLeftShare->cb_map, pChLeftShare->factors, pChLeftShare->lt_status.sfb_prediction_used, pChLeftShare->lt_status.ltp_data_present, pChVars[LEFT]->fxpCoef, pChLeftShare->qFormat, &(pVars->pns_cur_noise_state)); /* * apply_ms_synt can only be ran for common windows. * (where both the left and right channel share the * same grouping, window length, etc. * * pVars->hasmask will be > 0 only if * common windows are enabled for this frame. */ if (pVars->hasmask > 0) { apply_ms_synt( pFrameInfo, pChLeftShare->group, pVars->mask, pChLeftShare->cb_map, pChVars[LEFT]->fxpCoef, pChVars[RIGHT]->fxpCoef, pChLeftShare->qFormat, pChRightShare->qFormat); } for (ch = 0; (ch < pMC_Info->nch); ch++) { pFrameInfo = pVars->winmap[pChVars[ch]->wnd]; /* * Note: This MP4 library assumes that if there are two channels, * then the second channel is right AND it was a coupled channel, * therefore there is no need to check the "is_cpe" flag. */ if (ch > 0) { pns_intensity_right( pVars->hasmask, pFrameInfo, pChRightShare->group, pVars->mask, pChRightShare->cb_map, pChLeftShare->factors, pChRightShare->factors, pChRightShare->lt_status.sfb_prediction_used, pChRightShare->lt_status.ltp_data_present, pChVars[LEFT]->fxpCoef, pChVars[RIGHT]->fxpCoef, pChLeftShare->qFormat, pChRightShare->qFormat, &(pVars->pns_cur_noise_state)); } if (pChVars[ch]->pShareWfxpCoef->lt_status.ltp_data_present != FALSE) { /* * LTP - Long Term Prediction */ qPredictedSamples = long_term_prediction( pChVars[ch]->wnd, pChVars[ch]->pShareWfxpCoef->lt_status. weight_index, pChVars[ch]->pShareWfxpCoef->lt_status. delay, pChVars[ch]->ltp_buffer, pVars->ltp_buffer_state, pChVars[ch]->time_quant, pVars->share.predictedSamples, /* Scratch */ frameLength); trans4m_time_2_freq_fxp( pVars->share.predictedSamples, pChVars[ch]->wnd, pChVars[ch]->wnd_shape_prev_bk, pChVars[ch]->wnd_shape_this_bk, &qPredictedSamples, pVars->scratch.fft); /* scratch memory for FFT */ /* * To solve a potential problem where a pointer tied to * the qFormat was being incremented, a pointer to * pChVars[ch]->qFormat is passed in here rather than * the address of qPredictedSamples. * * Neither values are actually needed in the case of * inverse filtering, but the pointer was being * passed (and incremented) regardless. * * So, the solution is to pass a space of memory * that a pointer can happily point to. */ /* This is the inverse filter */ apply_tns( pVars->share.predictedSamples, /* scratch re-used for each ch */ pChVars[ch]->pShareWfxpCoef->qFormat, /* Not used by the inv_filter */ pFrameInfo, &(pChVars[ch]->pShareWfxpCoef->tns), TRUE, /* TRUE is FIR */ pVars->scratch.tns_inv_filter); /* * For the next function long_term_synthesis, * the third param win_sfb_top[], and * the tenth param coef_per_win, * are used differently that in the rest of the project. This * is because originally the ISO code was going to have * these parameters change as the "short window" changed. * These are all now the same value for each of the eight * windows. This is why there is a [0] at the * end of each of theses parameters. * Note in particular that win_sfb_top was originally an * array of pointers to arrays, but inside long_term_synthesis * it is now a simple array. * When the rest of the project functions are changed, the * structure FrameInfo changes, and the [0]'s are removed, * this comment could go away. */ long_term_synthesis( pChVars[ch]->wnd, pChVars[ch]->pShareWfxpCoef->max_sfb, pFrameInfo->win_sfb_top[0], /* Look above */ pChVars[ch]->pShareWfxpCoef->lt_status.win_prediction_used, pChVars[ch]->pShareWfxpCoef->lt_status.sfb_prediction_used, pChVars[ch]->fxpCoef, /* input and output */ pChVars[ch]->pShareWfxpCoef->qFormat, /* input and output */ pVars->share.predictedSamples, qPredictedSamples, /* q format for previous aray */ pFrameInfo->coef_per_win[0], /* Look above */ NUM_SHORT_WINDOWS, NUM_RECONSTRUCTED_SFB); } /* end if (pChVars[ch]->lt_status.ltp_data_present != FALSE) */ } /* for(ch) */ for (ch = 0; (ch < pMC_Info->nch); ch++) { pFrameInfo = pVars->winmap[pChVars[ch]->wnd]; /* * TNS - Temporal Noise Shaping */ /* This is the forward filter * * A special note: Scratch memory is not used by * the forward filter, but is passed in to maintain * common interface for inverse and forward filter */ apply_tns( pChVars[ch]->fxpCoef, pChVars[ch]->pShareWfxpCoef->qFormat, pFrameInfo, &(pChVars[ch]->pShareWfxpCoef->tns), FALSE, /* FALSE is IIR */ pVars->scratch.tns_inv_filter); /* * Normalize the q format across all scale factor bands * to one value. */ qFormatNorm = q_normalize( pChVars[ch]->pShareWfxpCoef->qFormat, pFrameInfo, pChVars[ch]->abs_max_per_window, pChVars[ch]->fxpCoef); /* * filterbank - converts frequency coeficients to time domain. */ #ifdef AAC_PLUS if (sbrBitStream->NrElements == 0 && pMC_Info->upsamplingFactor == 1) { trans4m_freq_2_time_fxp_2( pChVars[ch]->fxpCoef, pChVars[ch]->time_quant, pChVars[ch]->wnd, /* window sequence */ pChVars[ch]->wnd_shape_prev_bk, pChVars[ch]->wnd_shape_this_bk, qFormatNorm, pChVars[ch]->abs_max_per_window, pVars->scratch.fft, &pExt->pOutputBuffer[ch]); /* * Update LTP buffers if needed */ if (pVars->mc_info.audioObjectType == MP4AUDIO_LTP) { Int16 * pt = &pExt->pOutputBuffer[ch]; Int16 * ptr = &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state]); Int16 x, y; for (Int32 i = HALF_LONG_WINDOW; i != 0; i--) { x = *pt; pt += 2; y = *pt; pt += 2; *(ptr++) = x; *(ptr++) = y; } } } else { trans4m_freq_2_time_fxp_1( pChVars[ch]->fxpCoef, pChVars[ch]->time_quant, &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state + 288]), pChVars[ch]->wnd, /* window sequence */ pChVars[ch]->wnd_shape_prev_bk, pChVars[ch]->wnd_shape_this_bk, qFormatNorm, pChVars[ch]->abs_max_per_window, pVars->scratch.fft); } #else trans4m_freq_2_time_fxp_2( pChVars[ch]->fxpCoef, pChVars[ch]->time_quant, pChVars[ch]->wnd, /* window sequence */ pChVars[ch]->wnd_shape_prev_bk, pChVars[ch]->wnd_shape_this_bk, qFormatNorm, pChVars[ch]->abs_max_per_window, pVars->scratch.fft, &pExt->pOutputBuffer[ch]); /* * Update LTP buffers only if needed */ if (pVars->mc_info.audioObjectType == MP4AUDIO_LTP) { Int16 * pt = &pExt->pOutputBuffer[ch]; Int16 * ptr = &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state]); Int16 x, y; for (Int32 i = HALF_LONG_WINDOW; i != 0; i--) { x = *pt; pt += 2; y = *pt; pt += 2; *(ptr++) = x; *(ptr++) = y; } } #endif /* Update the window shape */ pChVars[ch]->wnd_shape_prev_bk = pChVars[ch]->wnd_shape_this_bk; } /* end for() */ /* * Copy to the final output buffer, taking into account the desired * channels from the calling environment, the actual channels, and * whether the data should be interleaved or not. * * If the stream had only one channel, write_output will not use * the right channel data. * */ /* CONSIDER USE OF DMA OPTIMIZATIONS WITHIN THE write_output FUNCTION. * * It is presumed that the ltp_buffer will reside in internal (fast) * memory, while the pExt->pOutputBuffer will reside in external * (slow) memory. * */ #ifdef AAC_PLUS if (sbrBitStream->NrElements || pMC_Info->upsamplingFactor == 2) { if (pVars->bno <= 1) /* allows console to operate with ADIF and audio config */ { if (sbrDec->outSampleRate == 0) /* do it only once (disregarding of signaling type) */ { sbr_open(samp_rate_info[pVars->mc_info.sampling_rate_idx].samp_rate, sbrDec, sbrDecoderData, pVars->mc_info.bDownSampledSbr); } } pMC_Info->upsamplingFactor = sbrDecoderData->SbrChannel[0].frameData.sbr_header.sampleRateMode; /* reuse right aac spectrum channel */ { Int16 *pt_left = &(pChVars[LEFT ]->ltp_buffer[pVars->ltp_buffer_state]); Int16 *pt_right = &(pChVars[RIGHT]->ltp_buffer[pVars->ltp_buffer_state]); if (sbr_applied(sbrDecoderData, sbrBitStream, pt_left, pt_right, pExt->pOutputBuffer, sbrDec, pVars, pMC_Info->nch) != SBRDEC_OK) { status = MP4AUDEC_INVALID_FRAME; } } } /* if( pExt->aacPlusEnabled == FALSE) */ #endif /* * Copied mono data in both channels or just leave it as mono, * according with desiredChannels (default is 2) */ if (pExt->desiredChannels == 2) { #if defined(AAC_PLUS) #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) if (pMC_Info->nch != 2 && pMC_Info->psPresentFlag != 1) #else if (pMC_Info->nch != 2) #endif #else if (pMC_Info->nch != 2) #endif { /* mono */ Int16 * pt = &pExt->pOutputBuffer[0]; Int16 * pt2 = &pExt->pOutputBuffer[1]; Int i; if (pMC_Info->upsamplingFactor == 2) { for (i = 0; i < 1024; i++) { *pt2 = *pt; pt += 2; pt2 += 2; } pt = &pExt->pOutputBuffer_plus[0]; pt2 = &pExt->pOutputBuffer_plus[1]; for (i = 0; i < 1024; i++) { *pt2 = *pt; pt += 2; pt2 += 2; } } else { for (i = 0; i < 1024; i++) { *pt2 = *pt; pt += 2; pt2 += 2; } } } #if defined(AAC_PLUS) #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) else if (pMC_Info->psPresentFlag == 1) { Int32 frameSize = 0; if (pExt->aacPlusEnabled == false) { /* * Decoding eaac+ when only aac is enabled, copy L into R */ frameSize = 1024; } else if (sbrDecoderData->SbrChannel[0].syncState != SBR_ACTIVE) { /* * Decoding eaac+ when no PS data was found, copy upsampled L into R */ frameSize = 2048; } Int16 * pt = &pExt->pOutputBuffer[0]; Int16 * pt2 = &pExt->pOutputBuffer[1]; Int i; for (i = 0; i < frameSize; i++) { *pt2 = *pt; pt += 2; pt2 += 2; } } #endif #endif } else { #if defined(AAC_PLUS) #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) if (pMC_Info->nch != 2 && pMC_Info->psPresentFlag != 1) #else if (pMC_Info->nch != 2) #endif #else if (pMC_Info->nch != 2) #endif { /* mono */ Int16 * pt = &pExt->pOutputBuffer[0]; Int16 * pt2 = &pExt->pOutputBuffer[0]; Int i; if (pMC_Info->upsamplingFactor == 2) { for (i = 0; i < 1024; i++) { *pt2++ = *pt; pt += 2; } pt = &pExt->pOutputBuffer_plus[0]; pt2 = &pExt->pOutputBuffer_plus[0]; for (i = 0; i < 1024; i++) { *pt2++ = *pt; pt += 2; } } else { for (i = 0; i < 1024; i++) { *pt2++ = *pt; pt += 2; } } } } /* pVars->ltp_buffer_state cycles between 0 and 1024. The value * indicates the location of the data corresponding to t == -2. * * | t == -2 | t == -1 | pVars->ltp_buffer_state == 0 * * | t == -1 | t == -2 | pVars->ltp_buffer_state == 1024 * */ #ifdef AAC_PLUS if (sbrBitStream->NrElements == 0 && pMC_Info->upsamplingFactor == 1) { pVars->ltp_buffer_state ^= frameLength; } else { pVars->ltp_buffer_state ^= (frameLength + 288); } #else pVars->ltp_buffer_state ^= frameLength; #endif if (pVars->bno <= 1) { /* * to set these values only during the second call * when they change. */ pExt->samplingRate = samp_rate_info[pVars->mc_info.sampling_rate_idx].samp_rate; pVars->mc_info.implicit_channeling = 0; /* disable flag, as this is allowed * only the first time */ #ifdef AAC_PLUS if (pMC_Info->upsamplingFactor == 2) { pExt->samplingRate *= pMC_Info->upsamplingFactor; pExt->aacPlusUpsamplingFactor = pMC_Info->upsamplingFactor; } #endif pExt->extendedAudioObjectType = pMC_Info->ExtendedAudioObjectType; pExt->audioObjectType = pMC_Info->audioObjectType; pExt->encodedChannels = pMC_Info->nch; pExt->frameLength = pVars->frameLength; } pVars->bno++; /* * Using unit analysis, the bitrate is a function of the sampling rate, bits, * points in a frame * * bits samples frame * ---- = --------- * bits * ------- * sec sec sample * * To save a divide, a shift is used. Presently only the value of * 1024 is used by this library, so make it the most accurate for that * value. This may need to be updated later. */ pExt->bitRate = (pExt->samplingRate * (pVars->inputStream.usedBits - initialUsedBits)) >> 10; /* LONG_WINDOW 1024 */ pExt->bitRate >>= (pMC_Info->upsamplingFactor - 1); } /* end if (status == SUCCESS) */ if (status != MP4AUDEC_SUCCESS) { /* * A non-SUCCESS decoding could be due to an error on the bitstream or * an incomplete frame. As access to the bitstream beyond frame boundaries * are not allowed, in those cases the bitstream reading routine return a 0 * Zero values guarantees that the data structures are filled in with values * that eventually will signal an error (like invalid parameters) or that allow * completion of the parsing routine. Either way, the partial frame condition * is verified at this time. */ if (pVars->prog_config.file_is_adts == TRUE) { status = MP4AUDEC_LOST_FRAME_SYNC; pVars->prog_config.headerless_frames = 0; /* synchronization forced */ } else { /* * Check if the decoding error was due to buffer overrun, if it was, * update status */ if (pVars->inputStream.usedBits > pVars->inputStream.availableBits) { /* all bits were used but were not enough to complete decoding */ pVars->inputStream.usedBits = pVars->inputStream.availableBits; status = MP4AUDEC_INCOMPLETE_FRAME; /* possible EOF or fractional frame */ } } } /* * Translate from units of bits back into units of words. */ pExt->inputBufferUsedLength = pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; pExt->remainderBits = (Int)(pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK); return (status); } /* PVMP4AudioDecoderDecodeFrame */