| /* ----------------------------------------------------------------------------- |
| 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 |
| ----------------------------------------------------------------------------- */ |
| |
| /**************************** AAC encoder library ****************************** |
| |
| Author(s): Markus Lohwasser |
| |
| Description: Mpeg Surround library interface functions |
| |
| *******************************************************************************/ |
| |
| /* Includes ******************************************************************/ |
| #include "mps_main.h" |
| #include "sacenc_lib.h" |
| |
| /* Data Types ****************************************************************/ |
| struct MPS_ENCODER { |
| HANDLE_MP4SPACE_ENCODER hSacEncoder; |
| |
| AUDIO_OBJECT_TYPE audioObjectType; |
| |
| FDK_bufDescr inBufDesc; |
| FDK_bufDescr outBufDesc; |
| SACENC_InArgs inargs; |
| SACENC_OutArgs outargs; |
| |
| void *pInBuffer[1]; |
| UINT pInBufferSize[1]; |
| UINT pInBufferElSize[1]; |
| UINT pInBufferType[1]; |
| |
| void *pOutBuffer[2]; |
| UINT pOutBufferSize[2]; |
| UINT pOutBufferElSize[2]; |
| UINT pOutBufferType[2]; |
| |
| UCHAR sacOutBuffer[1024]; /* Worst case memory consumption for ELDv2: 768 |
| bytes => 6144 bits (Core + SBR + MPS) */ |
| }; |
| |
| struct MPS_CONFIG_TAB { |
| AUDIO_OBJECT_TYPE audio_object_type; |
| CHANNEL_MODE channel_mode; |
| ULONG sbr_ratio; |
| ULONG sampling_rate; |
| ULONG bitrate_min; |
| ULONG bitrate_max; |
| }; |
| |
| /* Constants *****************************************************************/ |
| static const MPS_CONFIG_TAB mpsConfigTab[] = { |
| {AOT_ER_AAC_ELD, MODE_212, 0, 16000, 16000, 39999}, |
| {AOT_ER_AAC_ELD, MODE_212, 0, 22050, 16000, 49999}, |
| {AOT_ER_AAC_ELD, MODE_212, 0, 24000, 16000, 61999}, |
| {AOT_ER_AAC_ELD, MODE_212, 0, 32000, 20000, 84999}, |
| {AOT_ER_AAC_ELD, MODE_212, 0, 44100, 50000, 192000}, |
| {AOT_ER_AAC_ELD, MODE_212, 0, 48000, 62000, 192000}, |
| |
| {AOT_ER_AAC_ELD, MODE_212, 1, 16000, 18000, 31999}, |
| {AOT_ER_AAC_ELD, MODE_212, 1, 22050, 18000, 31999}, |
| {AOT_ER_AAC_ELD, MODE_212, 1, 24000, 20000, 64000}, |
| |
| {AOT_ER_AAC_ELD, MODE_212, 2, 32000, 18000, 64000}, |
| {AOT_ER_AAC_ELD, MODE_212, 2, 44100, 21000, 64000}, |
| {AOT_ER_AAC_ELD, MODE_212, 2, 48000, 26000, 64000} |
| |
| }; |
| |
| /* Function / Class Declarations *********************************************/ |
| |
| /* Function / Class Definition ***********************************************/ |
| static INT FDK_MpegsEnc_WriteFrameHeader(HANDLE_MPS_ENCODER hMpsEnc, |
| UCHAR *const pOutputBuffer, |
| const int outputBufferSize); |
| |
| MPS_ENCODER_ERROR FDK_MpegsEnc_Open(HANDLE_MPS_ENCODER *phMpsEnc) { |
| MPS_ENCODER_ERROR error = MPS_ENCODER_OK; |
| HANDLE_MPS_ENCODER hMpsEnc = NULL; |
| |
| if (phMpsEnc == NULL) { |
| error = MPS_ENCODER_INVALID_HANDLE; |
| goto bail; |
| } |
| |
| if (NULL == |
| (hMpsEnc = (HANDLE_MPS_ENCODER)FDKcalloc(1, sizeof(MPS_ENCODER)))) { |
| error = MPS_ENCODER_MEMORY_ERROR; |
| goto bail; |
| } |
| FDKmemclear(hMpsEnc, sizeof(MPS_ENCODER)); |
| |
| if (SACENC_OK != FDK_sacenc_open(&hMpsEnc->hSacEncoder)) { |
| error = MPS_ENCODER_MEMORY_ERROR; |
| goto bail; |
| } |
| |
| /* Return mps encoder instance */ |
| *phMpsEnc = hMpsEnc; |
| |
| bail: |
| if (error != MPS_ENCODER_OK) { |
| FDK_MpegsEnc_Close(&hMpsEnc); |
| } |
| return error; |
| } |
| |
| MPS_ENCODER_ERROR FDK_MpegsEnc_Close(HANDLE_MPS_ENCODER *phMpsEnc) { |
| MPS_ENCODER_ERROR error = MPS_ENCODER_OK; |
| |
| if (phMpsEnc == NULL) { |
| error = MPS_ENCODER_INVALID_HANDLE; |
| goto bail; |
| } |
| |
| if (*phMpsEnc != NULL) { |
| FDK_sacenc_close(&(*phMpsEnc)->hSacEncoder); |
| FDKfree(*phMpsEnc); |
| *phMpsEnc = NULL; |
| } |
| bail: |
| return error; |
| } |
| |
| MPS_ENCODER_ERROR FDK_MpegsEnc_Init(HANDLE_MPS_ENCODER hMpsEnc, |
| const AUDIO_OBJECT_TYPE audioObjectType, |
| const UINT samplingrate, const UINT bitrate, |
| const UINT sbrRatio, const UINT framelength, |
| const UINT inputBufferSizePerChannel, |
| const UINT coreCoderDelay) { |
| MPS_ENCODER_ERROR error = MPS_ENCODER_OK; |
| const UINT fs_low = 27713; /* low MPS sampling frequencies */ |
| const UINT fs_high = 55426; /* high MPS sampling frequencies */ |
| UINT nTimeSlots = 0, nQmfBandsLd = 0; |
| |
| if (hMpsEnc == NULL) { |
| error = MPS_ENCODER_INVALID_HANDLE; |
| goto bail; |
| } |
| |
| /* Combine MPS with SBR only if the number of QMF band fits together.*/ |
| switch (sbrRatio) { |
| case 1: /* downsampled sbr - 32 QMF bands required */ |
| if (!(samplingrate < fs_low)) { |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| break; |
| case 2: /* dualrate - 64 QMF bands required */ |
| if (!((samplingrate >= fs_low) && (samplingrate < fs_high))) { |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| break; |
| case 0: |
| default:; /* time interface - no samplingrate restriction */ |
| } |
| |
| /* 32 QMF-Bands ( fs < 27713 ) |
| * 64 QMF-Bands ( 27713 >= fs <= 55426 ) |
| * 128 QMF-Bands ( fs > 55426 ) |
| */ |
| nQmfBandsLd = |
| (samplingrate < fs_low) ? 5 : ((samplingrate > fs_high) ? 7 : 6); |
| nTimeSlots = framelength >> nQmfBandsLd; |
| |
| /* check if number of qmf bands is usable for given framelength */ |
| if (framelength != (nTimeSlots << nQmfBandsLd)) { |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| |
| /* is given bitrate intended to be supported */ |
| if ((INT)bitrate != FDK_MpegsEnc_GetClosestBitRate(audioObjectType, MODE_212, |
| samplingrate, sbrRatio, |
| bitrate)) { |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| |
| /* init SAC library */ |
| switch (audioObjectType) { |
| case AOT_ER_AAC_ELD: { |
| const UINT noInterFrameCoding = 0; |
| |
| if ((SACENC_OK != |
| FDK_sacenc_setParam(hMpsEnc->hSacEncoder, SACENC_LOWDELAY, |
| (noInterFrameCoding == 1) ? 1 : 2)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_ENC_MODE, SACENC_212)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_SAMPLERATE, samplingrate)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_FRAME_TIME_SLOTS, |
| nTimeSlots)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_PARAM_BANDS, |
| SACENC_BANDS_15)) || |
| (SACENC_OK != |
| FDK_sacenc_setParam(hMpsEnc->hSacEncoder, SACENC_TIME_DOM_DMX, 2)) || |
| (SACENC_OK != |
| FDK_sacenc_setParam(hMpsEnc->hSacEncoder, SACENC_COARSE_QUANT, 0)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_QUANT_MODE, |
| SACENC_QUANTMODE_FINE)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_TIME_ALIGNMENT, 0)) || |
| (SACENC_OK != FDK_sacenc_setParam(hMpsEnc->hSacEncoder, |
| SACENC_INDEPENDENCY_FACTOR, 20))) { |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| break; |
| } |
| default: |
| error = MPS_ENCODER_INIT_ERROR; |
| goto bail; |
| } |
| |
| if (SACENC_OK != FDK_sacenc_init(hMpsEnc->hSacEncoder, coreCoderDelay)) { |
| error = MPS_ENCODER_INIT_ERROR; |
| } |
| |
| hMpsEnc->audioObjectType = audioObjectType; |
| |
| hMpsEnc->inBufDesc.ppBase = (void **)&hMpsEnc->pInBuffer; |
| hMpsEnc->inBufDesc.pBufSize = hMpsEnc->pInBufferSize; |
| hMpsEnc->inBufDesc.pEleSize = hMpsEnc->pInBufferElSize; |
| hMpsEnc->inBufDesc.pBufType = hMpsEnc->pInBufferType; |
| hMpsEnc->inBufDesc.numBufs = 1; |
| |
| hMpsEnc->outBufDesc.ppBase = (void **)&hMpsEnc->pOutBuffer; |
| hMpsEnc->outBufDesc.pBufSize = hMpsEnc->pOutBufferSize; |
| hMpsEnc->outBufDesc.pEleSize = hMpsEnc->pOutBufferElSize; |
| hMpsEnc->outBufDesc.pBufType = hMpsEnc->pOutBufferType; |
| hMpsEnc->outBufDesc.numBufs = 2; |
| |
| hMpsEnc->pInBuffer[0] = NULL; |
| hMpsEnc->pInBufferSize[0] = 0; |
| hMpsEnc->pInBufferElSize[0] = sizeof(INT_PCM); |
| hMpsEnc->pInBufferType[0] = (FDK_BUF_TYPE_INPUT | FDK_BUF_TYPE_PCM_DATA); |
| |
| hMpsEnc->pOutBuffer[0] = NULL; |
| hMpsEnc->pOutBufferSize[0] = 0; |
| hMpsEnc->pOutBufferElSize[0] = sizeof(INT_PCM); |
| hMpsEnc->pOutBufferType[0] = (FDK_BUF_TYPE_OUTPUT | FDK_BUF_TYPE_PCM_DATA); |
| |
| hMpsEnc->pOutBuffer[1] = NULL; |
| hMpsEnc->pOutBufferSize[1] = 0; |
| hMpsEnc->pOutBufferElSize[1] = sizeof(UCHAR); |
| hMpsEnc->pOutBufferType[1] = (FDK_BUF_TYPE_OUTPUT | FDK_BUF_TYPE_BS_DATA); |
| |
| hMpsEnc->inargs.isInputInterleaved = 0; |
| hMpsEnc->inargs.inputBufferSizePerChannel = inputBufferSizePerChannel; |
| |
| bail: |
| return error; |
| } |
| |
| MPS_ENCODER_ERROR FDK_MpegsEnc_Process(HANDLE_MPS_ENCODER hMpsEnc, |
| INT_PCM *const pAudioSamples, |
| const INT nAudioSamples, |
| AACENC_EXT_PAYLOAD *pMpsExtPayload) { |
| MPS_ENCODER_ERROR error = MPS_ENCODER_OK; |
| |
| if (hMpsEnc == NULL) { |
| error = MPS_ENCODER_INVALID_HANDLE; |
| } else { |
| int sacHeaderFlag = 1; |
| int sacOutBufferOffset = 0; |
| |
| /* In case of eld the ssc is explicit and doesn't need to be inband */ |
| if (hMpsEnc->audioObjectType == AOT_ER_AAC_ELD) { |
| sacHeaderFlag = 0; |
| } |
| |
| /* 4 bits nibble after extension type */ |
| hMpsEnc->sacOutBuffer[0] = (sacHeaderFlag == 0) ? 0x3 : 0x7; |
| sacOutBufferOffset += 1; |
| |
| if (sacHeaderFlag) { |
| sacOutBufferOffset += FDK_MpegsEnc_WriteFrameHeader( |
| hMpsEnc, &hMpsEnc->sacOutBuffer[sacOutBufferOffset], |
| sizeof(hMpsEnc->sacOutBuffer) - sacOutBufferOffset); |
| } |
| |
| /* Register input and output buffer. */ |
| hMpsEnc->pInBuffer[0] = (void *)pAudioSamples; |
| hMpsEnc->inargs.nInputSamples = nAudioSamples; |
| |
| hMpsEnc->pOutBuffer[0] = (void *)pAudioSamples; |
| hMpsEnc->pOutBufferSize[0] = sizeof(INT_PCM) * nAudioSamples / 2; |
| |
| hMpsEnc->pOutBuffer[1] = (void *)&hMpsEnc->sacOutBuffer[sacOutBufferOffset]; |
| hMpsEnc->pOutBufferSize[1] = |
| sizeof(hMpsEnc->sacOutBuffer) - sacOutBufferOffset; |
| |
| /* encode SAC frame */ |
| if (SACENC_OK != FDK_sacenc_encode(hMpsEnc->hSacEncoder, |
| &hMpsEnc->inBufDesc, |
| &hMpsEnc->outBufDesc, &hMpsEnc->inargs, |
| &hMpsEnc->outargs)) { |
| error = MPS_ENCODER_ENCODE_ERROR; |
| goto bail; |
| } |
| |
| /* export MPS payload */ |
| pMpsExtPayload->pData = (UCHAR *)hMpsEnc->sacOutBuffer; |
| pMpsExtPayload->dataSize = |
| hMpsEnc->outargs.nOutputBits + 8 * (sacOutBufferOffset - 1); |
| pMpsExtPayload->dataType = EXT_LDSAC_DATA; |
| pMpsExtPayload->associatedChElement = -1; |
| } |
| |
| bail: |
| return error; |
| } |
| |
| INT FDK_MpegsEnc_WriteSpatialSpecificConfig(HANDLE_MPS_ENCODER hMpsEnc, |
| HANDLE_FDK_BITSTREAM hBs) { |
| INT sscBits = 0; |
| |
| if (NULL != hMpsEnc) { |
| MP4SPACEENC_INFO mp4SpaceEncoderInfo; |
| FDK_sacenc_getInfo(hMpsEnc->hSacEncoder, &mp4SpaceEncoderInfo); |
| |
| if (hBs != NULL) { |
| int i; |
| int writtenBits = 0; |
| for (i = 0; i<mp4SpaceEncoderInfo.pSscBuf->nSscSizeBits>> 3; i++) { |
| FDKwriteBits(hBs, mp4SpaceEncoderInfo.pSscBuf->pSsc[i], 8); |
| writtenBits += 8; |
| } |
| FDKwriteBits(hBs, mp4SpaceEncoderInfo.pSscBuf->pSsc[i], |
| mp4SpaceEncoderInfo.pSscBuf->nSscSizeBits - writtenBits); |
| } /* hBS */ |
| |
| sscBits = mp4SpaceEncoderInfo.pSscBuf->nSscSizeBits; |
| |
| } /* valid hMpsEnc */ |
| |
| return sscBits; |
| } |
| |
| static INT FDK_MpegsEnc_WriteFrameHeader(HANDLE_MPS_ENCODER hMpsEnc, |
| UCHAR *const pOutputBuffer, |
| const int outputBufferSize) { |
| const int sacTimeAlignFlag = 0; |
| |
| /* Initialize variables */ |
| int numBits = 0; |
| |
| if ((NULL != hMpsEnc) && (NULL != pOutputBuffer)) { |
| UINT alignAnchor, cnt; |
| FDK_BITSTREAM Bs; |
| FDKinitBitStream(&Bs, pOutputBuffer, outputBufferSize, 0, BS_WRITER); |
| |
| /* Calculate SSC length information */ |
| cnt = (FDK_MpegsEnc_WriteSpatialSpecificConfig(hMpsEnc, NULL) + 7) >> 3; |
| |
| /* Write SSC */ |
| FDKwriteBits(&Bs, sacTimeAlignFlag, 1); |
| |
| if (cnt < 127) { |
| FDKwriteBits(&Bs, cnt, 7); |
| } else { |
| FDKwriteBits(&Bs, 127, 7); |
| FDKwriteBits(&Bs, cnt - 127, 16); |
| } |
| |
| alignAnchor = FDKgetValidBits(&Bs); |
| FDK_MpegsEnc_WriteSpatialSpecificConfig(hMpsEnc, &Bs); |
| FDKbyteAlign(&Bs, alignAnchor); /* bsFillBits */ |
| |
| if (sacTimeAlignFlag) { |
| FDK_ASSERT(1); /* time alignment not supported */ |
| } |
| |
| numBits = FDKgetValidBits(&Bs); |
| } /* valid handle */ |
| |
| return ((numBits + 7) >> 3); |
| } |
| |
| INT FDK_MpegsEnc_GetClosestBitRate(const AUDIO_OBJECT_TYPE audioObjectType, |
| const CHANNEL_MODE channelMode, |
| const UINT samplingrate, const UINT sbrRatio, |
| const UINT bitrate) { |
| unsigned int i; |
| int targetBitrate = -1; |
| |
| for (i = 0; i < sizeof(mpsConfigTab) / sizeof(MPS_CONFIG_TAB); i++) { |
| if ((mpsConfigTab[i].audio_object_type == audioObjectType) && |
| (mpsConfigTab[i].channel_mode == channelMode) && |
| (mpsConfigTab[i].sbr_ratio == sbrRatio) && |
| (mpsConfigTab[i].sampling_rate == samplingrate)) { |
| targetBitrate = fMin(fMax(bitrate, mpsConfigTab[i].bitrate_min), |
| mpsConfigTab[i].bitrate_max); |
| } |
| } |
| |
| return targetBitrate; |
| } |
| |
| INT FDK_MpegsEnc_GetDelay(HANDLE_MPS_ENCODER hMpsEnc) { |
| INT delay = 0; |
| |
| if (NULL != hMpsEnc) { |
| MP4SPACEENC_INFO mp4SpaceEncoderInfo; |
| FDK_sacenc_getInfo(hMpsEnc->hSacEncoder, &mp4SpaceEncoderInfo); |
| delay = mp4SpaceEncoderInfo.nCodecDelay; |
| } |
| |
| return delay; |
| } |
| |
| INT FDK_MpegsEnc_GetDecDelay(HANDLE_MPS_ENCODER hMpsEnc) { |
| INT delay = 0; |
| |
| if (NULL != hMpsEnc) { |
| MP4SPACEENC_INFO mp4SpaceEncoderInfo; |
| FDK_sacenc_getInfo(hMpsEnc->hSacEncoder, &mp4SpaceEncoderInfo); |
| delay = mp4SpaceEncoderInfo.nDecoderDelay; |
| } |
| |
| return delay; |
| } |
| |
| MPS_ENCODER_ERROR FDK_MpegsEnc_GetLibInfo(LIB_INFO *info) { |
| MPS_ENCODER_ERROR error = MPS_ENCODER_OK; |
| |
| if (NULL == info) { |
| error = MPS_ENCODER_INVALID_HANDLE; |
| } else if (SACENC_OK != FDK_sacenc_getLibInfo(info)) { |
| error = MPS_ENCODER_INIT_ERROR; |
| } |
| |
| return error; |
| } |
