ac3_dec_downmixing.c

audio-video-codecs.rar语音编解码器

          Ipp32f c4 = karaokeTable[karaokeCapable][7];
          Ipp32f c5 = karaokeTable[karaokeCapable][8];

          ippsAddProductC_32f(samC, c0, samL, 128);
          ippsAddProductC_32f(samC+256, c0, samL+256, 128);
          ippsAddProductC_32f(samC, c1, samR, 128);
          ippsAddProductC_32f(samC+256, c1, samR+256, 128);

          ippsAddProductC_32f(karaokeSL, c2, samL, 128);
          ippsAddProductC_32f(karaokeSL+256, c2, samL+256, 128);
          ippsAddProductC_32f(karaokeSL, c3, samR, 128);
          ippsAddProductC_32f(karaokeSL+256, c3, samR+256, 128);

          ippsAddProductC_32f(samSR, c4, samL, 128);
          ippsAddProductC_32f(samSR+256, c4, samL+256, 128);
          ippsAddProductC_32f(samSR, c5, samR, 128);
          ippsAddProductC_32f(samSR+256, c5, samR+256, 128);

        } else {
          ippsAddProductC_32f(samC, cmixgain, samL, 128);
          ippsAddProductC_32f(samC+256, cmixgain, samL+256, 128);
          ippsAddProductC_32f(samC, cmixgain, samR, 128);
          ippsAddProductC_32f(samC+256, cmixgain, samR+256, 128);
          if (inrear == 1) {
            ippsAddProductC_32f(samS, smixgain * m3dB, samL, 128);
            ippsAddProductC_32f(samS+256, smixgain * m3dB, samL+256, 128);
            ippsAddProductC_32f(samS, smixgain * m3dB, samR, 128);
            ippsAddProductC_32f(samS+256, smixgain * m3dB, samR+256, 128);
          } else if (inrear == 2) {
            ippsAddProductC_32f(samSL, smixgain, samL, 128);
            ippsAddProductC_32f(samSL+256, smixgain, samL+256, 128);
            ippsAddProductC_32f(samSR, smixgain, samR, 128);
            ippsAddProductC_32f(samSR+256, smixgain, samR+256, 128);
          }
        }
      } else if (outfront == 3) {
        if (karaokeCapable >= 0) {
          Ipp32f c0 = karaokeTable[karaokeCapable][9];
          Ipp32f c1 = karaokeTable[karaokeCapable][10];
          Ipp32f c2 = karaokeTable[karaokeCapable][11];
          Ipp32f c3 = karaokeTable[karaokeCapable][12];
          Ipp32f c4 = karaokeTable[karaokeCapable][13];
          Ipp32f c5 = karaokeTable[karaokeCapable][14];
          Ipp32f c6 = karaokeTable[karaokeCapable][15];
          Ipp32f c7 = karaokeTable[karaokeCapable][16];
          Ipp32f c8 = karaokeTable[karaokeCapable][17];

          if (c0 >= 0) {
            ippsAddProductC_32f(samC, c3, samL, 128);
            ippsAddProductC_32f(samC+256, c3, samL+256, 128);
          } else {
            ippsAddProductC_32f(samC, c3, samR, 128);
            ippsAddProductC_32f(samC+256, c3, samR+256, 128);
          }

          if (c1 >= 0) {
            ippsAddProductC_32f(karaokeSL, c4, samL, 128);
            ippsAddProductC_32f(karaokeSL+256, c4, samL+256, 128);
          } else {
            ippsAddProductC_32f(karaokeSL, c4, samR, 128);
            ippsAddProductC_32f(karaokeSL+256, c4, samR+256, 128);
          }

          if (c2 >= 0) {
            ippsAddProductC_32f(samSR, c5, samL, 128);
            ippsAddProductC_32f(samSR+256, c5, samL+256, 128);
          } else {
            ippsAddProductC_32f(samSR, c5, samR, 128);
            ippsAddProductC_32f(samSR+256, c5, samR+256, 128);
          }

          ippsMulC_32f_I(c6, samC, 128);
          ippsMulC_32f_I(c6, samC+256, 128);
          ippsAddProductC_32f(karaokeSL, c7, samC, 128);
          ippsAddProductC_32f(karaokeSL+256, c7, samC+256, 128);
          ippsAddProductC_32f(samSR, c8, samC, 128);
          ippsAddProductC_32f(samSR+256, c8, samC+256, 128);
        } else {
          if (inrear == 1) {
            ippsAddProductC_32f(samS, smixgain, samC, 128);
            ippsAddProductC_32f(samS+256, smixgain, samC+256, 128);
          } else if (inrear == 2) {
            ippsAddProductC_32f(samSL, smixgain, samL, 128);
            ippsAddProductC_32f(samSL+256, smixgain, samL+256, 128);
            ippsAddProductC_32f(samSR, smixgain, samR, 128);
            ippsAddProductC_32f(samSR+256, smixgain, samR+256, 128);
          }
        }
      }
      ippsZero_32f(karaokeSL, 128);
      ippsZero_32f(karaokeSL+256, 128);
      ippsZero_32f(samSR, 128);
      ippsZero_32f(samSR+256, 128);
    } else {
      if (state->out_acmod == ACMOD_0) { /* Dolby Surround compatible */
        if (infront != 2) {
          ippsMulC_32f_I(m3dB, samC, 128);
          ippsMulC_32f_I(m3dB, samC+256, 128);
          ippsAdd_32f_I(samC, samL, 128);
          ippsAdd_32f_I(samC+256, samL+256, 128);
          ippsAdd_32f_I(samC, samR, 128);
          ippsAdd_32f_I(samC+256, samR+256, 128);
          if (infront != 1) downmix = 1;
        }
        if (inrear == 1) {
          ippsMulC_32f_I(m3dB, samS, 128);
          ippsMulC_32f_I(m3dB, samS+256, 128);
          ippsSub_32f_I(samS, samL, 128);
          ippsSub_32f_I(samS+256, samL+256, 128);
          ippsAdd_32f_I(samS, samR, 128);
          ippsAdd_32f_I(samS+256, samR+256, 128);
          downmix = 1;
        } else if (inrear == 2) {
          ippsAdd_32f_I(samSR, samSL, 128);
          ippsAdd_32f_I(samSR+256, samSL+256, 128);
          ippsMulC_32f_I(m3dB, samSL, 128);
          ippsMulC_32f_I(m3dB, samSL+256, 128);
          ippsSub_32f_I(samSL, samL, 128);
          ippsSub_32f_I(samSL+256, samL+256, 128);
          ippsAdd_32f_I(samSL, samR, 128);
          ippsAdd_32f_I(samSL+256, samR+256, 128);
          downmix = 1;
        }
      } else if (state->out_acmod == ACMOD_10) { /* center only */
        if (infront == 3) {
          ippsMulC_32f_I(2 * cmixgain * m3dB, samC, 128);
          ippsMulC_32f_I(2 * cmixgain * m3dB, samC+256, 128);
          downmix = 1;
        }
        if (infront != 1) {
          ippsAdd_32f_I(samL, samR, 128);
          ippsAdd_32f_I(samL+256, samR+256, 128);
          ippsAddProductC_32f(samR, m3dB, samC, 128);
          ippsAddProductC_32f(samR+256, m3dB, samC+256, 128);
          downmix = 1;
        }
        if (inrear == 1) {
          ippsAddProductC_32f(samS, smixgain * m3dB, samC, 128);
          ippsAddProductC_32f(samS+256, smixgain * m3dB, samC+256, 128);
          if (smixgain > 0) downmix = 1;
        } else if (inrear == 2) {
          ippsAdd_32f(samSL, samSR, samSL, 128);
          ippsAdd_32f(samSL+256, samSR+256, samSL+256, 128);
          ippsAddProductC_32f(samSL, smixgain * m3dB, samC, 128);
          ippsAddProductC_32f(samSL+256, smixgain * m3dB, samC+256, 128);
          if (smixgain > 0) downmix = 1;
        }
      } else {    /* more than center output requested */
        if (outfront == 2) {
          if (infront == 1) {
            ippsMulC_32f(samC, m3dB, samL, 128);
            ippsMulC_32f(samC+256, m3dB, samL+256, 128);
            ippsCopy_32f(samL, samR, 128);
            ippsCopy_32f(samL+256, samR+256, 128);
          } else if (infront == 3) {
            ippsMulC_32f_I(cmixgain, samC, 128);
            ippsMulC_32f_I(cmixgain, samC+256, 128);
            ippsAdd_32f_I(samC, samL, 128);
            ippsAdd_32f_I(samC+256, samL+256, 128);
            ippsAdd_32f_I(samC, samR, 128);
            ippsAdd_32f_I(samC+256, samR+256, 128);
            downmix = 1;
          }
        }
        if (inrear == 1) {        /* single surround channel coded */
          if (outrear == 0) {     /* no surround loudspeakers */
            ippsMulC_32f_I(smixgain * m3dB, samS, 128);
            ippsMulC_32f_I(smixgain * m3dB, samS+256, 128);
            ippsAdd_32f_I(samS, samL, 128);
            ippsAdd_32f_I(samS+256, samL+256, 128);
            ippsAdd_32f_I(samS, samR, 128);
            ippsAdd_32f_I(samS+256, samR+256, 128);
            if (smixgain > 0) downmix = 1;
          } else if (outrear == 2) {      /* two surround loudspeaker channels */
            ippsMulC_32f(samS, m3dB, samSL, 128);
            ippsMulC_32f(samS+256, m3dB, samSL+256, 128);
            ippsCopy_32f(samSL, samSR, 128);
            ippsCopy_32f(samSL+256, samSR+256, 128);
          }
        } else if (inrear == 2) { /* two surround channels encoded */
          if (outrear == 0) {
            ippsAddProductC_32f(samSL, smixgain, samL, 128);
            ippsAddProductC_32f(samSL+256, smixgain, samL+256, 128);
            ippsAddProductC_32f(samSR, smixgain, samR, 128);
            ippsAddProductC_32f(samSR+256, smixgain, samR+256, 128);
            if (smixgain > 0) downmix = 1;
          } else if (outrear == 1) {
            ippsAdd_32f_I(samSR, samSL, 128);
            ippsAdd_32f_I(samSR+256, samSL+256, 128);
            ippsMulC_32f(samSL, m3dB, samS, 128);
            ippsMulC_32f(samSL+256, m3dB, samS+256, 128);
            downmix = 1;
          }
        }
      }
    }
  }

 /* write out_channel */
  switch (state->out_acmod) {
  case ACMOD_0:
    state->temp[0] = samL;
    state->temp[1] = samR;

    if (state->outlfeon)
      state->temp[2] = samLFE;
    break;
  case ACMOD_10:
    state->temp[0] = samC;

    if (state->outlfeon)
      state->temp[1] = samLFE;
    break;

  case ACMOD_20:
    state->temp[0] = samL;
    state->temp[1] = samR;

    if (state->outlfeon)
      state->temp[2] = samLFE;
    break;

  case ACMOD_30:
    state->temp[0] = samL;
    state->temp[1] = samC;
    state->temp[2] = samR;

    if (state->outlfeon)
      state->temp[3] = samLFE;
    break;
  case ACMOD_21:
    state->temp[0] = samL;
    state->temp[1] = samR;
    state->temp[2] = samS;

    if (state->outlfeon)
      state->temp[3] = samLFE;
    break;

  case ACMOD_31:
    state->temp[0] = samL;
    state->temp[1] = samC;
    state->temp[2] = samR;
    state->temp[3] = samS;

    if (state->outlfeon)
      state->temp[4] = samLFE;
    break;

  case ACMOD_22:
    state->temp[0] = samL;
    state->temp[1] = samR;
    state->temp[2] = samSL;
    state->temp[3] = samSR;
    if (state->outlfeon)
      state->temp[4] = samLFE;
    break;

  case ACMOD_32:
    state->temp[0] = samL;
    state->temp[1] = samC;
    state->temp[2] = samR;
    state->temp[3] = samSL;
    state->temp[4] = samSR;

    if (state->outlfeon)
      state->temp[5] = samLFE;
    break;

  default:
    break;
  }

  if (state->bsi.acmod != ACMOD_0) {
    Ipp32s i;
    gain = drc(state->bsi.compre, state->bsi.compr, dynrng,
               downmix, state->bsi.dialnorm, state);
    if (before_imdct) {
      for (i = 0; i < (state->nChannelOut - state->outlfeon); i++) {
        ippsMulC_32f_I(gain, state->temp[i], 256);
      }
    } else {
      for (i = 0; i < (state->nChannelOut - state->outlfeon); i++) {
        ippsMulC_32f_I(gain, state->temp[i], 128);
        ippsMulC_32f_I(gain, state->temp[i]+256, 128);
      }
    }
  }

  if ((state->bsi.lfeon) && (state->outlfeon)) {
    if (before_imdct) {
      ippsMulC_32f_I(gain, state->temp[state->nChannelOut - 1], 256);
    } else {
      ippsMulC_32f_I(gain, state->temp[state->nChannelOut - 1], 128);
      ippsMulC_32f_I(gain, state->temp[state->nChannelOut - 1]+256, 128);
    }
  }
}

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