aac_dec_stream_elements.c

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

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

  w_offset = 0;
  for (g = 0; g < pData->num_window_groups;
       g++, w_offset += pData->len_window_group[g - 1]) {
    for (sfb = 0; sfb < pData->max_sfb; sfb++) {
      int     sfb_cb = pData->sfb_cb[g][sfb];
      int     sfb_begin = sfb_offset[sfb];
      int     sfb_end = sfb_offset[sfb + 1];
      int     shift = vlcShifts[sfb_cb];
      int     offset = vlcOffsets[sfb_cb];
      int     mask = (1 << (shift)) - 1;
      IppsVLCDecodeSpec_32s *pVLCDecSpec =
        (IppsVLCDecodeSpec_32s *) pData->p_huffman_tables[sfb_cb];

      switch (vlcTypes[sfb_cb]) {
      case 0:  /* 4 tuples */
        for (w = 0; w < pData->len_window_group[g]; w++) {
          qp = pData->p_spectrum[w_offset + w];

          ippsVLCDecodeBlock_1u16s(&pSrc, &bitoffset, pDst,
                                   (sfb_end - sfb_begin) >> 2, pVLCDecSpec);

          for (i = 0; i < (sfb_end - sfb_begin) >> 2; i++) {
            int     tmp = pDst[i];

            qp[0] = (short)(tmp >> (3 * shift));
            qp[1] = (short)(((tmp >> (2 * shift)) & mask) - offset);
            qp[2] = (short)(((tmp >> (shift)) & mask) - offset);
            qp[3] = (short)((tmp & mask) - offset);

            qp += 4;
          }
          pData->p_spectrum[w_offset + w] = qp;
        }
        break;
      case 1:  /* 2 tuples */
        for (w = 0; w < pData->len_window_group[g]; w++) {
          qp = pData->p_spectrum[w_offset + w];

          ippsVLCDecodeBlock_1u16s(&pSrc, &bitoffset, pDst,
                                   (sfb_end - sfb_begin) >> 1, pVLCDecSpec);

          for (i = 0; i < (sfb_end - sfb_begin) >> 1; i++) {
            int     tmp = pDst[i];

            qp[0] = (short)(tmp >> shift);
            qp[1] = (short)((tmp & mask) - offset);

            qp += 2;
          }
          pData->p_spectrum[w_offset + w] = qp;
        }
        break;
      case 2:  /* esc */
        for (w = 0; w < pData->len_window_group[g]; w++) {
          qp = pData->p_spectrum[w_offset + w];

          ippsVLCDecodeEscBlock_AAC_1u16s(&pSrc, &bitoffset, qp,
                                          (sfb_end - sfb_begin), pVLCDecSpec);
          qp += (sfb_end - sfb_begin);

          pData->p_spectrum[w_offset + w] = qp;
        }
        break;
      default:
        for (w = 0; w < pData->len_window_group[g]; w++) {
          qp = pData->p_spectrum[w_offset + w];
          qp += (sfb_end - sfb_begin);
          pData->p_spectrum[w_offset + w] = qp;
        }
        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_pulse_data(s_SE_Individual_channel_stream *pData,
                   sBitsreamBuffer *pBS)
{
  int     i;

  GET_BITS(pBS, pData->number_pulse, 2)
  GET_BITS(pBS, pData->pulse_start_sfb, 6)
  for (i = 0; i < pData->number_pulse + 1; i++) {
    GET_BITS(pBS, pData->pulse_offset[i], 5)
    GET_BITS(pBS, pData->pulse_amp[i], 4)
  }
  return 0;
}

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

int dec_tns_data(s_SE_Individual_channel_stream *pData,
                 sBitsreamBuffer *pBS)
{
  int     w;
  int     filt;
  int     i;
  int     coef_len;

  for (w = 0; w < pData->num_windows; w++) {
    int nbits;

    nbits = (pData->num_windows == 8) ? 1 : 2;
    GET_BITS(pBS, pData->n_filt[w], nbits)
    if (pData->n_filt[w] == 0)
      continue;
    GET_BITS(pBS, pData->coef_res[w], 1)

    for (filt = 0; filt < pData->n_filt[w]; filt++) {
      nbits = (pData->num_windows == 8) ? 4 : 6;
      GET_BITS(pBS, pData->length[w][filt], nbits)

      nbits = (pData->num_windows == 8) ? 3 : 5;
      GET_BITS(pBS, pData->order[w][filt], nbits)

      if (pData->order[w][filt] == 0)
        continue;

      GET_BITS(pBS, pData->direction[w][filt], 1)
      GET_BITS(pBS, pData->coef_compress[w][filt], 1)
      coef_len = 3 + pData->coef_res[w] - pData->coef_compress[w][filt];

      for (i = 0; i < pData->order[w][filt]; i++) {
        GET_BITS(pBS, pData->coef[w][filt][i], coef_len)
      }
    }
  }
  return 0;
}

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

int dec_coupling_channel_element(sCoupling_channel_element *pElement,
                                 sBitsreamBuffer *pBS,
                                 enum AudioObjectType audioObjectType)
{
  int     c;
  int     cge;
  short   t;
  int     g;
  int     sfb;
  unsigned char *pSrc;
  int     bitoffset;
  IppsVLCDecodeSpec_32s *pVLCDecSpec =
    (IppsVLCDecodeSpec_32s *) pElement->stream.p_huffman_tables[0];

  GET_BITS(pBS, pElement->element_instance_tag, 4)

  GET_BITS(pBS, pElement->ind_sw_cce_flag, 1)
  GET_BITS(pBS, pElement->num_coupled_elements, 3)

  pElement->num_gain_element_lists = 0;
  for (c = 0; c < pElement->num_coupled_elements + 1; c++) {
    pElement->num_gain_element_lists++;
    GET_BITS(pBS, pElement->cc_target_is_cpe[c], 1)
    GET_BITS(pBS, pElement->cc_target_tag_select[c], 4)
    if (pElement->cc_target_is_cpe[c]) {
      GET_BITS(pBS, pElement->cc_l[c], 1)
      GET_BITS(pBS, pElement->cc_r[c], 1)
      if (pElement->cc_l[c] && pElement->cc_r[c]) {
        pElement->num_gain_element_lists++;
      }
    }
  }

  GET_BITS(pBS, pElement->cc_domain, 1)
  GET_BITS(pBS, pElement->gain_element_sign, 1)
  GET_BITS(pBS, pElement->gain_element_scale, 2)

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

  for (c = 1; c < pElement->num_gain_element_lists; c++) {
    if (pElement->ind_sw_cce_flag) {
      cge = 1;
    } else {
      GET_BITS(pBS, pElement->common_gain_element_present[c], 1)
      cge = pElement->common_gain_element_present[c];
    }

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

    if (cge) {
      ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
      pElement->common_gain_element[c] = t;
    } else {
      for (g = 0; g < pElement->stream.num_window_groups; g++) {
        for (sfb = 0; sfb < pElement->stream.max_sfb; sfb++) {
          if (pElement->stream.sfb_cb[g][sfb] != ZERO_HCB) {
            ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &t, pVLCDecSpec);
          }
        }
      }
    }
    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_data_stream_element(sData_stream_element *pData,
                            sBitsreamBuffer *pBS)
{
  int     data_byte_align_flag;
  int     count;
  int     cnt;
  int     i;

  GET_BITS(pBS, pData->element_instance_tag, 4)
  GET_BITS(pBS, data_byte_align_flag, 1)
  GET_BITS(pBS, count, 8)
  cnt = count;
  if (cnt == 255) {
    GET_BITS(pBS, count, 8)
    cnt += count;
  }
  if (data_byte_align_flag) {
    Byte_alignment(pBS);
  }
  for (i = 0; i < cnt; i++) {
    GET_BITS(pBS, pData->data_stream_byte[i], 8)
  }
  return 0;
}

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

int dec_extension_payload(sSbrDecCommon * pSbr,
                          int *pNumFillSbr,
                          sDynamic_range_info *pInfo,
                          sBitsreamBuffer *pBS,
                          int cnt)
{
  int     extension_type;
  int     ret_value;
  int     fill_nibble;
  int     fill_byte;
  int     i;
  int     other_bits;

  ret_value = 0;
  GET_BITS(pBS, extension_type, 4)
  pSbr->cnt_bit -= 4;
  switch (extension_type) {
  case EXT_DYNAMIC_RANGE:
    ret_value = dec_dynamic_range_info(pInfo, pBS);
    break;

  case EXT_SBR_DATA:
    *pNumFillSbr += 1;
    ret_value = sbr_extension_data(pSbr->id_aac, 0, pSbr, pBS, cnt);
    break;

  case EXT_SBR_DATA_CRC:
    *pNumFillSbr += 1;
    ret_value = sbr_extension_data(pSbr->id_aac, 1, pSbr, pBS, cnt);
    break;

  case EXT_FILL_DATA:
    GET_BITS(pBS, fill_nibble, 4)
    for (i = 0; i < cnt - 1; i++) {
      GET_BITS(pBS, fill_byte, 8)
    }
    ret_value = cnt;
    break;
  default:
    for (i = 0; i < 8 * (cnt - 1) + 4; i++) {
      GET_BITS(pBS, other_bits, 1)
    }
    ret_value = cnt;
    break;
  }

  /******************************************************
   * ret_value - positive, number of bit has been read
   * but...
   * if there is error,
   * then ret_value = SBR_ERR_REQUIREMENTS
   ******************************************************/
  return ret_value;
}

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

int dec_fill_element(sSbrDecCommon *pSbr,
                     int *cnt_fill_sbr_element,
                     sDynamic_range_info *pInfo,
                     sBitsreamBuffer * pBS)
{
  int     cnt;
  int     ret;

  GET_BITS(pBS, cnt, 4)

  if (cnt == 15) {
    int tmp;

    GET_BITS(pBS, tmp, 8)
    cnt += tmp - 1;
  }
  pSbr->cnt_bit = cnt * 8;

  /******************************************************
   * ret - positive value, number of bit has been read
   * but...
   * if there is error,
   * then ret = SBR_ERR_REQUIREMENTS
   ******************************************************/
  while (cnt > 0) {
    ret = dec_extension_payload(pSbr, cnt_fill_sbr_element, pInfo, pBS, cnt);

    if ( SBR_ERR_REQUIREMENTS == ret )
      return SBR_ERR_REQUIREMENTS;
    else
      cnt -= ret;
  }

  return 0;
}

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

int dec_excluded_channels(sExcluded_channels *pData,
                          sBitsreamBuffer *pBS)
{
  int     n, i;

  n = 0;

  pData->num_excl_chan = 7;
  for (i = 0; i < 7; i++) {
    GET_BITS(pBS, pData->exclude_mask[i], 1)
    n++;
  }

  GET_BITS(pBS, pData->additional_excluded_chns[n - 1], 1)
  while (pData->additional_excluded_chns[n - 1] == 1) {
    for (i = pData->num_excl_chan; i < pData->num_excl_chan + 7; i++) {
      GET_BITS(pBS, pData->exclude_mask[i], 1)
    }
    n++;
    pData->num_excl_chan += 7;
    GET_BITS(pBS, pData->additional_excluded_chns[n - 1], 1)
  }
  return n;
}

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

int dec_dynamic_range_info(sDynamic_range_info *pInfo,
                           sBitsreamBuffer *pBS)
{
  int     n, i;

  n = 1;

  pInfo->drc_num_bands = 1;
  GET_BITS(pBS, pInfo->pce_tag_present, 1)

  if (pInfo->pce_tag_present == 1) {
    GET_BITS(pBS, pInfo->pce_innstance_tag, 4)
    GET_BITS(pBS, pInfo->drc_tag_reserved_bits, 4)
    n++;
  }

  GET_BITS(pBS, pInfo->excluded_chns_present, 1)

  if (pInfo->excluded_chns_present == 1) {
    n += dec_excluded_channels(&pInfo->ec_data, pBS);
  }

  GET_BITS(pBS, pInfo->drc_bands_present, 1)
  if (pInfo->drc_bands_present == 1) {
    GET_BITS(pBS, pInfo->drc_band_incr, 4)
    GET_BITS(pBS, pInfo->drc_bands_reserved_bits, 4)

    n++;

    pInfo->drc_num_bands += pInfo->drc_band_incr;

    for (i = 0; i < pInfo->drc_num_bands; i++) {
      GET_BITS(pBS, pInfo->drc_band_top[i], 8)
      n++;
    }
  }

  GET_BITS(pBS, pInfo->prog_ref_level_present, 1)

  if (pInfo->prog_ref_level_present == 1) {
    GET_BITS(pBS, pInfo->prog_ref_level, 7)
    GET_BITS(pBS, pInfo->prog_ref_level_reserved_bits, 1)

    n++;
  }

  for (i = 0; i < pInfo->drc_num_bands; i++) {
    GET_BITS(pBS, pInfo->dyn_rng_sgn[i], 1)
    GET_BITS(pBS, pInfo->dyn_rng_ctl[i], 7)

    n++;
  }

  return n;
}

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

int dec_gain_control_data(s_SE_Individual_channel_stream *pData,
                          sBitsreamBuffer *pBS)
{
  int     bd, ad, wd;
  int     adjust_num_bd_wd;

  GET_BITS(pBS, pData->max_band, 2)

  if (pData->window_sequence == ONLY_LONG_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 1; wd++) {
        GET_BITS(pBS, adjust_num_bd_wd, 3)
        for (ad = 0; ad < adjust_num_bd_wd; ad++) {
          GET_BITS(pBS, pData->alevcode[bd][wd][ad], 4)
          GET_BITS(pBS, pData->aloccode[bd][wd][ad], 5)
        }
      }
    }
  } else if (pData->window_sequence == LONG_START_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 2; wd++) {
        GET_BITS(pBS, pData->adjust_num[bd][wd], 3)
        for (ad = 0; ad < pData->adjust_num[bd][wd]; ad++) {
          GET_BITS(pBS, pData->alevcode[bd][wd][ad], 4)
          if (wd == 0) {
            GET_BITS(pBS, pData->aloccode[bd][wd][ad], 4)
          } else {
            GET_BITS(pBS, pData->aloccode[bd][wd][ad], 2)
          }
        }
      }
    }
  } else if (pData->window_sequence == EIGHT_SHORT_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 8; wd++) {
        GET_BITS(pBS, pData->adjust_num[bd][wd], 3)
        for (ad = 0; ad < pData->adjust_num[bd][wd]; ad++) {
          GET_BITS(pBS, pData->alevcode[bd][wd][ad], 4)
          GET_BITS(pBS, pData->aloccode[bd][wd][ad], 2)
        }
      }
    }
  } else if (pData->window_sequence == LONG_STOP_SEQUENCE) {
    for (bd = 1; bd <= pData->max_band; bd++) {
      for (wd = 0; wd < 2; wd++) {
        GET_BITS(pBS, pData->adjust_num[bd][wd], 3)
        for (ad = 0; ad < pData->adjust_num[bd][wd]; ad++) {
          GET_BITS(pBS, pData->alevcode[bd][wd][ad], 4)
          if (wd == 0) {
            GET_BITS(pBS, pData->aloccode[bd][wd][ad], 4)
          } else {
            GET_BITS(pBS, pData->aloccode[bd][wd][ad], 5)
          }
        }
      }
    }
  }

  return 0;
}

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

int ics_apply_pulse_I(s_SE_Individual_channel_stream *p_data)
{
  int     i, k;

  k = p_data->sfb_offset_long_window[p_data->pulse_start_sfb];

  for (i = 0; i <= p_data->number_pulse; i++) {
    k += p_data->pulse_offset[i];
    if (p_data->spectrum_data[k] > 0) {
      p_data->spectrum_data[k] = p_data->spectrum_data[k] + (short)p_data->pulse_amp[i];
    } else {
      p_data->spectrum_data[k] = p_data->spectrum_data[k] - (short)p_data->pulse_amp[i];
    }

  }
  return 0;
}

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