| |
| /* ----------------------------------------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2013 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 |
| ----------------------------------------------------------------------------------------------------------- */ |
| |
| /**************************** FDK PCM utils module ************************** |
| |
| Author(s): Christian Griebel |
| Description: Defines functions that perform downmixing or a simple channel |
| expansion in the PCM time domain. |
| |
| *******************************************************************************/ |
| #include <log/log.h> |
| #include "pcmutils_lib.h" |
| |
| #include "genericStds.h" |
| #include "fixpoint_math.h" |
| #include "FDK_core.h" |
| |
| |
| /* ------------------------ * |
| * GLOBAL SETTINGS (GFR): * |
| * ------------------------ */ |
| #define DSE_METADATA_ENABLE /*!< Enable this to support MPEG/ETSI DVB ancillary data for |
| encoder assisted downmixing of MPEG-4 AAC and |
| MPEG-1/2 layer 2 streams. */ |
| #define PCE_METADATA_ENABLE /*!< Enable this to support MPEG matrix mixdown with a |
| coefficient carried in the PCE. */ |
| |
| #define PCM_DMX_MAX_IN_CHANNELS ( 8 ) /* Neither the maximum number of input nor the maximum number of output channels ... */ |
| #define PCM_DMX_MAX_OUT_CHANNELS ( 8 ) /* ... must exceed the maximum number of channels that the framework can handle. */ |
| |
| /* ------------------------ * |
| * SPECIFIC SETTINGS: * |
| * ------------------------ */ |
| #define PCM_CHANNEL_EXTENSION_ENABLE /*!< Allow module to duplicate mono signals or add zero channels to achieve the |
| desired number of output channels. */ |
| |
| #define PCM_DMX_DFLT_MAX_OUT_CHANNELS ( 6 ) /*!< The maximum number of output channels. If the value is greater than 0 the module |
| will automatically create a mixdown for all input signals with more channels |
| than specified. */ |
| #define PCM_DMX_DFLT_MIN_OUT_CHANNELS ( 0 ) /*!< The minimum number of output channels. If the value is greater than 0 the module |
| will do channel extension automatically for all input signals with less channels |
| than specified. */ |
| #define PCM_DMX_MAX_DELAY_FRAMES ( 1 ) /*!< The maximum delay frames to align the bitstreams payload with the PCM output. */ |
| #define PCM_DMX_DFLT_EXPIRY_FRAME ( 50 ) /*!< If value is greater than 0 the mixdown coefficients will expire by default after the |
| given number of frames. The value 50 corresponds to at least 500ms (FL 960 @ 96kHz) */ |
| /* #define PCMDMX_DEBUG */ |
| |
| /* Derived setting: |
| * No need to edit beyond this line. */ |
| #if defined(DSE_METADATA_ENABLE) || defined(PCE_METADATA_ENABLE) || defined(ARIB_MIXDOWN_ENABLE) |
| #define PCM_DOWNMIX_ENABLE /*!< Generally enable down mixing. */ |
| #endif |
| #if (PCM_DMX_MAX_IN_CHANNELS > 2) || (PCM_DMX_MAX_OUT_CHANNELS > 2) |
| #define PCM_DMX_MAX_CHANNELS ( 8 ) |
| #define PCM_DMX_MAX_CHANNEL_GROUPS ( 4 ) |
| #define PCM_DMX_MAX_CHANNELS_PER_GROUP PCM_DMX_MAX_CHANNELS /* All channels can be in one group */ |
| #else |
| #define PCM_DMX_MAX_CHANNELS ( 3 ) /* Need to add 1 because there are three channel positions in first channel group. */ |
| #define PCM_DMX_MAX_CHANNEL_GROUPS ( 1 ) /* Only front channels supported. */ |
| #define PCM_DMX_MAX_CHANNELS_PER_GROUP ( 2 ) /* The maximum over all channel groups */ |
| #endif |
| #if (PCM_DMX_MAX_IN_CHANNELS > PCM_DMX_MAX_OUT_CHANNELS) |
| #define PCM_DMX_MAX_IO_CHANNELS PCM_DMX_MAX_IN_CHANNELS |
| #else |
| #define PCM_DMX_MAX_IO_CHANNELS PCM_DMX_MAX_OUT_CHANNELS |
| #endif |
| |
| /* Decoder library info */ |
| #define PCMDMX_LIB_VL0 2 |
| #define PCMDMX_LIB_VL1 4 |
| #define PCMDMX_LIB_VL2 2 |
| #define PCMDMX_LIB_TITLE "PCM Downmix Lib" |
| #ifdef __ANDROID__ |
| #define PCMDMX_LIB_BUILD_DATE "" |
| #define PCMDMX_LIB_BUILD_TIME "" |
| #else |
| #define PCMDMX_LIB_BUILD_DATE __DATE__ |
| #define PCMDMX_LIB_BUILD_TIME __TIME__ |
| #endif |
| |
| |
| /* Fixed and unique channel group indices. |
| * The last group index has to be smaller than PCM_DMX_MAX_CHANNEL_GROUPS. */ |
| #define CH_GROUP_FRONT ( 0 ) |
| #define CH_GROUP_SIDE ( 1 ) |
| #define CH_GROUP_REAR ( 2 ) |
| #define CH_GROUP_LFE ( 3 ) |
| |
| /* The ordering of the following fixed channel labels has to be in MPEG-4 style. |
| * From the center to the back with left and right channel interleaved (starting with left). |
| * The last channel label index has to be smaller than PCM_DMX_MAX_CHANNELS. */ |
| #define CENTER_FRONT_CHANNEL ( 0 ) /* C */ |
| #define LEFT_FRONT_CHANNEL ( 1 ) /* L */ |
| #define RIGHT_FRONT_CHANNEL ( 2 ) /* R */ |
| #define LEFT_REAR_CHANNEL ( 3 ) /* Lr (aka left back channel) or center back channel */ |
| #define RIGHT_REAR_CHANNEL ( 4 ) /* Rr (aka right back channel) */ |
| #define LOW_FREQUENCY_CHANNEL ( 5 ) /* Lf */ |
| #define LEFT_MULTIPRPS_CHANNEL ( 6 ) /* Left multipurpose channel */ |
| #define RIGHT_MULTIPRPS_CHANNEL ( 7 ) /* Right multipurpose channel */ |
| |
| /* More constants */ |
| #define ONE_CHANNEL ( 1 ) |
| #define TWO_CHANNEL ( 2 ) |
| #define SIX_CHANNEL ( 6 ) |
| #define EIGHT_CHANNEL ( 8 ) |
| |
| #define PCMDMX_A_IDX_DEFAULT ( 2 ) |
| #define PCMDMX_B_IDX_DEFAULT ( 2 ) |
| #define PCMDMX_LFE_IDX_DEFAULT ( 15 ) |
| #define PCMDMX_GAIN_5_DEFAULT ( 0 ) |
| #define PCMDMX_GAIN_2_DEFAULT ( 0 ) |
| |
| #define PCMDMX_MAX_HEADROOM ( 3 ) /* Defines the maximum PCM scaling headroom that can be done by a |
| postprocessing step. This value must be greater or equal to 0. */ |
| |
| #define FALSE 0 |
| #define TRUE 1 |
| #define IN 0 |
| #define OUT 1 |
| |
| /* Type definitions: */ |
| #ifndef DMX_HIGH_PRECISION_ENABLE |
| #define FIXP_DMX FIXP_SGL |
| #define FX_DMX2FX_DBL(x) FX_SGL2FX_DBL((FIXP_SGL)(x)) |
| #define FX_DBL2FX_DMX(x) FX_DBL2FX_SGL(x) |
| #define FL2FXCONST_DMX(x) FL2FXCONST_SGL(x) |
| #define MAXVAL_DMX MAXVAL_SGL |
| #define FX_DMX2SHRT(x) ((SHORT)(x)) |
| #define FX_DMX2FL(x) FX_DBL2FL(FX_DMX2FX_DBL(x)) |
| #else |
| #define FIXP_DMX FIXP_DBL |
| #define FX_DMX2FX_DBL(x) ((FIXP_DBL)(x)) |
| #define FX_DBL2FX_DMX(x) ((FIXP_DBL)(x) |
| #define FL2FXCONST_DMX(x) FL2FXCONST_DBL(x) |
| #define MAXVAL_DMX MAXVAL_DBL |
| #define FX_DMX2SHRT(x) ((SHORT)((x)>>FRACT_BITS)) |
| #define FX_DMX2FL(x) FX_DBL2FL(x) |
| #endif |
| |
| /* The number of channels positions for each group in the internal representation. |
| * See the channel labels above. */ |
| static const UCHAR maxChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS] = { |
| #if (PCM_DMX_MAX_CHANNELS > 3) |
| 3, 0, 2, 1 |
| #else |
| PCM_DMX_MAX_CHANNELS_PER_GROUP |
| #endif |
| }; |
| |
| /* List of packed channel modes */ |
| typedef enum |
| { /* CH_MODE_<numFrontCh>_<numSideCh>_<numBackCh>_<numLfCh> */ |
| CH_MODE_UNDEFINED = 0x0000, |
| /* 1 channel */ |
| CH_MODE_1_0_0_0 = 0x0001, /* chCfg 1 */ |
| /* 2 channels */ |
| CH_MODE_2_0_0_0 = 0x0002, /* chCfg 2 */ |
| /* 3 channels */ |
| CH_MODE_3_0_0_0 = 0x0003, /* chCfg 3 */ |
| CH_MODE_2_0_1_0 = 0x0102, |
| CH_MODE_2_0_0_1 = 0x1002, |
| /* 4 channels */ |
| CH_MODE_3_0_1_0 = 0x0103, /* chCfg 4 */ |
| CH_MODE_2_0_2_0 = 0x0202, |
| CH_MODE_2_0_1_1 = 0x1102, |
| CH_MODE_4_0_0_0 = 0x0004, |
| /* 5 channels */ |
| CH_MODE_3_0_2_0 = 0x0203, /* chCfg 5 */ |
| CH_MODE_2_0_2_1 = 0x1202, |
| CH_MODE_3_0_1_1 = 0x1103, |
| CH_MODE_3_2_0_0 = 0x0023, |
| CH_MODE_5_0_0_0 = 0x0005, |
| /* 6 channels */ |
| CH_MODE_3_0_2_1 = 0x1203, /* chCfg 6 */ |
| CH_MODE_3_2_0_1 = 0x1023, |
| CH_MODE_3_2_1_0 = 0x0123, |
| CH_MODE_5_0_1_0 = 0x0105, |
| CH_MODE_6_0_0_0 = 0x0006, |
| /* 7 channels */ |
| CH_MODE_2_2_2_1 = 0x1222, |
| CH_MODE_3_0_3_1 = 0x1303, /* chCfg 11 */ |
| CH_MODE_3_2_1_1 = 0x1123, |
| CH_MODE_3_2_2_0 = 0x0223, |
| CH_MODE_3_0_2_2 = 0x2203, |
| CH_MODE_5_0_2_0 = 0x0205, |
| CH_MODE_5_0_1_1 = 0x1105, |
| CH_MODE_7_0_0_0 = 0x0007, |
| /* 8 channels */ |
| CH_MODE_3_2_2_1 = 0x1223, |
| CH_MODE_3_0_4_1 = 0x1403, /* chCfg 12 */ |
| CH_MODE_5_0_2_1 = 0x1205, /* chCfg 7 + 14 */ |
| CH_MODE_5_2_1_0 = 0x0125, |
| CH_MODE_3_2_1_2 = 0x2123, |
| CH_MODE_2_2_2_2 = 0x2222, |
| CH_MODE_3_0_3_2 = 0x2303, |
| CH_MODE_8_0_0_0 = 0x0008 |
| |
| } PCM_DMX_CHANNEL_MODE; |
| |
| |
| /* These are the channel configurations linked to |
| the number of output channels give by the user: */ |
| static const PCM_DMX_CHANNEL_MODE outChModeTable[PCM_DMX_MAX_CHANNELS+1] = |
| { |
| CH_MODE_UNDEFINED, |
| CH_MODE_1_0_0_0, /* 1 channel */ |
| CH_MODE_2_0_0_0, /* 2 channels */ |
| CH_MODE_3_0_0_0 /* 3 channels */ |
| #if (PCM_DMX_MAX_CHANNELS > 3) |
| ,CH_MODE_3_0_1_0, /* 4 channels */ |
| CH_MODE_3_0_2_0, /* 5 channels */ |
| CH_MODE_3_0_2_1, /* 6 channels */ |
| CH_MODE_3_0_3_1, /* 7 channels */ |
| CH_MODE_3_0_4_1 /* 8 channels */ |
| #endif |
| }; |
| |
| static const FIXP_DMX abMixLvlValueTab[8] = |
| { |
| FL2FXCONST_DMX(0.500f), /* scaled by 1 */ |
| FL2FXCONST_DMX(0.841f), |
| FL2FXCONST_DMX(0.707f), |
| FL2FXCONST_DMX(0.596f), |
| FL2FXCONST_DMX(0.500f), |
| FL2FXCONST_DMX(0.422f), |
| FL2FXCONST_DMX(0.355f), |
| FL2FXCONST_DMX(0.0f) |
| }; |
| |
| static const FIXP_DMX lfeMixLvlValueTab[16] = |
| { /* value, scale */ |
| FL2FXCONST_DMX(0.7905f), /* 2 */ |
| FL2FXCONST_DMX(0.5000f), /* 2 */ |
| FL2FXCONST_DMX(0.8395f), /* 1 */ |
| FL2FXCONST_DMX(0.7065f), /* 1 */ |
| FL2FXCONST_DMX(0.5945f), /* 1 */ |
| FL2FXCONST_DMX(0.500f), /* 1 */ |
| FL2FXCONST_DMX(0.841f), /* 0 */ |
| FL2FXCONST_DMX(0.707f), /* 0 */ |
| FL2FXCONST_DMX(0.596f), /* 0 */ |
| FL2FXCONST_DMX(0.500f), /* 0 */ |
| FL2FXCONST_DMX(0.316f), /* 0 */ |
| FL2FXCONST_DMX(0.178f), /* 0 */ |
| FL2FXCONST_DMX(0.100f), /* 0 */ |
| FL2FXCONST_DMX(0.032f), /* 0 */ |
| FL2FXCONST_DMX(0.010f), /* 0 */ |
| FL2FXCONST_DMX(0.000f) /* 0 */ |
| }; |
| |
| |
| |
| #ifdef PCE_METADATA_ENABLE |
| /* MPEG matrix mixdown: |
| Set 1: L' = (1 + 2^-0.5 + A )^-1 * [L + C * 2^-0.5 + A * Ls]; |
| R' = (1 + 2^-0.5 + A )^-1 * [R + C * 2^-0.5 + A * Rs]; |
| |
| Set 2: L' = (1 + 2^-0.5 + 2A )^-1 * [L + C * 2^-0.5 - A * (Ls + Rs)]; |
| R' = (1 + 2^-0.5 + 2A )^-1 * [R + C * 2^-0.5 + A * (Ls + Rs)]; |
| |
| M = (3 + 2A)^-1 * [L + C + R + A*(Ls + Rs)]; |
| */ |
| static const FIXP_DMX mpegMixDownIdx2Coef[4] = |
| { |
| FL2FXCONST_DMX(0.70710678f), |
| FL2FXCONST_DMX(0.5f), |
| FL2FXCONST_DMX(0.35355339f), |
| FL2FXCONST_DMX(0.0f) |
| }; |
| |
| static const FIXP_SGL mpegMixDownIdx2PreFact[3][4] = |
| { { /* Set 1: */ |
| FL2FXCONST_DMX(0.4142135623730950f), |
| FL2FXCONST_DMX(0.4530818393219728f), |
| FL2FXCONST_DMX(0.4852813742385703f), |
| FL2FXCONST_DMX(0.5857864376269050f) |
| },{ /* Set 2: */ |
| FL2FXCONST_DMX(0.3203772410170407f), |
| FL2FXCONST_DMX(0.3693980625181293f), |
| FL2FXCONST_DMX(0.4142135623730950f), |
| FL2FXCONST_DMX(0.5857864376269050f) |
| },{ /* Mono DMX set: */ |
| FL2FXCONST_DMX(0.2265409196609864f), |
| FL2FXCONST_DMX(0.25f), |
| FL2FXCONST_DMX(0.2697521433898179f), |
| FL2FXCONST_DMX(0.3333333333333333f) } |
| }; |
| #endif /* PCE_METADATA_ENABLE */ |
| |
| |
| #define TYPE_NONE ( 0x0 ) |
| #define TYPE_DSE_DATA ( 0x1 ) |
| #define TYPE_PCE_DATA ( 0x2 ) |
| |
| typedef struct |
| { |
| UINT typeFlags; |
| /* From DSE */ |
| UCHAR cLevIdx; |
| UCHAR sLevIdx; |
| UCHAR dmixIdxA; |
| UCHAR dmixIdxB; |
| UCHAR dmixIdxLfe; |
| UCHAR dmxGainIdx2; |
| UCHAR dmxGainIdx5; |
| #ifdef PCE_METADATA_ENABLE |
| /* From PCE */ |
| UCHAR matrixMixdownIdx; |
| #endif |
| /* Attributes: */ |
| SCHAR pseudoSurround; /*!< If set to 1 the signal is pseudo surround compatible. The value 0 tells |
| that it is not. If the value is -1 the information is not available. */ |
| UINT expiryCount; /*!< Counter to monitor the life time of a meta data set. */ |
| |
| } DMX_BS_META_DATA; |
| |
| /* Default metadata */ |
| static const DMX_BS_META_DATA dfltMetaData = { |
| 0, 2, 2, 2, 2, 15, 0, 0, |
| #ifdef PCE_METADATA_ENABLE |
| 0, |
| #endif |
| -1, 0 |
| }; |
| |
| /* Dynamic (user) params: |
| See the definition of PCMDMX_PARAM for details on the specific fields. */ |
| typedef struct |
| { |
| UINT expiryFrame; /*!< Linked to DMX_BS_DATA_EXPIRY_FRAME */ |
| DUAL_CHANNEL_MODE dualChannelMode; /*!< Linked to DMX_DUAL_CHANNEL_MODE */ |
| PSEUDO_SURROUND_MODE pseudoSurrMode; /*!< Linked to DMX_PSEUDO_SURROUND_MODE */ |
| SHORT numOutChannelsMin; /*!< Linked to MIN_NUMBER_OF_OUTPUT_CHANNELS */ |
| SHORT numOutChannelsMax; /*!< Linked to MAX_NUMBER_OF_OUTPUT_CHANNELS */ |
| UCHAR frameDelay; /*!< Linked to DMX_BS_DATA_DELAY */ |
| |
| } PCM_DMX_USER_PARAMS; |
| |
| /* Modules main data structure: */ |
| struct PCM_DMX_INSTANCE |
| { |
| /* Metadata */ |
| DMX_BS_META_DATA bsMetaData[PCM_DMX_MAX_DELAY_FRAMES+1]; |
| PCM_DMX_USER_PARAMS userParams; |
| |
| UCHAR applyProcessing; /*!< Flag to en-/disable modules processing. |
| The max channel limiting is done independently. */ |
| }; |
| |
| /* Memory allocation macro */ |
| C_ALLOC_MEM_STATIC(PcmDmxInstance, struct PCM_DMX_INSTANCE, 1) |
| |
| |
| /** Evaluate a given channel configuration and extract a packed channel mode. In addition the |
| * function generates a channel offset table for the mapping to the internal representation. |
| * This function is the inverse to the getChannelDescription() routine. |
| * @param [in] The total number of channels of the given configuration. |
| * @param [in] Array holding the corresponding channel types for each channel. |
| * @param [in] Array holding the corresponding channel type indices for each channel. |
| * @param [out] Array where the buffer offsets for each channel are stored into. |
| * @param [out] The generated packed channel mode that represents the given input configuration. |
| * @returns Returns an error code. |
| **/ |
| static |
| PCMDMX_ERROR getChannelMode ( |
| const INT numChannels, /* in */ |
| const AUDIO_CHANNEL_TYPE channelType[], /* in */ |
| const UCHAR channelIndices[], /* in */ |
| UCHAR offsetTable[PCM_DMX_MAX_CHANNELS], /* out */ |
| PCM_DMX_CHANNEL_MODE *chMode /* out */ |
| ) |
| { |
| UCHAR chIdx[PCM_DMX_MAX_CHANNEL_GROUPS][PCM_DMX_MAX_CHANNELS_PER_GROUP]; |
| UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS]; /* Total num of channels per group of the input config */ |
| UCHAR numChFree[PCM_DMX_MAX_CHANNEL_GROUPS]; /* Number of free slots per group in the internal repr. */ |
| UCHAR hardToPlace[PCM_DMX_MAX_CHANNELS]; /* List of channels not matching the internal repr. */ |
| UCHAR h2pSortIdx[PCM_DMX_MAX_CHANNELS]; |
| PCMDMX_ERROR err = PCMDMX_OK; |
| int ch, grpIdx; |
| int numChToPlace = 0; |
| |
| FDK_ASSERT(channelType != NULL); |
| FDK_ASSERT(channelIndices != NULL); |
| FDK_ASSERT(offsetTable != NULL); |
| FDK_ASSERT(chMode != NULL); |
| |
| /* For details see ISO/IEC 13818-7:2005(E), 8.5.3 Channel configuration */ |
| FDKmemclear(numChInGrp, PCM_DMX_MAX_CHANNEL_GROUPS*sizeof(UCHAR)); |
| FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| FDKmemset(chIdx, 255, PCM_DMX_MAX_CHANNEL_GROUPS*PCM_DMX_MAX_CHANNELS_PER_GROUP*sizeof(UCHAR)); |
| FDKmemset(hardToPlace, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| FDKmemset(h2pSortIdx, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| /* Get the restrictions of the internal representation */ |
| FDKmemcpy(numChFree, maxChInGrp, PCM_DMX_MAX_CHANNEL_GROUPS*sizeof(UCHAR)); |
| |
| *chMode = CH_MODE_UNDEFINED; |
| |
| /* Categorize channels */ |
| for (ch = 0; ch < numChannels; ch += 1) { |
| UCHAR chGrpIdx = channelIndices[ch]; |
| int i = 0, j; |
| |
| switch (channelType[ch]) { |
| case ACT_FRONT_TOP: |
| chGrpIdx += numChInGrp[CH_GROUP_FRONT]; /* Append after normal plain */ |
| case ACT_FRONT: |
| grpIdx = CH_GROUP_FRONT; |
| break; |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| case ACT_SIDE_TOP: |
| chGrpIdx += numChInGrp[CH_GROUP_SIDE]; /* Append after normal plain */ |
| case ACT_SIDE: |
| grpIdx = CH_GROUP_SIDE; |
| break; |
| case ACT_BACK_TOP: |
| chGrpIdx += numChInGrp[CH_GROUP_REAR]; /* Append after normal plain */ |
| case ACT_BACK: |
| grpIdx = CH_GROUP_REAR; |
| break; |
| case ACT_LFE: |
| grpIdx = CH_GROUP_LFE; |
| break; |
| #endif |
| default: |
| /* Found a channel that can not be categorized! Most likely due to corrupt input signalling. |
| The rescue strategy is to append it to the front channels (=> ignore index). |
| This could cause strange behaviour so return an error to signal it. */ |
| err = PCMDMX_INVALID_MODE; |
| grpIdx = CH_GROUP_FRONT; |
| chGrpIdx = numChannels + numChToPlace; |
| numChToPlace += 1; |
| break; |
| } |
| |
| if (numChInGrp[grpIdx] < PCM_DMX_MAX_CHANNELS_PER_GROUP) { |
| /* Sort channels by index */ |
| while ( (i < numChInGrp[grpIdx]) && (chGrpIdx > channelIndices[chIdx[grpIdx][i]]) ) { |
| i += 1; |
| } |
| for (j = numChInGrp[grpIdx]; j > i; j -= 1) { |
| chIdx[grpIdx][j] = chIdx[grpIdx][j-1]; |
| } |
| chIdx[grpIdx][i] = ch; |
| numChInGrp[grpIdx] += 1; |
| } |
| } |
| |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| FDK_ASSERT( (numChInGrp[CH_GROUP_FRONT]+numChInGrp[CH_GROUP_SIDE] |
| +numChInGrp[CH_GROUP_REAR]+numChInGrp[CH_GROUP_LFE]) == numChannels); |
| #else |
| FDK_ASSERT( numChInGrp[CH_GROUP_FRONT] == numChannels ); |
| #endif |
| |
| /* Compose channel offset table: |
| * Map all channels to the internal representation. */ |
| numChToPlace = 0; |
| |
| /* Non-symmetric channels */ |
| if (numChInGrp[CH_GROUP_FRONT] & 0x1) { |
| /* Odd number of front channels -> we have a center channel. |
| In MPEG-4 the center has the index 0. */ |
| offsetTable[CENTER_FRONT_CHANNEL] = chIdx[CH_GROUP_FRONT][0]; |
| numChFree[CH_GROUP_FRONT] -= 1; |
| } |
| |
| for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) { |
| int chMapPos = 0; |
| ch = 0; /* Index of channel within the specific group */ |
| |
| switch (grpIdx) { |
| case CH_GROUP_FRONT: |
| chMapPos = LEFT_FRONT_CHANNEL; |
| ch = numChInGrp[grpIdx] & 0x1; |
| break; |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| case CH_GROUP_SIDE: |
| break; |
| case CH_GROUP_REAR: |
| chMapPos = LEFT_REAR_CHANNEL; |
| break; |
| case CH_GROUP_LFE: |
| chMapPos = LOW_FREQUENCY_CHANNEL; |
| break; |
| #endif |
| default: |
| FDK_ASSERT(0); |
| continue; |
| } |
| |
| /* Map all channels of the group */ |
| for ( ; ch < numChInGrp[grpIdx]; ch += 1) { |
| if (numChFree[grpIdx] > 0) { |
| offsetTable[chMapPos] = chIdx[grpIdx][ch]; |
| chMapPos += 1; |
| numChFree[grpIdx] -= 1; |
| } else { |
| /* Add to the list of hardship cases considering a MPEG-like sorting order: */ |
| int pos, sortIdx = grpIdx*PCM_DMX_MAX_CHANNELS_PER_GROUP + channelIndices[chIdx[grpIdx][ch]]; |
| for (pos = numChToPlace; pos > 0; pos -= 1) { |
| if (h2pSortIdx[pos-1] > sortIdx) { |
| hardToPlace[pos] = hardToPlace[pos-1]; |
| h2pSortIdx[pos] = h2pSortIdx[pos-1]; |
| } else { |
| /* Insert channel at the current index/position */ |
| break; |
| } |
| } |
| hardToPlace[pos] = chIdx[grpIdx][ch]; |
| h2pSortIdx[pos] = sortIdx; |
| numChToPlace += 1; |
| } |
| } |
| } |
| |
| { /* Assign the hardship cases */ |
| int chMapPos = 0; |
| int mappingHeat = 0; |
| for (ch = 0; ch < numChToPlace; ch+=1) { |
| int chAssigned = 0; |
| |
| /* Just assigning the channels to the next best slot can lead to undesired results (especially for x/x/1.x |
| configurations). Thus use the MPEG-like sorting index to find the best fitting slot for each channel. |
| If this is not possible the sorting index will be ignored (mappingHeat >= 2). */ |
| for ( ; chMapPos < PCM_DMX_MAX_CHANNELS; chMapPos+=1) { |
| if (offsetTable[chMapPos] == 255) { |
| int prvSortIdx = 0; |
| int nxtSortIdx = (CH_GROUP_LFE+1)*PCM_DMX_MAX_CHANNELS_PER_GROUP; |
| |
| if (mappingHeat < 2) { |
| if (chMapPos < LEFT_REAR_CHANNEL) { |
| /* Got front channel slot */ |
| prvSortIdx = CH_GROUP_FRONT*PCM_DMX_MAX_CHANNELS_PER_GROUP + chMapPos - CENTER_FRONT_CHANNEL; |
| nxtSortIdx = CH_GROUP_SIDE *PCM_DMX_MAX_CHANNELS_PER_GROUP; |
| } |
| else if (chMapPos < LOW_FREQUENCY_CHANNEL) { |
| /* Got back channel slot */ |
| prvSortIdx = CH_GROUP_REAR*PCM_DMX_MAX_CHANNELS_PER_GROUP + chMapPos - LEFT_REAR_CHANNEL; |
| nxtSortIdx = CH_GROUP_LFE *PCM_DMX_MAX_CHANNELS_PER_GROUP; |
| } |
| else if (chMapPos < LEFT_MULTIPRPS_CHANNEL) { |
| /* Got lfe channel slot */ |
| prvSortIdx = CH_GROUP_LFE *PCM_DMX_MAX_CHANNELS_PER_GROUP + chMapPos - LOW_FREQUENCY_CHANNEL; |
| nxtSortIdx = (CH_GROUP_LFE+1)*PCM_DMX_MAX_CHANNELS_PER_GROUP; |
| } |
| } |
| |
| /* Assign the channel only if its sort index is within the range */ |
| if ( (h2pSortIdx[ch] >= prvSortIdx) |
| && (h2pSortIdx[ch] < nxtSortIdx) ) { |
| offsetTable[chMapPos++] = hardToPlace[ch]; |
| chAssigned = 1; |
| break; |
| } |
| } |
| } |
| if (chAssigned == 0) { |
| chMapPos = 0; |
| ch -= 1; |
| mappingHeat += 1; |
| continue; |
| } |
| } |
| } |
| |
| /* Compose the channel mode */ |
| *chMode = (PCM_DMX_CHANNEL_MODE)( (numChInGrp[CH_GROUP_FRONT] & 0xF) |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| | (numChInGrp[CH_GROUP_SIDE] & 0xF) << 4 |
| | (numChInGrp[CH_GROUP_REAR] & 0xF) << 8 |
| | (numChInGrp[CH_GROUP_LFE] & 0xF) << 12 |
| #endif |
| ); |
| |
| return err; |
| } |
| |
| |
| /** Generate a channel offset table and complete channel description for a given (packed) channel mode. |
| * This function is the inverse to the getChannelMode() routine but does not support weird channel |
| * configurations. All channels have to be in the normal height layer and there must not be more |
| * channels in each group than given by maxChInGrp. |
| * @param [in] The packed channel mode of the configuration to be processed. |
| * @param [in] Array containing the channel mapping to be used (From MPEG PCE ordering to whatever is required). |
| * @param [out] Array where corresponding channel types for each channels are stored into. |
| * @param [out] Array where corresponding channel type indices for each output channel are stored into. |
| * @param [out] Array where the buffer offsets for each channel are stored into. |
| * @returns None. |
| **/ |
| static |
| void getChannelDescription ( |
| const PCM_DMX_CHANNEL_MODE chMode, /* in */ |
| const UCHAR channelMapping[][8], /* in */ |
| AUDIO_CHANNEL_TYPE channelType[], /* out */ |
| UCHAR channelIndices[], /* out */ |
| UCHAR offsetTable[PCM_DMX_MAX_CHANNELS] /* out */ |
| ) |
| { |
| const UCHAR *pChannelMap; |
| int grpIdx, ch = 0, numChannels = 0; |
| UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS]; |
| |
| FDK_ASSERT(channelType != NULL); |
| FDK_ASSERT(channelIndices != NULL); |
| FDK_ASSERT(channelMapping != NULL); |
| FDK_ASSERT(offsetTable != NULL); |
| |
| /* Init output arrays */ |
| FDKmemclear(channelType, PCM_DMX_MAX_IO_CHANNELS*sizeof(AUDIO_CHANNEL_TYPE)); |
| FDKmemclear(channelIndices, PCM_DMX_MAX_IO_CHANNELS*sizeof(UCHAR)); |
| FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| |
| /* Extract the number of channels per group */ |
| numChInGrp[CH_GROUP_FRONT] = chMode & 0xF; |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| numChInGrp[CH_GROUP_SIDE] = (chMode >> 4) & 0xF; |
| numChInGrp[CH_GROUP_REAR] = (chMode >> 8) & 0xF; |
| numChInGrp[CH_GROUP_LFE] = (chMode >> 12) & 0xF; |
| #endif |
| |
| /* Summerize to get the total number of channels */ |
| for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) { |
| numChannels += numChInGrp[grpIdx]; |
| } |
| |
| /* Get the appropriate channel map */ |
| switch (chMode) { |
| case CH_MODE_1_0_0_0: |
| case CH_MODE_2_0_0_0: |
| case CH_MODE_3_0_0_0: |
| case CH_MODE_3_0_1_0: |
| case CH_MODE_3_0_2_0: |
| case CH_MODE_3_0_2_1: |
| pChannelMap = channelMapping[numChannels]; |
| break; |
| case CH_MODE_3_0_3_1: |
| pChannelMap = channelMapping[11]; |
| break; |
| case CH_MODE_3_0_4_1: |
| pChannelMap = channelMapping[12]; |
| break; |
| case CH_MODE_5_0_2_1: |
| pChannelMap = channelMapping[7]; |
| break; |
| default: |
| /* fallback */ |
| pChannelMap = channelMapping[0]; |
| break; |
| } |
| |
| /* Compose channel offset table */ |
| |
| /* Non-symmetric channels */ |
| if (numChInGrp[CH_GROUP_FRONT] & 0x1) { |
| /* Odd number of front channels -> we have a center channel. |
| In MPEG-4 the center has the index 0. */ |
| int mappedIdx = pChannelMap[ch]; |
| offsetTable[CENTER_FRONT_CHANNEL] = mappedIdx; |
| channelType[mappedIdx] = ACT_FRONT; |
| channelIndices[mappedIdx] = 0; |
| ch += 1; |
| } |
| |
| for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) { |
| AUDIO_CHANNEL_TYPE type = ACT_NONE; |
| int chMapPos = 0, maxChannels = 0; |
| int chIdx = 0; /* Index of channel within the specific group */ |
| |
| switch (grpIdx) { |
| case CH_GROUP_FRONT: |
| type = ACT_FRONT; |
| chMapPos = LEFT_FRONT_CHANNEL; |
| maxChannels = 3; |
| chIdx = numChInGrp[grpIdx] & 0x1; |
| break; |
| #if (PCM_DMX_MAX_CHANNEL_GROUPS > 1) |
| case CH_GROUP_SIDE: |
| /* Always map side channels to the multipurpose group. */ |
| type = ACT_SIDE; |
| chMapPos = LEFT_MULTIPRPS_CHANNEL; |
| break; |
| case CH_GROUP_REAR: |
| type = ACT_BACK; |
| chMapPos = LEFT_REAR_CHANNEL; |
| maxChannels = 2; |
| break; |
| case CH_GROUP_LFE: |
| type = ACT_LFE; |
| chMapPos = LOW_FREQUENCY_CHANNEL; |
| maxChannels = 1; |
| break; |
| #endif |
| default: |
| break; |
| } |
| |
| /* Map all channels in this group */ |
| for ( ; chIdx < numChInGrp[grpIdx]; chIdx += 1) { |
| int mappedIdx = pChannelMap[ch]; |
| if (chIdx == maxChannels) { |
| /* No space left in this channel group! |
| Use the multipurpose group instead: */ |
| chMapPos = LEFT_MULTIPRPS_CHANNEL; |
| } |
| offsetTable[chMapPos] = mappedIdx; |
| channelType[mappedIdx] = type; |
| channelIndices[mappedIdx] = chIdx; |
| chMapPos += 1; |
| ch += 1; |
| } |
| } |
| } |
| |
| /** Private helper function for downmix matrix manipulation that initializes |
| * one row in a given downmix matrix (corresponding to one output channel). |
| * @param [inout] Pointer to fixed-point parts of the downmix matrix. |
| * @param [inout] Pointer to scale factor matrix associated to the downmix factors. |
| * @param [in] Index of channel (row) to be initialized. |
| * @returns Nothing to return. |
| **/ |
| static |
| void dmxInitChannel( |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| INT mixScales[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| const unsigned int outCh |
| ) |
| { |
| unsigned int inCh; |
| for (inCh=0; inCh < PCM_DMX_MAX_CHANNELS; inCh+=1) { |
| if (inCh == outCh) { |
| mixFactors[outCh][inCh] = FL2FXCONST_DMX(0.5f); |
| mixScales[outCh][inCh] = 1; |
| } else { |
| mixFactors[outCh][inCh] = FL2FXCONST_DMX(0.0f); |
| mixScales[outCh][inCh] = 0; |
| } |
| } |
| } |
| |
| /** Private helper function for downmix matrix manipulation that does a reset |
| * of one row in a given downmix matrix (corresponding to one output channel). |
| * @param [inout] Pointer to fixed-point parts of the downmix matrix. |
| * @param [inout] Pointer to scale factor matrix associated to the downmix factors. |
| * @param [in] Index of channel (row) to be cleared/reset. |
| * @returns Nothing to return. |
| **/ |
| static |
| void dmxClearChannel( |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| INT mixScales[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| const unsigned int outCh |
| ) |
| { |
| FDKmemclear(&mixFactors[outCh], PCM_DMX_MAX_CHANNELS*sizeof(FIXP_DMX)); |
| FDKmemclear(&mixScales[outCh], PCM_DMX_MAX_CHANNELS*sizeof(INT)); |
| } |
| |
| /** Private helper function for downmix matrix manipulation that applies a source channel (row) |
| * scaled by a given mix factor to a destination channel (row) in a given downmix matrix. |
| * Existing mix factors of the destination channel (row) will get overwritten. |
| * @param [inout] Pointer to fixed-point parts of the downmix matrix. |
| * @param [inout] Pointer to scale factor matrix associated to the downmix factors. |
| * @param [in] Index of source channel (row). |
| * @param [in] Index of destination channel (row). |
| * @param [in] Fixed-point part of mix factor to be applied. |
| * @param [in] Scale factor of mix factor to be applied. |
| * @returns Nothing to return. |
| **/ |
| static |
| void dmxSetChannel( |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| INT mixScales[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| const unsigned int dstCh, |
| const unsigned int srcCh, |
| const FIXP_DMX factor, |
| const INT scale |
| ) |
| { |
| int ch; |
| for (ch=0; ch < PCM_DMX_MAX_CHANNELS; ch+=1) { |
| if (mixFactors[srcCh][ch] != (FIXP_DMX)0) { |
| mixFactors[dstCh][ch] = FX_DBL2FX_DMX(fMult(mixFactors[srcCh][ch], factor)); |
| mixScales[dstCh][ch] = mixScales[srcCh][ch] + scale; |
| } |
| } |
| } |
| |
| /** Private helper function for downmix matrix manipulation that adds a source channel (row) |
| * scaled by a given mix factor to a destination channel (row) in a given downmix matrix. |
| * @param [inout] Pointer to fixed-point parts of the downmix matrix. |
| * @param [inout] Pointer to scale factor matrix associated to the downmix factors. |
| * @param [in] Index of source channel (row). |
| * @param [in] Index of destination channel (row). |
| * @param [in] Fixed-point part of mix factor to be applied. |
| * @param [in] Scale factor of mix factor to be applied. |
| * @returns Nothing to return. |
| **/ |
| static |
| void dmxAddChannel( |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| INT mixScales[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| const unsigned int dstCh, |
| const unsigned int srcCh, |
| const FIXP_DMX factor, |
| const INT scale |
| ) |
| { |
| int ch; |
| for (ch=0; ch < PCM_DMX_MAX_CHANNELS; ch+=1) { |
| FIXP_DBL addFact = fMult(mixFactors[srcCh][ch], factor); |
| if (addFact != (FIXP_DMX)0) { |
| INT newScale = mixScales[srcCh][ch] + scale; |
| if (mixFactors[dstCh][ch] != (FIXP_DMX)0) { |
| if (newScale > mixScales[dstCh][ch]) { |
| mixFactors[dstCh][ch] >>= newScale - mixScales[dstCh][ch]; |
| } else { |
| addFact >>= mixScales[dstCh][ch] - newScale; |
| newScale = mixScales[dstCh][ch]; |
| } |
| } |
| mixFactors[dstCh][ch] += FX_DBL2FX_DMX(addFact); |
| mixScales[dstCh][ch] = newScale; |
| } |
| } |
| } |
| |
| |
| /** Private function that creates a downmix factor matrix depending on the input and output |
| * configuration, the user parameters as well as the given metadata. This function is the modules |
| * brain and hold all downmix algorithms. |
| * @param [in] Flag that indicates if inChMode holds a real (packed) channel mode or has been |
| converted to a MPEG-4 channel configuration index. |
| * @param [in] Dependent on the inModeIsCfg flag this field hands in a (packed) channel mode or |
| the corresponding MPEG-4 channel configuration index.of the input configuration. |
| * @param [in] The (packed) channel mode of the output configuration. |
| * @param [in] Pointer to structure holding all current user parameter. |
| * @param [in] Pointer to field holding all current meta data. |
| * @param [out] Pointer to fixed-point parts of the downmix matrix. Normalized to one scale factor. |
| * @param [out] The common scale factor of the downmix matrix. |
| * @returns An error code. |
| **/ |
| static |
| PCMDMX_ERROR getMixFactors ( |
| const UCHAR inModeIsCfg, |
| PCM_DMX_CHANNEL_MODE inChMode, |
| const PCM_DMX_CHANNEL_MODE outChMode, |
| const PCM_DMX_USER_PARAMS *pParams, |
| const DMX_BS_META_DATA *pMetaData, |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS], |
| INT *pOutScale |
| ) |
| { |
| PCMDMX_ERROR err = PCMDMX_OK; |
| INT mixScales[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS]; |
| INT maxScale = 0; |
| int numInChannel, numOutChannel; |
| unsigned int outCh, inCh, inChCfg = 0; |
| unsigned int valid[PCM_DMX_MAX_CHANNELS] = { 0 }; |
| |
| FDK_ASSERT(pMetaData != NULL); |
| FDK_ASSERT(mixFactors != NULL); |
| /* Check on a supported output configuration */ |
| FDK_ASSERT( (outChMode == CH_MODE_1_0_0_0) |
| || (outChMode == CH_MODE_2_0_0_0) |
| || (outChMode == CH_MODE_3_0_2_1) ); |
| |
| if (inModeIsCfg) { |
| /* Workaround for the ambiguity of the internal channel modes. |
| Convert channel config to channel mode: */ |
| inChCfg = (unsigned int)inChMode; |
| switch (inChCfg) { |
| case 1: case 2: case 3: |
| #if (PCM_DMX_MAX_CHANNELS > 3) |
| case 4: case 5: case 6: |
| #endif |
| inChMode = outChModeTable[inChCfg]; |
| break; |
| case 11: |
| inChMode = CH_MODE_3_0_3_1; |
| break; |
| case 12: |
| inChMode = CH_MODE_3_0_4_1; |
| break; |
| case 7: case 14: |
| inChMode = CH_MODE_5_0_2_1; |
| break; |
| default: |
| FDK_ASSERT(0); |
| } |
| } |
| |
| /* Extract the total number of input channels */ |
| numInChannel = (inChMode&0xF) |
| + ((inChMode>> 4)&0xF) |
| + ((inChMode>> 8)&0xF) |
| + ((inChMode>>12)&0xF); |
| /* Extract the total number of output channels */ |
| numOutChannel = (outChMode&0xF) |
| + ((outChMode>> 4)&0xF) |
| + ((outChMode>> 8)&0xF) |
| + ((outChMode>>12)&0xF); |
| |
| /* MPEG ammendment 4 aka ETSI metadata and fallback mode: */ |
| |
| |
| /* Create identity DMX matrix: */ |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| dmxInitChannel( mixFactors, mixScales, outCh ); |
| } |
| if (((inChMode>>12)&0xF) == 0) { |
| /* Clear empty or wrongly mapped input channel */ |
| dmxClearChannel( mixFactors, mixScales, LOW_FREQUENCY_CHANNEL ); |
| } |
| |
| /* FIRST STAGE: */ |
| if (numInChannel > SIX_CHANNEL) |
| { /* Always use MPEG equations either with meta data or with default values. */ |
| FIXP_DMX dMixFactA, dMixFactB; |
| INT dMixScaleA, dMixScaleB; |
| int isValidCfg = TRUE; |
| |
| /* Get factors from meta data */ |
| dMixFactA = abMixLvlValueTab[pMetaData->dmixIdxA]; |
| dMixScaleA = (pMetaData->dmixIdxA==0) ? 1 : 0; |
| dMixFactB = abMixLvlValueTab[pMetaData->dmixIdxB]; |
| dMixScaleB = (pMetaData->dmixIdxB==0) ? 1 : 0; |
| |
| /* Check if input is in the list of supported configurations */ |
| switch (inChMode) { |
| case CH_MODE_3_0_3_1: /* chCfg 11 */ |
| /* 6.1ch: C' = C; L' = L; R' = R; LFE' = LFE; |
| Ls' = Ls*dmix_a_idx + Cs*dmix_b_idx; |
| Rs' = Rs*dmix_a_idx + Cs*dmix_b_idx; */ |
| dmxClearChannel( mixFactors, mixScales, RIGHT_MULTIPRPS_CHANNEL ); /* clear empty input channel */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, RIGHT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| break; |
| case CH_MODE_3_2_1_0: |
| case CH_MODE_3_2_1_1: /* chCfg 11 but with side channels */ |
| /* 6.1ch: C' = C; L' = L; R' = R; LFE' = LFE; |
| Ls' = Ls*dmix_a_idx + Cs*dmix_b_idx; |
| Rs' = Rs*dmix_a_idx + Cs*dmix_b_idx; */ |
| dmxClearChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL ); /* clear empty input channel */ |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, RIGHT_MULTIPRPS_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_MULTIPRPS_CHANNEL, dMixFactA, dMixScaleA ); |
| isValidCfg = FALSE; |
| err = PCMDMX_INVALID_MODE; |
| break; |
| case CH_MODE_5_2_1_0: |
| case CH_MODE_5_0_1_0: |
| case CH_MODE_5_0_1_1: |
| /* Ls' = Cs*dmix_a_idx; |
| Rs' = Cs*dmix_a_idx; */ |
| dmxClearChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL ); /* clear empty input channel */ |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| isValidCfg = FALSE; |
| err = PCMDMX_INVALID_MODE; |
| break; |
| case CH_MODE_3_0_4_1: /* chCfg 12 */ |
| /* 7.1ch Surround Back: C' = C; L' = L; R' = R; LFE' = LFE; |
| Ls' = Ls*dmix_a_idx + Lsr*dmix_b_idx; |
| Rs' = Rs*dmix_a_idx + Rsr*dmix_b_idx; */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, RIGHT_REAR_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, RIGHT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| break; |
| case CH_MODE_5_0_2_1: /* chCfg 7 || 14 */ |
| if (inChCfg == 14) { |
| /* 7.1ch Front Height: C' = C; Ls' = Ls; Rs' = Rs; LFE' = LFE; |
| L' = L*dmix_a_idx + Lv*dmix_b_idx; |
| R' = R*dmix_a_idx + Rv*dmix_b_idx; */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB ); |
| } else { |
| /* 7.1ch Front: Ls' = Ls; Rs' = Rs; LFE' = LFE; |
| C' = C + (Lc+Rc)*dmix_a_idx; |
| L' = L + Lc*dmix_b_idx; |
| R' = R + Rc*dmix_b_idx; |
| CAUTION: L+R are not at (MPEG) index 1+2. */ |
| dmxSetChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, dMixFactA, dMixScaleA ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_MULTIPRPS_CHANNEL, FL2FXCONST_DMX(0.5f), 1 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, dMixFactB, dMixScaleB ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_MULTIPRPS_CHANNEL, FL2FXCONST_DMX(0.5f), 1 ); |
| } |
| break; |
| default: |
| /* Nothing to do. Just use the identity matrix. */ |
| isValidCfg = FALSE; |
| err = PCMDMX_INVALID_MODE; |
| break; |
| } |
| |
| /* Add additional DMX gain */ |
| if ( (isValidCfg == TRUE) |
| && (pMetaData->dmxGainIdx5 != 0)) |
| { /* Apply DMX gain 5 */ |
| FIXP_DMX dmxGain; |
| INT dmxScale; |
| INT sign = (pMetaData->dmxGainIdx5 & 0x40) ? -1 : 1; |
| INT val = pMetaData->dmxGainIdx5 & 0x3F; |
| |
| /* 10^(dmx_gain_5/80) */ |
| dmxGain = FX_DBL2FX_DMX( fLdPow( |
| FL2FXCONST_DBL(0.830482023721841f), 2, /* log2(10) */ |
| (FIXP_DBL)(sign*val*(LONG)FL2FXCONST_DBL(0.0125f)), 0, |
| &dmxScale ) |
| ); |
| /* Currently only positive scale factors supported! */ |
| if (dmxScale < 0) { |
| dmxGain >>= -dmxScale; |
| dmxScale = 0; |
| } |
| |
| dmxSetChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_REAR_CHANNEL, RIGHT_REAR_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, LOW_FREQUENCY_CHANNEL, LOW_FREQUENCY_CHANNEL, dmxGain, dmxScale ); |
| } |
| |
| /* Mark the output channels */ |
| valid[CENTER_FRONT_CHANNEL] = 1; |
| valid[LEFT_FRONT_CHANNEL] = 1; |
| valid[RIGHT_FRONT_CHANNEL] = 1; |
| valid[LEFT_REAR_CHANNEL] = 1; |
| valid[RIGHT_REAR_CHANNEL] = 1; |
| valid[LOW_FREQUENCY_CHANNEL] = 1; |
| |
| /* Update channel mode for the next stage */ |
| inChMode = CH_MODE_3_0_2_1; |
| } |
| |
| /* SECOND STAGE: */ |
| if (numOutChannel <= TWO_CHANNEL) { |
| /* Create DMX matrix according to input configuration */ |
| switch (inChMode) { |
| case CH_MODE_2_0_0_0: /* chCfg 2 */ |
| /* Apply the dual channel mode. */ |
| switch (pParams->dualChannelMode) { |
| case CH1_MODE: /* L' = 0.707 * Ch1; |
| R' = 0.707 * Ch1; */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| break; |
| case CH2_MODE: /* L' = 0.707 * Ch2; |
| R' = 0.707 * Ch2; */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| break; |
| case MIXED_MODE: /* L' = 0.5*Ch1 + 0.5*Ch2; |
| R' = 0.5*Ch1 + 0.5*Ch2; */ |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0 ); |
| break; |
| default: |
| case STEREO_MODE: |
| /* Nothing to do */ |
| break; |
| } |
| break; |
| case CH_MODE_2_0_1_0: |
| /* L' = L + 0.707*S; |
| R' = R + 0.707*S; */ |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| break; |
| case CH_MODE_3_0_0_0: /* chCfg 3 */ |
| /* L' = L + 0.707*C; |
| R' = R + 0.707*C; */ |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| break; |
| case CH_MODE_3_0_1_0: /* chCfg 4 */ |
| /* L' = L + 0.707*C + 0.707*S; |
| R' = R + 0.707*C + 0.707*S; */ |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.707f), 0 ); |
| break; |
| case CH_MODE_3_0_2_0: /* chCfg 5 */ |
| case CH_MODE_3_0_2_1: /* chCfg 6 */ |
| /* MPEG + ITU + DLB |
| But because the default downmix equations and coefficients are equal we stick to MPEG. */ |
| if ( (pMetaData->typeFlags & TYPE_DSE_DATA) |
| || !(pMetaData->typeFlags & TYPE_PCE_DATA) ) |
| { |
| FIXP_DMX cMixLvl, sMixLvl, lMixLvl; |
| INT cMixScale, sMixScale, lMixScale; |
| |
| /* Get factors from meta data */ |
| cMixLvl = abMixLvlValueTab[pMetaData->cLevIdx]; |
| cMixScale = (pMetaData->cLevIdx==0) ? 1 : 0; |
| sMixLvl = abMixLvlValueTab[pMetaData->sLevIdx]; |
| sMixScale = (pMetaData->sLevIdx==0) ? 1 : 0; |
| lMixLvl = lfeMixLvlValueTab[pMetaData->dmixIdxLfe]; |
| if (pMetaData->dmixIdxLfe <= 1) { |
| lMixScale = 2; |
| } else if (pMetaData->dmixIdxLfe <= 5) { |
| lMixScale = 1; |
| } else { |
| lMixScale = 0; |
| } |
| /* Setup the DMX matrix */ |
| if ( (pParams->pseudoSurrMode == FORCE_PS_DMX) |
| || ((pParams->pseudoSurrMode == AUTO_PS_DMX) && (pMetaData->pseudoSurround==1))) |
| { /* L' = L + C*clev - (Ls+Rs)*slev + LFE*lflev; |
| R' = R + C*clev + (Ls+Rs)*slev + LFE*lflev; */ |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, cMixLvl, cMixScale ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, -sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, RIGHT_REAR_CHANNEL, -sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, cMixLvl, cMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_REAR_CHANNEL, sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale ); |
| } |
| else |
| { /* L' = L + C*clev + Ls*slev + LFE*llev; |
| R' = R + C*clev + Rs*slev + LFE*llev; */ |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, cMixLvl, cMixScale ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, cMixLvl, cMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_REAR_CHANNEL, sMixLvl, sMixScale ); |
| dmxAddChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale ); |
| } |
| |
| /* Add additional DMX gain */ |
| if ( pMetaData->dmxGainIdx2 != 0 ) |
| { /* Apply DMX gain 2 */ |
| FIXP_DMX dmxGain; |
| INT dmxScale; |
| INT sign = (pMetaData->dmxGainIdx2 & 0x40) ? -1 : 1; |
| INT val = pMetaData->dmxGainIdx2 & 0x3F; |
| |
| /* 10^(dmx_gain_2/80) */ |
| dmxGain = FX_DBL2FX_DMX( fLdPow( |
| FL2FXCONST_DBL(0.830482023721841f), 2, /* log2(10) */ |
| (FIXP_DBL)(sign*val*(LONG)FL2FXCONST_DBL(0.0125f)), 0, |
| &dmxScale ) |
| ); |
| /* Currently only positive scale factors supported! */ |
| if (dmxScale < 0) { |
| dmxGain >>= -dmxScale; |
| dmxScale = 0; |
| } |
| |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, dmxGain, dmxScale ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, dmxGain, dmxScale ); |
| } |
| } |
| #ifdef PCE_METADATA_ENABLE |
| else { |
| FIXP_DMX flev, clev, slevLL, slevLR, slevRL, slevRR; |
| FIXP_DMX mtrxMixDwnCoef = mpegMixDownIdx2Coef[pMetaData->matrixMixdownIdx]; |
| |
| if ( (pParams->pseudoSurrMode == FORCE_PS_DMX) |
| || ((pParams->pseudoSurrMode == AUTO_PS_DMX) && (pMetaData->pseudoSurround==1))) |
| { /* 3/2 input: L' = (1.707+2*A)^-1 * [L+0.707*C-A*Ls-A*Rs]; |
| R' = (1.707+2*A)^-1 * [R+0.707*C+A*Ls+A*Rs]; */ |
| flev = mpegMixDownIdx2PreFact[1][pMetaData->matrixMixdownIdx]; |
| slevRR = slevRL = FX_DBL2FX_DMX(fMult(flev, mtrxMixDwnCoef)); |
| slevLL = slevLR = -slevRL; |
| } |
| else { |
| /* 3/2 input: L' = (1.707+A)^-1 * [L+0.707*C+A*Ls]; |
| R' = (1.707+A)^-1 * [R+0.707*C+A*Rs]; */ |
| flev = mpegMixDownIdx2PreFact[0][pMetaData->matrixMixdownIdx]; |
| slevRR = slevLL = FX_DBL2FX_DMX(fMult(flev, mtrxMixDwnCoef)); |
| slevLR = slevRL = (FIXP_SGL)0; |
| } |
| /* common factor */ |
| clev = FX_DBL2FX_DMX(fMult(flev, mpegMixDownIdx2Coef[0] /* 0.707 */)); |
| |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, flev, 0 ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, clev, 0 ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, slevLL, 0 ); |
| dmxSetChannel( mixFactors, mixScales, LEFT_FRONT_CHANNEL, RIGHT_REAR_CHANNEL, slevLR, 0 ); |
| |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, flev, 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, CENTER_FRONT_CHANNEL, clev, 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, LEFT_REAR_CHANNEL, slevRL, 0 ); |
| dmxSetChannel( mixFactors, mixScales, RIGHT_FRONT_CHANNEL, RIGHT_REAR_CHANNEL, slevRR, 0 ); |
| } |
| #endif /* PCE_METADATA_ENABLE */ |
| break; |
| default: |
| /* This configuration does not fit to any known downmix equation! */ |
| err = PCMDMX_INVALID_MODE; |
| break; |
| } |
| /* Mark the output channels */ |
| FDKmemclear(valid, PCM_DMX_MAX_CHANNELS*sizeof(unsigned int)); |
| valid[LEFT_FRONT_CHANNEL] = 1; |
| valid[RIGHT_FRONT_CHANNEL] = 1; |
| /* Update channel mode for the next stage */ |
| inChMode = CH_MODE_2_0_0_0; |
| } |
| |
| if (numOutChannel == ONE_CHANNEL) { |
| FIXP_DMX monoMixLevel; |
| INT monoMixScale; |
| |
| #ifdef PCE_METADATA_ENABLE |
| if ( (pMetaData->typeFlags & TYPE_PCE_DATA) |
| && !(pMetaData->typeFlags & TYPE_DSE_DATA) ) |
| { /* C' = (3+2*A)^-1 * [C+L+R+A*Ls+A+Rs]; */ |
| monoMixLevel = mpegMixDownIdx2PreFact[2][pMetaData->matrixMixdownIdx]; |
| monoMixScale = 0; |
| |
| dmxClearChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL ); |
| mixFactors[CENTER_FRONT_CHANNEL][CENTER_FRONT_CHANNEL] = monoMixLevel; |
| mixFactors[CENTER_FRONT_CHANNEL][LEFT_FRONT_CHANNEL] = monoMixLevel; |
| mixFactors[CENTER_FRONT_CHANNEL][RIGHT_FRONT_CHANNEL] = monoMixLevel; |
| monoMixLevel = FX_DBL2FX_DMX(fMult(monoMixLevel, mpegMixDownIdx2Coef[pMetaData->matrixMixdownIdx])); |
| mixFactors[CENTER_FRONT_CHANNEL][LEFT_REAR_CHANNEL] = monoMixLevel; |
| mixFactors[CENTER_FRONT_CHANNEL][RIGHT_REAR_CHANNEL] = monoMixLevel; |
| } |
| else |
| #endif |
| { /* C' = L + R; [default] */ |
| monoMixLevel = FL2FXCONST_DMX(0.5f); |
| monoMixScale = 1; |
| dmxClearChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL ); /* C is not in the mix */ |
| dmxSetChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL, LEFT_FRONT_CHANNEL, monoMixLevel, monoMixScale ); |
| dmxAddChannel( mixFactors, mixScales, CENTER_FRONT_CHANNEL, RIGHT_FRONT_CHANNEL, monoMixLevel, monoMixScale ); |
| } |
| |
| /* Mark the output channel */ |
| FDKmemclear(valid, PCM_DMX_MAX_CHANNELS*sizeof(unsigned int)); |
| valid[CENTER_FRONT_CHANNEL] = 1; |
| } |
| |
| #define MAX_SEARCH_START_VAL ( -7 ) |
| |
| { |
| LONG chSum[PCM_DMX_MAX_CHANNELS]; |
| INT chSumMax = MAX_SEARCH_START_VAL; |
| |
| /* Determine the current maximum scale factor */ |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| if (valid[outCh]!=0) { |
| for (inCh=0; inCh < PCM_DMX_MAX_CHANNELS; inCh+=1) { |
| if (mixScales[outCh][inCh] > maxScale) |
| { /* Store the new maximum */ |
| maxScale = mixScales[outCh][inCh]; |
| } |
| } |
| } |
| } |
| |
| /* Individualy analyse output chanal levels */ |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| chSum[outCh] = MAX_SEARCH_START_VAL; |
| if (valid[outCh]!=0) { |
| int ovrflwProtScale = 0; |
| |
| /* Accumulate all factors for each output channel */ |
| chSum[outCh] = 0; |
| for (inCh=0; inCh < PCM_DMX_MAX_CHANNELS; inCh+=1) { |
| SHORT addFact = FX_DMX2SHRT(mixFactors[outCh][inCh]); |
| if ( mixScales[outCh][inCh] <= maxScale ) { |
| addFact >>= maxScale - mixScales[outCh][inCh]; |
| } else { |
| addFact <<= mixScales[outCh][inCh] - maxScale; |
| } |
| chSum[outCh] += addFact; |
| } |
| if (chSum[outCh] > (LONG)MAXVAL_SGL) { |
| while (chSum[outCh] > (LONG)MAXVAL_SGL) { |
| ovrflwProtScale += 1; |
| chSum[outCh] >>= 1; |
| } |
| } else if (chSum[outCh] > 0) { |
| while ((chSum[outCh]<<1) <= (LONG)MAXVAL_SGL) { |
| ovrflwProtScale -= 1; |
| chSum[outCh] <<= 1; |
| } |
| } |
| /* Store the differential scaling in the same array */ |
| chSum[outCh] = ovrflwProtScale; |
| } |
| } |
| |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| if ( (valid[outCh] != 0) |
| && (chSum[outCh] > chSumMax) ) |
| { /* Store the new maximum */ |
| chSumMax = chSum[outCh]; |
| } |
| } |
| maxScale = FDKmax(maxScale+chSumMax, 0); |
| |
| /* Normalize all factors */ |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| if (valid[outCh]!=0) { |
| for (inCh=0; inCh < PCM_DMX_MAX_CHANNELS; inCh+=1) { |
| if (mixFactors[outCh][inCh] != (FIXP_DMX)0) { |
| if ( mixScales[outCh][inCh] <= maxScale ) { |
| mixFactors[outCh][inCh] >>= maxScale - mixScales[outCh][inCh]; |
| } else { |
| mixFactors[outCh][inCh] <<= mixScales[outCh][inCh] - maxScale; |
| } |
| mixScales[outCh][inCh] = maxScale; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /* return the scale factor */ |
| *pOutScale = maxScale; |
| |
| return (err); |
| } |
| |
| |
| /** Open and initialize an instance of the PCM downmix module |
| * @param [out] Pointer to a buffer receiving the handle of the new instance. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_Open ( |
| HANDLE_PCM_DOWNMIX *pSelf |
| ) |
| { |
| HANDLE_PCM_DOWNMIX self; |
| |
| if (pSelf == NULL) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| |
| *pSelf = NULL; |
| |
| self = (HANDLE_PCM_DOWNMIX) GetPcmDmxInstance( 0 ); |
| if (self == NULL) { |
| return (PCMDMX_OUT_OF_MEMORY); |
| } |
| |
| /* Reset the full instance */ |
| pcmDmx_Reset( self, PCMDMX_RESET_FULL ); |
| |
| *pSelf = self; |
| |
| return (PCMDMX_OK); |
| } |
| |
| |
| /** Reset all static values like e.g. mixdown coefficients. |
| * @param [in] Handle of PCM downmix module instance. |
| * @param [in] Flags telling which parts of the module shall be reset. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_Reset ( |
| HANDLE_PCM_DOWNMIX self, |
| UINT flags |
| ) |
| { |
| if (self == NULL) { return (PCMDMX_INVALID_HANDLE); } |
| |
| if (flags & PCMDMX_RESET_PARAMS) { |
| PCM_DMX_USER_PARAMS *pParams = &self->userParams; |
| |
| pParams->dualChannelMode = STEREO_MODE; |
| pParams->pseudoSurrMode = NEVER_DO_PS_DMX; |
| pParams->numOutChannelsMax = PCM_DMX_DFLT_MAX_OUT_CHANNELS; |
| pParams->numOutChannelsMin = PCM_DMX_DFLT_MIN_OUT_CHANNELS; |
| pParams->frameDelay = 0; |
| pParams->expiryFrame = PCM_DMX_DFLT_EXPIRY_FRAME; |
| |
| self->applyProcessing = 0; |
| } |
| |
| if (flags & PCMDMX_RESET_BS_DATA) { |
| int slot; |
| /* Init all slots with a default set */ |
| for (slot = 0; slot <= PCM_DMX_MAX_DELAY_FRAMES; slot += 1) { |
| FDKmemcpy(&self->bsMetaData[slot], &dfltMetaData, sizeof(DMX_BS_META_DATA)); |
| } |
| } |
| |
| return (PCMDMX_OK); |
| } |
| |
| |
| /** Set one parameter for one instance of the PCM downmix module. |
| * @param [in] Handle of PCM downmix module instance. |
| * @param [in] Parameter to be set. |
| * @param [in] Parameter value. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_SetParam ( |
| HANDLE_PCM_DOWNMIX self, |
| const PCMDMX_PARAM param, |
| const INT value |
| ) |
| { |
| switch (param) |
| { |
| case DMX_BS_DATA_EXPIRY_FRAME: |
| if (self == NULL) |
| return (PCMDMX_INVALID_HANDLE); |
| self->userParams.expiryFrame = (value > 0) ? (UINT)value : 0; |
| break; |
| |
| case DMX_BS_DATA_DELAY: |
| if ( (value > PCM_DMX_MAX_DELAY_FRAMES) |
| || (value < 0) ) { |
| return (PCMDMX_UNABLE_TO_SET_PARAM); |
| } |
| if (self == NULL) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| self->userParams.frameDelay = (UCHAR)value; |
| break; |
| |
| case MIN_NUMBER_OF_OUTPUT_CHANNELS: |
| switch (value) { /* supported output channels */ |
| case -1: case 0: case ONE_CHANNEL: case TWO_CHANNEL: |
| #if (PCM_DMX_MAX_OUT_CHANNELS >= 6) |
| case SIX_CHANNEL: |
| #endif |
| #if (PCM_DMX_MAX_OUT_CHANNELS >= 8) |
| case EIGHT_CHANNEL: |
| #endif |
| break; |
| default: |
| return (PCMDMX_UNABLE_TO_SET_PARAM); |
| } |
| if (self == NULL) |
| return (PCMDMX_INVALID_HANDLE); |
| /* Store the new value */ |
| self->userParams.numOutChannelsMin = (value > 0) ? value : -1; |
| if ( (value > 0) |
| && (self->userParams.numOutChannelsMax > 0) |
| && (value > self->userParams.numOutChannelsMax) ) |
| { /* MIN > MAX would be an invalid state. Thus set MAX = MIN in this case. */ |
| self->userParams.numOutChannelsMax = self->userParams.numOutChannelsMin; |
| } |
| break; |
| |
| case MAX_NUMBER_OF_OUTPUT_CHANNELS: |
| switch (value) { /* supported output channels */ |
| case -1: case 0: case ONE_CHANNEL: case TWO_CHANNEL: |
| #if (PCM_DMX_MAX_OUT_CHANNELS >= 6) |
| case SIX_CHANNEL: |
| #endif |
| #if (PCM_DMX_MAX_OUT_CHANNELS >= 8) |
| case EIGHT_CHANNEL: |
| #endif |
| break; |
| default: |
| return (PCMDMX_UNABLE_TO_SET_PARAM); |
| } |
| if (self == NULL) |
| return (PCMDMX_INVALID_HANDLE); |
| /* Store the new value */ |
| self->userParams.numOutChannelsMax = (value > 0) ? value : -1; |
| if ( (value > 0) |
| && (value < self->userParams.numOutChannelsMin) ) |
| { /* MAX < MIN would be an invalid state. Thus set MIN = MAX in this case. */ |
| self->userParams.numOutChannelsMin = self->userParams.numOutChannelsMax; |
| } |
| break; |
| |
| case DMX_DUAL_CHANNEL_MODE: |
| switch ((DUAL_CHANNEL_MODE)value) { |
| case STEREO_MODE: |
| case CH1_MODE: |
| case CH2_MODE: |
| case MIXED_MODE: |
| break; |
| default: |
| return (PCMDMX_UNABLE_TO_SET_PARAM); |
| } |
| if (self == NULL) |
| return (PCMDMX_INVALID_HANDLE); |
| self->userParams.dualChannelMode = (DUAL_CHANNEL_MODE)value; |
| self->applyProcessing = 1; /* Force processing */ |
| break; |
| |
| case DMX_PSEUDO_SURROUND_MODE: |
| switch ((PSEUDO_SURROUND_MODE)value) { |
| case NEVER_DO_PS_DMX: |
| case AUTO_PS_DMX: |
| case FORCE_PS_DMX: |
| break; |
| default: |
| return (PCMDMX_UNABLE_TO_SET_PARAM); |
| } |
| if (self == NULL) |
| return (PCMDMX_INVALID_HANDLE); |
| self->userParams.pseudoSurrMode = (PSEUDO_SURROUND_MODE)value; |
| break; |
| |
| default: |
| return (PCMDMX_UNKNOWN_PARAM); |
| } |
| |
| return (PCMDMX_OK); |
| } |
| |
| /** Get one parameter value of one PCM downmix module instance. |
| * @param [in] Handle of PCM downmix module instance. |
| * @param [in] Parameter to be set. |
| * @param [out] Pointer to buffer receiving the parameter value. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_GetParam ( |
| HANDLE_PCM_DOWNMIX self, |
| const PCMDMX_PARAM param, |
| INT * const pValue |
| ) |
| { |
| PCM_DMX_USER_PARAMS *pUsrParams; |
| |
| if ( (self == NULL) |
| || (pValue == NULL) ) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| pUsrParams = &self->userParams; |
| |
| switch (param) |
| { |
| case DMX_BS_DATA_EXPIRY_FRAME: |
| *pValue = (INT)pUsrParams->expiryFrame; |
| break; |
| case DMX_BS_DATA_DELAY: |
| *pValue = (INT)pUsrParams->frameDelay; |
| break; |
| case MIN_NUMBER_OF_OUTPUT_CHANNELS: |
| *pValue = (INT)pUsrParams->numOutChannelsMin; |
| break; |
| case MAX_NUMBER_OF_OUTPUT_CHANNELS: |
| *pValue = (INT)pUsrParams->numOutChannelsMax; |
| break; |
| case DMX_DUAL_CHANNEL_MODE: |
| *pValue = (INT)pUsrParams->dualChannelMode; |
| break; |
| case DMX_PSEUDO_SURROUND_MODE: |
| *pValue = (INT)pUsrParams->pseudoSurrMode; |
| break; |
| default: |
| return (PCMDMX_UNKNOWN_PARAM); |
| } |
| |
| return (PCMDMX_OK); |
| } |
| |
| |
| #ifdef DSE_METADATA_ENABLE |
| |
| #define MAX_DSE_ANC_BYTES ( 16 ) /* 15 bytes */ |
| #define ANC_DATA_SYNC_BYTE ( 0xBC ) /* ancillary data sync byte. */ |
| |
| /* |
| * Read DMX meta-data from a data stream element. |
| */ |
| PCMDMX_ERROR pcmDmx_Parse ( |
| HANDLE_PCM_DOWNMIX self, |
| HANDLE_FDK_BITSTREAM hBs, |
| UINT ancDataBits, |
| int isMpeg2 |
| ) |
| { |
| PCMDMX_ERROR errorStatus = PCMDMX_OK; |
| DMX_BS_META_DATA *pBsMetaData = &self->bsMetaData[0]; |
| |
| int skip4Dmx = 0, skip4Ext = 0; |
| int dmxLvlAvail = 0, extDataAvail = 0; |
| int foundNewData = 0; |
| UINT minAncBits = ((isMpeg2) ? 5 : 3)*8; |
| |
| if ( (self == NULL) |
| || (hBs == NULL) ) { return (PCMDMX_INVALID_HANDLE); } |
| |
| ancDataBits = FDKgetValidBits(hBs); |
| |
| /* sanity checks */ |
| if ( (ancDataBits < minAncBits) |
| || (ancDataBits > FDKgetValidBits(hBs)) ) { |
| return (PCMDMX_CORRUPT_ANC_DATA); |
| } |
| |
| pBsMetaData = &self->bsMetaData[0]; |
| |
| if (isMpeg2) { |
| /* skip DVD ancillary data */ |
| FDKpushFor(hBs, 16); |
| } |
| |
| /* check sync word */ |
| if (FDKreadBits(hBs,8) != ANC_DATA_SYNC_BYTE) { |
| return (PCMDMX_CORRUPT_ANC_DATA); |
| } |
| |
| /* skip MPEG audio type and Dolby surround mode */ |
| FDKpushFor(hBs, 4); |
| |
| if (isMpeg2) { |
| /* int numAncBytes = */ FDKreadBits(hBs, 4); |
| /* advanced dynamic range control */ |
| if (FDKreadBit(hBs)) skip4Dmx += 24; |
| /* dialog normalization */ |
| if (FDKreadBit(hBs)) skip4Dmx += 8; |
| /* reproduction_level */ |
| if (FDKreadBit(hBs)) skip4Dmx += 8; |
| } else { |
| FDKpushFor(hBs, 2); /* drc presentation mode */ |
| pBsMetaData->pseudoSurround = FDKreadBit(hBs); |
| FDKpushFor(hBs, 4); /* reserved bits */ |
| } |
| |
| /* downmixing levels MPEGx status */ |
| dmxLvlAvail = FDKreadBit(hBs); |
| |
| if (isMpeg2) { |
| /* scale factor CRC status */ |
| if (FDKreadBit(hBs)) skip4Ext += 16; |
| } else { |
| /* ancillary data extension status */ |
| extDataAvail = FDKreadBit(hBs); |
| } |
| |
| /* audio coding and compression status */ |
| if (FDKreadBit(hBs)) skip4Ext += 16; |
| /* coarse grain timecode status */ |
| if (FDKreadBit(hBs)) skip4Ext += 16; |
| /* fine grain timecode status */ |
| if (FDKreadBit(hBs)) skip4Ext += 16; |
| |
| /* skip the useless data to get to the DMX levels */ |
| FDKpushFor(hBs, skip4Dmx); |
| |
| /* downmix_levels_MPEGX */ |
| if (dmxLvlAvail) |
| { |
| if (FDKreadBit(hBs)) { /* center_mix_level_on */ |
| pBsMetaData->cLevIdx = FDKreadBits(hBs, 3); |
| foundNewData = 1; |
| } else { |
| FDKreadBits(hBs, 3); |
| } |
| if (FDKreadBit(hBs)) { /* surround_mix_level_on */ |
| pBsMetaData->sLevIdx = FDKreadBits(hBs, 3); |
| foundNewData = 1; |
| } else { |
| FDKreadBits(hBs, 3); |
| } |
| } |
| |
| /* skip the useless data to get to the ancillary data extension */ |
| FDKpushFor(hBs, skip4Ext); |
| |
| /* anc data extension (MPEG-4 only) */ |
| if (extDataAvail) { |
| int extDmxLvlSt, extDmxGainSt, extDmxLfeSt; |
| |
| FDKreadBit(hBs); /* reserved bit */ |
| extDmxLvlSt = FDKreadBit(hBs); |
| extDmxGainSt = FDKreadBit(hBs); |
| extDmxLfeSt = FDKreadBit(hBs); |
| FDKreadBits(hBs, 4); /* reserved bits */ |
| |
| if (extDmxLvlSt) { |
| pBsMetaData->dmixIdxA = FDKreadBits(hBs, 3); |
| pBsMetaData->dmixIdxB = FDKreadBits(hBs, 3); |
| FDKreadBits(hBs, 2); /* reserved bits */ |
| foundNewData = 1; |
| } |
| if (extDmxGainSt) { |
| pBsMetaData->dmxGainIdx5 = FDKreadBits(hBs, 7); |
| FDKreadBit(hBs); /* reserved bit */ |
| pBsMetaData->dmxGainIdx2 = FDKreadBits(hBs, 7); |
| FDKreadBit(hBs); /* reserved bit */ |
| foundNewData = 1; |
| } |
| if (extDmxLfeSt) { |
| pBsMetaData->dmixIdxLfe = FDKreadBits(hBs, 4); |
| FDKreadBits(hBs, 4); /* reserved bits */ |
| foundNewData = 1; |
| } |
| } |
| |
| /* final sanity check on the amount of read data */ |
| if ((INT)FDKgetValidBits(hBs) < 0) { |
| errorStatus = PCMDMX_CORRUPT_ANC_DATA; |
| } |
| |
| if ( (errorStatus == PCMDMX_OK) |
| && (foundNewData == 1) ) { |
| /* announce new data */ |
| pBsMetaData->typeFlags |= TYPE_DSE_DATA; |
| /* reset expiry counter */ |
| pBsMetaData->expiryCount = 0; |
| } |
| |
| return (errorStatus); |
| } |
| |
| /* |
| * Read DMX meta-data from a data stream element. |
| */ |
| PCMDMX_ERROR pcmDmx_ReadDvbAncData ( |
| HANDLE_PCM_DOWNMIX self, |
| UCHAR *pAncDataBuf, |
| UINT ancDataBytes, |
| int isMpeg2 |
| ) |
| { |
| FDK_BITSTREAM bs; |
| HANDLE_FDK_BITSTREAM hBs = &bs; |
| PCMDMX_ERROR errorStatus = PCMDMX_OK; |
| |
| if (self == NULL) { return (PCMDMX_INVALID_HANDLE); } |
| |
| /* sanity checks */ |
| if ( (pAncDataBuf == NULL) |
| || (ancDataBytes == 0) ) { |
| return (PCMDMX_CORRUPT_ANC_DATA); |
| } |
| |
| FDKinitBitStream (hBs, pAncDataBuf, MAX_DSE_ANC_BYTES, ancDataBytes*8, BS_READER); |
| |
| errorStatus = pcmDmx_Parse ( |
| self, |
| hBs, |
| ancDataBytes*8, |
| isMpeg2 ); |
| |
| return (errorStatus); |
| } |
| #endif /* DSE_METADATA_ENABLE */ |
| |
| #ifdef PCE_METADATA_ENABLE |
| /** Set the matrix mixdown information extracted from the PCE of an AAC bitstream. |
| * Note: Call only if matrix_mixdown_idx_present is true. |
| * @param [in] Handle of PCM downmix module instance. |
| * @param [in] The 2 bit matrix mixdown index extracted from PCE. |
| * @param [in] The pseudo surround enable flag extracted from PCE. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_SetMatrixMixdownFromPce ( |
| HANDLE_PCM_DOWNMIX self, |
| int matrixMixdownPresent, |
| int matrixMixdownIdx, |
| int pseudoSurroundEnable |
| ) |
| { |
| DMX_BS_META_DATA *pBsMetaData = &self->bsMetaData[0]; |
| |
| if (self == NULL) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| |
| if (matrixMixdownPresent) { |
| pBsMetaData->pseudoSurround = pseudoSurroundEnable; |
| pBsMetaData->matrixMixdownIdx = matrixMixdownIdx & 0x03; |
| pBsMetaData->typeFlags |= TYPE_PCE_DATA; |
| /* Reset expiry counter */ |
| pBsMetaData->expiryCount = 0; |
| } |
| |
| return (PCMDMX_OK); |
| } |
| #endif /* PCE_METADATA_ENABLE */ |
| |
| |
| /** Apply down or up mixing. |
| * @param [in] Handle of PCM downmix module instance. |
| * @param [inout] Pointer to buffer that hold the time domain signal. |
| * @param [in] Pointer where the amount of output samples is returned into. |
| * @param [inout] Pointer where the amount of output channels is returned into. |
| * @param [in] Flag which indicates if output time data are writtern interleaved or as subsequent blocks. |
| * @param [inout] Array where the corresponding channel type for each output audio channel is stored into. |
| * @param [inout] Array where the corresponding channel type index for each output audio channel is stored into. |
| * @param [in] Array containing the out channel mapping to be used (From MPEG PCE ordering to whatever is required). |
| * @param [out] Pointer on a field receiving the scale factor that has to be applied on all samples afterwards. |
| * If the handed pointer is NULL scaling is done internally. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_ApplyFrame ( |
| HANDLE_PCM_DOWNMIX self, |
| INT_PCM *pPcmBuf, |
| UINT frameSize, |
| INT *nChannels, |
| int fInterleaved, |
| AUDIO_CHANNEL_TYPE channelType[], |
| UCHAR channelIndices[], |
| const UCHAR channelMapping[][8], |
| INT *pDmxOutScale |
| ) |
| { |
| PCM_DMX_USER_PARAMS *pParam = NULL; |
| PCMDMX_ERROR errorStatus = PCMDMX_OK; |
| DUAL_CHANNEL_MODE dualChannelMode; |
| PCM_DMX_CHANNEL_MODE inChMode; |
| PCM_DMX_CHANNEL_MODE outChMode; |
| INT devNull; /* Just a dummy to avoid a lot of branches in the code */ |
| int numOutChannels, numInChannels; |
| int inStride, outStride, offset; |
| int dmxMaxScale, dmxScale; |
| int ch, slot; |
| UCHAR inOffsetTable[PCM_DMX_MAX_CHANNELS]; |
| |
| DMX_BS_META_DATA bsMetaData; |
| |
| if ( (self == NULL) |
| || (nChannels == NULL) |
| || (channelType == NULL) |
| || (channelIndices == NULL) |
| || (channelMapping == NULL) ) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| |
| /* Init the output scaling */ |
| dmxScale = 0; |
| if (pDmxOutScale != NULL) { |
| /* Avoid final scaling internally and hand it to the outside world. */ |
| *pDmxOutScale = 0; |
| dmxMaxScale = PCMDMX_MAX_HEADROOM; |
| } else { |
| /* Apply the scaling internally. */ |
| pDmxOutScale = &devNull; /* redirect to temporal stack memory */ |
| dmxMaxScale = 0; |
| } |
| |
| pParam = &self->userParams; |
| numInChannels = *nChannels; |
| |
| /* Perform some input sanity checks */ |
| if (pPcmBuf == NULL) { return (PCMDMX_INVALID_ARGUMENT); } |
| if (frameSize == 0) { return (PCMDMX_INVALID_ARGUMENT); } |
| if ( (numInChannels == 0) |
| || (numInChannels > PCM_DMX_MAX_IN_CHANNELS) ) |
| { return (PCMDMX_INVALID_ARGUMENT); } |
| |
| /* Check on misconfiguration */ |
| FDK_ASSERT( (pParam->numOutChannelsMax <= 0) \ |
| || (pParam->numOutChannelsMax >= pParam->numOutChannelsMin)); |
| |
| /* Determine if the module has to do processing */ |
| if ( (self->applyProcessing == 0) |
| && ((pParam->numOutChannelsMax <= 0) |
| || (pParam->numOutChannelsMax >= numInChannels)) |
| && (pParam->numOutChannelsMin <= numInChannels) ) { |
| /* Nothing to do */ |
| return (errorStatus); |
| } |
| |
| /* Determine the number of output channels */ |
| if ( (pParam->numOutChannelsMax > 0) |
| && (numInChannels > pParam->numOutChannelsMax) ) { |
| numOutChannels = pParam->numOutChannelsMax; |
| } |
| else if (numInChannels < pParam->numOutChannelsMin) { |
| numOutChannels = pParam->numOutChannelsMin; |
| } |
| else { |
| numOutChannels = numInChannels; |
| } |
| |
| dualChannelMode = pParam->dualChannelMode; |
| |
| /* Analyse input channel configuration and get channel offset |
| * table that can be accessed with the fixed channel labels. */ |
| errorStatus = getChannelMode( |
| numInChannels, |
| channelType, |
| channelIndices, |
| inOffsetTable, |
| &inChMode |
| ); |
| if ( PCMDMX_IS_FATAL_ERROR(errorStatus) |
| || (inChMode == CH_MODE_UNDEFINED) ) { |
| /* We don't need to restore because the channel |
| configuration has not been changed. Just exit. */ |
| return (PCMDMX_INVALID_CH_CONFIG); |
| } |
| |
| /* Set input stride and offset */ |
| if (fInterleaved) { |
| inStride = numInChannels; |
| offset = 1; /* Channel specific offset factor */ |
| } else { |
| inStride = 1; |
| offset = frameSize; /* Channel specific offset factor */ |
| } |
| |
| /* Reset downmix meta data if necessary */ |
| if ( (pParam->expiryFrame > 0) |
| && (++self->bsMetaData[0].expiryCount > pParam->expiryFrame) ) |
| { /* The metadata read from bitstream is too old. */ |
| PCMDMX_ERROR err = pcmDmx_Reset(self, PCMDMX_RESET_BS_DATA); |
| FDK_ASSERT(err == PCMDMX_OK); |
| } |
| FDKmemcpy(&bsMetaData, &self->bsMetaData[pParam->frameDelay], sizeof(DMX_BS_META_DATA)); |
| /* Maintain delay line */ |
| for (slot = pParam->frameDelay; slot > 0; slot -= 1) { |
| FDKmemcpy(&self->bsMetaData[slot], &self->bsMetaData[slot-1], sizeof(DMX_BS_META_DATA)); |
| } |
| |
| /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ |
| #ifdef PCM_DOWNMIX_ENABLE |
| if ( numInChannels > numOutChannels ) |
| { /* Apply downmix */ |
| INT_PCM *pInPcm[PCM_DMX_MAX_IN_CHANNELS] = { NULL }; |
| INT_PCM *pOutPcm[PCM_DMX_MAX_OUT_CHANNELS] = { NULL }; |
| FIXP_DMX mixFactors[PCM_DMX_MAX_CHANNELS][PCM_DMX_MAX_CHANNELS]; |
| UCHAR outOffsetTable[PCM_DMX_MAX_CHANNELS]; |
| UINT sample; |
| int chCfg = 0; |
| int bypScale = 0; |
| |
| #if (PCM_DMX_MAX_IN_CHANNELS >= 7) |
| if (numInChannels > SIX_CHANNEL) { |
| AUDIO_CHANNEL_TYPE multiPurposeChType[2]; |
| |
| /* Get the type of the multipurpose channels */ |
| multiPurposeChType[0] = channelType[inOffsetTable[LEFT_MULTIPRPS_CHANNEL]]; |
| multiPurposeChType[1] = channelType[inOffsetTable[RIGHT_MULTIPRPS_CHANNEL]]; |
| |
| /* Check if the input configuration is one defined in the standard. */ |
| switch (inChMode) { |
| case CH_MODE_5_0_2_1: /* chCfg 7 || 14 */ |
| /* Further analyse the input config to distinguish the two CH_MODE_5_0_2_1 configs. */ |
| if ( (multiPurposeChType[0] == ACT_FRONT_TOP) |
| && (multiPurposeChType[1] == ACT_FRONT_TOP) ) { |
| chCfg = 14; |
| } else { |
| chCfg = 7; |
| } |
| break; |
| case CH_MODE_3_0_3_1: /* chCfg 11 */ |
| chCfg = 11; |
| break; |
| case CH_MODE_3_0_4_1: /* chCfg 12 */ |
| chCfg = 12; |
| break; |
| default: |
| chCfg = 0; /* Not a known config */ |
| break; |
| } |
| } |
| #endif |
| |
| /* Set this stages output stride and channel mode: */ |
| outStride = (fInterleaved) ? numOutChannels : 1; |
| outChMode = outChModeTable[numOutChannels]; |
| |
| /* Get channel description and channel mapping for the desired output configuration. */ |
| getChannelDescription( |
| outChMode, |
| channelMapping, |
| channelType, |
| channelIndices, |
| outOffsetTable |
| ); |
| /* Now there is no way back because we modified the channel configuration! */ |
| |
| /* Create the DMX matrix */ |
| errorStatus = getMixFactors ( |
| (chCfg>0) ? 1 : 0, |
| (chCfg>0) ? (PCM_DMX_CHANNEL_MODE)chCfg : inChMode, |
| outChMode, |
| pParam, |
| &bsMetaData, |
| mixFactors, |
| &dmxScale |
| ); |
| /* No fatal errors can occur here. The function is designed to always return a valid matrix. |
| The error code is used to signal configurations and matrices that are not conform to any standard. */ |
| |
| /* Determine the final scaling */ |
| bypScale = FDKmin(dmxMaxScale, dmxScale); |
| *pDmxOutScale += bypScale; |
| dmxScale -= bypScale; |
| |
| { /* Set channel pointer for input. Remove empty cols. */ |
| int inCh, outCh, map[PCM_DMX_MAX_CHANNELS]; |
| ch = 0; |
| for (inCh=0; inCh < PCM_DMX_MAX_CHANNELS; inCh+=1) { |
| if (inOffsetTable[inCh] != 255) { |
| pInPcm[ch] = &pPcmBuf[inOffsetTable[inCh]*offset]; |
| map[ch++] = inCh; |
| } |
| } |
| if (ch != numInChannels) { |
| ALOGE("b/23876444"); |
| return PCMDMX_INVALID_ARGUMENT; |
| } |
| |
| /* Remove unused cols from factor matrix */ |
| for (inCh=0; inCh < numInChannels; inCh+=1) { |
| if (inCh != map[inCh]) { |
| int outCh; |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| mixFactors[outCh][inCh] = mixFactors[outCh][map[inCh]]; |
| } |
| } |
| } |
| |
| /* Set channel pointer for output. Remove empty cols. */ |
| ch = 0; |
| for (outCh=0; outCh < PCM_DMX_MAX_CHANNELS; outCh+=1) { |
| if (outOffsetTable[outCh] != 255) { |
| pOutPcm[ch] = &pPcmBuf[outOffsetTable[outCh]*offset]; |
| map[ch++] = outCh; |
| } |
| } |
| FDK_ASSERT(ch == numOutChannels); |
| |
| /* Remove unused rows from factor matrix */ |
| for (outCh=0; outCh < numOutChannels; outCh+=1) { |
| if (outCh != map[outCh]) { |
| FDKmemcpy(&mixFactors[outCh], &mixFactors[map[outCh]], PCM_DMX_MAX_CHANNELS*sizeof(FIXP_DMX)); |
| } |
| } |
| } |
| |
| /* Sample processing loop */ |
| for (sample = 0; sample < frameSize; sample++) |
| { |
| FIXP_PCM tIn[PCM_DMX_MAX_IN_CHANNELS]; |
| FIXP_DBL tOut[PCM_DMX_MAX_OUT_CHANNELS] = { (FIXP_DBL)0 }; |
| int inCh, outCh; |
| |
| /* Preload all input samples */ |
| for (inCh=0; inCh < numInChannels; inCh+=1) { |
| tIn[inCh] = (FIXP_PCM)*pInPcm[inCh]; |
| pInPcm[inCh] += inStride; |
| } |
| /* Apply downmix coefficients to input samples and accumulate for output */ |
| for (outCh=0; outCh < numOutChannels; outCh+=1) { |
| for (inCh=0; inCh < numInChannels; inCh+=1) { |
| tOut[outCh] += fMult(tIn[inCh], mixFactors[outCh][inCh]); |
| } |
| /* Write sample */ |
| #if (SAMPLE_BITS == DFRACT_BITS) |
| *pOutPcm[outCh] = (INT_PCM)SATURATE_LEFT_SHIFT(tOut[outCh], dmxScale, SAMPLE_BITS); |
| #else |
| *pOutPcm[outCh] = (INT_PCM)SATURATE_RIGHT_SHIFT(tOut[outCh], DFRACT_BITS-SAMPLE_BITS-dmxScale, SAMPLE_BITS); |
| #endif |
| pOutPcm[outCh] += outStride; |
| } |
| } |
| |
| /* Update the number of output channels */ |
| *nChannels = numOutChannels; |
| |
| } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ |
| else |
| #endif /* PCM_DOWNMIX_ENABLE */ |
| #ifdef PCM_CHANNEL_EXTENSION_ENABLE |
| if ( numInChannels < numOutChannels ) |
| { /* Apply rudimentary upmix */ |
| /* Set up channel pointer */ |
| UINT sample; |
| UCHAR outOffsetTable[PCM_DMX_MAX_CHANNELS]; |
| |
| /* FIRST STAGE |
| Create a stereo/dual channel signal */ |
| if (numInChannels == ONE_CHANNEL) |
| { |
| INT_PCM *pInPcm[PCM_DMX_MAX_CHANNELS]; |
| INT_PCM *pOutLF, *pOutRF; |
| |
| /* Set this stages output stride and channel mode: */ |
| outStride = (fInterleaved) ? TWO_CHANNEL : 1; |
| outChMode = outChModeTable[TWO_CHANNEL]; |
| |
| /* Get channel description and channel mapping for this |
| * stages number of output channels (always STEREO). */ |
| getChannelDescription( |
| outChMode, |
| channelMapping, |
| channelType, |
| channelIndices, |
| outOffsetTable |
| ); |
| /* Now there is no way back because we modified the channel configuration! */ |
| |
| /* Set input channel pointer. The first channel is always at index 0. */ |
| pInPcm[CENTER_FRONT_CHANNEL] = &pPcmBuf[(frameSize-1)*inStride]; /* Considering input mapping could lead to a invalid pointer |
| here if the channel is not declared to be a front channel. */ |
| |
| /* Set output channel pointer (for this stage). */ |
| pOutLF = &pPcmBuf[outOffsetTable[LEFT_FRONT_CHANNEL]*offset+(frameSize-1)*outStride]; |
| pOutRF = &pPcmBuf[outOffsetTable[RIGHT_FRONT_CHANNEL]*offset+(frameSize-1)*outStride]; |
| |
| /* 1/0 input: */ |
| for (sample = 0; sample < frameSize; sample++) { |
| /* L' = C; R' = C; */ |
| *pOutLF = *pOutRF = *pInPcm[CENTER_FRONT_CHANNEL]; |
| |
| pInPcm[CENTER_FRONT_CHANNEL] -= inStride; |
| pOutLF -= outStride; pOutRF -= outStride; |
| } |
| |
| /* Prepare for next stage: */ |
| inStride = outStride; |
| inChMode = outChMode; |
| FDKmemcpy(inOffsetTable, outOffsetTable, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| } |
| |
| #if (PCM_DMX_MAX_OUT_CHANNELS > 2) |
| /* SECOND STAGE |
| Extend with zero channels to achieved the desired number of output channels. */ |
| if (numOutChannels > TWO_CHANNEL) |
| { |
| INT_PCM *pIn[PCM_DMX_MAX_CHANNELS] = { NULL }; |
| INT_PCM *pOut[PCM_DMX_MAX_CHANNELS] = { NULL }; |
| AUDIO_CHANNEL_TYPE inChTypes[PCM_DMX_MAX_CHANNELS]; |
| UCHAR inChIndices[PCM_DMX_MAX_CHANNELS]; |
| UCHAR numChPerGrp[2][PCM_DMX_MAX_CHANNEL_GROUPS]; |
| int nContentCh = 0; /* Number of channels with content */ |
| int nEmptyCh = 0; /* Number of channels with content */ |
| int ch, chGrp, isCompatible = 1; |
| |
| /* Do not change the signalling which is the channel types and indices. |
| Just reorder and add channels. So first save the input signalling. */ |
| FDKmemcpy(inChTypes, channelType, PCM_DMX_MAX_CHANNELS*sizeof(AUDIO_CHANNEL_TYPE)); |
| FDKmemcpy(inChIndices, channelIndices, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| |
| /* Set this stages output stride and channel mode: */ |
| outStride = (fInterleaved) ? numOutChannels : 1; |
| outChMode = outChModeTable[numOutChannels]; |
| |
| /* Check if input channel config can be easily mapped to the desired output config. */ |
| for (chGrp = 0; chGrp < PCM_DMX_MAX_CHANNEL_GROUPS; chGrp += 1) { |
| numChPerGrp[IN][chGrp] = (inChMode >> (chGrp*4)) & 0xF; |
| numChPerGrp[OUT][chGrp] = (outChMode >> (chGrp*4)) & 0xF; |
| |
| if (numChPerGrp[IN][chGrp] > numChPerGrp[OUT][chGrp]) { |
| isCompatible = 0; |
| break; |
| } |
| } |
| |
| if ( isCompatible ) { |
| /* Get new channel description and channel |
| * mapping for the desired output channel mode. */ |
| getChannelDescription( |
| outChMode, |
| channelMapping, |
| channelType, |
| channelIndices, |
| outOffsetTable |
| ); |
| /* If the input config has a back center channel but the output |
| config has not, copy it to left and right (if available). */ |
| if ( (numChPerGrp[IN][CH_GROUP_REAR]%2) |
| && !(numChPerGrp[OUT][CH_GROUP_REAR]%2) ) { |
| if (numChPerGrp[IN][CH_GROUP_REAR] == 1) { |
| inOffsetTable[RIGHT_REAR_CHANNEL] = inOffsetTable[LEFT_REAR_CHANNEL]; |
| } else if (numChPerGrp[IN][CH_GROUP_REAR] == 3) { |
| inOffsetTable[RIGHT_MULTIPRPS_CHANNEL] = inOffsetTable[LEFT_MULTIPRPS_CHANNEL]; |
| } |
| } |
| } |
| else { |
| /* Just copy and extend the original config */ |
| FDKmemcpy(outOffsetTable, inOffsetTable, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR)); |
| } |
| |
| /* Set I/O channel pointer. |
| Note: The following assignment algorithm clears the channel offset tables. |
| Thus they can not be used afterwards. */ |
| for (ch = 0; ch < PCM_DMX_MAX_CHANNELS; ch+=1) { |
| if ( (outOffsetTable[ch] < 255) |
| && (inOffsetTable[ch] < 255) ) |
| { /* Set I/O pointer: */ |
| pIn[nContentCh] = &pPcmBuf[inOffsetTable[ch]*offset+(frameSize-1)*inStride]; |
| pOut[nContentCh] = &pPcmBuf[outOffsetTable[ch]*offset+(frameSize-1)*outStride]; |
| /* Update signalling */ |
| channelType[outOffsetTable[ch]] = inChTypes[inOffsetTable[ch]]; |
| channelIndices[outOffsetTable[ch]] = inChIndices[inOffsetTable[ch]]; |
| inOffsetTable[ch] = 255; |
| outOffsetTable[ch] = 255; |
| nContentCh += 1; |
| } |
| } |
| if ( isCompatible ) { |
| /* Assign the remaining input channels. |
| This is just a safety appliance. We should never need it. */ |
| for (ch = 0; ch < PCM_DMX_MAX_CHANNELS; ch+=1) { |
| if (inOffsetTable[ch] < 255) { |
| int outCh; |
| for (outCh = 0 ; outCh < PCM_DMX_MAX_CHANNELS; outCh += 1) { |
| if (outOffsetTable[outCh] < 255) { |
| break; |
| } |
| } |
| /* Set I/O pointer: */ |
| pIn[nContentCh] = &pPcmBuf[inOffsetTable[ch]*offset+(frameSize-1)*inStride]; |
| pOut[nContentCh] = &pPcmBuf[outOffsetTable[outCh]*offset+(frameSize-1)*outStride]; |
| /* Update signalling */ |
| channelType[outOffsetTable[outCh]] = inChTypes[inOffsetTable[ch]]; |
| channelIndices[outOffsetTable[outCh]] = inChIndices[inOffsetTable[ch]]; |
| inOffsetTable[ch] = 255; |
| outOffsetTable[outCh] = 255; |
| nContentCh += 1; |
| } |
| } |
| /* Set the remaining output channel pointer */ |
| for (ch = 0; ch < PCM_DMX_MAX_CHANNELS; ch+=1) { |
| if (outOffsetTable[ch] < 255) { |
| pOut[nContentCh+nEmptyCh] = &pPcmBuf[outOffsetTable[ch]*offset+(frameSize-1)*outStride]; |
| /* Expand output signalling */ |
| channelType[outOffsetTable[ch]] = ACT_NONE; |
| channelIndices[outOffsetTable[ch]] = nEmptyCh; |
| outOffsetTable[ch] = 255; |
| nEmptyCh += 1; |
| } |
| } |
| } |
| else { |
| /* Set the remaining output channel pointer */ |
| for (ch = nContentCh; ch < numOutChannels; ch+=1) { |
| pOut[ch] = &pPcmBuf[ch*offset+(frameSize-1)*outStride]; |
| /* Expand output signalling */ |
| channelType[ch] = ACT_NONE; |
| channelIndices[ch] = nEmptyCh; |
| nEmptyCh += 1; |
| } |
| } |
| |
| /* First copy the channels that have signal */ |
| for (sample = 0; sample < frameSize; sample+=1) { |
| INT_PCM tIn[PCM_DMX_MAX_CHANNELS]; |
| /* Read all channel samples */ |
| for (ch = 0; ch < nContentCh; ch+=1) { |
| tIn[ch] = *pIn[ch]; |
| pIn[ch] -= inStride; |
| } |
| /* Write all channel samples */ |
| for (ch = 0; ch < nContentCh; ch+=1) { |
| *pOut[ch] = tIn[ch]; |
| pOut[ch] -= outStride; |
| } |
| } |
| |
| /* Clear all the other channels */ |
| for (sample = 0; sample < frameSize; sample++) { |
| for (ch = nContentCh; ch < numOutChannels; ch+=1) { |
| *pOut[ch] = (INT_PCM)0; |
| pOut[ch] -= outStride; |
| } |
| } |
| } |
| #endif /* if (PCM_DMX_MAX_OUT_CHANNELS > 2) */ |
| |
| /* update the number of output channels */ |
| *nChannels = numOutChannels; |
| } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ |
| else |
| #endif /* PCM_CHANNEL_EXTENSION_ENABLE */ |
| if ( numInChannels == numOutChannels ) |
| { |
| /* Don't need to change the channel description here */ |
| |
| switch (numInChannels) |
| { |
| case 2: |
| { /* Set up channel pointer */ |
| INT_PCM *pInPcm[PCM_DMX_MAX_CHANNELS]; |
| INT_PCM *pOutL, *pOutR; |
| FIXP_DMX flev; |
| |
| UINT sample; |
| int inStride, outStride, offset; |
| |
| if (fInterleaved) { |
| inStride = numInChannels; |
| outStride = 2; /* fixed !!! (below stereo is donwmixed to mono if required */ |
| offset = 1; /* Channel specific offset factor */ |
| } else { |
| inStride = 1; |
| outStride = 1; |
| offset = frameSize; /* Channel specific offset factor */ |
| } |
| |
| /* Set input channel pointer */ |
| pInPcm[LEFT_FRONT_CHANNEL] = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset]; |
| pInPcm[RIGHT_FRONT_CHANNEL] = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset]; |
| |
| /* Set output channel pointer (same as input) */ |
| pOutL = pInPcm[LEFT_FRONT_CHANNEL]; |
| pOutR = pInPcm[RIGHT_FRONT_CHANNEL]; |
| |
| /* Set downmix levels: */ |
| flev = FL2FXCONST_DMX(0.70710678f); |
| /* 2/0 input: */ |
| switch (dualChannelMode) |
| { |
| case CH1_MODE: /* L' = 0.707 * Ch1; R' = 0.707 * Ch1 */ |
| for (sample = 0; sample < frameSize; sample++) { |
| *pOutL = *pOutR = |
| (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInPcm[LEFT_FRONT_CHANNEL], flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS); |
| |
| pInPcm[LEFT_FRONT_CHANNEL] += inStride; |
| pOutL += outStride; pOutR += outStride; |
| } |
| break; |
| case CH2_MODE: /* L' = 0.707 * Ch2; R' = 0.707 * Ch2 */ |
| for (sample = 0; sample < frameSize; sample++) { |
| *pOutL = *pOutR = |
| (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInPcm[RIGHT_FRONT_CHANNEL], flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS); |
| |
| pInPcm[RIGHT_FRONT_CHANNEL] += inStride; |
| pOutL += outStride; pOutR += outStride; |
| } |
| break; |
| case MIXED_MODE: /* L' = 0.5*Ch1 + 0.5*Ch2; R' = 0.5*Ch1 + 0.5*Ch2 */ |
| for (sample = 0; sample < frameSize; sample++) { |
| *pOutL = *pOutR = (*pInPcm[LEFT_FRONT_CHANNEL] >> 1) + (*pInPcm[RIGHT_FRONT_CHANNEL] >> 1); |
| |
| pInPcm[LEFT_FRONT_CHANNEL] += inStride; pInPcm[RIGHT_FRONT_CHANNEL] += inStride; |
| pOutL += outStride; pOutR += outStride; |
| } |
| break; |
| default: |
| case STEREO_MODE: |
| /* nothing to do */ |
| break; |
| } |
| } |
| break; |
| |
| default: |
| /* nothing to do */ |
| break; |
| } |
| } |
| |
| return (errorStatus); |
| } |
| |
| |
| /** Close an instance of the PCM downmix module. |
| * @param [inout] Pointer to a buffer containing the handle of the instance. |
| * @returns Returns an error code. |
| **/ |
| PCMDMX_ERROR pcmDmx_Close ( |
| HANDLE_PCM_DOWNMIX *pSelf |
| ) |
| { |
| if (pSelf == NULL) { |
| return (PCMDMX_INVALID_HANDLE); |
| } |
| |
| FreePcmDmxInstance( pSelf ); |
| *pSelf = NULL; |
| |
| return (PCMDMX_OK); |
| } |
| |
| |
| /** Get library info for this module. |
| * @param [out] Pointer to an allocated LIB_INFO structure. |
| * @returns Returns an error code. |
| */ |
| PCMDMX_ERROR pcmDmx_GetLibInfo( LIB_INFO *info ) |
| { |
| int i; |
| |
| if (info == NULL) { |
| return PCMDMX_INVALID_ARGUMENT; |
| } |
| |
| /* Search for next free tab */ |
| for (i = 0; i < FDK_MODULE_LAST; i++) { |
| if (info[i].module_id == FDK_NONE) break; |
| } |
| if (i == FDK_MODULE_LAST) { |
| return PCMDMX_UNKNOWN; |
| } |
| |
| /* Add the library info */ |
| info[i].module_id = FDK_PCMDMX; |
| info[i].version = LIB_VERSION(PCMDMX_LIB_VL0, PCMDMX_LIB_VL1, PCMDMX_LIB_VL2); |
| LIB_VERSION_STRING(info+i); |
| info[i].build_date = PCMDMX_LIB_BUILD_DATE; |
| info[i].build_time = PCMDMX_LIB_BUILD_TIME; |
| info[i].title = PCMDMX_LIB_TITLE; |
| |
| /* Set flags */ |
| info[i].flags = 0 |
| #ifdef PCM_DOWNMIX_ENABLE |
| | CAPF_DMX_BLIND /* At least blind downmixing is possible */ |
| #ifdef PCE_METADATA_ENABLE |
| | CAPF_DMX_PCE /* Guided downmix with data from MPEG-2/4 Program Config Elements (PCE). */ |
| #ifdef ARIB_MIXDOWN_ENABLE |
| | CAPF_DMX_ARIB /* PCE guided downmix with slightly different equations and levels. */ |
| #endif |
| #endif /* PCE_METADATA_ENABLE */ |
| #ifdef DSE_METADATA_ENABLE |
| | CAPF_DMX_DVB /* Guided downmix with data from DVB ancillary data fields. */ |
| #endif |
| #endif /* PCM_DOWNMIX_ENABLE */ |
| #ifdef PCM_CHANNEL_EXTENSION_ENABLE |
| | CAPF_DMX_CH_EXP /* Simple upmixing by dublicating channels or adding zero channels. */ |
| #endif |
| ; |
| |
| /* Add lib info for FDK tools (if not yet done). */ |
| FDK_toolsGetLibInfo(info); |
| |
| return PCMDMX_OK; |
| } |
| |
| |
| |