PageRenderTime 759ms CodeModel.GetById 101ms app.highlight 579ms RepoModel.GetById 65ms app.codeStats 1ms

/libPCMutils/src/pcmutils_lib.cpp

https://bitbucket.org/bohlooli/aac
C++ | 1278 lines | 825 code | 164 blank | 289 comment | 142 complexity | bea0d39743a9ff6b47baf9557e3b14c4 MD5 | raw file
   1
   2/* -----------------------------------------------------------------------------------------------------------
   3Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5� Copyright  1995 - 2012 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
   6  All rights reserved.
   7
   8 1.    INTRODUCTION
   9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
  10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
  11This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
  12
  13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
  14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
  15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
  16of the MPEG specifications.
  17
  18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
  19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
  20individually for the purpose of encoding or decoding bit streams in products that are compliant with
  21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
  22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
  23software may already be covered under those patent licenses when it is used for those licensed purposes only.
  24
  25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
  26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
  27applications information and documentation.
  28
  292.    COPYRIGHT LICENSE
  30
  31Redistribution and use in source and binary forms, with or without modification, are permitted without
  32payment of copyright license fees provided that you satisfy the following conditions:
  33
  34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
  35your modifications thereto in source code form.
  36
  37You must retain the complete text of this software license in the documentation and/or other materials
  38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
  39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
  40modifications thereto to recipients of copies in binary form.
  41
  42The name of Fraunhofer may not be used to endorse or promote products derived from this library without
  43prior written permission.
  44
  45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
  46software or your modifications thereto.
  47
  48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
  49and the date of any change. For modified versions of the FDK AAC Codec, the term
  50"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
  51"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
  52
  533.    NO PATENT LICENSE
  54
  55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
  56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
  57respect to this software.
  58
  59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
  60by appropriate patent licenses.
  61
  624.    DISCLAIMER
  63
  64This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
  65"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
  66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
  68including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
  69or business interruption, however caused and on any theory of liability, whether in contract, strict
  70liability, or tort (including negligence), arising in any way out of the use of this software, even if
  71advised of the possibility of such damage.
  72
  735.    CONTACT INFORMATION
  74
  75Fraunhofer Institute for Integrated Circuits IIS
  76Attention: Audio and Multimedia Departments - FDK AAC LL
  77Am Wolfsmantel 33
  7891058 Erlangen, Germany
  79
  80www.iis.fraunhofer.de/amm
  81amm-info@iis.fraunhofer.de
  82----------------------------------------------------------------------------------------------------------- */
  83
  84/****************************  FDK PCM utils module  **************************
  85
  86   Author(s):   Christian Griebel
  87   Description: Defines functions to interface with the PCM post processing
  88                module.
  89
  90*******************************************************************************/
  91
  92#include "pcmutils_lib.h"
  93
  94#include "genericStds.h"
  95#include "fixpoint_math.h"
  96
  97/* Decoder library info */
  98#define PCMDMX_LIB_VL0 2
  99#define PCMDMX_LIB_VL1 3
 100#define PCMDMX_LIB_VL2 1
 101#define PCMDMX_LIB_TITLE "PCM Downmix Lib"
 102#define PCMDMX_LIB_BUILD_DATE __DATE__
 103#define PCMDMX_LIB_BUILD_TIME __TIME__
 104
 105/* Library settings */
 106#define PCM_DMX_MAX_DELAY_FRAMES        ( 1 )
 107#define PCM_DMX_MAX_CHANNELS            ( 8 )
 108#define PCM_DMX_MAX_CHANNEL_GROUPS      ( 4 )
 109#define PCM_DMX_MAX_CHANNELS_PER_GROUP  ( 3 )   /* The maximum over all groups */
 110#define PCMDMX_DFLT_EXPIRY_FRAME        ( 50 )  /* At least 500ms (FL 960 @ 96kHz) */
 111
 112/* Fixed and unique channel group indices.
 113 * The last group index has to be smaller than PCM_DMX_MAX_CHANNEL_GROUPS. */
 114#define CH_GROUP_FRONT ( 0 )
 115#define CH_GROUP_SIDE  ( 1 )
 116#define CH_GROUP_REAR  ( 2 )
 117#define CH_GROUP_LFE   ( 3 )
 118
 119/* The ordering of the following fixed channel labels has to be in MPEG-4 style.
 120 * From the center to the back with left and right channel interleaved (starting with left).
 121 * The last channel label index has to be smaller than PCM_DMX_MAX_CHANNELS. */
 122#define CENTER_FRONT_CHANNEL    ( 0 )     /* C  */
 123#define LEFT_FRONT_CHANNEL      ( 1 )     /* L  */
 124#define RIGHT_FRONT_CHANNEL     ( 2 )     /* R  */
 125#define LEFT_OUTSIDE_CHANNEL    ( 3 )     /* Lo */
 126#define RIGHT_OUTSIDE_CHANNEL   ( 4 )     /* Ro */
 127#define LEFT_REAR_CHANNEL       ( 5 )     /* Lr  aka left back channel  */
 128#define RIGHT_REAR_CHANNEL      ( 6 )     /* Rr  aka right back channel */
 129#define LOW_FREQUENCY_CHANNEL   ( 7 )     /* Lf */
 130
 131/* More constants */
 132#define ANC_DATA_SYNC_BYTE      ( 0xBC )  /* ancillary data sync byte. */
 133#define ATTENUATION_FACTOR_1    ( FL2FXCONST_SGL(0.70710678f) )
 134#define TWO_CHANNEL             ( 2 )
 135
 136/* Sanity checks on library setting: */
 137
 138/* List of packed channel modes */
 139typedef enum
 140{ /* CH_MODE_<numFrontCh>_<numOutsideCh>_<numRearCh>_<numLfCh> */
 141  CH_MODE_UNDEFINED = 0x0000,
 142  /* 1 channel */
 143  CH_MODE_1_0_0_0   = 0x0001,   /* chCfg 1 */
 144  /* 2 channels */
 145  CH_MODE_2_0_0_0   = 0x0002,   /* chCfg 2 */
 146  /* 3 channels */
 147  CH_MODE_3_0_0_0   = 0x0003,   /* chCfg 3 */
 148  CH_MODE_2_0_1_0   = 0x0102,
 149  CH_MODE_2_0_0_1   = 0x1002,
 150  /* 4 channels */
 151  CH_MODE_3_0_1_0   = 0x0103,   /* chCfg 4 */
 152  CH_MODE_2_0_2_0   = 0x0202,
 153  CH_MODE_2_0_1_1   = 0x1102,
 154  /* 5 channels */
 155  CH_MODE_3_0_2_0   = 0x0203,   /* chCfg 5 */
 156  CH_MODE_2_0_2_1   = 0x1202,
 157  CH_MODE_3_0_1_1   = 0x1103,
 158  CH_MODE_3_2_0_0   = 0x0023,
 159  /* 6 channels */
 160  CH_MODE_3_0_2_1   = 0x1203,   /* chCfg 6 */
 161  CH_MODE_3_2_1_0   = 0x0123,
 162  /* 7 channels */
 163  CH_MODE_2_2_2_1   = 0x1222,
 164  CH_MODE_3_2_1_1   = 0x1123,
 165  CH_MODE_3_2_2_0   = 0x0223,
 166  /* 8 channels */
 167  CH_MODE_3_2_2_1   = 0x1222,   /* chCfg 7 */
 168  CH_MODE_3_2_1_2   = 0x2123,
 169  CH_MODE_2_2_2_2   = 0x2222
 170
 171} PCM_DMX_CHANNEL_MODE;
 172
 173
 174/* These are the channel configurations linked to
 175   the number of output channels give by the user: */
 176static const PCM_DMX_CHANNEL_MODE outChModeTable[PCM_DMX_MAX_CHANNELS] =
 177{
 178  CH_MODE_1_0_0_0,  /* 1 channel  */
 179  CH_MODE_2_0_0_0,  /* 2 channels */
 180  CH_MODE_3_0_0_0,  /* 3 channels */
 181  CH_MODE_3_0_1_0,  /* 4 channels */
 182  CH_MODE_3_0_2_0,  /* 5 channels */
 183  CH_MODE_3_0_2_1,  /* 6 channels */
 184  CH_MODE_3_2_2_0,  /* 7 channels */
 185  CH_MODE_3_2_2_1   /* 8 channels */
 186};
 187
 188static const FIXP_SGL dvbDownmixFactors[8] =
 189{
 190  FL2FXCONST_SGL(1.0f),
 191  FL2FXCONST_SGL(0.841f),
 192  FL2FXCONST_SGL(0.707f),
 193  FL2FXCONST_SGL(0.596f),
 194  FL2FXCONST_SGL(0.500f),
 195  FL2FXCONST_SGL(0.422f),
 196  FL2FXCONST_SGL(0.355f),
 197  FL2FXCONST_SGL(0.0f)
 198};
 199
 200
 201  /* MPEG matrix mixdown:
 202      Set 1:  L' = (1 + 2^-0.5 + A )^-1 * [L + C * 2^-0.5 + A * Ls];
 203              R' = (1 + 2^-0.5 + A )^-1 * [R + C * 2^-0.5 + A * Rs];
 204
 205      Set 2:  L' = (1 + 2^-0.5 + 2A )^-1 * [L + C * 2^-0.5 - A * (Ls + Rs)];
 206              R' = (1 + 2^-0.5 + 2A )^-1 * [R + C * 2^-0.5 + A * (Ls + Rs)];
 207
 208      M = (3 + 2A)^-1 * [L + C + R + A*(Ls + Rs)];
 209  */
 210  static const FIXP_SGL mpegMixDownIdx2Coef[4] =
 211  {
 212    FL2FXCONST_SGL(0.70710678f),
 213    FL2FXCONST_SGL(0.5f),
 214    FL2FXCONST_SGL(0.35355339f),
 215    FL2FXCONST_SGL(0.0f)
 216  };
 217
 218  static const FIXP_SGL mpegMixDownIdx2PreFact[4] =
 219  {
 220    FL2FXCONST_SGL(0.4142135623730950f),
 221    FL2FXCONST_SGL(0.4530818393219728f),
 222    FL2FXCONST_SGL(0.4852813742385703f),
 223    FL2FXCONST_SGL(0.5857864376269050f)
 224  };
 225
 226  typedef struct
 227  {
 228    USHORT  matrixMixdownIdx;       /*!< MPEG mixdown index extracted from PCE.            */
 229    USHORT  pseudoSurroundEnable;   /*!< Pseudo surround enable flag extracted from PCE.   */
 230    USHORT  mixdownAvailable;       /*!< Will be set to 1 if we found a valid coefficient. */
 231
 232  } MPEG_MIXDOWN_INFO;
 233
 234
 235typedef struct
 236{
 237  FIXP_SGL  centerMixLevelValue;    /*!< DVB mixdown level for the center channel extracted from anc data.  */
 238  FIXP_SGL  surroundMixLevelValue;  /*!< DVB mixdown level for back channels extracted from anc data.       */
 239
 240  UCHAR     mixLevelsAvail;         /*!< Will be set to 1 if we found a valid coefficient.                  */
 241
 242} DVB_MIXDOWN_LEVELS;
 243
 244
 245/* Modules main data structure: */
 246struct PCM_DMX_INSTANCE
 247{
 248  DVB_MIXDOWN_LEVELS  dvbMixDownLevels[PCM_DMX_MAX_DELAY_FRAMES+1];
 249  MPEG_MIXDOWN_INFO   mpegMixDownInfo[PCM_DMX_MAX_DELAY_FRAMES+1];
 250  DUAL_CHANNEL_MODE dualChannelMode;
 251  UINT expiryFrame;
 252  UINT expiryCount;
 253  SHORT numOutputChannels;
 254  UCHAR applyProcessing;
 255  UCHAR frameDelay;
 256};
 257
 258/* Memory allocation macro */
 259C_ALLOC_MEM_STATIC(PcmDmxInstance, struct PCM_DMX_INSTANCE, 1)
 260
 261
 262/** Evaluate a given channel configuration and extract a packed channel mode and generate a channel offset table
 263 *  This function is the inverse to the getChannelDescription() routine.
 264 * @param [in] The total number of channels of the given configuration.
 265 * @param [in] Array holding the corresponding channel types for each channel.
 266 * @param [in] Array holding the corresponding channel type indices for each channel.
 267 * @param [out] Array where the buffer offsets for each channel are stored into.
 268 * @returns Returns the packed channel mode.
 269 **/
 270static
 271PCM_DMX_CHANNEL_MODE getChannelMode (
 272        const INT                numChannels,                           /* in */
 273        const AUDIO_CHANNEL_TYPE channelType[],                         /* in */
 274        const UCHAR              channelIndices[],                      /* in */
 275        UCHAR                    offsetTable[PCM_DMX_MAX_CHANNELS]      /* out */
 276      )
 277{
 278  UINT  chMode = CH_MODE_UNDEFINED;
 279  UCHAR chIdx[PCM_DMX_MAX_CHANNEL_GROUPS][PCM_DMX_MAX_CHANNELS_PER_GROUP];
 280  UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS];
 281  int   ch, grpIdx, err = 0;
 282
 283  FDK_ASSERT(channelType != NULL);
 284  FDK_ASSERT(channelIndices != NULL);
 285  FDK_ASSERT(offsetTable != NULL);
 286
 287  /* For details see ISO/IEC 13818-7:2005(E), 8.5.3 Channel configuration */
 288  FDKmemclear(numChInGrp, PCM_DMX_MAX_CHANNEL_GROUPS*sizeof(UCHAR));
 289  FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
 290  FDKmemset(chIdx, 255, PCM_DMX_MAX_CHANNEL_GROUPS*PCM_DMX_MAX_CHANNELS_PER_GROUP*sizeof(UCHAR));
 291
 292  /* Categorize channels */
 293  for (ch = 0; ch < numChannels; ch += 1) {
 294    int i = 0, j, chGrpIdx = channelIndices[ch];
 295
 296    switch (channelType[ch]) {
 297    case ACT_FRONT:
 298    case ACT_FRONT_TOP:
 299      grpIdx = CH_GROUP_FRONT;
 300      break;
 301    case ACT_SIDE:
 302    case ACT_SIDE_TOP:
 303      grpIdx = CH_GROUP_SIDE;
 304      break;
 305    case ACT_BACK:
 306    case ACT_BACK_TOP:
 307      grpIdx = CH_GROUP_REAR;
 308      break;
 309    case ACT_LFE:
 310      grpIdx = CH_GROUP_LFE;
 311      break;
 312    default:
 313      err = -1;
 314      continue;
 315    }
 316
 317    if (numChInGrp[grpIdx] < PCM_DMX_MAX_CHANNELS_PER_GROUP) {
 318      /* Sort channels by index */
 319      while ( (i < numChInGrp[grpIdx]) && (chGrpIdx > channelIndices[chIdx[grpIdx][i]]) ) {
 320        i += 1;
 321      }
 322      for (j = numChInGrp[grpIdx]; j > i; j -= 1) {
 323        chIdx[grpIdx][j] = chIdx[grpIdx][j-1];
 324      }
 325      chIdx[grpIdx][i] = ch;
 326      numChInGrp[grpIdx] += 1;
 327    }
 328  }
 329
 330  /* Compose channel offset table */
 331
 332  /* Non-symmetric channels */
 333  if (numChInGrp[CH_GROUP_FRONT] & 0x1) {
 334    /* Odd number of front channels -> we have a center channel.
 335       In MPEG-4 the center has the index 0. */
 336    offsetTable[CENTER_FRONT_CHANNEL] = chIdx[CH_GROUP_FRONT][0];
 337  }
 338
 339  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
 340    int chMapPos, maxChannels = 0;
 341    ch = 0;
 342
 343    switch (grpIdx) {
 344    case CH_GROUP_FRONT:
 345      chMapPos = LEFT_FRONT_CHANNEL;
 346      maxChannels = 3;
 347      ch = numChInGrp[grpIdx] & 0x1;
 348      break;
 349    case CH_GROUP_SIDE:
 350      chMapPos = LEFT_OUTSIDE_CHANNEL;
 351      maxChannels = 2;
 352      break;
 353    case CH_GROUP_REAR:
 354      chMapPos = LEFT_REAR_CHANNEL;
 355      maxChannels = 2;
 356      break;
 357    case CH_GROUP_LFE:
 358      chMapPos = LOW_FREQUENCY_CHANNEL;
 359      maxChannels = 1;
 360      break;
 361    default:
 362      err = -1;
 363      continue;
 364    }
 365
 366    for ( ; ch < numChInGrp[grpIdx]; ch += 1) {
 367      if (ch < maxChannels) {
 368        offsetTable[chMapPos] = chIdx[grpIdx][ch];
 369        chMapPos += 1;
 370      } else {
 371        err = -1;
 372      }
 373    }
 374  }
 375
 376  if (err == 0) {
 377    /* Compose the channel mode */
 378    chMode = (numChInGrp[CH_GROUP_LFE]   & 0xF) << 12
 379           | (numChInGrp[CH_GROUP_REAR]  & 0xF) <<  8
 380           | (numChInGrp[CH_GROUP_SIDE]  & 0xF) <<  4
 381           | (numChInGrp[CH_GROUP_FRONT] & 0xF);
 382  }
 383
 384  return (PCM_DMX_CHANNEL_MODE)chMode;
 385}
 386
 387
 388/** Generate a channel offset table and complete channel description for a given (packed) channel mode.
 389 *  This function is the inverse to the getChannelMode() routine.
 390 * @param [in] The total number of channels of the given configuration.
 391 * @param [in] Array containing the channel mapping to be used (From MPEG PCE ordering to whatever is required).
 392 * @param [out] Array where corresponding channel types for each channels are stored into.
 393 * @param [out] Array where corresponding channel type indices for each output channel are stored into.
 394 * @param [out] Array where the buffer offsets for each channel are stored into.
 395 * @returns None.
 396 **/
 397void getChannelDescription (
 398        const PCM_DMX_CHANNEL_MODE  chMode,                                 /* in */
 399        const UCHAR                 channelMapping[][PCM_DMX_MAX_CHANNELS], /* in */
 400        AUDIO_CHANNEL_TYPE          channelType[],                          /* out */
 401        UCHAR                       channelIndices[],                       /* out */
 402        UCHAR                       offsetTable[PCM_DMX_MAX_CHANNELS]       /* out */
 403      )
 404{
 405  const UCHAR *pChannelMap;
 406  int   grpIdx, ch = 0, numChannels = 0;
 407  UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS];
 408
 409  FDK_ASSERT(channelType != NULL);
 410  FDK_ASSERT(channelIndices != NULL);
 411  FDK_ASSERT(channelMapping != NULL);
 412  FDK_ASSERT(offsetTable != NULL);
 413
 414  /* Init output arrays */
 415  FDKmemclear(channelType,    PCM_DMX_MAX_CHANNELS*sizeof(AUDIO_CHANNEL_TYPE));
 416  FDKmemclear(channelIndices, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
 417  FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
 418
 419  /* Extract the number of channels per group */
 420  numChInGrp[CH_GROUP_FRONT] =  chMode        & 0xF;
 421  numChInGrp[CH_GROUP_SIDE]  = (chMode >>  4) & 0xF;
 422  numChInGrp[CH_GROUP_REAR]  = (chMode >>  8) & 0xF;
 423  numChInGrp[CH_GROUP_LFE]   = (chMode >> 12) & 0xF;
 424
 425  /* Summerize to get the total number of channels */
 426  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
 427    numChannels += numChInGrp[grpIdx];
 428  }
 429
 430  /* Get the appropriate channel map */
 431  pChannelMap = channelMapping[numChannels-1];
 432
 433  /* Compose channel offset table */
 434
 435  /* Non-symmetric channels */
 436  if (numChInGrp[CH_GROUP_FRONT] & 0x1) {
 437    /* Odd number of front channels -> we have a center channel.
 438       In MPEG-4 the center has the index 0. */
 439    offsetTable[CENTER_FRONT_CHANNEL] = pChannelMap[0];
 440    channelType[0] = ACT_FRONT;
 441    ch += 1;
 442  }
 443
 444  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
 445    AUDIO_CHANNEL_TYPE type;
 446    int chMapPos, maxChannels = 0;
 447    int chIdx = 0;
 448
 449    switch (grpIdx) {
 450    case CH_GROUP_FRONT:
 451      type = ACT_FRONT;
 452      chMapPos = LEFT_FRONT_CHANNEL;
 453      maxChannels = 3;
 454      chIdx = numChInGrp[grpIdx] & 0x1;
 455      break;
 456    case CH_GROUP_SIDE:
 457      type = ACT_SIDE;
 458      chMapPos = LEFT_OUTSIDE_CHANNEL;
 459      maxChannels = 2;
 460      break;
 461    case CH_GROUP_REAR:
 462      type = ACT_BACK;
 463      chMapPos = LEFT_REAR_CHANNEL;
 464      maxChannels = 2;
 465      break;
 466    case CH_GROUP_LFE:
 467      type = ACT_LFE;
 468      chMapPos = LOW_FREQUENCY_CHANNEL;
 469      maxChannels = 1;
 470      break;
 471    default:
 472      break;
 473    }
 474
 475    for ( ; (chIdx < numChInGrp[grpIdx]) && (chIdx < maxChannels); chIdx += 1) {
 476      offsetTable[chMapPos] = pChannelMap[ch];
 477      channelType[ch]    = type;
 478      channelIndices[ch] = chIdx;
 479      chMapPos += 1;
 480      ch += 1;
 481    }
 482  }
 483}
 484
 485
 486/** Open and initialize an instance of the PCM downmix module
 487 * @param [out] Pointer to a buffer receiving the handle of the new instance.
 488 * @returns Returns an error code.
 489 **/
 490PCMDMX_ERROR pcmDmx_Open (
 491    HANDLE_PCM_DOWNMIX *pSelf
 492  )
 493{
 494  HANDLE_PCM_DOWNMIX self;
 495  
 496  if (pSelf == NULL) {
 497    return (PCMDMX_INVALID_HANDLE);
 498  }
 499
 500  *pSelf = NULL;
 501
 502  self = (HANDLE_PCM_DOWNMIX) GetPcmDmxInstance( 0 );
 503  if (self == NULL) {
 504    return (PCMDMX_OUT_OF_MEMORY);
 505  }
 506
 507  /* Reset the full instance */
 508  pcmDmx_Reset( self, PCMDMX_RESET_FULL );
 509
 510  *pSelf = self;
 511
 512  return (PCMDMX_OK);
 513}
 514
 515
 516/** Reset all static values like e.g. mixdown coefficients.
 517 * @param [in] Handle of PCM downmix module instance.
 518 * @param [in] Flags telling which parts of the module shall be reset.
 519 * @returns Returns an error code.
 520 **/
 521PCMDMX_ERROR pcmDmx_Reset (
 522    HANDLE_PCM_DOWNMIX  self,
 523    UINT                flags
 524  )
 525{
 526  if (self == NULL) { return (PCMDMX_INVALID_HANDLE); }
 527
 528  if (flags & PCMDMX_RESET_PARAMS) {
 529    self->dualChannelMode   = STEREO_MODE;
 530    self->numOutputChannels = 0;
 531    self->applyProcessing   = 0;
 532    self->frameDelay        = 0;
 533    self->expiryFrame       = PCMDMX_DFLT_EXPIRY_FRAME;
 534  }
 535
 536  if (flags & PCMDMX_RESET_BS_DATA) {
 537    int slot;
 538    for (slot = 0; slot <= PCM_DMX_MAX_DELAY_FRAMES; slot += 1) {
 539      self->dvbMixDownLevels[slot].centerMixLevelValue    = dvbDownmixFactors[2]; /* 0.707 */
 540      self->dvbMixDownLevels[slot].surroundMixLevelValue  = dvbDownmixFactors[0]; /* 1.000 */
 541      self->dvbMixDownLevels[slot].mixLevelsAvail = 0;
 542
 543      self->mpegMixDownInfo[slot].mixdownAvailable = 0;
 544    }
 545    /* Reset expiry counter */
 546    self->expiryCount = 0;
 547  }
 548
 549  return (PCMDMX_OK);
 550}
 551
 552
 553/** Set one parameter for one instance of the PCM downmix module.
 554 * @param [in] Handle of PCM downmix module instance.
 555 * @param [in] Parameter to be set.
 556 * @param [in] Parameter value.
 557 * @returns Returns an error code.
 558 **/
 559PCMDMX_ERROR pcmDmx_SetParam (
 560    HANDLE_PCM_DOWNMIX  self,
 561    PCMDMX_PARAM        param,
 562    UINT                value
 563  )
 564{
 565  switch (param)
 566  {
 567  case DMX_BS_DATA_EXPIRY_FRAME:
 568    if (self == NULL)
 569      return (PCMDMX_INVALID_HANDLE);
 570    self->expiryFrame = value;
 571    break;
 572
 573  case DMX_BS_DATA_DELAY:
 574    if (value > PCM_DMX_MAX_DELAY_FRAMES) {
 575      return (PCMDMX_UNABLE_TO_SET_PARAM);
 576    }
 577    if (self == NULL) {
 578      return (PCMDMX_INVALID_HANDLE);
 579    }
 580    self->frameDelay = value;
 581    break;
 582
 583  case NUMBER_OF_OUTPUT_CHANNELS:
 584    switch ((int)value) {  /* supported output channels */
 585    case -1: case 0: case 1: case 2:
 586    case 6: case 8:
 587      break;
 588    default:
 589      return (PCMDMX_UNABLE_TO_SET_PARAM);
 590    }
 591    if (self == NULL)
 592      return (PCMDMX_INVALID_HANDLE);
 593    if ((int)value > 0) {
 594      self->numOutputChannels = (int)value;
 595      self->applyProcessing = 1;
 596    } else {
 597      self->numOutputChannels = 0;
 598      self->applyProcessing = 0;
 599    }
 600    break;
 601
 602  case DUAL_CHANNEL_DOWNMIX_MODE:
 603    switch ((DUAL_CHANNEL_MODE)value) {
 604    case STEREO_MODE:
 605    case CH1_MODE:
 606    case CH2_MODE:
 607    case MIXED_MODE:
 608      break;
 609    default:
 610      return (PCMDMX_UNABLE_TO_SET_PARAM);
 611    }
 612    if (self == NULL)
 613      return (PCMDMX_INVALID_HANDLE);
 614    self->dualChannelMode = (DUAL_CHANNEL_MODE)value;
 615    self->applyProcessing = 1;
 616    break;
 617
 618  default:
 619    return (PCMDMX_UNKNOWN_PARAM);
 620  }
 621
 622  return (PCMDMX_OK);
 623}
 624
 625
 626/** Read the ancillary data transported in DSEs of DVB streams with MPEG-4 content
 627 * @param [in] Handle of PCM downmix module instance.
 628 * @param [in] Pointer to ancillary data buffer.
 629 * @param [in] Size of ancillary data.
 630 * @param [in] Flag indicating wheter the DVB ancillary data is from an MPEG-1/2 or an MPEG-4 stream.
 631 * @returns Returns an error code.
 632 **/
 633PCMDMX_ERROR pcmDmx_ReadDvbAncData (
 634    HANDLE_PCM_DOWNMIX  self,
 635    UCHAR *pAncDataBuf,
 636    UINT   ancDataBytes,
 637    int    isMpeg2
 638  )
 639{
 640  DVB_MIXDOWN_LEVELS *pDownmixLevels = &self->dvbMixDownLevels[0];
 641
 642  int   offset = (isMpeg2) ? 2 : 0;
 643  UCHAR ancDataStatus;
 644
 645  if (self == NULL) { return (PCMDMX_INVALID_HANDLE); }
 646
 647  /* sanity checks */
 648  if (pAncDataBuf == NULL || ancDataBytes < (UCHAR)(3+offset)) {
 649    return (PCMDMX_CORRUPT_ANC_DATA);
 650  }
 651
 652  /* check sync word */
 653  if (pAncDataBuf[offset] != ANC_DATA_SYNC_BYTE) {
 654    return (PCMDMX_CORRUPT_ANC_DATA);
 655  }
 656
 657  offset += 2;
 658  ancDataStatus = pAncDataBuf[offset++];
 659
 660  if (isMpeg2) {
 661    /* skip advanced_dynamic_range_control */
 662    if (ancDataStatus & 0x80) offset += 3;
 663    /* skip dialog_normalization */
 664    if (ancDataStatus & 0x40) offset += 1;
 665    /* skip reproduction_level */
 666    if (ancDataStatus & 0x20) offset += 1;
 667  }
 668  else {
 669    /* check reserved bits */
 670    if (ancDataStatus & 0xE8) { return (PCMDMX_CORRUPT_ANC_DATA); }
 671  }
 672
 673  /* downmix_levels_MPEGX */
 674  if (ancDataStatus & 0x10)
 675  {
 676    int   foundNewData = 0;
 677    UCHAR downmixData = pAncDataBuf[offset++];
 678
 679    if (downmixData & 0x80) {  /* center_mix_level_on */
 680      pDownmixLevels->centerMixLevelValue =
 681        dvbDownmixFactors[(downmixData >> 4) & 0x07];
 682      foundNewData = 1;
 683    } else {
 684      pDownmixLevels->centerMixLevelValue = dvbDownmixFactors[0];
 685      if (downmixData & 0x70) { return (PCMDMX_CORRUPT_ANC_DATA); }
 686    }
 687
 688    if (downmixData & 0x08) {  /* surround_mix_level_on */
 689      pDownmixLevels->surroundMixLevelValue =
 690        dvbDownmixFactors[downmixData & 0x07];
 691      foundNewData = 1;
 692    } else {
 693      pDownmixLevels->surroundMixLevelValue = dvbDownmixFactors[0];
 694      if (downmixData & 0x07) { return (PCMDMX_CORRUPT_ANC_DATA); }
 695    }
 696
 697    pDownmixLevels->mixLevelsAvail = foundNewData;
 698  }
 699
 700  /* Reset expiry counter */
 701  self->expiryCount = 0;
 702
 703  return (PCMDMX_OK);
 704}
 705
 706/** Set the matrix mixdown information extracted from the PCE of an AAC bitstream.
 707 *  Note: Call only if matrix_mixdown_idx_present is true.
 708 * @param [in] Handle of PCM downmix module instance.
 709 * @param [in] The 2 bit matrix mixdown index extracted from PCE.
 710 * @param [in] The pseudo surround enable flag extracted from PCE.
 711 * @returns Returns an error code.
 712 **/
 713PCMDMX_ERROR pcmDmx_SetMatrixMixdownFromPce (
 714    HANDLE_PCM_DOWNMIX  self,
 715    int                 matrixMixdownPresent,
 716    int                 matrixMixdownIdx,
 717    int                 pseudoSurroundEnable
 718  )
 719{
 720  MPEG_MIXDOWN_INFO *pMpegMixDownInfo;
 721
 722  if (self == NULL) {
 723    return (PCMDMX_INVALID_HANDLE);
 724  }
 725
 726  pMpegMixDownInfo = &self->mpegMixDownInfo[0];
 727
 728  if (matrixMixdownPresent) {
 729    pMpegMixDownInfo->matrixMixdownIdx     = matrixMixdownIdx & 0x03;
 730    pMpegMixDownInfo->pseudoSurroundEnable = pseudoSurroundEnable;
 731  }
 732
 733  pMpegMixDownInfo->mixdownAvailable = matrixMixdownPresent;
 734  /* Reset expiry counter */
 735  self->expiryCount = 0;
 736
 737  return (PCMDMX_OK);
 738}
 739
 740
 741/** Apply down or up mixing.
 742 * @param [in]    Handle of PCM downmix module instance.
 743 * @param [inout] Pointer to time buffer. Depending on interface configuration, the content of pTimeData is ignored,
 744 *                and the internal QMF buffer will be used as input data source. Otherwise, the MPEG Surround processing is
 745 *                applied to the timesignal pTimeData. For both variants, the resulting MPEG Surround signal is written into pTimeData.
 746 * @param [in]    Pointer where the amount of output samples is returned into.
 747 * @param [inout] Pointer where the amount of output channels is returned into.
 748 * @param [in]    Flag which indicates if output time data are writtern interleaved or as subsequent blocks.
 749 * @param [inout] Array where the corresponding channel type for each output audio channel is stored into.
 750 * @param [inout] Array where the corresponding channel type index for each output audio channel is stored into.
 751 * @param [in]    Array containing the output channel mapping to be used (From MPEG PCE ordering to whatever is required).
 752 * @returns Returns an error code.
 753 **/
 754PCMDMX_ERROR pcmDmx_ApplyFrame (
 755        HANDLE_PCM_DOWNMIX      self,
 756        INT_PCM                *pPcmBuf,
 757        UINT                    frameSize,
 758        INT                    *nChannels,
 759
 760        int                     fInterleaved,
 761        AUDIO_CHANNEL_TYPE      channelType[],
 762        UCHAR                   channelIndices[],
 763        const UCHAR             channelMapping[][8]
 764  )
 765{
 766  PCMDMX_ERROR  errorStatus = PCMDMX_OK;
 767  DUAL_CHANNEL_MODE  dualChannelMode;
 768  PCM_DMX_CHANNEL_MODE  inChMode;
 769  int   numOutChannels;
 770  int   numInChannels = *nChannels;
 771  int   slot;
 772  UCHAR inOffsetTable[PCM_DMX_MAX_CHANNELS];
 773
 774  MPEG_MIXDOWN_INFO   mpegMixDownInfo;
 775  DVB_MIXDOWN_LEVELS  dvbMixDownLevels;
 776
 777  if (self == NULL) { return (PCMDMX_INVALID_HANDLE); }
 778
 779  if ( (self->expiryFrame > 0)
 780    && (++self->expiryCount > self->expiryFrame) )
 781  { /* The metadata read from bitstream is too old. */
 782    errorStatus = pcmDmx_Reset(self, PCMDMX_RESET_BS_DATA);
 783  }
 784
 785  FDKmemcpy(&mpegMixDownInfo, &self->mpegMixDownInfo[self->frameDelay], sizeof(MPEG_MIXDOWN_INFO));
 786  /* Maintain delay line */
 787  for (slot = self->frameDelay; slot > 0; slot -= 1) {
 788    FDKmemcpy(&self->mpegMixDownInfo[slot], &self->mpegMixDownInfo[slot-1], sizeof(MPEG_MIXDOWN_INFO));
 789  }
 790  FDKmemcpy(&dvbMixDownLevels, &self->dvbMixDownLevels[self->frameDelay], sizeof(DVB_MIXDOWN_LEVELS));
 791  /* Maintain delay line */
 792  for (slot = self->frameDelay; slot > 0; slot -= 1) {
 793    FDKmemcpy(&self->dvbMixDownLevels[slot], &self->dvbMixDownLevels[slot-1], sizeof(DVB_MIXDOWN_LEVELS));
 794  }
 795
 796  if (self->applyProcessing == 0) { return (errorStatus); }
 797
 798  if (pPcmBuf == NULL)     { return (PCMDMX_INVALID_ARGUMENT); }
 799  if (frameSize == 0)      { return (PCMDMX_INVALID_ARGUMENT); }
 800  if (numInChannels == 0)  { return (PCMDMX_INVALID_ARGUMENT); }
 801
 802  if (self->numOutputChannels <= 0) {
 803    numOutChannels = numInChannels;
 804  } else {
 805    numOutChannels = self->numOutputChannels;
 806  }
 807  dualChannelMode = self->dualChannelMode;
 808
 809  /* Analyse input channel configuration and get channel offset
 810   * table that can be accessed with the fixed channel labels. */
 811  inChMode = getChannelMode(
 812                   numInChannels,
 813                   channelType,
 814                   channelIndices,
 815                   inOffsetTable
 816                 );
 817  if (inChMode == CH_MODE_UNDEFINED) {
 818    /* We don't need to restore because the channel
 819       configuration has not been changed. Just exit. */
 820    return (PCMDMX_INVALID_CH_CONFIG);
 821  }
 822
 823  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 824  if ( numInChannels > numOutChannels )
 825  { /* Apply downmix */
 826    INT_PCM  *pInCF, *pInLF, *pInRF, *pInLO, *pInRO, *pInLR, *pInRR, *pOutL, *pOutR;
 827    FIXP_SGL  flev, clev, slev;
 828
 829    UINT   sample;
 830    int    inStride, outStride, offset;
 831    int    useGuidedDownMix = 0;
 832    UCHAR  outOffsetTable[PCM_DMX_MAX_CHANNELS];
 833
 834    /* Set I/O strides and offsets */
 835    if (fInterleaved) {
 836      inStride  = numInChannels;
 837      outStride = TWO_CHANNEL;   /* The output of STAGE ONE is always STEREO !!!
 838                                    STAGE TWO creates a downmix to mono if required. */
 839      offset = 1;                /* Channel specific offset factor */
 840    } else {
 841      inStride  = 1;
 842      outStride = 1;
 843      offset = frameSize;        /* Channel specific offset factor */
 844    }
 845
 846    /* Get channel description and channel mapping for this
 847     * stages number of output channels (always STEREO). */
 848    getChannelDescription(
 849            CH_MODE_2_0_0_0,
 850            channelMapping,
 851            channelType,
 852            channelIndices,
 853            outOffsetTable
 854           );
 855    /* Now there is no way back because we modified the channel configuration! */
 856
 857    /* Set channel pointer for input */
 858    pInCF = &pPcmBuf[inOffsetTable[CENTER_FRONT_CHANNEL]*offset];
 859    pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
 860    pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
 861    pInLO = &pPcmBuf[inOffsetTable[LEFT_OUTSIDE_CHANNEL]*offset];
 862    pInRO = &pPcmBuf[inOffsetTable[RIGHT_OUTSIDE_CHANNEL]*offset];
 863    pInLR = &pPcmBuf[inOffsetTable[LEFT_REAR_CHANNEL]*offset];
 864    pInRR = &pPcmBuf[inOffsetTable[RIGHT_REAR_CHANNEL]*offset];
 865
 866    /* Set channel pointer for output
 867       Caution: Different channel mapping compared to input */
 868    pOutL = &pPcmBuf[outOffsetTable[LEFT_FRONT_CHANNEL]*offset];    /* LEFT_FRONT_CHANNEL  */
 869    pOutR = &pPcmBuf[outOffsetTable[RIGHT_FRONT_CHANNEL]*offset];   /* RIGHT_FRONT_CHANNEL */
 870
 871    /* Set downmix levels: */
 872    flev = ATTENUATION_FACTOR_1;    /* 0.707 */
 873    clev = ATTENUATION_FACTOR_1;    /* 0.707 */
 874    slev = ATTENUATION_FACTOR_1;    /* 0.707 */
 875
 876    if ( dvbMixDownLevels.mixLevelsAvail ) {
 877      clev = dvbMixDownLevels.centerMixLevelValue;
 878      slev = dvbMixDownLevels.surroundMixLevelValue;
 879      useGuidedDownMix = 1;
 880    }
 881
 882    /* FIRST STAGE:
 883         Always downmix to 2 channel output: */
 884    switch ( inChMode )
 885    {
 886    case CH_MODE_2_0_0_0:
 887    case CH_MODE_2_0_0_1: 
 888      /* 2/0 input: */
 889      switch (dualChannelMode)
 890      {
 891      case CH1_MODE:  /* L' = 0.707 * Ch1;  R' = 0.707 * Ch1 */
 892        for (sample = 0; sample < frameSize; sample++) {
 893          *pOutL = *pOutR =
 894            (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInLF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
 895
 896          pInLF += inStride;
 897          pOutL += outStride; pOutR += outStride;
 898        }
 899        break;
 900
 901      case CH2_MODE:  /* L' = 0.707 * Ch2;  R' = 0.707 * Ch2 */
 902        for (sample = 0; sample < frameSize; sample++) {
 903          *pOutL = *pOutR =
 904            (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInRF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
 905
 906          pInRF += inStride;
 907          pOutL += outStride; pOutR += outStride;
 908        }
 909        break;
 910      case MIXED_MODE:  /* L' = 0.5*Ch1 + 0.5*Ch2;  R' = 0.5*Ch1 + 0.5*Ch2 */
 911        for (sample = 0; sample < frameSize; sample++) {
 912          *pOutL = *pOutR = (*pInLF >> 1) + (*pInRF >> 1);
 913
 914          pInLF += inStride;  pInRF += inStride;
 915          pOutL += outStride; pOutR += outStride;
 916        }
 917        break;
 918      default:
 919      case STEREO_MODE:
 920        /* nothing to do */
 921        break;
 922      }
 923      break;
 924
 925    case CH_MODE_3_0_0_0:
 926      /* 3/0 input:  L' = L + 0.707*C;  R' = R + 0.707*C; */
 927      for (sample = 0; sample < frameSize; sample++)
 928      {
 929        FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev);
 930#if (SAMPLE_BITS == 32)
 931        /* left channel */
 932        *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>1)+tCF, 1, SAMPLE_BITS);
 933        /* right channel */
 934        *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>1)+tCF, 1, SAMPLE_BITS);
 935#else
 936        /* left channel */
 937        *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>1)+tCF, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
 938        /* right channel */
 939        *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>1)+tCF, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
 940#endif
 941        pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;
 942        pOutL += outStride; pOutR += outStride;
 943      }
 944      break;
 945
 946    /* 2/1 input: not supported!
 947    case CH_MODE_2_0_1_0: */
 948
 949    case CH_MODE_3_0_1_0:
 950      if (useGuidedDownMix) {
 951        /* 3/1 input:  L' = L + clev*C + 0.707*slev*S;  R' = R + clev*C + 0.707*slev*S; */
 952        slev = FX_DBL2FX_SGL(fMult(flev, slev));  /* 0.707*slef */
 953
 954        for (sample = 0; sample < frameSize; sample++)
 955        {
 956          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
 957          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
 958#if (SAMPLE_BITS == 32)
 959          /* left channel */
 960          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
 961          /* right channel */
 962          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
 963#else
 964          /* left channel */
 965          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
 966          /* right channel */
 967          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
 968#endif
 969          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;
 970          pOutL += outStride; pOutR += outStride;
 971        }
 972      } else {
 973        /* 3/1 input:  L' = L + 0.707*C - 0.707*S;  R' = R + 0.707*C + 0.707*S */
 974        for (sample = 0; sample < frameSize; sample++)
 975        {
 976          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
 977          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
 978#if (SAMPLE_BITS == 32)
 979          /* left channel */
 980          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, 2, SAMPLE_BITS);
 981          /* right channel */
 982          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
 983#else
 984          /* left channel */
 985          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
 986          /* right channel */
 987          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
 988#endif
 989          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;
 990          pOutL += outStride; pOutR += outStride;
 991        }
 992      }
 993      break;
 994
 995    /* 2/2 input: not supported!
 996    case CH_MODE_2_0_2_0: */
 997
 998    case CH_MODE_3_0_2_0:   /* 5.0ch input */
 999    case CH_MODE_3_0_2_1:   /* 5.1ch input */
