aac_dec_stream_elements.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_huff_tables.h"
#include "aac_dec_own.h"

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

int     dec_ics_info(s_SE_Individual_channel_stream *pData,
                     sBitsreamBuffer *pBS,
                     enum AudioObjectType audioObjectType);

int     ics_info_copy(s_SE_Individual_channel_stream *pDataSrc,
                      s_SE_Individual_channel_stream *pDataDst);

int     dec_section_data(s_SE_Individual_channel_stream *pData,
                         sBitsreamBuffer *pBS);
int     dec_scale_factor_data(s_SE_Individual_channel_stream *pData,
                              sBitsreamBuffer *pBS);
int     dec_spectral_data(s_SE_Individual_channel_stream *pData,
                          sBitsreamBuffer *BS);
int     dec_pulse_data(s_SE_Individual_channel_stream *pData,
                       sBitsreamBuffer *pBS);
int     dec_tns_data(s_SE_Individual_channel_stream *pData,
                     sBitsreamBuffer *pBS);
int     dec_gain_control_data(s_SE_Individual_channel_stream *pData,
                              sBitsreamBuffer *pBS);
int     dec_ltp_data(s_SE_Individual_channel_stream *pData,
                     sBitsreamBuffer *pBS,
                     enum AudioObjectType audioObjectType);

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

int dec_cpe_channel_element(sCpe_channel_element *pElement,
                            sBitsreamBuffer *pBS,
                            enum AudioObjectType audioObjectType)
{
  int     g;
  int     sfb;
  int     max_sfb;
  int     num_window_groups;

  GET_BITS(pBS, pElement->element_instance_tag, 4)

  GET_BITS(pBS, pElement->common_window, 1)

  if (pElement->common_window) {
    if (dec_ics_info(&pElement->streams[0], pBS, audioObjectType) < 0)
      return -1;

    ics_info_copy(&pElement->streams[0], &pElement->streams[1]);

    if (audioObjectType == AOT_AAC_LTP &&
        EIGHT_SHORT_SEQUENCE != pElement->streams[1].window_sequence) {
      pElement->streams[1].ltp_data_present = 0;
      if (pElement->streams[1].predictor_data_present) {
        GET_BITS(pBS, pElement->streams[1].ltp_data_present, 1)
        if (pElement->streams[1].ltp_data_present) {
          dec_ltp_data(&pElement->streams[1], pBS, audioObjectType);
        }
      }
    }

    GET_BITS(pBS, pElement->ms_mask_present, 2)
    if (pElement->ms_mask_present == 1) {
      max_sfb = pElement->streams[0].max_sfb;
      num_window_groups = pElement->streams[0].num_window_groups;
      for (g = 0; g < num_window_groups; g++) {
        for (sfb = 0; sfb < max_sfb; sfb++) {
          GET_BITS(pBS, pElement->ms_used[g][sfb], 1)
        }
      }
    }
  } else {
    pElement->ms_mask_present = 0;
  }
  if (dec_individual_channel_stream
      (&pElement->streams[0], pBS, pElement->common_window, 0,
       audioObjectType) < 0)
    return -1;
  if (dec_individual_channel_stream
      (&pElement->streams[1], pBS, pElement->common_window, 0,
       audioObjectType) < 0)
    return -1;

  return 0;
}

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

int dec_sce_channel_element(sSce_channel_element *pElement,
                            sBitsreamBuffer *pBS,
                            enum AudioObjectType audioObjectType)
{
  GET_BITS(pBS, pElement->element_instance_tag, 4)

  if (dec_individual_channel_stream
      (&pElement->stream, pBS, 0, 0, audioObjectType) < 0)
    return -1;

  return 0;
}

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

int dec_lfe_channel_element(sLfe_channel_element *pElement,
                            sBitsreamBuffer *pBS,
                            enum AudioObjectType audioObjectType)
{
  GET_BITS(pBS, pElement->element_instance_tag, 4)

  if (dec_individual_channel_stream
      (&pElement->stream, pBS, 0, 0, audioObjectType) < 0)
    return -1;

