fenix
/
fdk-aac
mirror of https://github.com/mstorsjo/fdk-aac.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
fdk-aac/libSBRenc/include/sbr_encoder.h

484 lines
19 KiB
C++
Raw Blame History

/* -----------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
Forschung e.V. All rights reserved.
1. INTRODUCTION
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
scheme for digital audio. This FDK AAC Codec software is intended to be used on
a wide variety of Android devices.
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
general perceptual audio codecs. AAC-ELD is considered the best-performing
full-bandwidth communications codec by independent studies and is widely
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
specifications.
Patent licenses for necessary patent claims for the FDK AAC Codec (including
those of Fraunhofer) may be obtained through Via Licensing
(www.vialicensing.com) or through the respective patent owners individually for
the purpose of encoding or decoding bit streams in products that are compliant
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
Android devices already license these patent claims through Via Licensing or
directly from the patent owners, and therefore FDK AAC Codec software may
already be covered under those patent licenses when it is used for those
licensed purposes only.
Commercially-licensed AAC software libraries, including floating-point versions
with enhanced sound quality, are also available from Fraunhofer. Users are
encouraged to check the Fraunhofer website for additional applications
information and documentation.
2. COPYRIGHT LICENSE
Redistribution and use in source and binary forms, with or without modification,
are permitted without payment of copyright license fees provided that you
satisfy the following conditions:
You must retain the complete text of this software license in redistributions of
the FDK AAC Codec or your modifications thereto in source code form.
You must retain the complete text of this software license in the documentation
and/or other materials provided with redistributions of the FDK AAC Codec or
your modifications thereto in binary form. You must make available free of
charge copies of the complete source code of the FDK AAC Codec and your
modifications thereto to recipients of copies in binary form.
The name of Fraunhofer may not be used to endorse or promote products derived
from this library without prior written permission.
You may not charge copyright license fees for anyone to use, copy or distribute
the FDK AAC Codec software or your modifications thereto.
Your modified versions of the FDK AAC Codec must carry prominent notices stating
that you changed the software and the date of any change. For modified versions
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
AAC Codec Library for Android."
3. NO PATENT LICENSE
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
Fraunhofer provides no warranty of patent non-infringement with respect to this
software.
You may use this FDK AAC Codec software or modifications thereto only for
purposes that are authorized by appropriate patent licenses.
4. DISCLAIMER
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
including but not limited to the implied warranties of merchantability and
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
or consequential damages, including but not limited to procurement of substitute
goods or services; loss of use, data, or profits, or business interruption,
however caused and on any theory of liability, whether in contract, strict
liability, or tort (including negligence), arising in any way out of the use of
this software, even if advised of the possibility of such damage.
5. CONTACT INFORMATION
Fraunhofer Institute for Integrated Circuits IIS
Attention: Audio and Multimedia Departments - FDK AAC LL
Am Wolfsmantel 33
91058 Erlangen, Germany
www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
----------------------------------------------------------------------------- */
/**************************** SBR encoder library ******************************
Author(s):
Description: SBR encoder top level processing prototype
*******************************************************************************/
#ifndef SBR_ENCODER_H
#define SBR_ENCODER_H
#include "common_fix.h"
#include "FDK_audio.h"
#include "FDK_bitstream.h"
/* core coder helpers */
#define MAX_TRANS_FAC 8
#define MAX_CODEC_FRAME_RATIO 2
#define MAX_PAYLOAD_SIZE 256
typedef enum codecType {
CODEC_AAC = 0,
CODEC_AACLD = 1,
CODEC_UNSPECIFIED = 99
} CODEC_TYPE;
typedef struct {
INT bitRate;
INT nChannels;
INT sampleFreq;
INT transFac;
INT standardBitrate;
} CODEC_PARAM;
typedef enum {
SBR_MONO,
SBR_LEFT_RIGHT,
SBR_COUPLING,
SBR_SWITCH_LRC
} SBR_STEREO_MODE;
/* bitstream syntax flags */
enum {
SBR_SYNTAX_LOW_DELAY = 0x0001,
SBR_SYNTAX_SCALABLE = 0x0002,
SBR_SYNTAX_CRC = 0x0004,
SBR_SYNTAX_DRM_CRC = 0x0008,
SBR_SYNTAX_ELD_REDUCED_DELAY = 0x0010
};
typedef enum { FREQ_RES_LOW = 0, FREQ_RES_HIGH } FREQ_RES;
typedef struct {
CODEC_TYPE coreCoder; /*!< LC or ELD */
UINT bitrateFrom; /*!< inclusive */
UINT bitrateTo; /*!< exclusive */
UINT sampleRate; /*!< */
UCHAR numChannels; /*!< */
UCHAR startFreq; /*!< bs_start_freq */
UCHAR startFreqSpeech; /*!< bs_start_freq for speech config flag */
UCHAR stopFreq; /*!< bs_stop_freq */
UCHAR stopFreqSpeech; /*!< bs_stop_freq for speech config flag */
UCHAR numNoiseBands; /*!< */
UCHAR noiseFloorOffset; /*!< */
SCHAR noiseMaxLevel; /*!< */
SBR_STEREO_MODE stereoMode; /*!< */
UCHAR freqScale; /*!< */
} sbrTuningTable_t;
typedef struct sbrConfiguration {
/*
core coder dependent configurations
*/
CODEC_PARAM
codecSettings; /*!< Core coder settings. To be set from core coder. */
INT SendHeaderDataTime; /*!< SBR header send update frequency in ms. */
INT useWaveCoding; /*!< Flag: usage of wavecoding tool. */
INT crcSbr; /*!< Flag: usage of SBR-CRC. */
INT dynBwSupported; /*!< Flag: support for dynamic bandwidth in this
combination. */
INT parametricCoding; /*!< Flag: usage of parametric coding tool. */
INT downSampleFactor; /*!< Sampling rate relation between the SBR and the core
encoder. */
FREQ_RES freq_res_fixfix[2]; /*!< Frequency resolution of envelopes in frame
class FIXFIX, for non-split case and split
case */
UCHAR fResTransIsLow; /*!< Frequency resolution of envelopes in transient
frames: low (0) or variable (1) */
/*
core coder dependent tuning parameters
*/
INT tran_thr; /*!< SBR transient detector threshold (* 100). */
INT noiseFloorOffset; /*!< Noise floor offset. */
UINT useSpeechConfig; /*!< Flag: adapt tuning parameters according to speech.
*/
/*
core coder independent configurations
*/
INT sbrFrameSize; /*!< SBR frame size in samples. Will be calculated from core
coder settings. */
INT sbr_data_extra; /*!< Flag usage of data extra. */
INT amp_res; /*!< Amplitude resolution. */
INT ana_max_level; /*!< Noise insertion maximum level. */
INT tran_fc; /*!< Transient detector start frequency. */
INT tran_det_mode; /*!< Transient detector mode. */
INT spread; /*!< Flag: usage of SBR spread. */
INT stat; /*!< Flag: usage of static framing. */
INT e; /*!< Number of envelopes when static framing is chosen. */
SBR_STEREO_MODE stereoMode; /*!< SBR stereo mode. */
INT deltaTAcrossFrames; /*!< Flag: allow time-delta coding. */
FIXP_DBL dF_edge_1stEnv; /*!< Extra fraction delta-F coding is allowed to be
more expensive. */
FIXP_DBL dF_edge_incr; /*!< Increment dF_edge_1stEnv this much if dT-coding
was used this frame. */
INT sbr_invf_mode; /*!< Inverse filtering mode. */
INT sbr_xpos_mode; /*!< Transposer mode. */
INT sbr_xpos_ctrl; /*!< Transposer control. */
INT sbr_xpos_level; /*!< Transposer 3rd order level. */
INT startFreq; /*!< The start frequency table index. */
INT stopFreq; /*!< The stop frequency table index. */
INT useSaPan; /*!< Flag: usage of SAPAN stereo. */
INT dynBwEnabled; /*!< Flag: usage of dynamic bandwidth. */
INT bParametricStereo; /*!< Flag: usage of parametric stereo coding tool. */
/*
header_extra1 configuration
*/
UCHAR freqScale; /*!< Frequency grouping. */
INT alterScale; /*!< Scale resolution. */
INT sbr_noise_bands; /*!< Number of noise bands. */
/*
header_extra2 configuration
*/
INT sbr_limiter_bands; /*!< Number of limiter bands. */
INT sbr_limiter_gains; /*!< Gain of limiter. */
INT sbr_interpol_freq; /*!< Flag: use interpolation in freq. direction. */
INT sbr_smoothing_length; /*!< Flag: choose length 4 or 0 (=on, off). */
UCHAR init_amp_res_FF;
FIXP_DBL threshold_AmpRes_FF_m;
SCHAR threshold_AmpRes_FF_e;
} sbrConfiguration, *sbrConfigurationPtr;
typedef struct SBR_CONFIG_DATA {
UINT sbrSyntaxFlags; /**< SBR syntax flags derived from AOT. */
INT nChannels; /**< Number of channels. */
INT nSfb[2]; /**< Number of SBR scalefactor bands for LO_RES and HI_RES (?) */
INT num_Master; /**< Number of elements in v_k_master. */
INT sampleFreq; /**< SBR sampling frequency. */
INT frameSize;
INT xOverFreq; /**< The SBR start frequency. */
INT dynXOverFreq; /**< Used crossover frequency when dynamic bandwidth is
enabled. */
INT noQmfBands; /**< Number of QMF frequency bands. */
INT noQmfSlots; /**< Number of QMF slots. */
UCHAR *freqBandTable[2]; /**< Frequency table for low and hires, only
MAX_FREQ_COEFFS/2 +1 coeffs actually needed for
lowres. */
UCHAR
*v_k_master; /**< Master BandTable where freqBandTable is derived from. */
SBR_STEREO_MODE stereoMode;
INT noEnvChannels; /**< Number of envelope channels. */
INT useWaveCoding; /**< Flag indicates whether to use wave coding at all. */
INT useParametricCoding; /**< Flag indicates whether to use para coding at
all. */
INT xposCtrlSwitch; /**< Flag indicates whether to switch xpos ctrl on the
fly. */
INT switchTransposers; /**< Flag indicates whether to switch xpos on the fly .
*/
UCHAR initAmpResFF;
FIXP_DBL thresholdAmpResFF_m;
SCHAR thresholdAmpResFF_e;
} SBR_CONFIG_DATA, *HANDLE_SBR_CONFIG_DATA;
typedef struct {
MP4_ELEMENT_ID elType;
INT bitRate;
int instanceTag;
UCHAR fParametricStereo;
UCHAR fDualMono; /**< This flags allows to disable coupling in sbr channel
pair element */
UCHAR nChannelsInEl;
UCHAR ChannelIndex[2];
} SBR_ELEMENT_INFO;
#ifdef __cplusplus
extern "C" {
#endif
typedef struct SBR_ENCODER *HANDLE_SBR_ENCODER;
/**
* \brief Get the max required input buffer size including delay balancing
* space for N audio channels.
* \param noChannels Number of audio channels.
* \return Max required input buffer size in bytes.
*/
INT sbrEncoder_GetInBufferSize(int noChannels);
INT sbrEncoder_Open(HANDLE_SBR_ENCODER *phSbrEncoder, INT nElements,
INT nChannels, INT supportPS);
/**
* \brief Get closest working bitrate to specified desired
* bitrate for a single SBR element.
* \param bitRate The desired target bit rate
* \param numChannels The amount of audio channels
* \param coreSampleRate The sample rate of the core coder
* \param aot The current Audio Object Type
* \return Closest working bit rate to bitRate value
*/
UINT sbrEncoder_LimitBitRate(UINT bitRate, UINT numChannels,
UINT coreSampleRate, AUDIO_OBJECT_TYPE aot);
/**
* \brief Check whether downsampled SBR single rate is possible
* with given audio object type.
* \param aot The Audio object type.
* \return 0 when downsampled SBR is not possible,
* 1 when downsampled SBR is possible.
*/
UINT sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot);
/**
* \brief Initialize SBR Encoder instance.
* \param phSbrEncoder Pointer to a SBR Encoder instance.
* \param elInfo Structure that describes the element/channel
* arrangement.
* \param noElements Amount of elements described in elInfo.
* \param inputBuffer Pointer to the encoder audio buffer
* \param inputBufferBufSize Buffer offset of one channel (frameSize + delay)
* \param bandwidth Returns the core audio encoder bandwidth (output)
* \param bufferOffset Returns the offset for the audio input data in order
* to do delay balancing.
* \param numChannels Input: Encoder input channels. output: core encoder
* channels.
* \param sampleRate Input: Encoder samplerate. output core encoder
* samplerate.
* \param downSampleFactor Input: Relation between SBR and core coder sampling
* rate;
* \param frameLength Input: Encoder frameLength. output core encoder
* frameLength.
* \param aot Input: AOT..
* \param delay Input: core encoder delay. Output: total delay
* because of SBR.
* \param transformFactor The core encoder transform factor (blockswitching).
* \param headerPeriod Repetition rate of the SBR header:
* - (-1) means intern configuration.
* - (1-10) corresponds to header repetition rate in
* frames.
* \return 0 on success, and non-zero if failed.
*/
INT sbrEncoder_Init(HANDLE_SBR_ENCODER hSbrEncoder,
SBR_ELEMENT_INFO elInfo[(8)], int noElements,
INT_PCM *inputBuffer, UINT inputBufferBufSize,
INT *coreBandwidth, INT *inputBufferOffset,
INT *numChannels, const UINT syntaxFlags, INT *sampleRate,
UINT *downSampleFactor, INT *frameLength,
AUDIO_OBJECT_TYPE aot, int *delay, int transformFactor,
const int headerPeriod, ULONG statesInitFlag);
/**
* \brief Do delay line buffers housekeeping. To be called after
* each encoded audio frame.
* \param hEnvEnc SBR Encoder handle.
* \param timeBuffer Pointer to the encoder audio buffer.
* \param timeBufferBufSIze buffer size for one channel
* \return 0 on success, and non-zero if failed.
*/
INT sbrEncoder_UpdateBuffers(HANDLE_SBR_ENCODER hEnvEnc, INT_PCM *timeBuffer,
UINT timeBufferBufSIze);
/**
* \brief Close SBR encoder instance.
* \param phEbrEncoder Handle of SBR encoder instance to be closed.
* \return void
*/
void sbrEncoder_Close(HANDLE_SBR_ENCODER *phEbrEncoder);
/**
* \brief Encode SBR data of one complete audio frame.
* \param hEnvEncoder Handle of SBR encoder instance.
* \param samples Time samples, not interleaved.
* \param timeInStride Channel offset of samples buffer.
* \param sbrDataBits Size of SBR payload in bits.
* \param sbrData SBR payload.
* \return 0 on success, and non-zero if failed.
*/
INT sbrEncoder_EncodeFrame(HANDLE_SBR_ENCODER hEnvEncoder, INT_PCM *samples,
UINT samplesBufSize, UINT sbrDataBits[(8)],
UCHAR sbrData[(8)][MAX_PAYLOAD_SIZE]);
/**
* \brief Write SBR headers of one SBR element.
* \param sbrEncoder Handle of the SBR encoder instance.
* \param hBs Handle of bit stream handle to write SBR header to.
* \param element_index Index of the SBR element which header should be written.
* \param fSendHeaders Flag indicating that the SBR encoder should send more
* headers in the SBR payload or not.
* \return void
*/
void sbrEncoder_GetHeader(HANDLE_SBR_ENCODER sbrEncoder,
HANDLE_FDK_BITSTREAM hBs, INT element_index,
int fSendHeaders);
/**
* \brief Request to write SBR header.
* \param hSbrEncoder SBR encoder handle.
* \return 0 on success, and non-zero if failed.
*/
INT sbrEncoder_SendHeader(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Request if last sbr payload contains an SBR header.
* \param hSbrEncoder SBR encoder handle.
* \return 1 contains sbr header, 0 without sbr header.
*/
INT sbrEncoder_ContainsHeader(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief SBR header delay in frames.
* \param hSbrEncoder SBR encoder handle.
* \return Delay in frames, -1 on failure.
*/
INT sbrEncoder_GetHeaderDelay(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Bitstrem delay in SBR frames.
* \param hSbrEncoder SBR encoder handle.
* \return Delay in frames, -1 on failure.
*/
INT sbrEncoder_GetBsDelay(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Prepare SBR payload for SAP.
* \param hSbrEncoder SBR encoder handle.
* \return 0 on success, and non-zero if failed.
*/
INT sbrEncoder_SAPPrepare(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief SBR encoder bitrate estimation.
* \param hSbrEncoder SBR encoder handle.
* \return Estimated bitrate.
*/
INT sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Delay between input data and downsampled output data.
* \param hSbrEncoder SBR encoder handle.
* \return Delay.
*/
INT sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Delay caused by the SBR decoder.
* \param hSbrEncoder SBR encoder handle.
* \return Delay.
*/
INT sbrEncoder_GetSbrDecDelay(HANDLE_SBR_ENCODER hSbrEncoder);
/**
* \brief Get decoder library version info.
* \param info Pointer to an allocated LIB_INFO struct, where library info is
* written to.
* \return 0 on sucess.
*/
INT sbrEncoder_GetLibInfo(LIB_INFO *info);
void sbrPrintRAM(void);
void sbrPrintROM(void);
#ifdef __cplusplus
}
#endif
#endif /* ifndef __SBR_MAIN_H */
Reference in New Issue View Git Blame Copy Permalink