aac_dec_decoding_fp.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives AAC Decode Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel(R) Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ipplic.htm located in the root directory of your Intel(R) IPP
//  product installation for more information.
//
//  MPEG-4 and AAC are international standards promoted by ISO, IEC, ITU, ETSI
//  and other organizations. Implementations of these standards, or the standard
//  enabled platforms may require licenses from various entities, including
//  Intel Corporation.
//
*/

/********************************************************************/

#include "aac_dec_own.h"
#include <math.h>

/********************************************************************/

static int is_intensity(s_SE_Individual_channel_stream *pData,
                        int group,
                        int sfb);

static int is_noise(s_SE_Individual_channel_stream *pData,
                    int group,
                    int sfb);

/********************************************************************/

int ics_apply_scale_factors(s_SE_Individual_channel_stream *pData,
                            float *p_spectrum)
{
  int     g;
  int     w;
  int     w_num;
  float   real_sf[60];

  ippsPow43_16s32f(pData->spectrum_data, p_spectrum, 1024);

  if (pData->window_sequence != EIGHT_SHORT_SEQUENCE) {
    ippsCalcSF_16s32f(pData->sf[0], SF_OFFSET, real_sf, pData->max_sfb);
    ippsScale_32f_I(p_spectrum, real_sf, pData->sfb_offset_long_window,
                    pData->max_sfb);

  } else {
    w = 0;
    for (g = 0; g < pData->num_window_groups; g++) {
      w_num = pData->len_window_group[g];
      ippsCalcSF_16s32f(pData->sf[g], SF_OFFSET, real_sf, pData->max_sfb);
      for (; w_num; w_num--) {
        ippsScale_32f_I(&p_spectrum[w * 128], real_sf,
                        pData->sfb_offset_short_window, pData->max_sfb);
        w++;
      }
    }
  }

  return 0;
}

/********************************************************************/

int cpe_apply_ms(sCpe_channel_element *pElement,
                 float *l_spec,
                 float *r_spec)
{
  int     i, g, b, sfb, k;
  Ipp32f  tmp;
  int     group;
  int    *sfb_offset;
  s_SE_Individual_channel_stream *p_ics_right;

  p_ics_right = &pElement->streams[1];

  sfb_offset =
    pElement->streams[0].window_sequence == EIGHT_SHORT_SEQUENCE ?
    pElement->streams[0].sfb_offset_short_window :
    pElement->streams[0].sfb_offset_long_window;

  if (pElement->ms_mask_present >= 1) {
    group = 0;
    for (g = 0; g < pElement->streams[0].num_window_groups; g++) {
      for (b = 0; b < pElement->streams[0].len_window_group[g]; b++) {
        for (sfb = 0; sfb < pElement->streams[0].max_sfb; sfb++) {
          if ((pElement->ms_used[g][sfb] || pElement->ms_mask_present == 2) &&
              !is_intensity(p_ics_right, g, sfb) &&
              !is_noise(p_ics_right, g, sfb)) {
            for (i = sfb_offset[sfb]; i < sfb_offset[sfb + 1]; i++) {
              k = (group * 128) + i;
              tmp = l_spec[k] - r_spec[k];
              l_spec[k] = l_spec[k] + r_spec[k];
              r_spec[k] = tmp;
            }
          }
        }
        group++;
      }
    }
  }
  return 0;
}

/********************************************************************/

static int invert_intensity(sCpe_channel_element *pElement,
                            int group,
                            int sfb)
{
  if (pElement->ms_mask_present == 1)
    return (1 - 2 * pElement->ms_used[group][sfb]);
  return 1;
}

/********************************************************************/

