2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
5 © Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16 of the MPEG specifications.
18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27 applications information and documentation.
31 Redistribution and use in source and binary forms, with or without modification, are permitted without
32 payment of copyright license fees provided that you satisfy the following conditions:
34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35 your modifications thereto in source code form.
37 You must retain the complete text of this software license in the documentation and/or other materials
38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40 modifications thereto to recipients of copies in binary form.
42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43 prior written permission.
45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46 software or your modifications thereto.
48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49 and the date of any change. For modified versions of the FDK AAC Codec, the term
50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57 respect to this software.
59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60 by appropriate patent licenses.
64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69 or business interruption, however caused and on any theory of liability, whether in contract, strict
70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
71 advised of the possibility of such damage.
73 5. CONTACT INFORMATION
75 Fraunhofer Institute for Integrated Circuits IIS
76 Attention: Audio and Multimedia Departments - FDK AAC LL
78 91058 Erlangen, Germany
80 www.iis.fraunhofer.de/amm
81 amm-info@iis.fraunhofer.de
82 ----------------------------------------------------------------------------------------------------------- */
84 /**************************** MPEG-4 HE-AAC Encoder *************************
86 Initial author: M. Lohwasser
87 contents/description: FDK HE-AAC Encoder interface library functions
89 ****************************************************************************/
91 #include "aacenc_lib.h"
92 #include "FDK_audio.h"
95 #include "aacEnc_ram.h"
96 #include "FDK_core.h" /* FDK_tools versioning info */
98 /* Encoder library info */
99 #define AACENCODER_LIB_VL0 3
100 #define AACENCODER_LIB_VL1 4
101 #define AACENCODER_LIB_VL2 12
102 #define AACENCODER_LIB_TITLE "AAC Encoder"
103 #define AACENCODER_LIB_BUILD_DATE __DATE__
104 #define AACENCODER_LIB_BUILD_TIME __TIME__
107 #include "sbr_encoder.h"
108 #include "../src/sbr_ram.h"
109 #include "channel_map.h"
111 #include "psy_const.h"
114 #include "tpenc_lib.h"
116 #include "metadata_main.h"
118 #define SBL(fl) (fl/8) /*!< Short block length (hardcoded to 8 short blocks per long block) */
119 #define BSLA(fl) (4*SBL(fl)+SBL(fl)/2) /*!< AAC block switching look-ahead */
120 #define DELAY_AAC(fl) (fl+BSLA(fl)) /*!< MDCT + blockswitching */
121 #define DELAY_AACELD(fl) ((fl)/2) /*!< ELD FB delay (no framing delay included) */
123 #define INPUTBUFFER_SIZE (1537+100+2048)
125 #define DEFAULT_HEADER_PERIOD_REPETITION_RATE 10 /*!< Default header repetition rate used in transport library and for SBR header. */
127 ////////////////////////////////////////////////////////////////////////////////////
129 * Flags to characterize encoder modules to be supported in present instance.
132 ENC_MODE_FLAG_AAC
= 0x0001,
133 ENC_MODE_FLAG_SBR
= 0x0002,
134 ENC_MODE_FLAG_PS
= 0x0004,
135 ENC_MODE_FLAG_SAC
= 0x0008,
136 ENC_MODE_FLAG_META
= 0x0010
139 ////////////////////////////////////////////////////////////////////////////////////
141 AUDIO_OBJECT_TYPE userAOT
; /*!< Audio Object Type. */
142 UINT userSamplerate
; /*!< Sampling frequency. */
143 UINT nChannels
; /*!< will be set via channelMode. */
144 CHANNEL_MODE userChannelMode
;
146 UINT userBitrateMode
;
148 UINT userAfterburner
;
149 UINT userFramelength
;
150 UINT userAncDataRate
;
152 UCHAR userTns
; /*!< Use TNS coding. */
153 UCHAR userPns
; /*!< Use PNS coding. */
154 UCHAR userIntensity
; /*!< Use Intensity coding. */
156 TRANSPORT_TYPE userTpType
; /*!< Transport type */
157 UCHAR userTpSignaling
; /*!< Extension AOT signaling mode. */
158 UCHAR userTpNsubFrames
; /*!< Number of sub frames in a transport frame for LOAS/LATM or ADTS (default 1). */
159 UCHAR userTpAmxv
; /*!< AudioMuxVersion to be used for LATM (default 0). */
160 UCHAR userTpProtection
;
161 UCHAR userTpHeaderPeriod
; /*!< Parameter used to configure LATM/LOAS SMC rate. Moreover this parameters is
162 used to configure repetition rate of PCE in raw_data_block. */
164 UCHAR userErTools
; /*!< Use VCB11, HCR and/or RVLC ER tool. */
165 UINT userPceAdditions
; /*!< Configure additional bits in PCE. */
167 UCHAR userMetaDataMode
; /*!< Meta data library configuration. */
169 UCHAR userSbrEnabled
; /*!< Enable SBR for ELD. */
170 UINT userSbrRatio
; /*!< SBR sampling rate ratio. Dual- or single-rate. */
174 ////////////////////////////////////////////////////////////////////////////////////
176 /****************************************************************************
177 Structure Definitions
178 ****************************************************************************/
180 typedef struct AACENC_CONFIG
*HANDLE_AACENC_CONFIG
;
186 CODER_CONFIG coderConfig
;
189 AACENC_CONFIG aacConfig
;
190 HANDLE_AAC_ENC hAacEnc
;
193 HANDLE_SBR_ENCODER hEnvEnc
;
196 HANDLE_FDK_METADATA_ENCODER hMetadataEnc
;
197 INT metaDataAllowed
; /* Signal whether chosen configuration allows metadata. Necessary for delay
198 compensation. Metadata mode is a separate parameter. */
201 HANDLE_TRANSPORTENC hTpEnc
;
204 UCHAR
*outBuffer
; /* Internal bitstream buffer */
205 INT outBufferInBytes
; /* Size of internal bitstream buffer*/
208 INT_PCM
*inputBuffer
; /* Internal input buffer. Input source for AAC encoder */
209 INT inputBufferOffset
; /* Where to write new input samples. */
211 INT nSamplesToRead
; /* number of input samples neeeded for encoding one frame */
212 INT nSamplesRead
; /* number of input samples already in input buffer */
213 INT nZerosAppended
; /* appended zeros at end of file*/
214 INT nDelay
; /* encoder delay */
216 AACENC_EXT_PAYLOAD extPayload
[MAX_TOTAL_EXT_PAYLOADS
];
217 /* Extension payload */
218 UCHAR extPayloadData
[(1)][(8)][MAX_PAYLOAD_SIZE
];
219 UINT extPayloadSize
[(1)][(8)]; /* payload sizes in bits */
221 ULONG InitFlags
; /* internal status to treggier re-initialization */
224 /* Memory allocation info. */
233 /* Capability flags */
240 ULONG samplingRate
; /*!< Encoder output sampling rate. */
241 ULONG bitrateRange
; /*!< Lower bitrate range for config entry. */
243 UCHAR lowDelaySbr
; /*!< 0: ELD sbr off,
246 UCHAR downsampledSbr
; /*!< 0: ELD with dualrate sbr,
247 1: ELD with downsampled sbr */
249 } ELD_SBR_CONFIGURATOR
;
252 * \brief This table defines ELD/SBR default configurations.
254 static const ELD_SBR_CONFIGURATOR eldSbrAutoConfigTab
[] =
257 { 48000, 64001, 0, 0 },
260 { 44100, 64001, 0, 0 },
263 { 32000, 28000, 1, 1 },
264 { 32000, 56000, 0, 0 },
267 { 24000, 40000, 0, 0 },
270 { 16000, 28000, 0, 0 }
275 * \brief Configure SBR for ELD configuration.
277 * This function finds default SBR configuration for ELD based on sampling rate and channel bitrate.
278 * Outputparameters are SBR on/off, and SBR ratio.
280 * \param samplingRate Audio signal sampling rate.
281 * \param channelMode Channel configuration to be used.
282 * \param totalBitrate Overall bitrate.
283 * \param eldSbr Pointer to eldSbr parameter, filled on return.
284 * \param eldSbrRatio Pointer to eldSbrRatio parameter, filled on return.
286 * \return - AACENC_OK, all fine.
287 * - AACENC_INVALID_CONFIG, on failure.
289 static AACENC_ERROR
eldSbrConfigurator(
290 const ULONG samplingRate
,
291 const CHANNEL_MODE channelMode
,
292 const ULONG totalBitrate
,
294 UINT
* const eldSbrRatio
297 AACENC_ERROR err
= AACENC_OK
;
299 const ULONG channelBitrate
= totalBitrate
/ FDKaacEnc_GetChannelModeConfiguration(channelMode
)->nChannelsEff
;
301 for (i
=0; i
<(sizeof(eldSbrAutoConfigTab
)/sizeof(ELD_SBR_CONFIGURATOR
)); i
++) {
302 if ( (samplingRate
<= eldSbrAutoConfigTab
[i
].samplingRate
)
303 && (channelBitrate
>= eldSbrAutoConfigTab
[i
].bitrateRange
) )
310 *eldSbr
= (eldSbrAutoConfigTab
[cfgIdx
].lowDelaySbr
==0) ? 0 : 1;
311 *eldSbrRatio
= (eldSbrAutoConfigTab
[cfgIdx
].downsampledSbr
==0) ? 2 : 1;
314 err
= AACENC_INVALID_CONFIG
; /* no default configuration for eld-sbr available. */
320 static inline INT
isSbrActive(const HANDLE_AACENC_CONFIG hAacConfig
)
324 if ( (hAacConfig
->audioObjectType
==AOT_SBR
) || (hAacConfig
->audioObjectType
==AOT_PS
)
325 || (hAacConfig
->audioObjectType
==AOT_MP2_SBR
) || (hAacConfig
->audioObjectType
==AOT_MP2_PS
)
326 || (hAacConfig
->audioObjectType
==AOT_DABPLUS_SBR
) || (hAacConfig
->audioObjectType
==AOT_DABPLUS_PS
)
327 || (hAacConfig
->audioObjectType
==AOT_DRM_SBR
) || (hAacConfig
->audioObjectType
==AOT_DRM_MPEG_PS
) )
331 if (hAacConfig
->audioObjectType
== AOT_ER_AAC_ELD
&& (hAacConfig
->syntaxFlags
& AC_SBR_PRESENT
))
339 static inline INT
isPsActive(const AUDIO_OBJECT_TYPE audioObjectType
)
343 if ( (audioObjectType
==AOT_PS
)
344 || (audioObjectType
==AOT_MP2_PS
)
345 || (audioObjectType
==AOT_DABPLUS_PS
)
346 || (audioObjectType
==AOT_DRM_MPEG_PS
) )
354 static SBR_PS_SIGNALING
getSbrSignalingMode(
355 const AUDIO_OBJECT_TYPE audioObjectType
,
356 const TRANSPORT_TYPE transportType
,
357 const UCHAR transportSignaling
,
362 SBR_PS_SIGNALING sbrSignaling
;
364 if (transportType
==TT_UNKNOWN
|| sbrRatio
==0) {
365 sbrSignaling
= SIG_UNKNOWN
; /* Needed parameters have not been set */
368 sbrSignaling
= SIG_IMPLICIT
; /* default: implicit signaling */
371 if ((audioObjectType
==AOT_AAC_LC
) || (audioObjectType
==AOT_SBR
) || (audioObjectType
==AOT_PS
) ||
372 (audioObjectType
==AOT_MP2_AAC_LC
) || (audioObjectType
==AOT_MP2_SBR
) || (audioObjectType
==AOT_MP2_PS
) ) {
373 switch (transportType
) {
376 sbrSignaling
= SIG_IMPLICIT
; /* For MPEG-2 transport types, only implicit signaling is possible */
380 case TT_MP4_LATM_MCP1
:
381 case TT_MP4_LATM_MCP0
:
384 if ( transportSignaling
==0xFF ) {
387 sbrSignaling
= SIG_EXPLICIT_HIERARCHICAL
; /* For downsampled SBR, explicit signaling is mandatory */
389 sbrSignaling
= SIG_IMPLICIT
; /* For dual-rate SBR, implicit signaling is default */
392 /* User set parameters */
393 /* Attention: Backward compatible explicit signaling does only work with AMV1 for LATM/LOAS */
394 sbrSignaling
= (SBR_PS_SIGNALING
)transportSignaling
;
403 /****************************************************************************
405 ****************************************************************************/
407 H_ALLOC_MEM (_AacEncoder
, AACENCODER
)
408 C_ALLOC_MEM (_AacEncoder
, AACENCODER
, 1)
414 * Map Encoder specific config structures to CODER_CONFIG.
416 static void FDKaacEnc_MapConfig(
417 CODER_CONFIG
*const cc
,
418 const USER_PARAM
*const extCfg
,
419 const SBR_PS_SIGNALING sbrSignaling
,
420 const HANDLE_AACENC_CONFIG hAacConfig
423 AUDIO_OBJECT_TYPE transport_AOT
= AOT_NULL_OBJECT
;
424 FDKmemclear(cc
, sizeof(CODER_CONFIG
));
428 /* Map virtual aot to transport aot. */
429 switch (hAacConfig
->audioObjectType
) {
431 transport_AOT
= AOT_AAC_LC
;
434 transport_AOT
= AOT_SBR
;
438 transport_AOT
= AOT_PS
;
442 transport_AOT
= hAacConfig
->audioObjectType
;
445 if (hAacConfig
->audioObjectType
== AOT_ER_AAC_ELD
) {
446 cc
->flags
|= (hAacConfig
->syntaxFlags
& AC_SBR_PRESENT
) ? CC_SBR
: 0;
449 /* transport type is usually AAC-LC. */
450 if ( (transport_AOT
== AOT_SBR
) || (transport_AOT
== AOT_PS
) ) {
451 cc
->aot
= AOT_AAC_LC
;
454 cc
->aot
= transport_AOT
;
457 /* Configure extension aot. */
458 if (sbrSignaling
==SIG_IMPLICIT
) {
459 cc
->extAOT
= AOT_NULL_OBJECT
; /* implicit */
462 if ( (sbrSignaling
==SIG_EXPLICIT_BW_COMPATIBLE
) && ( (transport_AOT
==AOT_SBR
) || (transport_AOT
==AOT_PS
) ) ) {
463 cc
->extAOT
= AOT_SBR
; /* explicit backward compatible */
466 cc
->extAOT
= transport_AOT
; /* explicit hierarchical */
470 if ( (transport_AOT
==AOT_SBR
) || (transport_AOT
==AOT_PS
) ) {
472 if (transport_AOT
==AOT_PS
) {
476 cc
->sbrSignaling
= sbrSignaling
;
478 cc
->extSamplingRate
= extCfg
->userSamplerate
;
479 cc
->bitRate
= hAacConfig
->bitRate
;
480 cc
->noChannels
= hAacConfig
->nChannels
;
481 cc
->flags
|= CC_IS_BASELAYER
;
482 cc
->channelMode
= hAacConfig
->channelMode
;
484 cc
->nSubFrames
= (hAacConfig
->nSubFrames
> 1 && extCfg
->userTpNsubFrames
== 1)
485 ? hAacConfig
->nSubFrames
486 : extCfg
->userTpNsubFrames
;
488 cc
->flags
|= (extCfg
->userTpProtection
) ? CC_PROTECTION
: 0;
490 if (extCfg
->userTpHeaderPeriod
!=0xFF) {
491 cc
->headerPeriod
= extCfg
->userTpHeaderPeriod
;
493 else { /* auto-mode */
494 switch (extCfg
->userTpType
) {
497 case TT_MP4_LATM_MCP1
:
498 cc
->headerPeriod
= DEFAULT_HEADER_PERIOD_REPETITION_RATE
;
501 cc
->headerPeriod
= 0;
505 cc
->samplesPerFrame
= hAacConfig
->framelength
;
506 cc
->samplingRate
= hAacConfig
->sampleRate
;
508 /* Mpeg-4 signaling for transport library. */
509 switch ( hAacConfig
->audioObjectType
) {
513 cc
->flags
&= ~CC_MPEG_ID
; /* Required for ADTS. */
514 cc
->extAOT
= AOT_NULL_OBJECT
;
517 cc
->flags
|= CC_MPEG_ID
;
520 /* ER-tools signaling. */
521 cc
->flags
|= (hAacConfig
->syntaxFlags
& AC_ER_VCB11
) ? CC_VCB11
: 0;
522 cc
->flags
|= (hAacConfig
->syntaxFlags
& AC_ER_HCR
) ? CC_HCR
: 0;
523 cc
->flags
|= (hAacConfig
->syntaxFlags
& AC_ER_RVLC
) ? CC_RVLC
: 0;
525 /* Matrix mixdown coefficient configuration. */
526 if ( (extCfg
->userPceAdditions
&0x1) && (hAacConfig
->epConfig
==-1)
527 && ((cc
->channelMode
==MODE_1_2_2
)||(cc
->channelMode
==MODE_1_2_2_1
)) )
529 cc
->matrixMixdownA
= ((extCfg
->userPceAdditions
>>1)&0x3)+1;
530 cc
->flags
|= (extCfg
->userPceAdditions
>>3)&0x1 ? CC_PSEUDO_SURROUND
: 0;
533 cc
->matrixMixdownA
= 0;
538 * Examine buffer descriptor regarding choosen identifier.
540 * \param pBufDesc Pointer to buffer descriptor
541 * \param identifier Buffer identifier to look for.
543 * \return - Buffer descriptor index.
544 * -1, if there is no entry available.
546 static INT
getBufDescIdx(
547 const AACENC_BufDesc
*pBufDesc
,
548 const AACENC_BufferIdentifier identifier
553 for (i
=0; i
<pBufDesc
->numBufs
; i
++) {
554 if ( (AACENC_BufferIdentifier
)pBufDesc
->bufferIdentifiers
[i
] == identifier
) {
563 /****************************************************************************
564 Function Declarations
565 ****************************************************************************/
567 AAC_ENCODER_ERROR
aacEncDefaultConfig(HANDLE_AACENC_CONFIG hAacConfig
,
570 /* make reasonable default settings */
571 FDKaacEnc_AacInitDefaultConfig (hAacConfig
);
573 /* clear configuration structure and copy default settings */
574 FDKmemclear(config
, sizeof(USER_PARAM
));
576 /* copy encoder configuration settings */
577 config
->nChannels
= hAacConfig
->nChannels
;
578 config
->userAOT
= hAacConfig
->audioObjectType
= AOT_AAC_LC
;
579 config
->userSamplerate
= hAacConfig
->sampleRate
;
580 config
->userChannelMode
= hAacConfig
->channelMode
;
581 config
->userBitrate
= hAacConfig
->bitRate
;
582 config
->userBitrateMode
= hAacConfig
->bitrateMode
;
583 config
->userBandwidth
= hAacConfig
->bandWidth
;
584 config
->userTns
= hAacConfig
->useTns
;
585 config
->userPns
= hAacConfig
->usePns
;
586 config
->userIntensity
= hAacConfig
->useIS
;
587 config
->userAfterburner
= hAacConfig
->useRequant
;
588 config
->userFramelength
= (UINT
)-1;
590 if (hAacConfig
->syntaxFlags
& AC_ER_VCB11
) {
591 config
->userErTools
|= 0x01;
593 if (hAacConfig
->syntaxFlags
& AC_ER_HCR
) {
594 config
->userErTools
|= 0x02;
597 /* initialize transport parameters */
598 config
->userTpType
= TT_UNKNOWN
;
599 config
->userTpAmxv
= 0;
600 config
->userTpSignaling
= 0xFF; /* choose signaling automatically */
601 config
->userTpNsubFrames
= 1;
602 config
->userTpProtection
= 0; /* not crc protected*/
603 config
->userTpHeaderPeriod
= 0xFF; /* header period in auto mode */
604 config
->userPceAdditions
= 0; /* no matrix mixdown coefficient */
605 config
->userMetaDataMode
= 0; /* do not embed any meta data info */
607 config
->userAncDataRate
= 0;
609 /* SBR rate is set to 0 here, which means it should be set automatically
610 in FDKaacEnc_AdjustEncSettings() if the user did not set a rate
612 config
->userSbrRatio
= 0;
614 /* SBR enable set to -1 means to inquire ELD audio configurator for reasonable configuration. */
615 config
->userSbrEnabled
= -1;
621 void aacEncDistributeSbrBits(CHANNEL_MAPPING
*channelMapping
, SBR_ELEMENT_INFO
*sbrElInfo
, INT bitRate
)
623 INT codebits
= bitRate
;
626 /* Copy Element info */
627 for (el
=0; el
<channelMapping
->nElements
; el
++) {
628 sbrElInfo
[el
].ChannelIndex
[0] = channelMapping
->elInfo
[el
].ChannelIndex
[0];
629 sbrElInfo
[el
].ChannelIndex
[1] = channelMapping
->elInfo
[el
].ChannelIndex
[1];
630 sbrElInfo
[el
].elType
= channelMapping
->elInfo
[el
].elType
;
631 sbrElInfo
[el
].bitRate
= (INT
)(fMultNorm(channelMapping
->elInfo
[el
].relativeBits
, (FIXP_DBL
)bitRate
));
632 sbrElInfo
[el
].instanceTag
= channelMapping
->elInfo
[el
].instanceTag
;
633 sbrElInfo
[el
].nChannelsInEl
= channelMapping
->elInfo
[el
].nChannelsInEl
;
635 codebits
-= sbrElInfo
[el
].bitRate
;
637 sbrElInfo
[0].bitRate
+= codebits
;
642 INT
aacEncoder_LimitBitrate(
643 const HANDLE_TRANSPORTENC hTpEnc
,
644 const INT samplingRate
,
645 const INT frameLength
,
647 const CHANNEL_MODE channelMode
,
649 const INT nSubFrames
,
651 const INT sbrDownSampleRate
,
652 const AUDIO_OBJECT_TYPE aot
655 INT coreSamplingRate
;
658 FDKaacEnc_InitChannelMapping(channelMode
, CH_ORDER_MPEG
, &cm
);
661 coreSamplingRate
= samplingRate
>> (sbrEncoder_IsSingleRatePossible(aot
) ? (sbrDownSampleRate
-1):1);
663 coreSamplingRate
= samplingRate
;
666 /* Consider bandwidth channel bit rate limit (see bandwidth.cpp: GetBandwidthEntry()) */
667 if (aot
== AOT_ER_AAC_LD
|| aot
== AOT_ER_AAC_ELD
) {
668 bitRate
= FDKmin(360000*nChannels
, bitRate
);
669 bitRate
= FDKmax(8000*nChannels
, bitRate
);
672 if (aot
== AOT_AAC_LC
|| aot
== AOT_SBR
|| aot
== AOT_PS
) {
673 bitRate
= FDKmin(576000*nChannels
, bitRate
);
674 /*bitRate = FDKmax(0*nChannels, bitRate);*/
678 /* Limit bit rate in respect to the core coder */
679 bitRate
= FDKaacEnc_LimitBitrate(
692 /* Limit bit rate in respect to available SBR modes if active */
695 int numIterations
= 0;
696 INT initialBitrate
, adjustedBitrate
;
697 initialBitrate
= adjustedBitrate
= bitRate
;
699 /* Find total bitrate which provides valid configuration for each SBR element. */
702 SBR_ELEMENT_INFO sbrElInfo
[(8)];
703 FDK_ASSERT(cm
.nElements
<= (8));
705 initialBitrate
= adjustedBitrate
;
707 /* Get bit rate for each SBR element */
708 aacEncDistributeSbrBits(&cm
, sbrElInfo
, initialBitrate
);
710 for (e
=0; e
<cm
.nElements
; e
++)
712 INT sbrElementBitRateIn
, sbrBitRateOut
;
714 if (cm
.elInfo
[e
].elType
!= ID_SCE
&& cm
.elInfo
[e
].elType
!= ID_CPE
) {
717 sbrElementBitRateIn
= sbrElInfo
[e
].bitRate
;
718 sbrBitRateOut
= sbrEncoder_LimitBitRate(sbrElementBitRateIn
, cm
.elInfo
[e
].nChannelsInEl
, coreSamplingRate
, aot
);
719 if (sbrBitRateOut
== 0) {
723 /* If bitrates don't match, distribution and limiting needs to be determined again.
724 Abort element loop and restart with adapted bitrate. */
725 if (sbrElementBitRateIn
!= sbrBitRateOut
) {
727 if (sbrElementBitRateIn
< sbrBitRateOut
) {
728 adjustedBitrate
= fMax(initialBitrate
, (INT
)fDivNorm((FIXP_DBL
)(sbrBitRateOut
+8), cm
.elInfo
[e
].relativeBits
));
732 if (sbrElementBitRateIn
> sbrBitRateOut
) {
733 adjustedBitrate
= fMin(initialBitrate
, (INT
)fDivNorm((FIXP_DBL
)(sbrBitRateOut
-8), cm
.elInfo
[e
].relativeBits
));
737 } /* sbrElementBitRateIn != sbrBitRateOut */
741 numIterations
++; /* restrict iteration to worst case of num elements */
743 } while ( (initialBitrate
!=adjustedBitrate
) && (numIterations
<=cm
.nElements
) );
745 /* Unequal bitrates mean that no reasonable bitrate configuration found. */
746 bitRate
= (initialBitrate
==adjustedBitrate
) ? adjustedBitrate
: 0;
749 FDK_ASSERT(bitRate
> 0);
755 * \brief Consistency check of given USER_PARAM struct and
756 * copy back configuration from public struct into internal
757 * encoder configuration struct.
759 * \hAacEncoder Internal encoder config which is to be updated
760 * \param config User provided config (public struct)
761 * \return ´returns always AAC_ENC_OK
764 AACENC_ERROR
FDKaacEnc_AdjustEncSettings(HANDLE_AACENCODER hAacEncoder
,
767 AACENC_ERROR err
= AACENC_OK
;
769 /* Get struct pointers. */
770 HANDLE_AACENC_CONFIG hAacConfig
= &hAacEncoder
->aacConfig
;
772 hAacConfig
->nChannels
= config
->nChannels
;
774 /* Encoder settings update. */
775 hAacConfig
->sampleRate
= config
->userSamplerate
;
776 hAacConfig
->useTns
= config
->userTns
;
777 hAacConfig
->usePns
= config
->userPns
;
778 hAacConfig
->useIS
= config
->userIntensity
;
779 hAacConfig
->bitRate
= config
->userBitrate
;
780 hAacConfig
->channelMode
= config
->userChannelMode
;
781 hAacConfig
->bitrateMode
= config
->userBitrateMode
;
782 hAacConfig
->bandWidth
= config
->userBandwidth
;
783 hAacConfig
->useRequant
= config
->userAfterburner
;
785 hAacConfig
->audioObjectType
= config
->userAOT
;
786 hAacConfig
->anc_Rate
= config
->userAncDataRate
;
787 hAacConfig
->syntaxFlags
= 0;
788 hAacConfig
->epConfig
= -1;
790 /* Adapt internal AOT when necessary. */
791 switch ( hAacConfig
->audioObjectType
) {
795 hAacConfig
->usePns
= 0;
799 config
->userTpType
= (config
->userTpType
!=TT_UNKNOWN
) ? config
->userTpType
: TT_MP4_ADTS
;
800 hAacConfig
->framelength
= (config
->userFramelength
!=(UINT
)-1) ? config
->userFramelength
: 1024;
801 if (hAacConfig
->framelength
!= 1024) {
802 return AACENC_INVALID_CONFIG
;
806 hAacConfig
->epConfig
= 0;
807 hAacConfig
->syntaxFlags
|= AC_ER
|AC_LD
;
808 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x1) ? AC_ER_VCB11
: 0);
809 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x2) ? AC_ER_HCR
: 0);
810 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x4) ? AC_ER_RVLC
: 0);
811 config
->userTpType
= (config
->userTpType
!=TT_UNKNOWN
) ? config
->userTpType
: TT_MP4_LOAS
;
812 hAacConfig
->framelength
= (config
->userFramelength
!=(UINT
)-1) ? config
->userFramelength
: 512;
813 if (hAacConfig
->framelength
!= 512 && hAacConfig
->framelength
!= 480) {
814 return AACENC_INVALID_CONFIG
;
818 hAacConfig
->epConfig
= 0;
819 hAacConfig
->syntaxFlags
|= AC_ER
|AC_ELD
;
820 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x1) ? AC_ER_VCB11
: 0);
821 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x2) ? AC_ER_HCR
: 0);
822 hAacConfig
->syntaxFlags
|= ((config
->userErTools
& 0x4) ? AC_ER_RVLC
: 0);
823 hAacConfig
->syntaxFlags
|= ((config
->userSbrEnabled
==1) ? AC_SBR_PRESENT
: 0);
824 config
->userTpType
= (config
->userTpType
!=TT_UNKNOWN
) ? config
->userTpType
: TT_MP4_LOAS
;
825 hAacConfig
->framelength
= (config
->userFramelength
!=(UINT
)-1) ? config
->userFramelength
: 512;
826 if (hAacConfig
->framelength
!= 512 && hAacConfig
->framelength
!= 480) {
827 return AACENC_INVALID_CONFIG
;
834 switch ( hAacConfig
->audioObjectType
) {
837 if (config
->userBitrateMode
==8) {
838 hAacConfig
->bitrateMode
= 0;
840 if (config
->userBitrateMode
==0) {
841 hAacConfig
->bitreservoir
= 100*config
->nChannels
; /* default, reduced bitreservoir */
843 if (hAacConfig
->bitrateMode
!=0) {
844 return AACENC_INVALID_CONFIG
;
851 hAacConfig
->bitRate
= config
->userBitrate
;
853 /* get bitrate in VBR configuration */
854 if ( (hAacConfig
->bitrateMode
>=1) && (hAacConfig
->bitrateMode
<=5) ) {
855 /* In VBR mode; SBR-modul depends on bitrate, core encoder on bitrateMode. */
856 hAacConfig
->bitRate
= FDKaacEnc_GetVBRBitrate(hAacConfig
->bitrateMode
, hAacConfig
->channelMode
);
861 /* Set default bitrate if no external bitrate declared. */
862 if ( (hAacConfig
->bitrateMode
==0) && (config
->userBitrate
==(UINT
)-1) ) {
863 INT bitrate
= FDKaacEnc_GetChannelModeConfiguration(hAacConfig
->channelMode
)->nChannelsEff
* hAacConfig
->sampleRate
;
865 if ( isPsActive(hAacConfig
->audioObjectType
) ) {
866 hAacConfig
->bitRate
= (bitrate
>>1); /* 0.5 bit per sample */
868 else if ( isSbrActive(hAacConfig
) )
870 if ( (config
->userSbrRatio
==2) || ((config
->userSbrRatio
==0)&&(hAacConfig
->audioObjectType
!=AOT_ER_AAC_ELD
)) ) {
871 hAacConfig
->bitRate
= (bitrate
+ (bitrate
>>2))>>1; /* 0.625 bits per sample */
873 if ( (config
->userSbrRatio
==1) || ((config
->userSbrRatio
==0)&&(hAacConfig
->audioObjectType
==AOT_ER_AAC_ELD
)) ) {
874 hAacConfig
->bitRate
= (bitrate
+ (bitrate
>>3)); /* 1.125 bits per sample */
878 hAacConfig
->bitRate
= bitrate
+ (bitrate
>>1); /* 1.5 bits per sample */
882 /* Initialize SBR parameters */
883 if ( (hAacConfig
->audioObjectType
==AOT_ER_AAC_ELD
)
884 && (config
->userSbrEnabled
== (UCHAR
)-1) && (config
->userSbrRatio
==0) )
887 UINT eldSbrRatio
= 0;
889 if ( AACENC_OK
!=(err
=eldSbrConfigurator(
890 hAacConfig
->sampleRate
,
891 hAacConfig
->channelMode
,
899 hAacConfig
->syntaxFlags
|= ((eldSbr
) ? AC_SBR_PRESENT
: 0);
900 hAacConfig
->sbrRatio
= eldSbrRatio
;
903 if ( (config
->userSbrRatio
==0) && (isSbrActive(hAacConfig
)) ) {
904 /* Automatic SBR ratio configuration
905 * - downsampled SBR for ELD
906 * - otherwise always dualrate SBR
908 hAacConfig
->sbrRatio
= (hAacConfig
->audioObjectType
==AOT_ER_AAC_ELD
) ? 1 : 2;
911 /* SBR ratio has been set by the user, so use it. */
912 hAacConfig
->sbrRatio
= config
->userSbrRatio
;
916 UCHAR tpSignaling
=getSbrSignalingMode(hAacConfig
->audioObjectType
, config
->userTpType
, config
->userTpSignaling
, hAacConfig
->sbrRatio
);
918 if ( (hAacConfig
->audioObjectType
==AOT_AAC_LC
|| hAacConfig
->audioObjectType
==AOT_SBR
|| hAacConfig
->audioObjectType
==AOT_PS
) &&
919 (config
->userTpType
==TT_MP4_LATM_MCP1
|| config
->userTpType
==TT_MP4_LATM_MCP0
|| config
->userTpType
==TT_MP4_LOAS
) &&
920 (tpSignaling
==1) && (config
->userTpAmxv
==0) ) {
921 /* For backward compatible explicit signaling, AMV1 has to be active */
922 return AACENC_INVALID_CONFIG
;
925 if ( (hAacConfig
->audioObjectType
==AOT_AAC_LC
|| hAacConfig
->audioObjectType
==AOT_SBR
|| hAacConfig
->audioObjectType
==AOT_PS
) &&
926 (tpSignaling
==0) && (hAacConfig
->sbrRatio
==1)) {
927 /* Downsampled SBR has to be signaled explicitely (for transmission of SBR sampling fequency) */
928 return AACENC_INVALID_CONFIG
;
934 /* We need the frame length to call aacEncoder_LimitBitrate() */
935 hAacConfig
->bitRate
= aacEncoder_LimitBitrate(
937 hAacConfig
->sampleRate
,
938 hAacConfig
->framelength
,
939 hAacConfig
->nChannels
,
940 hAacConfig
->channelMode
,
942 hAacConfig
->nSubFrames
,
943 isSbrActive(hAacConfig
),
944 hAacConfig
->sbrRatio
,
945 hAacConfig
->audioObjectType
949 if ( ((hAacConfig
->bitrateMode
>=1) && (hAacConfig
->bitrateMode
<=5)) /* VBR without PNS. */
950 || (hAacConfig
->useTns
== 0) ) /* TNS required. */
952 hAacConfig
->usePns
= 0;
955 if (hAacConfig
->epConfig
>= 0) {
956 hAacConfig
->syntaxFlags
|= AC_ER
;
957 if (((INT
)hAacConfig
->channelMode
< 1) || ((INT
)hAacConfig
->channelMode
> 7)) {
958 return AACENC_INVALID_CONFIG
; /* Cannel config 0 not supported. */
962 if ( FDKaacEnc_DetermineEncoderMode(&hAacConfig
->channelMode
, hAacConfig
->nChannels
) != AAC_ENC_OK
) {
963 return AACENC_INVALID_CONFIG
; /* nChannels doesn't match chMode, this is just a check-up */
966 if ( (hAacConfig
->nChannels
> hAacEncoder
->nMaxAacChannels
)
967 || ( (FDKaacEnc_GetChannelModeConfiguration(hAacConfig
->channelMode
)->nChannelsEff
> hAacEncoder
->nMaxSbrChannels
) &&
968 isSbrActive(hAacConfig
) )
971 return AACENC_INVALID_CONFIG
; /* not enough channels allocated */
974 /* Meta data restriction. */
975 switch (hAacConfig
->audioObjectType
)
977 /* Allow metadata support */
981 hAacEncoder
->metaDataAllowed
= 1;
982 if (((INT
)hAacConfig
->channelMode
< 1) || ((INT
)hAacConfig
->channelMode
> 7)) {
983 config
->userMetaDataMode
= 0;
986 /* Prohibit metadata support */
988 hAacEncoder
->metaDataAllowed
= 0;
995 INT
aacenc_SbrCallback(
997 HANDLE_FDK_BITSTREAM hBs
,
998 const INT sampleRateIn
,
999 const INT sampleRateOut
,
1000 const INT samplesPerFrame
,
1001 const AUDIO_OBJECT_TYPE coreCodec
,
1002 const MP4_ELEMENT_ID elementID
,
1003 const INT elementIndex
1006 HANDLE_AACENCODER hAacEncoder
= (HANDLE_AACENCODER
)self
;
1008 sbrEncoder_GetHeader(hAacEncoder
->hEnvEnc
, hBs
, elementIndex
, 0);
1013 static AACENC_ERROR
aacEncInit(HANDLE_AACENCODER hAacEncoder
,
1017 AACENC_ERROR err
= AACENC_OK
;
1019 INT aacBufferOffset
= 0;
1020 HANDLE_SBR_ENCODER
*hSbrEncoder
= &hAacEncoder
->hEnvEnc
;
1021 HANDLE_AACENC_CONFIG hAacConfig
= &hAacEncoder
->aacConfig
;
1023 hAacEncoder
->nZerosAppended
= 0; /* count appended zeros */
1025 INT frameLength
= hAacConfig
->framelength
;
1027 if ( (InitFlags
& AACENC_INIT_CONFIG
) )
1029 CHANNEL_MODE prevChMode
= hAacConfig
->channelMode
;
1031 /* Verify settings and update: config -> heAacEncoder */
1032 if ( (err
=FDKaacEnc_AdjustEncSettings(hAacEncoder
, config
)) != AACENC_OK
) {
1035 frameLength
= hAacConfig
->framelength
; /* adapt temporal framelength */
1037 /* Seamless channel reconfiguration in sbr not fully implemented */
1038 if ( (prevChMode
!=hAacConfig
->channelMode
) && isSbrActive(hAacConfig
) ) {
1039 InitFlags
|= AACENC_INIT_STATES
;
1043 /* Clear input buffer */
1044 if ( (InitFlags
== AACENC_INIT_ALL
) ) {
1045 FDKmemclear(hAacEncoder
->inputBuffer
, sizeof(INT_PCM
)*hAacEncoder
->nMaxAacChannels
*INPUTBUFFER_SIZE
);
1048 if ( (InitFlags
& AACENC_INIT_CONFIG
) )
1050 aacBufferOffset
= 0;
1051 if (hAacConfig
->audioObjectType
== AOT_ER_AAC_ELD
) {
1052 hAacEncoder
->nDelay
= DELAY_AACELD(hAacConfig
->framelength
);
1055 hAacEncoder
->nDelay
= DELAY_AAC(hAacConfig
->framelength
); /* AAC encoder delay */
1057 hAacConfig
->ancDataBitRate
= 0;
1060 if ( isSbrActive(hAacConfig
) &&
1061 ((InitFlags
& AACENC_INIT_CONFIG
) || (InitFlags
& AACENC_INIT_STATES
)) )
1064 SBR_ELEMENT_INFO sbrElInfo
[(8)];
1065 CHANNEL_MAPPING channelMapping
;
1067 if ( FDKaacEnc_InitChannelMapping(hAacConfig
->channelMode
,
1068 hAacConfig
->channelOrder
,
1069 &channelMapping
) != AAC_ENC_OK
)
1071 return AACENC_INIT_ERROR
;
1074 /* Check return value and if the SBR encoder can handle enough elements */
1075 if (channelMapping
.nElements
> (8)) {
1076 return AACENC_INIT_ERROR
;
1079 aacEncDistributeSbrBits(&channelMapping
, sbrElInfo
, hAacConfig
->bitRate
);
1082 initFlag
+= (InitFlags
& AACENC_INIT_STATES
) ? 1 : 0;
1084 /* Let the SBR encoder take a look at the configuration and change if required. */
1085 sbrError
= sbrEncoder_Init(
1088 channelMapping
.nElements
,
1089 hAacEncoder
->inputBuffer
,
1090 &hAacConfig
->bandWidth
,
1092 &hAacConfig
->nChannels
,
1093 &hAacConfig
->sampleRate
,
1094 &hAacConfig
->sbrRatio
,
1096 hAacConfig
->audioObjectType
,
1097 &hAacEncoder
->nDelay
,
1098 (hAacConfig
->audioObjectType
== AOT_ER_AAC_ELD
) ? 1 : TRANS_FAC
,
1099 (config
->userTpHeaderPeriod
!=0xFF) ? config
->userTpHeaderPeriod
: DEFAULT_HEADER_PERIOD_REPETITION_RATE
,
1103 /* Suppress AOT reconfiguration and check error status. */
1105 return AACENC_INIT_SBR_ERROR
;
1108 if (hAacConfig
->nChannels
== 1) {
1109 hAacConfig
->channelMode
= MODE_1
;
1112 /* Never use PNS if SBR is active */
1113 if ( hAacConfig
->usePns
) {
1114 hAacConfig
->usePns
= 0;
1117 /* estimated bitrate consumed by SBR or PS */
1118 hAacConfig
->ancDataBitRate
= sbrEncoder_GetEstimateBitrate(*hSbrEncoder
) ;
1120 } /* sbr initialization */
1124 * Initialize Transport - Module.
1126 if ( (InitFlags
& AACENC_INIT_TRANSPORT
) )
1130 FDKaacEnc_MapConfig(
1131 &hAacEncoder
->coderConfig
,
1133 getSbrSignalingMode(hAacConfig
->audioObjectType
, config
->userTpType
, config
->userTpSignaling
, hAacConfig
->sbrRatio
),
1136 /* create flags for transport encoder */
1137 if (config
->userTpAmxv
== 1) {
1138 flags
|= TP_FLAG_LATM_AMV
;
1140 /* Clear output buffer */
1141 FDKmemclear(hAacEncoder
->outBuffer
, hAacEncoder
->outBufferInBytes
*sizeof(UCHAR
));
1143 /* Initialize Bitstream encoder */
1144 if ( transportEnc_Init(hAacEncoder
->hTpEnc
, hAacEncoder
->outBuffer
, hAacEncoder
->outBufferInBytes
, config
->userTpType
, &hAacEncoder
->coderConfig
, flags
) != 0) {
1145 return AACENC_INIT_TP_ERROR
;
1148 } /* transport initialization */
1151 * Initialize AAC - Core.
1153 if ( (InitFlags
& AACENC_INIT_CONFIG
) ||
1154 (InitFlags
& AACENC_INIT_STATES
) )
1156 AAC_ENCODER_ERROR err
;
1157 err
= FDKaacEnc_Initialize(hAacEncoder
->hAacEnc
,
1159 hAacEncoder
->hTpEnc
,
1160 (InitFlags
& AACENC_INIT_STATES
) ? 1 : 0);
1162 if (err
!= AAC_ENC_OK
) {
1163 return AACENC_INIT_AAC_ERROR
;
1166 } /* aac initialization */
1169 * Initialize Meta Data - Encoder.
1171 if ( hAacEncoder
->hMetadataEnc
&& (hAacEncoder
->metaDataAllowed
!=0) &&
1172 ((InitFlags
& AACENC_INIT_CONFIG
) ||(InitFlags
& AACENC_INIT_STATES
)) )
1174 INT inputDataDelay
= DELAY_AAC(hAacConfig
->framelength
);
1176 if ( isSbrActive(hAacConfig
) && hSbrEncoder
!=NULL
) {
1177 inputDataDelay
= hAacConfig
->sbrRatio
*inputDataDelay
+ sbrEncoder_GetInputDataDelay(*hSbrEncoder
);
1180 if ( FDK_MetadataEnc_Init(hAacEncoder
->hMetadataEnc
,
1181 ((InitFlags
&AACENC_INIT_STATES
) ? 1 : 0),
1182 config
->userMetaDataMode
,
1185 config
->userSamplerate
,
1187 config
->userChannelMode
,
1188 hAacConfig
->channelOrder
) != 0)
1190 return AACENC_INIT_META_ERROR
;
1193 hAacEncoder
->nDelay
+= FDK_MetadataEnc_GetDelay(hAacEncoder
->hMetadataEnc
);
1197 * Update pointer to working buffer.
1199 if ( (InitFlags
& AACENC_INIT_CONFIG
) )
1201 hAacEncoder
->inputBufferOffset
= aacBufferOffset
;
1203 hAacEncoder
->nSamplesToRead
= frameLength
* config
->nChannels
;
1205 /* Make nDelay comparison compatible with config->nSamplesRead */
1206 hAacEncoder
->nDelay
*= config
->nChannels
;
1208 } /* parameter changed */
1214 AACENC_ERROR
aacEncOpen(
1215 HANDLE_AACENCODER
*phAacEncoder
,
1216 const UINT encModules
,
1217 const UINT maxChannels
1220 AACENC_ERROR err
= AACENC_OK
;
1221 HANDLE_AACENCODER hAacEncoder
= NULL
;
1223 if (phAacEncoder
== NULL
) {
1224 err
= AACENC_INVALID_HANDLE
;
1228 /* allocate memory */
1229 hAacEncoder
= Get_AacEncoder();
1231 if (hAacEncoder
== NULL
) {
1232 err
= AACENC_MEMORY_ERROR
;
1236 FDKmemclear(hAacEncoder
, sizeof(AACENCODER
));
1238 /* Specify encoder modules to be allocated. */
1239 if (encModules
==0) {
1240 hAacEncoder
->encoder_modis
= ENC_MODE_FLAG_AAC
;
1241 hAacEncoder
->encoder_modis
|= ENC_MODE_FLAG_SBR
;
1242 hAacEncoder
->encoder_modis
|= ENC_MODE_FLAG_PS
;
1243 hAacEncoder
->encoder_modis
|= ENC_MODE_FLAG_META
;
1246 /* consider SAC and PS module */
1247 hAacEncoder
->encoder_modis
= encModules
;
1250 /* Determine max channel configuration. */
1251 if (maxChannels
==0) {
1252 hAacEncoder
->nMaxAacChannels
= (8);
1253 hAacEncoder
->nMaxSbrChannels
= (8);
1256 hAacEncoder
->nMaxAacChannels
= (maxChannels
&0x00FF);
1257 if ( (hAacEncoder
->encoder_modis
&ENC_MODE_FLAG_SBR
) ) {
1258 hAacEncoder
->nMaxSbrChannels
= (maxChannels
&0xFF00) ? (maxChannels
>>8) : hAacEncoder
->nMaxAacChannels
;
1261 if ( (hAacEncoder
->nMaxAacChannels
>(8)) || (hAacEncoder
->nMaxSbrChannels
>(8)) ) {
1262 err
= AACENC_INVALID_CONFIG
;
1265 } /* maxChannels==0 */
1267 /* Max number of elements could be tuned any more. */
1268 hAacEncoder
->nMaxAacElements
= fixMin((8), hAacEncoder
->nMaxAacChannels
);
1269 hAacEncoder
->nMaxSbrElements
= fixMin((8), hAacEncoder
->nMaxSbrChannels
);
1270 hAacEncoder
->nMaxSubFrames
= (1);
1273 /* In case of memory overlay, allocate memory out of libraries */
1275 hAacEncoder
->inputBuffer
= (INT_PCM
*)FDKcalloc(hAacEncoder
->nMaxAacChannels
*INPUTBUFFER_SIZE
, sizeof(INT_PCM
));
1277 /* Open SBR Encoder */
1278 if (hAacEncoder
->encoder_modis
&ENC_MODE_FLAG_SBR
) {
1279 if ( sbrEncoder_Open(&hAacEncoder
->hEnvEnc
,
1280 hAacEncoder
->nMaxSbrElements
,
1281 hAacEncoder
->nMaxSbrChannels
,
1282 (hAacEncoder
->encoder_modis
&ENC_MODE_FLAG_PS
) ? 1 : 0 ) )
1284 err
= AACENC_MEMORY_ERROR
;
1287 } /* (encoder_modis&ENC_MODE_FLAG_SBR) */
1290 /* Open Aac Encoder */
1291 if ( FDKaacEnc_Open(&hAacEncoder
->hAacEnc
,
1292 hAacEncoder
->nMaxAacElements
,
1293 hAacEncoder
->nMaxAacChannels
,
1294 (1)) != AAC_ENC_OK
)
1296 err
= AACENC_MEMORY_ERROR
;
1300 { /* Get bitstream outputbuffer size */
1302 for (ld_M
=1; (UINT
)(1<<ld_M
) < (hAacEncoder
->nMaxSubFrames
*hAacEncoder
->nMaxAacChannels
*6144)>>3; ld_M
++) ;
1303 hAacEncoder
->outBufferInBytes
= (1<<ld_M
); /* buffer has to be 2^n */
1305 hAacEncoder
->outBuffer
= GetRam_bsOutbuffer();
1306 if (OUTPUTBUFFER_SIZE
< hAacEncoder
->outBufferInBytes
) {
1307 err
= AACENC_MEMORY_ERROR
;
1311 /* Open Meta Data Encoder */
1312 if (hAacEncoder
->encoder_modis
&ENC_MODE_FLAG_META
) {
1313 if ( FDK_MetadataEnc_Open(&hAacEncoder
->hMetadataEnc
) )
1315 err
= AACENC_MEMORY_ERROR
;
1318 } /* (encoder_modis&ENC_MODE_FLAG_META) */
1320 /* Open Transport Encoder */
1321 if ( transportEnc_Open(&hAacEncoder
->hTpEnc
) != 0 )
1323 err
= AACENC_MEMORY_ERROR
;
1327 C_ALLOC_SCRATCH_START(pLibInfo
, LIB_INFO
, FDK_MODULE_LAST
);
1329 FDKinitLibInfo( pLibInfo
);
1330 transportEnc_GetLibInfo( pLibInfo
);
1332 /* Get capabilty flag for transport encoder. */
1333 hAacEncoder
->CAPF_tpEnc
= FDKlibInfo_getCapabilities( pLibInfo
, FDK_TPENC
);
1335 C_ALLOC_SCRATCH_END(pLibInfo
, LIB_INFO
, FDK_MODULE_LAST
);
1337 if ( transportEnc_RegisterSbrCallback(hAacEncoder
->hTpEnc
, aacenc_SbrCallback
, hAacEncoder
) != 0 ) {
1338 err
= AACENC_INIT_TP_ERROR
;
1342 /* Initialize encoder instance with default parameters. */
1343 aacEncDefaultConfig(&hAacEncoder
->aacConfig
, &hAacEncoder
->extParam
);
1345 /* Initialize headerPeriod in coderConfig for aacEncoder_GetParam(). */
1346 hAacEncoder
->coderConfig
.headerPeriod
= hAacEncoder
->extParam
.userTpHeaderPeriod
;
1348 /* All encoder modules have to be initialized */
1349 hAacEncoder
->InitFlags
= AACENC_INIT_ALL
;
1351 /* Return encoder instance */
1352 *phAacEncoder
= hAacEncoder
;
1357 aacEncClose(&hAacEncoder
);
1364 AACENC_ERROR
aacEncClose(HANDLE_AACENCODER
*phAacEncoder
)
1366 AACENC_ERROR err
= AACENC_OK
;
1368 if (phAacEncoder
== NULL
) {
1369 err
= AACENC_INVALID_HANDLE
;
1373 if (*phAacEncoder
!= NULL
) {
1374 HANDLE_AACENCODER hAacEncoder
= *phAacEncoder
;
1377 if (hAacEncoder
->inputBuffer
!=NULL
) {
1378 FDKfree(hAacEncoder
->inputBuffer
);
1379 hAacEncoder
->inputBuffer
= NULL
;
1382 if (hAacEncoder
->outBuffer
) {
1383 FreeRam_bsOutbuffer(&hAacEncoder
->outBuffer
);
1386 if (hAacEncoder
->hEnvEnc
) {
1387 sbrEncoder_Close (&hAacEncoder
->hEnvEnc
);
1389 if (hAacEncoder
->hAacEnc
) {
1390 FDKaacEnc_Close (&hAacEncoder
->hAacEnc
);
1393 transportEnc_Close(&hAacEncoder
->hTpEnc
);
1395 if (hAacEncoder
->hMetadataEnc
) {
1396 FDK_MetadataEnc_Close (&hAacEncoder
->hMetadataEnc
);
1399 Free_AacEncoder(phAacEncoder
);
1406 AACENC_ERROR
aacEncEncode(
1407 const HANDLE_AACENCODER hAacEncoder
,
1408 const AACENC_BufDesc
*inBufDesc
,
1409 const AACENC_BufDesc
*outBufDesc
,
1410 const AACENC_InArgs
*inargs
,
1411 AACENC_OutArgs
*outargs
1414 AACENC_ERROR err
= AACENC_OK
;
1415 INT i
, nBsBytes
= 0;
1417 int nExtensions
= 0;
1418 int ancDataExtIdx
= -1;
1420 /* deal with valid encoder handle */
1421 if (hAacEncoder
==NULL
) {
1422 err
= AACENC_INVALID_HANDLE
;
1428 * Adjust user settings and trigger reinitialization.
1430 if (hAacEncoder
->InitFlags
!=0) {
1432 err
= aacEncInit(hAacEncoder
,
1433 hAacEncoder
->InitFlags
,
1434 &hAacEncoder
->extParam
);
1436 if (err
!=AACENC_OK
) {
1437 /* keep init flags alive! */
1440 hAacEncoder
->InitFlags
= AACENC_INIT_NONE
;
1443 if (outargs
!=NULL
) {
1444 FDKmemclear(outargs
, sizeof(AACENC_OutArgs
));
1447 if (outBufDesc
!=NULL
) {
1448 for (i
=0; i
<outBufDesc
->numBufs
; i
++) {
1449 if (outBufDesc
->bufs
[i
]!=NULL
) {
1450 FDKmemclear(outBufDesc
->bufs
[i
], outBufDesc
->bufSizes
[i
]);
1456 * If only encoder handle given, independent (re)initialization can be triggered.
1458 if ( (hAacEncoder
!=NULL
) & (inBufDesc
==NULL
) && (outBufDesc
==NULL
) && (inargs
==NULL
) && (outargs
==NULL
) ) {
1462 /* reset buffer wich signals number of valid bytes in output bitstream buffer */
1463 FDKmemclear(outBytes
, hAacEncoder
->aacConfig
.nSubFrames
*sizeof(INT
));
1466 * Manage incoming audio samples.
1468 if ( (inargs
->numInSamples
> 0) && (getBufDescIdx(inBufDesc
,IN_AUDIO_DATA
) != -1) )
1470 /* Fetch data until nSamplesToRead reached */
1471 INT idx
= getBufDescIdx(inBufDesc
,IN_AUDIO_DATA
);
1472 INT newSamples
= fixMax(0,fixMin(inargs
->numInSamples
, hAacEncoder
->nSamplesToRead
-hAacEncoder
->nSamplesRead
));
1473 INT_PCM
*pIn
= hAacEncoder
->inputBuffer
+hAacEncoder
->inputBufferOffset
+hAacEncoder
->nSamplesRead
;
1475 /* Copy new input samples to internal buffer */
1476 if (inBufDesc
->bufElSizes
[idx
]==(INT
)sizeof(INT_PCM
)) {
1477 FDKmemcpy(pIn
, (INT_PCM
*)inBufDesc
->bufs
[idx
], newSamples
*sizeof(INT_PCM
)); /* Fast copy. */
1479 else if (inBufDesc
->bufElSizes
[idx
]>(INT
)sizeof(INT_PCM
)) {
1480 for (i
=0; i
<newSamples
; i
++) {
1481 pIn
[i
] = (INT_PCM
)(((LONG
*)inBufDesc
->bufs
[idx
])[i
]>>16); /* Convert 32 to 16 bit. */
1485 for (i
=0; i
<newSamples
; i
++) {
1486 pIn
[i
] = ((INT_PCM
)(((SHORT
*)inBufDesc
->bufs
[idx
])[i
]))<<16; /* Convert 16 to 32 bit. */
1489 hAacEncoder
->nSamplesRead
+= newSamples
;
1491 /* Number of fetched input buffer samples. */
1492 outargs
->numInSamples
= newSamples
;
1495 /* input buffer completely filled ? */
1496 if (hAacEncoder
->nSamplesRead
< hAacEncoder
->nSamplesToRead
)
1498 /* - eof reached and flushing enabled, or
1499 - return to main and wait for further incoming audio samples */
1500 if (inargs
->numInSamples
==-1)
1502 if ( (hAacEncoder
->nZerosAppended
< hAacEncoder
->nDelay
)
1505 int nZeros
= hAacEncoder
->nSamplesToRead
- hAacEncoder
->nSamplesRead
;
1507 FDK_ASSERT(nZeros
>= 0);
1509 /* clear out until end-of-buffer */
1511 FDKmemclear(hAacEncoder
->inputBuffer
+hAacEncoder
->inputBufferOffset
+hAacEncoder
->nSamplesRead
, sizeof(INT_PCM
)*nZeros
);
1512 hAacEncoder
->nZerosAppended
+= nZeros
;
1513 hAacEncoder
->nSamplesRead
= hAacEncoder
->nSamplesToRead
;
1516 else { /* flushing completed */
1517 err
= AACENC_ENCODE_EOF
; /* eof reached */
1521 else { /* inargs->numInSamples!= -1 */
1522 goto bail
; /* not enough samples in input buffer and no flushing enabled */
1527 FDKmemclear(hAacEncoder
->extPayload
, sizeof(AACENC_EXT_PAYLOAD
) * MAX_TOTAL_EXT_PAYLOADS
);
1528 for (i
= 0; i
< MAX_TOTAL_EXT_PAYLOADS
; i
++) {
1529 hAacEncoder
->extPayload
[i
].associatedChElement
= -1;
1531 FDKmemclear(hAacEncoder
->extPayloadData
, sizeof(hAacEncoder
->extPayloadData
));
1532 FDKmemclear(hAacEncoder
->extPayloadSize
, sizeof(hAacEncoder
->extPayloadSize
));
1536 * Calculate Meta Data info.
1538 if ( (hAacEncoder
->hMetadataEnc
!=NULL
) && (hAacEncoder
->metaDataAllowed
!=0) ) {
1540 const AACENC_MetaData
*pMetaData
= NULL
;
1541 AACENC_EXT_PAYLOAD
*pMetaDataExtPayload
= NULL
;
1542 UINT nMetaDataExtensions
= 0;
1543 INT matrix_mixdown_idx
= 0;
1545 /* New meta data info available ? */
1546 if ( getBufDescIdx(inBufDesc
,IN_METADATA_SETUP
) != -1 ) {
1547 pMetaData
= (AACENC_MetaData
*)inBufDesc
->bufs
[getBufDescIdx(inBufDesc
,IN_METADATA_SETUP
)];
1550 FDK_MetadataEnc_Process(hAacEncoder
->hMetadataEnc
,
1551 hAacEncoder
->inputBuffer
+hAacEncoder
->inputBufferOffset
,
1552 hAacEncoder
->nSamplesRead
,
1554 &pMetaDataExtPayload
,
1555 &nMetaDataExtensions
,
1559 for (i
=0; i
<(INT
)nMetaDataExtensions
; i
++) { /* Get meta data extension payload. */
1560 hAacEncoder
->extPayload
[nExtensions
++] = pMetaDataExtPayload
[i
];
1563 if ( (matrix_mixdown_idx
!=-1)
1564 && ((hAacEncoder
->extParam
.userChannelMode
==MODE_1_2_2
)||(hAacEncoder
->extParam
.userChannelMode
==MODE_1_2_2_1
)) )
1566 /* Set matrix mixdown coefficient. */
1567 UINT pceValue
= (UINT
)( (1<<3) | ((matrix_mixdown_idx
&0x3)<<1) | 1 );
1568 if (hAacEncoder
->extParam
.userPceAdditions
!= pceValue
) {
1569 hAacEncoder
->extParam
.userPceAdditions
= pceValue
;
1570 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1576 if ( isSbrActive(&hAacEncoder
->aacConfig
) ) {
1583 if (sbrEncoder_EncodeFrame(hAacEncoder
->hEnvEnc
,
1584 hAacEncoder
->inputBuffer
,
1585 hAacEncoder
->extParam
.nChannels
,
1586 hAacEncoder
->extPayloadSize
[nPayload
],
1587 hAacEncoder
->extPayloadData
[nPayload
]
1588 #if defined(EVAL_PACKAGE_SILENCE) || defined(EVAL_PACKAGE_SBR_SILENCE)
1589 ,hAacEncoder
->hAacEnc
->clearOutput
1593 err
= AACENC_ENCODE_ERROR
;
1597 /* Add SBR extension payload */
1598 for (i
= 0; i
< (8); i
++) {
1599 if (hAacEncoder
->extPayloadSize
[nPayload
][i
] > 0) {
1600 hAacEncoder
->extPayload
[nExtensions
].pData
= hAacEncoder
->extPayloadData
[nPayload
][i
];
1602 hAacEncoder
->extPayload
[nExtensions
].dataSize
= hAacEncoder
->extPayloadSize
[nPayload
][i
];
1603 hAacEncoder
->extPayload
[nExtensions
].associatedChElement
= i
;
1605 hAacEncoder
->extPayload
[nExtensions
].dataType
= EXT_SBR_DATA
; /* Once SBR Encoder supports SBR CRC set EXT_SBR_DATA_CRC */
1606 nExtensions
++; /* or EXT_SBR_DATA according to configuration. */
1607 FDK_ASSERT(nExtensions
<=MAX_TOTAL_EXT_PAYLOADS
);
1614 if ( (inargs
->numAncBytes
> 0) && ( getBufDescIdx(inBufDesc
,IN_ANCILLRY_DATA
)!=-1 ) ) {
1615 INT idx
= getBufDescIdx(inBufDesc
,IN_ANCILLRY_DATA
);
1616 hAacEncoder
->extPayload
[nExtensions
].dataSize
= inargs
->numAncBytes
* 8;
1617 hAacEncoder
->extPayload
[nExtensions
].pData
= (UCHAR
*)inBufDesc
->bufs
[idx
];
1618 hAacEncoder
->extPayload
[nExtensions
].dataType
= EXT_DATA_ELEMENT
;
1619 hAacEncoder
->extPayload
[nExtensions
].associatedChElement
= -1;
1620 ancDataExtIdx
= nExtensions
; /* store index */
1625 * Encode AAC - Core.
1627 if ( FDKaacEnc_EncodeFrame( hAacEncoder
->hAacEnc
,
1628 hAacEncoder
->hTpEnc
,
1629 hAacEncoder
->inputBuffer
,
1631 hAacEncoder
->extPayload
1634 err
= AACENC_ENCODE_ERROR
;
1638 if (ancDataExtIdx
>= 0) {
1639 outargs
->numAncBytes
= inargs
->numAncBytes
- (hAacEncoder
->extPayload
[ancDataExtIdx
].dataSize
>>3);
1642 /* samples exhausted */
1643 hAacEncoder
->nSamplesRead
-= hAacEncoder
->nSamplesToRead
;
1646 * Delay balancing buffer handling
1648 if (isSbrActive(&hAacEncoder
->aacConfig
)) {
1649 sbrEncoder_UpdateBuffers(hAacEncoder
->hEnvEnc
, hAacEncoder
->inputBuffer
);
1653 * Make bitstream public
1655 if (outBufDesc
->numBufs
>=1) {
1657 INT bsIdx
= getBufDescIdx(outBufDesc
,OUT_BITSTREAM_DATA
);
1658 INT auIdx
= getBufDescIdx(outBufDesc
,OUT_AU_SIZES
);
1660 for (i
=0,nBsBytes
=0; i
<hAacEncoder
->aacConfig
.nSubFrames
; i
++) {
1661 nBsBytes
+= outBytes
[i
];
1664 ((INT
*)outBufDesc
->bufs
[auIdx
])[i
] = outBytes
[i
];
1668 if ( (bsIdx
!=-1) && (outBufDesc
->bufSizes
[bsIdx
]>=nBsBytes
) ) {
1669 FDKmemcpy(outBufDesc
->bufs
[bsIdx
], hAacEncoder
->outBuffer
, sizeof(UCHAR
)*nBsBytes
);
1670 outargs
->numOutBytes
= nBsBytes
;
1673 /* output buffer too small, can't write valid bitstream */
1674 err
= AACENC_ENCODE_ERROR
;
1680 if (err
== AACENC_ENCODE_ERROR
) {
1681 /* All encoder modules have to be initialized */
1682 hAacEncoder
->InitFlags
= AACENC_INIT_ALL
;
1689 AAC_ENCODER_ERROR
aacEncGetConf(HANDLE_AACENCODER hAacEncoder
,
1693 FDK_BITSTREAM tmpConf
;
1698 /* Init bit buffer */
1699 FDKinitBitStream(&tmpConf
, buf
, 64, 0, BS_WRITER
);
1701 /* write conf in tmp buffer */
1702 err
= transportEnc_GetConf(hAacEncoder
->hTpEnc
, &hAacEncoder
->coderConfig
, &tmpConf
, &confType
);
1704 /* copy data to outbuffer: length in bytes */
1705 FDKbyteAlign(&tmpConf
, 0);
1707 /* Check buffer size */
1708 if (FDKgetValidBits(&tmpConf
) > ((*size
)<<3))
1709 return AAC_ENC_UNKNOWN
;
1711 FDKfetchBuffer(&tmpConf
, confBuffer
, size
);
1714 return AAC_ENC_UNKNOWN
;
1720 AACENC_ERROR
aacEncGetLibInfo(LIB_INFO
*info
)
1725 return AACENC_INVALID_HANDLE
;
1728 FDK_toolsGetLibInfo( info
);
1729 transportEnc_GetLibInfo( info
);
1731 sbrEncoder_GetLibInfo( info
);
1733 /* search for next free tab */
1734 for (i
= 0; i
< FDK_MODULE_LAST
; i
++) {
1735 if (info
[i
].module_id
== FDK_NONE
) break;
1737 if (i
== FDK_MODULE_LAST
) {
1738 return AACENC_INIT_ERROR
;
1741 info
[i
].module_id
= FDK_AACENC
;
1742 info
[i
].build_date
= (char*)AACENCODER_LIB_BUILD_DATE
;
1743 info
[i
].build_time
= (char*)AACENCODER_LIB_BUILD_TIME
;
1744 info
[i
].title
= (char*)AACENCODER_LIB_TITLE
;
1745 info
[i
].version
= LIB_VERSION(AACENCODER_LIB_VL0
, AACENCODER_LIB_VL1
, AACENCODER_LIB_VL2
);;
1746 LIB_VERSION_STRING(&info
[i
]);
1748 /* Capability flags */
1750 | CAPF_AAC_1024
| CAPF_AAC_LC
1760 AACENC_ERROR
aacEncoder_SetParam(
1761 const HANDLE_AACENCODER hAacEncoder
,
1762 const AACENC_PARAM param
,
1766 AACENC_ERROR err
= AACENC_OK
;
1767 USER_PARAM
*settings
= &hAacEncoder
->extParam
;
1769 /* check encoder handle */
1770 if (hAacEncoder
== NULL
) {
1771 err
= AACENC_INVALID_HANDLE
;
1775 /* apply param value */
1779 if (settings
->userAOT
!= (AUDIO_OBJECT_TYPE
)value
) {
1780 /* check if AOT matches the allocated modules */
1784 if (!(hAacEncoder
->encoder_modis
& (ENC_MODE_FLAG_PS
))) {
1785 err
= AACENC_INVALID_CONFIG
;
1790 if (!(hAacEncoder
->encoder_modis
& (ENC_MODE_FLAG_SBR
))) {
1791 err
= AACENC_INVALID_CONFIG
;
1795 case AOT_MP2_AAC_LC
:
1797 case AOT_ER_AAC_ELD
:
1798 if (!(hAacEncoder
->encoder_modis
& (ENC_MODE_FLAG_AAC
))) {
1799 err
= AACENC_INVALID_CONFIG
;
1804 err
= AACENC_INVALID_CONFIG
;
1807 settings
->userAOT
= (AUDIO_OBJECT_TYPE
)value
;
1808 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_STATES
| AACENC_INIT_TRANSPORT
;
1811 case AACENC_BITRATE
:
1812 if (settings
->userBitrate
!= value
) {
1813 settings
->userBitrate
= value
;
1814 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_TRANSPORT
;
1817 case AACENC_BITRATEMODE
:
1818 if (settings
->userBitrateMode
!= value
) {
1827 settings
->userBitrateMode
= value
;
1828 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_TRANSPORT
;
1831 err
= AACENC_INVALID_CONFIG
;
1833 } /* switch value */
1836 case AACENC_SAMPLERATE
:
1837 if (settings
->userSamplerate
!= value
) {
1838 if ( !( (value
==8000) || (value
==11025) || (value
==12000) || (value
==16000) || (value
==22050) || (value
==24000) ||
1839 (value
==32000) || (value
==44100) || (value
==48000) || (value
==64000) || (value
==88200) || (value
==96000) ) )
1841 err
= AACENC_INVALID_CONFIG
;
1844 settings
->userSamplerate
= value
;
1845 hAacEncoder
->nSamplesRead
= 0; /* reset internal inputbuffer */
1846 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_STATES
| AACENC_INIT_TRANSPORT
;
1849 case AACENC_CHANNELMODE
:
1850 if (settings
->userChannelMode
!= (CHANNEL_MODE
)value
) {
1851 const CHANNEL_MODE_CONFIG_TAB
* pConfig
= FDKaacEnc_GetChannelModeConfiguration((CHANNEL_MODE
)value
);
1852 if (pConfig
==NULL
) {
1853 err
= AACENC_INVALID_CONFIG
;
1856 if ( (pConfig
->nElements
> hAacEncoder
->nMaxAacElements
)
1857 || (pConfig
->nChannelsEff
> hAacEncoder
->nMaxAacChannels
)
1858 || !(((value
>=1) && (value
<=7))||((value
>=33) && (value
<=34)))
1861 err
= AACENC_INVALID_CONFIG
;
1865 settings
->userChannelMode
= (CHANNEL_MODE
)value
;
1866 settings
->nChannels
= pConfig
->nChannels
;
1867 hAacEncoder
->nSamplesRead
= 0; /* reset internal inputbuffer */
1868 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_TRANSPORT
;
1871 case AACENC_BANDWIDTH
:
1872 if (settings
->userBandwidth
!= value
) {
1873 settings
->userBandwidth
= value
;
1874 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
;
1877 case AACENC_CHANNELORDER
:
1878 if (hAacEncoder
->aacConfig
.channelOrder
!= (CHANNEL_ORDER
)value
) {
1879 if (! ((value
==0) || (value
==1) || (value
==2)) ) {
1880 err
= AACENC_INVALID_CONFIG
;
1883 hAacEncoder
->aacConfig
.channelOrder
= (CHANNEL_ORDER
)value
;
1884 hAacEncoder
->nSamplesRead
= 0; /* reset internal inputbuffer */
1885 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_STATES
| AACENC_INIT_TRANSPORT
;
1888 case AACENC_AFTERBURNER
:
1889 if (settings
->userAfterburner
!= value
) {
1890 if (! ((value
==0) || (value
==1)) ) {
1891 err
= AACENC_INVALID_CONFIG
;
1894 settings
->userAfterburner
= value
;
1895 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
;
1898 case AACENC_GRANULE_LENGTH
:
1899 if (settings
->userFramelength
!= value
) {
1904 settings
->userFramelength
= value
;
1905 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_TRANSPORT
;
1908 err
= AACENC_INVALID_CONFIG
;
1913 case AACENC_SBR_RATIO
:
1914 if (settings
->userSbrRatio
!= value
) {
1915 if (! ((value
==0) || (value
==1) || (value
==2)) ) {
1916 err
= AACENC_INVALID_CONFIG
;
1919 settings
->userSbrRatio
= value
;
1920 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_STATES
| AACENC_INIT_TRANSPORT
;
1923 case AACENC_SBR_MODE
:
1924 if (settings
->userSbrEnabled
!= value
) {
1925 settings
->userSbrEnabled
= value
;
1926 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
| AACENC_INIT_STATES
| AACENC_INIT_TRANSPORT
;
1929 case AACENC_TRANSMUX
:
1930 if (settings
->userTpType
!= (TRANSPORT_TYPE
)value
) {
1932 TRANSPORT_TYPE type
= (TRANSPORT_TYPE
)value
;
1933 UINT flags
= hAacEncoder
->CAPF_tpEnc
;
1935 if ( !( ((type
==TT_MP4_ADIF
) && (flags
&CAPF_ADIF
))
1936 || ((type
==TT_MP4_ADTS
) && (flags
&CAPF_ADTS
))
1937 || ((type
==TT_MP4_LATM_MCP0
) && ((flags
&CAPF_LATM
) && (flags
&CAPF_RAWPACKETS
)))
1938 || ((type
==TT_MP4_LATM_MCP1
) && ((flags
&CAPF_LATM
) && (flags
&CAPF_RAWPACKETS
)))
1939 || ((type
==TT_MP4_LOAS
) && (flags
&CAPF_LOAS
))
1940 || ((type
==TT_MP4_RAW
) && (flags
&CAPF_RAWPACKETS
))
1943 err
= AACENC_INVALID_CONFIG
;
1946 settings
->userTpType
= (TRANSPORT_TYPE
)value
;
1947 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1950 case AACENC_SIGNALING_MODE
:
1951 if (settings
->userTpSignaling
!= value
) {
1952 if ( !((value
==0) || (value
==1) || (value
==2)) ) {
1953 err
= AACENC_INVALID_CONFIG
;
1956 settings
->userTpSignaling
= value
;
1957 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1960 case AACENC_PROTECTION
:
1961 if (settings
->userTpProtection
!= value
) {
1962 if ( !((value
==0) || (value
==1)) ) {
1963 err
= AACENC_INVALID_CONFIG
;
1966 settings
->userTpProtection
= value
;
1967 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1970 case AACENC_HEADER_PERIOD
:
1971 if (settings
->userTpHeaderPeriod
!= value
) {
1972 settings
->userTpHeaderPeriod
= value
;
1973 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1976 case AACENC_TPSUBFRAMES
:
1977 if (settings
->userTpNsubFrames
!= value
) {
1978 if (! ( (value
>=1) && (value
<=4) ) ) {
1979 err
= AACENC_INVALID_CONFIG
;
1982 settings
->userTpNsubFrames
= value
;
1983 hAacEncoder
->InitFlags
|= AACENC_INIT_TRANSPORT
;
1986 case AACENC_ANCILLARY_BITRATE
:
1987 if (settings
->userAncDataRate
!= value
) {
1988 settings
->userAncDataRate
= value
;
1991 case AACENC_CONTROL_STATE
:
1992 if (hAacEncoder
->InitFlags
!= value
) {
1993 if (value
&AACENC_RESET_INBUFFER
) {
1994 hAacEncoder
->nSamplesRead
= 0;
1996 hAacEncoder
->InitFlags
= value
;
1999 case AACENC_METADATA_MODE
:
2000 if ((UINT
)settings
->userMetaDataMode
!= value
) {
2001 if ( !((value
>=0) && (value
<=2)) ) {
2002 err
= AACENC_INVALID_CONFIG
;
2005 settings
->userMetaDataMode
= value
;
2006 hAacEncoder
->InitFlags
|= AACENC_INIT_CONFIG
;
2010 err
= AACENC_UNSUPPORTED_PARAMETER
;
2012 } /* switch(param) */
2018 UINT
aacEncoder_GetParam(
2019 const HANDLE_AACENCODER hAacEncoder
,
2020 const AACENC_PARAM param
2024 USER_PARAM
*settings
= &hAacEncoder
->extParam
;
2026 /* check encoder handle */
2027 if (hAacEncoder
== NULL
) {
2031 /* apply param value */
2035 value
= (UINT
)hAacEncoder
->aacConfig
.audioObjectType
;
2037 case AACENC_BITRATE
:
2038 value
= (UINT
)((hAacEncoder
->aacConfig
.bitrateMode
==AACENC_BR_MODE_CBR
) ? hAacEncoder
->aacConfig
.bitRate
: -1);
2040 case AACENC_BITRATEMODE
:
2041 value
= (UINT
)hAacEncoder
->aacConfig
.bitrateMode
;
2043 case AACENC_SAMPLERATE
:
2044 value
= (UINT
)hAacEncoder
->coderConfig
.extSamplingRate
;
2046 case AACENC_CHANNELMODE
:
2047 value
= (UINT
)hAacEncoder
->aacConfig
.channelMode
;
2049 case AACENC_BANDWIDTH
:
2050 value
= (UINT
)hAacEncoder
->aacConfig
.bandWidth
;
2052 case AACENC_CHANNELORDER
:
2053 value
= (UINT
)hAacEncoder
->aacConfig
.channelOrder
;
2055 case AACENC_AFTERBURNER
:
2056 value
= (UINT
)hAacEncoder
->aacConfig
.useRequant
;
2058 case AACENC_GRANULE_LENGTH
:
2059 value
= (UINT
)hAacEncoder
->aacConfig
.framelength
;
2061 case AACENC_SBR_RATIO
:
2062 value
= isSbrActive(&hAacEncoder
->aacConfig
) ? hAacEncoder
->aacConfig
.sbrRatio
: 0;
2064 case AACENC_SBR_MODE
:
2065 value
= (UINT
) (hAacEncoder
->aacConfig
.syntaxFlags
& AC_SBR_PRESENT
) ? 1 : 0;
2067 case AACENC_TRANSMUX
:
2068 value
= (UINT
)settings
->userTpType
;
2070 case AACENC_SIGNALING_MODE
:
2071 value
= (UINT
)getSbrSignalingMode(hAacEncoder
->aacConfig
.audioObjectType
, settings
->userTpType
, settings
->userTpSignaling
, hAacEncoder
->aacConfig
.sbrRatio
);
2073 case AACENC_PROTECTION
:
2074 value
= (UINT
)settings
->userTpProtection
;
2076 case AACENC_HEADER_PERIOD
:
2077 value
= (UINT
)hAacEncoder
->coderConfig
.headerPeriod
;
2079 case AACENC_TPSUBFRAMES
:
2080 value
= (UINT
)settings
->userTpNsubFrames
;
2082 case AACENC_ANCILLARY_BITRATE
:
2083 value
= (UINT
)hAacEncoder
->aacConfig
.anc_Rate
;
2085 case AACENC_CONTROL_STATE
:
2086 value
= (UINT
)hAacEncoder
->InitFlags
;
2088 case AACENC_METADATA_MODE
:
2089 value
= (hAacEncoder
->metaDataAllowed
==0) ? 0 : (UINT
)settings
->userMetaDataMode
;
2092 //err = MPS_INVALID_PARAMETER;
2094 } /* switch(param) */
2100 AACENC_ERROR
aacEncInfo(
2101 const HANDLE_AACENCODER hAacEncoder
,
2102 AACENC_InfoStruct
*pInfo
2105 AACENC_ERROR err
= AACENC_OK
;
2107 FDKmemclear(pInfo
, sizeof(AACENC_InfoStruct
));
2108 pInfo
->confSize
= 64; /* pre-initialize */
2110 pInfo
->maxOutBufBytes
= ((hAacEncoder
->nMaxAacChannels
*6144)+7)>>3;
2111 pInfo
->maxAncBytes
= hAacEncoder
->aacConfig
.maxAncBytesPerAU
;
2112 pInfo
->inBufFillLevel
= hAacEncoder
->nSamplesRead
/hAacEncoder
->extParam
.nChannels
;
2113 pInfo
->inputChannels
= hAacEncoder
->extParam
.nChannels
;
2114 pInfo
->frameLength
= hAacEncoder
->nSamplesToRead
/hAacEncoder
->extParam
.nChannels
;
2115 pInfo
->encoderDelay
= hAacEncoder
->nDelay
/hAacEncoder
->extParam
.nChannels
;
2117 /* Get encoder configuration */
2118 if ( aacEncGetConf(hAacEncoder
, &pInfo
->confSize
, &pInfo
->confBuf
[0]) != AAC_ENC_OK
) {
2119 err
= AACENC_INIT_ERROR
;