  return 0;
}

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

int dec_individual_channel_stream(s_SE_Individual_channel_stream *pData,
                                  sBitsreamBuffer *pBS,
                                  int common_window,
                                  int scal_flag,
                                  enum AudioObjectType audioObjectType)
{
  int     i;

  GET_BITS(pBS, pData->global_gain, 8)

  if (!common_window && !scal_flag) {
    if (dec_ics_info(pData, pBS, audioObjectType) < 0)
      return -1;
  }

  if (dec_section_data(pData, pBS) < 0)
    return -1;

  dec_scale_factor_data(pData, pBS);

  if (!scal_flag) {

    GET_BITS(pBS, pData->pulse_data_present, 1)
    if (pData->pulse_data_present) {
      dec_pulse_data(pData, pBS);
    }

    GET_BITS(pBS, pData->tns_data_present, 1)
    if (pData->tns_data_present) {
      dec_tns_data(pData, pBS);
    }
    GET_BITS(pBS, pData->gain_control_data_present, 1)
    if (pData->gain_control_data_present) {
      if (AOT_AAC_SSR == audioObjectType) {
        dec_gain_control_data(pData, pBS);
      } else {
        return -1;
      }
    }
  }

  for (i = 0; i < pData->num_windows; i++) {
    pData->p_spectrum[i] = &pData->spectrum_data[i * 128];
  }

  dec_spectral_data(pData, pBS);

  return 0;
}

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

int dec_ics_info(s_SE_Individual_channel_stream *pData,
                 sBitsreamBuffer *pBS,
                 enum AudioObjectType audioObjectType)
{
  int     i;
  int     pred_min_sfb;

  GET_BITS(pBS, pData->ics_reserved_bit, 1)
  GET_BITS(pBS, pData->window_sequence, 2)
  GET_BITS(pBS, pData->window_shape, 1)

  pData->num_window_groups = 1;
  pData->len_window_group[0] = 1;
  pData->predictor_reset = 0;
  pData->ltp_data_present = 0;

  if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
    pData->num_windows = 8;
    GET_BITS(pBS, pData->max_sfb, 4)
    if (pData->num_swb_short < pData->max_sfb)
      return -1;
    for (i = 0; i < 7; i++) {
      GET_BITS(pBS, pData->scale_factor_grouping[i], 1)

      if (pData->scale_factor_grouping[i] == 0) {
        pData->len_window_group[pData->num_window_groups] = 1;
        pData->num_window_groups++;
      } else {
        pData->len_window_group[pData->num_window_groups - 1]++;

      }
    }

  } else {
    pData->num_windows = 1;
    GET_BITS(pBS, pData->max_sfb, 6)
    if (pData->num_swb_long < pData->max_sfb)
      return -1;
    GET_BITS(pBS, pData->predictor_data_present, 1)
    if (pData->predictor_data_present) {
      if (audioObjectType == AOT_AAC_MAIN) {
        GET_BITS(pBS, pData->predictor_reset, 1)
        if (pData->predictor_reset) {
          GET_BITS(pBS, pData->predictor_reset_group_number, 5)
        }
        pred_min_sfb =
          pData->max_sfb <
          pData->pred_max_sfb ? pData->max_sfb : pData->pred_max_sfb;
        for (i = 0; i < pred_min_sfb; i++) {
          GET_BITS(pBS, pData->prediction_used[i], 1)
        }
      } else if (audioObjectType == AOT_AAC_LTP) {
        GET_BITS(pBS, pData->ltp_data_present, 1)
        if (pData->ltp_data_present) {
//                    dbg_trace("ltp_data_present\n");
          dec_ltp_data(pData, pBS, audioObjectType);
        }
      } else {
        return -1;
      }
    }
  }

  return 0;
}

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

