mp3enc_bitstream.c

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

  Ipp32s sblimit     = state->mc_sblimit;
  Ipp16s (*allocation)[32] = state->allocation;
  Ipp32s *nbal_alloc_table = state->nbal_alloc_table;
  Ipp32s center = state->mc_header.center;
  Ipp16u (*scfsi)[32] = state->scfsi;

  if (state->mc_header.lfe)
  {
    PutBitsDst(stream, state->mc_lfe_alloc, 4);
  }

  for (i = 0; i < sblimit; i++)
  {
    l = mp3_mc_sb_group[i];
    for (m = stereo; m < stereo + stereomc; ++m)
    {
      k = mp3enc_mc_trans_channel(state, l, m);

      if ((state->mc_header.center != 3) || (i < 12) || (k !=2))
        if (mp3enc_mc_dyn_channel(state, l, m) == 1)
          PutBitsDst(stream, allocation[k][i], nbal_alloc_table[i]);
    }
  }

  for (i = 0; i < sblimit; i++)
  {
    n = mp3_mc_sb_group[i];
    for (m = stereo; m < stereo + stereomc; m++)
    {
      k = mp3enc_mc_trans_channel(state, n, m);

      if (allocation[k][i] && (i < 12 || m != 2 || center != 3))
        PutBitsDst(stream, scfsi[k][i], 2);
    }
  }
}

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

void mp3enc_mc_encode_scale(MP3Enc_com *state,
                      sBitsreamBuffer *stream)
{
  Ipp32s stereo  = state->stereo;
  Ipp32s stereomc    = state->mc_channel;
  Ipp32s sblimit;
  Ipp32s i, j, k, m, n;
//  Ipp32s pci, pred;
  Ipp32s center = state->mc_header.center;
  Ipp32s lfe = state->mc_header.lfe;
  Ipp16s (*allocation)[32] = state->allocation;
  Ipp16u (*scfsi)[32] = state->scfsi;
  Ipp16s (*scalefactor)[3][32] = state->scalefactor;

  sblimit = state->mc_sblimit;

/*
  pred = 0;
  if (start == stereo)
  {
    if (state->mc_prediction_on == 1)
    {
      for (i = 0; i < 8; i++)
      {
        if (state->mc_prediction[i] == 1)
        {
          Ipp32s val;
          val = mp3_mc_pred_coef_table[state->mc_pred_mode][state->mc_dyn_cross_mode[i]];
          for (m = 0; m < val; m++)
          {
            if (state->mc_predsi[i][m] != 0)
            {
              PutBitsDst(stream, state->mc_delay_comp[i][m], 3);
              pred += 3;
              for (pci = 0; pci < state->mc_predsi[i][m]; pci++)
              {
                PutBitsDst(stream, state->mc_pred_coeff[i][m][pci], 8);
                pred += 8;
              }
            }
          }
        }
      }
    }
  }*/

  if (/*start == stereo && */
    lfe && state->mc_lfe_alloc)
    PutBitsDst(stream, state->mc_lfe_scf, 6);

  for (i = 0; i < sblimit; i++)
  {
    n = mp3_mc_sb_group[i];
    for (m = stereo; m < stereo + stereomc; m++)
    {
      k = mp3enc_mc_trans_channel (state, n, m);

      if (allocation[k][i] && (i < 12 || m != 2 || center != 3)) {
        switch (scfsi[k][i])       {
        case 0:
          for (j = 0; j < 3; j++)
            PutBitsDst (stream, scalefactor[k][j][i], 6);
          break;
        case 1:
        case 3:
          PutBitsDst (stream, scalefactor[k][0][i], 6);
          PutBitsDst (stream, scalefactor[k][2][i], 6);
          break;
        case 2:
          PutBitsDst (stream, scalefactor[k][0][i], 6);
        }
      }
    }
  }
}

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