int cpe_apply_intensity(sCpe_channel_element *pElement,
                        float *l_spec,
                        float *r_spec)
{
  int     i, g, b, sfb, k;
  float   scale;
  int     group;
  int    *sfb_offset;
  s_SE_Individual_channel_stream *p_ics_right;

  p_ics_right = &pElement->streams[1];

  sfb_offset =
    pElement->streams[0].window_sequence == EIGHT_SHORT_SEQUENCE ?
    pElement->streams[0].sfb_offset_short_window :
    pElement->streams[0].sfb_offset_long_window;

  group = 0;
  for (g = 0; g < p_ics_right->num_window_groups; g++) {
    for (b = 0; b < p_ics_right->len_window_group[g]; b++) {
      for (sfb = 0; sfb < p_ics_right->max_sfb; sfb++) {
        if (is_intensity(p_ics_right, g, sfb)) {
          scale =
            is_intensity(p_ics_right, g, sfb) * invert_intensity(pElement, g,
                                                                 sfb) *
            (float)pow(0.5, (0.25 * p_ics_right->sf[g][sfb]));
          for (i = sfb_offset[sfb]; i < sfb_offset[sfb + 1]; i++) {
            k = (group * 128) + i;
            r_spec[k] = l_spec[k] * scale;
          }
        }
      }
      group++;
    }
  }

  return 0;
}

/********************************************************************/

int is_intensity(s_SE_Individual_channel_stream *pData,
                 int group,
                 int sfb)
{
  switch (pData->sfb_cb[group][sfb]) {
  case INTENSITY_HCB:
    return 1;
  case INTENSITY_HCB2:
    return -1;
  default:
    return 0;
  }
}

/********************************************************************/

int is_noise(s_SE_Individual_channel_stream *pData,
             int group,
             int sfb)
{
  if (pData->sfb_cb[group][sfb] == NOISE_HCB)
    return 1;
  return 0;
}

/********************************************************************/

static float noise_generator(float *dst,
                             int   len,
                             int   *noiseState)
{
  float norm;
  int seed, i;

  norm = 0;
  seed = *noiseState;
  for (i = 0; i < len; i++) {
    seed = (1664525L * seed) + 1013904223L;
    dst[i] = (float)seed;
    norm += dst[i] * dst[i];
  }
  *noiseState = seed;

  norm = (float)(1 / sqrt(norm));
  return(norm);
}

/********************************************************************/

int apply_pns(s_SE_Individual_channel_stream *pDataL,
              s_SE_Individual_channel_stream *pDataR,
              float *p_spectrumL,
              float *p_spectrumR,
              int   numCh,
              int   ms_mask_present,
              int   ms_used[8][49],
              int   *noiseState)
{
  int     i, g, b, sfb, k, ich;
  float   norm;
  int     group;
  int     *sfb_offset;
  int     num_window_groups, max_sfb;
  int     *len_window_group;
  s_SE_Individual_channel_stream *pData = pDataL;
  float *p_spectrum = p_spectrumL;

  for (ich = 0; ich < numCh; ich++) {
    sfb_offset = pData->window_sequence == EIGHT_SHORT_SEQUENCE ?
      pData->sfb_offset_short_window : pData->sfb_offset_long_window;

    num_window_groups = pData->num_window_groups;
    len_window_group = pData->len_window_group;
    max_sfb = pData->max_sfb;

    group = 0;
    for (g = 0; g < num_window_groups; g++) {
      for (b = 0; b < len_window_group[g]; b++) {
        for (sfb = 0; sfb < max_sfb; sfb++) {
          if (pData->sfb_cb[g][sfb] == NOISE_HCB) {
            int tmp = 0;
            if ((ich == 1) && (ms_mask_present >= 1)) {
              if ((ms_used[g][sfb] != 0) || (ms_mask_present == 2)) {
                tmp = 1;
              }
            }

            if (tmp) {
              norm = (float)pow(2.0, 0.25 * (pData->sf[g][sfb] - pDataL->sf[g][sfb]));
              for (i = sfb_offset[sfb]; i < sfb_offset[sfb + 1]; i++) {
                k = (group * 128) + i;
                p_spectrum[k] = norm * p_spectrumL[k];
              }
            } else {
              norm = noise_generator(p_spectrum + (group * 128) + sfb_offset[sfb],
                                     sfb_offset[sfb + 1] - sfb_offset[sfb],
                                     noiseState);

              norm *= (float)pow(2.0, 0.25 * (pData->sf[g][sfb]));
              for (i = sfb_offset[sfb]; i < sfb_offset[sfb + 1]; i++) {
                k = (group * 128) + i;
                p_spectrum[k] *= norm;
              }
            }
          }
        }
        group++;
      }
    }
    pData = pDataR;
    p_spectrum = p_spectrumR;
  }
  return 0;
}

/********************************************************************/