int ics_info_copy(s_SE_Individual_channel_stream *pDataSrc,
                  s_SE_Individual_channel_stream *pDataDst)
{
  int     i;
  int     pred_min_sfb;

  pDataDst->ics_reserved_bit = pDataSrc->ics_reserved_bit;
  pDataDst->window_sequence = pDataSrc->window_sequence;
  pDataDst->window_shape = pDataSrc->window_shape;

  pDataDst->num_window_groups = 1;
  pDataDst->len_window_group[0] = 1;

  if (pDataSrc->window_sequence == EIGHT_SHORT_SEQUENCE) {
    pDataDst->num_windows = 8;
    pDataDst->max_sfb = pDataSrc->max_sfb;

    for (i = 0; i < 7; i++) {
      pDataDst->scale_factor_grouping[i] = pDataSrc->scale_factor_grouping[i];

      if (pDataDst->scale_factor_grouping[i] == 0) {
        pDataDst->len_window_group[pDataDst->num_window_groups] = 1;
        pDataDst->num_window_groups++;
      } else {
        pDataDst->len_window_group[pDataDst->num_window_groups - 1]++;

      }
    }

  } else {
    pDataDst->num_windows = 1;
    pDataDst->max_sfb = pDataSrc->max_sfb;
    pDataDst->predictor_data_present = pDataSrc->predictor_data_present;

    if (pDataDst->predictor_data_present) {
      pDataDst->predictor_reset = pDataSrc->predictor_reset;
      if (pDataDst->predictor_reset) {
        pDataDst->predictor_reset_group_number =
          pDataSrc->predictor_reset_group_number;
      }
      pred_min_sfb =
        pDataDst->max_sfb <
        pDataDst->pred_max_sfb ? pDataDst->max_sfb : pDataDst->pred_max_sfb;
      for (i = 0; i < pred_min_sfb; i++) {
        pDataDst->prediction_used[i] = pDataSrc->prediction_used[i];
      }
    }
  }

  return 0;
}

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

int dec_ltp_data(s_SE_Individual_channel_stream *pData,
                 sBitsreamBuffer *pBS,
                 enum AudioObjectType audioObjectType)
{
  int     i;
  int     w;
  int     pred_max_sfb;

  pred_max_sfb =
    MAX_LTP_SFB_LONG < pData->max_sfb ? MAX_LTP_SFB_LONG : pData->max_sfb;
  if (audioObjectType == AOT_ER_AAC_LD) {
    GET_BITS(pBS, pData->ltp_lag_update, 1)
    if (pData->ltp_lag_update) {
      GET_BITS(pBS, pData->ltp_lag, 10)
    } else {
    }
    GET_BITS(pBS, pData->ltp_coef, 3)
    for (i = 0; i < pred_max_sfb; i++) {
      GET_BITS(pBS, pData->ltp_long_used[i], 1)
    }
  } else {
    GET_BITS(pBS, pData->ltp_lag, 11)
    GET_BITS(pBS, pData->ltp_coef, 3)

    if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
      for (w = 0; w < pData->num_windows; w++) {
        GET_BITS(pBS, pData->ltp_short_used[w], 1)
        if (pData->ltp_short_used[w]) {
          GET_BITS(pBS, pData->ltp_short_lag_present[w], 1)
          if (pData->ltp_short_lag_present[w]) {
            GET_BITS(pBS, pData->ltp_short_lag[w], 4)
          } else {
            pData->ltp_short_lag[w] = 0;
          }

        }
      }

    } else {
      for (i = 0; i < pred_max_sfb; i++) {
        GET_BITS(pBS, pData->ltp_long_used[i], 1)
      }

      for (i = pred_max_sfb; i < pData->max_sfb; i++) {
        pData->ltp_long_used[i] = 0;
      }
    }
  }
  return 0;
}

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