1000      if (useGuidedDownMix) {
1001        /* 3/2 input:  L' = L + clev*C + slev*Ls;  R' = R + clev*C + slev*Rs; */
1002        for (sample = 0; sample < frameSize; sample++)
1003        {
1004          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
1005          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
1006          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev) >> 1;
1007#if (SAMPLE_BITS == 32)
1008          /* left channel */
1009          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
1010          /* right channel */
1011          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tRR, 2, SAMPLE_BITS);
1012#else
1013          /* left channel */
1014          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
1015          /* right channel */
1016          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tRR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
1017#endif
1018          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
1019          pOutL += outStride; pOutR += outStride;
1020        }
1021      }
1022      else if (mpegMixDownInfo.mixdownAvailable) {
1023        /* 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]; */
1024        FIXP_SGL mtrxMixDwnCoef    = mpegMixDownIdx2Coef[mpegMixDownInfo.matrixMixdownIdx];
1025        FIXP_SGL mtrxMixDwnPreFact = mpegMixDownIdx2PreFact[mpegMixDownInfo.matrixMixdownIdx];
1026        clev = FX_DBL2FX_SGL(fMult(mtrxMixDwnPreFact, flev /* 0.707 */));
1027        flev = mtrxMixDwnPreFact;
1028        slev = FX_DBL2FX_SGL(fMult(mtrxMixDwnPreFact, mtrxMixDwnCoef));
1029
1030        for (sample = 0; sample < frameSize; sample++)
1031        {
1032          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev);
1033          FIXP_DBL tLF = fMultDiv2((FIXP_PCM)*pInLF, flev);
1034          FIXP_DBL tRF = fMultDiv2((FIXP_PCM)*pInRF, flev);
1035          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev);
1036          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev);
1037
1038#if (SAMPLE_BITS == 32)
1039          /* left channel */
1040          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT(tLF+tCF+tLR, 1, SAMPLE_BITS);
1041          /* right channel */
1042          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT(tRF+tCF+tRR, 1, SAMPLE_BITS);
1043#else
1044          /* left channel */
1045          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT(tLF+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
1046          /* right channel */
1047          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT(tRF+tCF+tRR, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
1048#endif
1049
1050          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
1051          pOutL += outStride; pOutR += outStride;
1052        }
1053      }
1054      else {
1055        /* 3/2 input:  L' = L + 0.707*C - 0.707*Ls - 0.707*Rs;  R' = R + 0.707*C + 0.707*Ls + 0.707*Rs */
1056        for (sample = 0; sample < frameSize; sample++)
1057        {
1058          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 2;
1059          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 2;
1060          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev) >> 2;
1061#if (SAMPLE_BITS == 32)
1062          /* left channel */
1063          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>3)+tCF-tLR-tRR, 3, SAMPLE_BITS);
1064          /* right channel */
1065          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>3)+tCF+tLR+tRR, 3, SAMPLE_BITS);
1066#else
1067          /* left channel */
1068          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>3)+tCF-tLR-tRR, DFRACT_BITS-SAMPLE_BITS-3, SAMPLE_BITS);
1069          /* right channel */
1070          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>3)+tCF+tLR+tRR, DFRACT_BITS-SAMPLE_BITS-3, SAMPLE_BITS);
1071#endif
1072          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
1073          pOutL += outStride; pOutR += outStride;
1074        }
1075      }
1076      break;
1077
1078    default:
1079      errorStatus = PCMDMX_INVALID_MODE;
1080      break;
1081    }
1082
1083    /* SECOND STAGE:
1084         If desired create a mono donwmix:
1085         Note: Input are always two channels! */
1086    if (numOutChannels == 1)
1087    {
1088      INT_PCM *pOutC;
1089      FIXP_SGL mlev;
1090
1091      if (useGuidedDownMix) mlev = FL2FXCONST_SGL(1.0f); else mlev = flev;
1092
1093      /* Output of STAGE ONE = Input of STAGE TWO */
1094      FDKmemcpy(inOffsetTable, outOffsetTable, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
1095
1096      /* Set I/O strides and offsets */
1097      inStride  = outStride;          /* output from STAGE ONE */
1098      outStride = numOutChannels;     /* final output */
1099
1100      /* Get channel description and channel mapping for this
1101       * stages number of output channels (always MONO). */
1102      getChannelDescription(
1103              CH_MODE_1_0_0_0,
1104              channelMapping,
1105              channelType,
1106              channelIndices,
1107              outOffsetTable
1108             );
1109
1110      /* Set input channel pointer. */
1111      pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
1112      pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
1113
1114      /* Set output channel pointer */
1115      pOutC = &pPcmBuf[outOffsetTable[CENTER_FRONT_CHANNEL]*offset];
1116
1117      /* C' = 0.707*L + 0.707*R */
1118      for (sample = 0; sample < frameSize; sample++) {
1119#if (SAMPLE_BITS == 32)
1120        *pOutC =
1121          (INT_PCM)SATURATE_LEFT_SHIFT(fMultDiv2((FIXP_PCM)*pInLF,mlev)+fMultDiv2((FIXP_PCM)*pInRF,mlev), 1, SAMPLE_BITS);
1122#else
1123        *pOutC =
1124          (INT_PCM)SATURATE_RIGHT_SHIFT(fMultDiv2((FIXP_PCM)*pInLF,mlev)+fMultDiv2((FIXP_PCM)*pInRF,mlev), DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
1125#endif
1126
1127        pInLF += inStride; pInRF += inStride;
1128        pOutC += 1;
1129      }
1130      /* Finished STAGE TWO */
1131    }
1132
1133    /* Update the number of output channels */
1134    *nChannels = self->numOutputChannels;
1135
1136  } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
1137  else
1138  if ( numInChannels == numOutChannels )
1139  {
1140    /* Don't need to change the channel description here */
1141
1142    switch (numInChannels)
1143    {
1144    case 2:
1145      { /* Set up channel pointer */
1146        INT_PCM *pInLF, *pInRF, *pOutL, *pOutR;
1147        FIXP_SGL flev;
1148
1149        UINT sample;
1150        int inStride, outStride, offset;
1151
1152        if (fInterleaved) {
1153          inStride  = numInChannels;
1154          outStride = 2;  /* fixed !!! (below stereo is donwmixed to mono if required */
1155          offset = 1; /* Channel specific offset factor */
1156        } else {
1157          inStride  = 1;
1158          outStride = 1;
1159          offset = frameSize;  /* Channel specific offset factor */
1160        }
1161
1162        /* Set input channel pointer */
1163        pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
1164        pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
1165
1166        /* Set output channel pointer (same as input) */
1167        pOutL  =  pInLF;
1168        pOutR  =  pInRF;
1169
1170        /* Set downmix levels: */
1171        flev = ATTENUATION_FACTOR_1;    /* 0.707 */
1172        /* 2/0 input: */
1173        switch (dualChannelMode)
1174        {
1175        case CH1_MODE:  /* L' = 0.707 * Ch1;  R' = 0.707 * Ch1 */
1176          for (sample = 0; sample < frameSize; sample++) {
1177            *pOutL = *pOutR =
1178              (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInLF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
1179
1180            pInLF += inStride;
1181            pOutL += outStride; pOutR += outStride;
1182          }
1183          break;
1184        case CH2_MODE:  /* L' = 0.707 * Ch2;  R' = 0.707 * Ch2 */
1185          for (sample = 0; sample < frameSize; sample++) {
1186            *pOutL = *pOutR =
1187              (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInRF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
1188
1189            pInRF += inStride;
1190            pOutL += outStride; pOutR += outStride;
1191          }
1192          break;
1193        case MIXED_MODE:  /* L' = 0.5*Ch1 + 0.5*Ch2;  R' = 0.5*Ch1 + 0.5*Ch2 */
1194          for (sample = 0; sample < frameSize; sample++) {
1195            *pOutL = *pOutR = (*pInLF >> 1) + (*pInRF >> 1);
1196
1197            pInLF += inStride;  pInRF += inStride;
1198            pOutL += outStride; pOutR += outStride;
1199          }
1200          break;
1201        default:
1202        case STEREO_MODE:
1203          /* nothing to do */
1204          break;
1205        }
1206      }
1207      break;
1208
1209    default:
1210      /* nothing to do */
1211      break;
1212    }
1213  }
1214
1215  return (errorStatus);
1216}
1217
1218
1219/** Close an instance of the PCM downmix module.
1220 * @param [inout] Pointer to a buffer containing the handle of the instance.
1221 * @returns Returns an error code.
1222 **/
1223PCMDMX_ERROR pcmDmx_Close (
1224    HANDLE_PCM_DOWNMIX *pSelf
1225  )
1226{
1227  if (pSelf == NULL) {
1228    return (PCMDMX_INVALID_HANDLE);
1229  }
1230
1231  FreePcmDmxInstance( pSelf );
1232  *pSelf = NULL;
1233
1234  return (PCMDMX_OK);
1235}
1236
1237
1238/** Get library info for this module.
1239 * @param [out] Pointer to an allocated LIB_INFO structure.
1240 * @returns Returns an error code.
1241 */
1242PCMDMX_ERROR pcmDmx_GetLibInfo( LIB_INFO *info )
1243{
1244  int i;
1245
1246  if (info == NULL) {
1247    return PCMDMX_INVALID_ARGUMENT;
1248  }
1249
1250  /* Search for next free tab */
1251  for (i = 0; i < FDK_MODULE_LAST; i++) {
1252    if (info[i].module_id == FDK_NONE) break;
1253  }
1254  if (i == FDK_MODULE_LAST) {
1255    return PCMDMX_UNKNOWN;
1256  }
1257  info += i;
1258
1259  /* Add the library info */
1260  info->module_id  = FDK_PCMDMX;
1261  info->version    = LIB_VERSION(PCMDMX_LIB_VL0, PCMDMX_LIB_VL1, PCMDMX_LIB_VL2);
1262  LIB_VERSION_STRING(info);
1263  info->build_date = PCMDMX_LIB_BUILD_DATE;
1264  info->build_time = PCMDMX_LIB_BUILD_TIME;
1265  info->title      = PCMDMX_LIB_TITLE;
1266
1267  /* Set flags */
1268  info->flags = 0
1269      | CAPF_DMX_BLIND   /* At least blind downmixing is possible */
1270      | CAPF_DMX_PCE     /* Guided downmix with data from MPEG-2/4 Program Config Elements (PCE). */
1271      | CAPF_DMX_DVB     /* Guided downmix with data from DVB ancillary data fields. */
1272      ;
1273
1274  return PCMDMX_OK;
1275}
1276
1277
1278