static void mp3enc_mc_sample_encoding_l2(MP3Enc_com *state,
                            sBitsreamBuffer *stream)
{
  Ipp32s i, j, k, s, l, m;
  Ipp32s center      = state->mc_header.center;
  Ipp32s stereo      = state->stereo;
  Ipp32s stereomc    = state->mc_channel;
  Ipp32s sblimit     = state->mc_sblimit;
  Ipp32s lfe  =     state->mc_header.lfe;
  Ipp8u  *alloc_table = state->alloc_table;
  Ipp32s (*sample)[32][36] = state->sample;
  Ipp16s (*allocation)[32] = state->allocation;

  for (s = 0; s < 3; s++)
    for (j = 0; j < 4; j ++)
    {
      if (lfe)
        PutBitsDst(stream, state->mc_lfe_spl[s*4+j], state->mc_lfe_alloc + 1);

      for (i = 0; i < sblimit; i++)
      {
        l = mp3_mc_sb_group[i];
        for (m = stereo; m < stereo + stereomc; m++)
        {
          k = mp3enc_mc_trans_channel(state, l, m);

          if (allocation[k][i] && (i < 12 || m != 2 || center != 3))
          {
            Ipp32s idx = alloc_table[i * 16 + state->allocation[m][i]];
            Ipp32s c;
            Ipp32s gr = s*4+j;

            idx = mp3_cls_quant[idx];

            if (idx < 0) {
              idx = - idx;

              if(idx == 5) {
                c = sample[m][i][3 * gr + 0] +
                  sample[m][i][3 * gr + 1] * 3 +
                  sample[m][i][3 * gr + 2] * 9;
              }
              else if(idx == 7) {
                c = sample[m][i][3 * gr + 0] +
                  sample[m][i][3 * gr + 1] * 5 +
                  sample[m][i][3 * gr + 2] * 25;
              }
              else {
                c = sample[m][i][3 * gr + 0] +
                  sample[m][i][3 * gr + 1] * 9 +
                  sample[m][i][3 * gr + 2] * 81;
              }

              PutBits(c, idx);
            } else {
              PutBits(sample[m][i][3 * gr + 0], idx);
              PutBits(sample[m][i][3 * gr + 1], idx);
              PutBits(sample[m][i][3 * gr + 2], idx);
            }
          }
        }
      }
    }
}

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

static Ipp32s mp3enc_encodeSideInfo_m1l3(MP3Enc_com *state) {
  Ipp32s i, gr, ch;
  Ipp32s stereo = state->stereo;

  mp3enc_encodeHeader(state, &state->sideStream);

// side info
    PutBitsSI(state->si_main_data_begin, 9);

    if (stereo == 2)
      PutBitsSI(state->si_private_bits, 3)
    else
     PutBitsSI(state->si_private_bits, 5);

    for (ch = 0; ch < stereo; ch++)
      for (i = 0; i < 4; i++)
        PutBitsSI(state->si_scfsi[ch][i], 1);

    for (gr = 0; gr < 2; gr++)
      for (ch = 0; ch < stereo; ch++) {
        PutBitsSI(state->si_part23Len[gr][ch], 12);
        PutBitsSI(state->si_bigVals[gr][ch], 9);
        PutBitsSI(state->si_globGain[gr][ch], 8);
        PutBitsSI(state->si_sfCompress[gr][ch], 4);
        PutBitsSI(state->si_winSwitch[gr][ch], 1);

        if (state->si_winSwitch[gr][ch]) {
          PutBitsSI(state->si_blockType[gr][ch], 2);
          PutBitsSI(state->si_mixedBlock[gr][ch], 1);

          for (i = 0; i < 2; i++)
            PutBitsSI(state->si_pTableSelect[gr][ch][i], 5);
          for (i = 0; i < 3; i++)
            PutBitsSI(state->si_pSubBlkGain[gr][ch][i], 3);
        } else {
          for (i = 0; i < 3; i++)
            PutBitsSI(state->si_pTableSelect[gr][ch][i], 5);

          PutBitsSI(state->si_reg0Cnt[gr][ch], 4);
          PutBitsSI(state->si_reg1Cnt[gr][ch], 3);
        }

        PutBitsSI(state->si_preFlag[gr][ch], 1);
        PutBitsSI(state->si_sfScale[gr][ch], 1);
        PutBitsSI(state->si_cnt1TabSel[gr][ch], 1);
      }

    return 0;
}

static Ipp32s mp3enc_encodeSideInfo_m2l3(MP3Enc_com *state) {
    Ipp32s i, gr = 0, ch;
    Ipp32s stereo = state->stereo;

    mp3enc_encodeHeader(state, &state->sideStream);

    PutBitsSI(state->si_main_data_begin, 8);

    if (stereo == 2)
      PutBitsSI(state->si_private_bits, 2)
    else
      PutBitsSI(state->si_private_bits, 1);

    for (ch = 0; ch < stereo; ch++) {
      PutBitsSI(state->si_part23Len[gr][ch], 12);
      PutBitsSI(state->si_bigVals[gr][ch], 9);
      PutBitsSI(state->si_globGain[gr][ch], 8);
      PutBitsSI(state->si_sfCompress[gr][ch], 9);
      PutBitsSI(state->si_winSwitch[gr][ch], 1);

      if (state->si_winSwitch[gr][ch]) {
        PutBitsSI(state->si_blockType[gr][ch], 2);
        PutBitsSI(state->si_mixedBlock[gr][ch], 1);

        for (i = 0; i < 2; i++)
          PutBitsSI(state->si_pTableSelect[gr][ch][i], 5);
        for (i = 0; i < 3; i++)
          PutBitsSI(state->si_pSubBlkGain[gr][ch][i], 3);
      } else {
        for (i = 0; i < 3; i++)
          PutBitsSI(state->si_pTableSelect[gr][ch][i], 5);

        PutBitsSI(state->si_reg0Cnt[gr][ch], 4);
        PutBitsSI(state->si_reg1Cnt[gr][ch], 3);
      }

      PutBitsSI(state->si_sfScale[gr][ch], 1);
      PutBitsSI(state->si_cnt1TabSel[gr][ch], 1);
    }

    return 0;
}

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