int dec_section_data(s_SE_Individual_channel_stream *pData,
                     sBitsreamBuffer *pBS)
{
  int     sfb;
  int     k;
  int     g;
  int     sect_esc_val;
  int     sect_len_incr;
  int     esc_code_len;
  int     sect_cb;
  int     sect_len;

  if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
    sect_esc_val = (1 << 3) - 1;
    esc_code_len = 3;
  } else {
    sect_esc_val = (1 << 5) - 1;
    esc_code_len = 5;
  }
  for (g = 0; g < pData->num_window_groups; g++) {
    k = 0;
    while (k < pData->max_sfb) {
      GET_BITS(pBS, sect_cb, 4)
      sect_len = 0;
      GET_BITS(pBS, sect_len_incr, esc_code_len)
      while (sect_len_incr == sect_esc_val) {
        sect_len += sect_esc_val;
        GET_BITS(pBS, sect_len_incr, esc_code_len)
      }
      sect_len += sect_len_incr;

      for (sfb = k; sfb < k + sect_len; sfb++) {
        pData->sfb_cb[g][sfb] = sect_cb;
      }
      k += sect_len;

      if (k > pData->max_sfb) {
        return -1;
      }
    }
    for (; k < 51; k++) {
      pData->sfb_cb[g][k] = 0;
    }
  }

  return 0;
}

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

int dec_scale_factor_data(s_SE_Individual_channel_stream *pData,
                          sBitsreamBuffer *pBS)
{
  int     g;
  int     sfb;
  short   t;
  int     is_pos;
  int     scale_factor;
  int     noise_pcm_flag;
  int     noise_nrg;
  unsigned char *pSrc;
  int     bitoffset;
  IppsVLCDecodeSpec_32s *pVLCDecSpec =
    (IppsVLCDecodeSpec_32s *) pData->p_huffman_tables[0];

  is_pos = 0;
  noise_pcm_flag = 1;
  noise_nrg = pData->global_gain;
  noise_nrg -= 90;

  scale_factor = pData->global_gain;
  pSrc = (Ipp8u *)pBS->pCurrent_dword + ((32 - pBS->nBit_offset) >> 3);
  bitoffset = (32 - pBS->nBit_offset) & 0x7;

  for (g = 0; g < pData->num_window_groups; g++) {
    for (sfb = 0; sfb < pData->max_sfb; sfb++) {
      switch (pData->sfb_cb[g][sfb]) {
      case ZERO_HCB:
        pData->sf[g][sfb] = 0;
        break;
      case INTENSITY_HCB:
      case INTENSITY_HCB2:
        ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
        is_pos += t - SF_MID;
        pData->sf[g][sfb] = (short)is_pos;
        break;
      case NOISE_HCB:
        if (noise_pcm_flag) {
          pBS->pCurrent_dword = (Ipp32u *)(pSrc - ((Ipp32s)(pSrc) & 3));
          pBS->nBit_offset =
            32 - ((pSrc - (Ipp8u *)pBS->pCurrent_dword) << 3) - bitoffset;
          noise_pcm_flag = 0;
          GET_BITS(pBS, t, 9)
          pSrc = (Ipp8u *)pBS->pCurrent_dword + ((32 - pBS->nBit_offset) >> 3);
          bitoffset = (32 - pBS->nBit_offset) & 0x7;
        } else {
          ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
          t -= SF_MID;
        }
        noise_nrg += t;
        pData->sf[g][sfb] = (short)noise_nrg;
        break;
      default:
        ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
        scale_factor += t - SF_MID;
        pData->sf[g][sfb] = (short)scale_factor;
        break;
      }
    }
  }
  pBS->pCurrent_dword = (Ipp32u *)(pSrc - ((Ipp32s)(pSrc) & 3));
  pBS->dword = BSWAP(pBS->pCurrent_dword[0]);
  pBS->nBit_offset =
    32 - ((pSrc - (Ipp8u *)pBS->pCurrent_dword) << 3) - bitoffset;
  return 0;
}

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

int dec_spectral_data(s_SE_Individual_channel_stream *pData,
                      sBitsreamBuffer *pBS)
{
  int     g;       // / group counter
  int     w;
  int     w_offset;     //
  int     sfb;
  int    *sfb_offset;
  short  *qp;
  Ipp8u  *pSrc;
  Ipp16s  pDst[512];
  int     bitoffset, i;

  ippsZero_16s(pData->spectrum_data, 1024);

  if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
    sfb_offset = pData->sfb_offset_short_window;
  } else {
    sfb_offset = pData->sfb_offset_long_window;
  }