static void mp3enc_encodeMainData_l1(MP3Enc_com *state, Ipp32s *nbits)
{
  Ipp32s ch, sb, s, nb;
  Ipp32s stereo = state->stereo;

  for(sb = 0; sb < 32; sb++)
    for(ch = 0; ch < stereo; ch++)
      PutBits(state->allocation[ch][sb], 4);

  GET_BITS_COUNT(&state->mainStream, nb)
  *nbits = nb;

  for(sb = 0; sb < 32; sb++)
    for(ch = 0; ch < stereo; ch++)
      if (state->allocation[ch][sb] != 0)
        PutBits(state->scalefactor_l1[ch][sb],6);

  for(s = 0; s < 12; s++)
    for(sb = 0; sb < 32; sb++)
      for(ch = 0; ch < stereo; ch++)
        if (state->allocation[ch][sb] != 0)
          PutBits(state->sample[ch][sb][s], state->allocation[ch][sb] + 1);
}

static void mp3enc_encodeMainData_l2(MP3Enc_com *state, Ipp32s *nbits) {
  Ipp32s sb, ch, gr, nb;
  Ipp32s sblimit = state->sblimit;
  Ipp32s jsbound = state->jsbound;
  Ipp32s stereo = state->stereo;

  Ipp32s *nbal_alloc_table = state->nbal_alloc_table;
  Ipp8u  *alloc_table = state->alloc_table;

  for (sb = 0; sb < jsbound; sb++) {
    for (ch = 0; ch < stereo; ch++) {
      PutBits(state->allocation[ch][sb], nbal_alloc_table[sb]);
    }
  }

  for (sb = jsbound; sb < sblimit; sb++) {
    PutBits(state->allocation[0][sb], nbal_alloc_table[sb]);
  }

  for (sb = 0; sb < sblimit; sb++) {
    for (ch = 0; ch < stereo; ch++) {
      if (state->allocation[ch][sb]) {
        PutBits(state->scfsi[ch][sb], 2);
      }
    }
  }

  GET_BITS_COUNT(&state->mainStream, nb)
  *nbits = nb;

  for (sb = 0; sb < sblimit; sb++) {
    for (ch = 0; ch < stereo; ch++) {
      if (state->allocation[ch][sb] != 0) {
        if (state->scfsi[ch][sb] == 0) {
          PutBits(state->scalefactor[ch][0][sb], 6);
          PutBits(state->scalefactor[ch][1][sb], 6);
          PutBits(state->scalefactor[ch][2][sb], 6);
        } else if ((state->scfsi[ch][sb] == 1)) {
          PutBits(state->scalefactor[ch][0][sb], 6);
          PutBits(state->scalefactor[ch][2][sb], 6);
        } else if (state->scfsi[ch][sb] == 2) {
          PutBits(state->scalefactor[ch][0][sb], 6);
        } else if (state->scfsi[ch][sb] == 3) {
          PutBits(state->scalefactor[ch][0][sb], 6);
          PutBits(state->scalefactor[ch][1][sb], 6);
        }
      }
    }
  }

  for (gr = 0; gr < 12; gr++) {
    for (sb = 0; sb < sblimit; sb++) {
      for (ch = 0; ch < ((sb < jsbound) ? stereo : 1); ch++) {
        if (state->allocation[ch][sb] != 0) {
          Ipp32s idx = alloc_table[sb * 16 + state->allocation[ch][sb]];
          Ipp32s c;

          idx = mp3_cls_quant[idx];

          if (idx < 0) {
            idx = - idx;

            if(idx == 5){
              c = state->sample[ch][sb][3 * gr + 0] +
                state->sample[ch][sb][3 * gr + 1] * 3 +
                state->sample[ch][sb][3 * gr + 2] * 9;
            }
            else if(idx == 7){
              c = state->sample[ch][sb][3 * gr + 0] +
                state->sample[ch][sb][3 * gr + 1] * 5 +
                state->sample[ch][sb][3 * gr + 2] * 25;
            }
            else {
              c = state->sample[ch][sb][3 * gr + 0] +
                state->sample[ch][sb][3 * gr + 1] * 9 +
                state->sample[ch][sb][3 * gr + 2] * 81;
            }

            PutBits(c, idx);
          } else {
            PutBits(state->sample[ch][sb][3 * gr + 0], idx);
            PutBits(state->sample[ch][sb][3 * gr + 1], idx);
            PutBits(state->sample[ch][sb][3 * gr + 2], idx);
          }
        }
      }
    }
  }
}

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

static void mp3enc_encodeMainData_l3(MP3Enc_com *state)
{
    Ipp32s i, gr, ch, sfb, window;

    if (state->header.id) {
      for (gr = 0; gr < 2; gr++) {
        for (ch = 0; ch < state->stereo; ch++) {
          Ipp16s slen1 = (Ipp16s)mp3enc_slen1_tab[state->si_sfCompress[gr][ch]];