mp3enc_bitstream.c

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

          Ipp16s slen2 = (Ipp16s)mp3enc_slen2_tab[state->si_sfCompress[gr][ch]];

          if ((state->si_winSwitch[gr][ch] == 1) && (state->si_blockType[gr][ch] == 2)) {
            if (state->si_mixedBlock[gr][ch]) {
              for (sfb = 0; sfb < 8; sfb++)
                PutBits(state->scalefac_l[gr][ch][sfb], slen1);

              for (sfb = 3; sfb < 6; sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen1);

              for (sfb = 6; sfb < 12; sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen2);

            } else {
              for (sfb = 0; sfb < 6; sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen1);

              for (sfb = 6; sfb < 12; sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen2);
            }
          } else {
            if ((gr == 0) || (state->si_scfsi[ch][0] == 0))
              for (sfb = 0; sfb < 6; sfb++)
                PutBits(state->scalefac_l[gr][ch][sfb], slen1);

            if ((gr == 0) || (state->si_scfsi[ch][1] == 0))
              for (sfb = 6; sfb < 11; sfb++)
                PutBits(state->scalefac_l[gr][ch][sfb], slen1);

            if ((gr == 0) || (state->si_scfsi[ch][2] == 0))
              for (sfb = 11; sfb < 16; sfb++)
                PutBits(state->scalefac_l[gr][ch][sfb], slen2);

            if ((gr == 0) || (state->si_scfsi[ch][3] == 0))
              for (sfb = 16; sfb < 21; sfb++)
                PutBits(state->scalefac_l[gr][ch][sfb], slen2);
          }

          mp3enc_huffmanCodeBits(state, gr, ch);

        }
      }
    } else {
      gr = 0;
      for (ch = 0; ch < state->stereo; ch++) {
        Ipp32s sfb_part;
        Ipp32s s = 0;
        if ((state->si_winSwitch[gr][ch] == 1) && (state->si_blockType[gr][ch] == 2)) {
          if (state->si_mixedBlock[gr][ch]) {
            sfb_part = 0;
            for (sfb = 0; sfb < 6; sfb++)
              PutBits(state->scalefac_l[gr][ch][sfb], state->slen[ch][sfb_part] );

            sfb = 3;
            for (sfb_part = 1; sfb_part < 4; sfb_part++) {
              Ipp32s sfbs = state->sfb_part_table[ch][sfb_part] / 3;
              Ipp32s slen = state->slen[ch][sfb_part];
              for (i = 0; i < sfbs; i++, sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen );
            }
          } else {
            sfb = 0;
            for (sfb_part = 0; sfb_part < 4; sfb_part++ ) {
              Ipp32s sfbs = state->sfb_part_table[ch][sfb_part] / 3;
              Ipp32s slen = state->slen[ch][sfb_part];
              for (i = 0; i < sfbs; i++, sfb++)
                for (window = 0; window < 3; window++)
                  PutBits(state->scalefac_s[gr][ch][sfb][window], slen );
            }
          }
        } else {
          sfb = 0;
          for (sfb_part = 0; sfb_part < 4; sfb_part++ ) {
            Ipp32s sfbs = state->sfb_part_table[ch][sfb_part];
            Ipp32s slen = state->slen[ch][sfb_part];
            for (i = 0; i < sfbs; i++, sfb++) {
              PutBits(state->scalefac_l[gr][ch][sfb], slen );
              s += slen;
            }
          }
        }
        mp3enc_huffmanCodeBits(state, gr, ch);
      }
    }
}

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

static Ipp32s mp3enc_writeFrame(MP3Enc_com *state,
                                Ipp32s si_bits,
                                Ipp32s bits,
                                Ipp8u *pOutputData)
{
    Ipp32s i, slot, res, len;
    Ipp8u *ptr_main = (Ipp8u *)state->buffer_main_data;
    Ipp8u *ptr_side = (Ipp8u *)state->buffer_side_info;
    Ipp8u *ptr_out = pOutputData;
    Ipp32s si_bytes, bytes;

    Ipp32s resr_bytes;
    Ipp32s resr_mod_slot;
    Ipp32s si_beg, si_new, si_num;
    Ipp32s slot_size;
    Ipp32u si_main_data_begin;
    Ipp8u (*si_buf)[40];
    Ipp32s maxbits;

    if (state->header.id)
      maxbits = 511;
    else
      maxbits = 255;

    resr_bytes = state->resr_bytes;
    resr_mod_slot = state->resr_mod_slot;
    si_beg = state->si_beg;
    si_new = state->si_new;
    si_num = state->si_num;
    slot_size = state->slot_size;
    si_main_data_begin = state->si_main_data_begin;
    si_buf = state->si_buf;

    slot = slot_size;
    bits = (bits + 7) & ~7;
    si_bytes = si_bits >> 3;
    bytes = bits >> 3;
    res = 0;

    if (state->br_mode == MPAENC_ABR) {
      len = (Ipp32s)si_main_data_begin < bytes ? (Ipp32s)si_main_data_begin : bytes;
      for (i = 0; i < len; i++)
        *ptr_out++ = *ptr_main++;
      res += len;
      bytes -= len;
      if ((Ipp32s)si_main_data_begin > len) {
        for (i = 0; i < (Ipp32s)si_main_data_begin - len; i++)
          *ptr_out++ = 0;
         res += si_main_data_begin - len;
      }

      for (i = 0; i < si_bytes; i++)
        *ptr_out++ = *ptr_side++;
      res += si_bytes;

      for (i = 0; i < bytes; i++)
        *ptr_out++ = *ptr_main++;
      res += bytes;

      len = state->slot_sizes[state->header.bitRate] - si_bytes - bytes;
      if (len > maxbits) {
        for (i = 0; i < len - maxbits; i++)
          *ptr_out++ = 0;
        res += len - maxbits;
        len = maxbits;
      }
      si_main_data_begin = len;

      state->bytes_in_gbuf += slot_size - state->slot_sizes[state->header.bitRate];
    } else {
      resr_bytes += slot;

      for (i = 0; i < si_bytes; i++)
          state->si_buf[si_new][i] = *ptr_side++;

      si_num++;
      si_new++;

      if (si_new >= SI_MAX)
          si_new = 0;

      do {
          Ipp32s left = resr_mod_slot;

          len = left < bytes ? left : bytes;

          for (i = 0; i < len; i++)
              *ptr_out++ = *ptr_main++;

          res += len;
          bytes -= len;
          resr_bytes -= len;
          resr_mod_slot -= len;
          if (resr_mod_slot < 0)
              resr_mod_slot += slot;

          if (len == left && si_num > 0) {
              for (i = 0; i < si_bytes; i++)
                  *ptr_out++ =
                      si_buf[si_beg][i];
              res += si_bytes;
              resr_bytes -= si_bytes;
              resr_mod_slot -= si_bytes;
              if (resr_mod_slot < 0)
                  resr_mod_slot += slot;
              si_num--;
              si_beg++;
              if (si_beg >= SI_MAX)
                  si_beg = 0;
          }
      } while(bytes);

      while ((si_main_data_begin = resr_bytes  - si_num * si_bytes) > (Ipp32u)maxbits) {
          Ipp32s left = resr_mod_slot;

          len = left < ((Ipp32s)si_main_data_begin - maxbits) ?
              left : ((Ipp32s)si_main_data_begin - maxbits);

          for (i = 0; i < len; i++)
              *ptr_out++ = 0;

          res += len;
          resr_bytes -= len;
          resr_mod_slot -= len;
          if (resr_mod_slot < 0)
              resr_mod_slot += slot;

          if (len == left && si_num > 0) {
              for (i = 0; i < si_bytes; i++)
                  *ptr_out++ = si_buf[si_beg][i];

              res += si_bytes;
              resr_bytes -= si_bytes;
              resr_mod_slot -= si_bytes;
              if (resr_mod_slot < 0)
                  resr_mod_slot += slot;
              si_num--;
              si_beg++;
              if (si_beg >= SI_MAX)
                  si_beg = 0;
          }
      }
  /*
      if (bitrate[header.bitRate] == 320) {
          if (si_main_data_begin > 0) {
              for (i = 0; i < si_main_data_begin; i++)
                  *ptr_out++ = 0;
              res += si_main_data_begin;
              resr_bytes -= si_main_data_begin;
          }
          si_main_data_begin = 0;
      }
  */
      state->resr_bytes = resr_bytes;
      state->resr_mod_slot = resr_mod_slot;
      state->si_beg = si_beg;
      state->si_new = si_new;
      state->si_num = si_num;
      state->slot_size = slot_size;
    }
    state->si_main_data_begin = si_main_data_begin;

    return res;
}

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

Ipp32s mp3enc_formatBitstream_l12(MP3Enc_com *state, Ipp8u *pOutputData)
{
  Ipp32s bits, bytes;
  Ipp32s layer = state->header.layer;
  Ipp32u crc, crc_mc = 0;
  Ipp32s crc_nbits, crc_mc_nbits;
  Ipp32u *ptr, *ptr_mc_crc = 0;
  Ipp32s offset, offset_mc_crc = 0;

  INIT_BITSTREAM(&state->mainStream, pOutputData)

  mp3enc_encodeHeader(state, &state->mainStream);

  if (layer == 1)
    mp3enc_encodeMainData_l1(state, &crc_nbits);
  else
    mp3enc_encodeMainData_l2(state, &crc_nbits);

  crc_nbits -= 48;

/* encode multichannel data */
  if (state->mc_channel/* || state->mc_header.lfe*/) {
    ptr = state->mainStream.pCurrent_dword;
    offset = state->mainStream.nBit_offset;
    mp3enc_mc_encodeHeader(state, &state->mainStream, &crc_mc_nbits);
    SAVE_BITSTREAM(&state->mainStream)
    bs_CRC_reset(&crc_mc);
    bs_CRC_update(ptr, offset, crc_mc_nbits, &crc_mc);

    ptr_mc_crc = state->mainStream.pCurrent_dword;
    offset_mc_crc = state->mainStream.nBit_offset;
    PutBits(crc_mc, 16);

    ptr = state->mainStream.pCurrent_dword;
    offset = state->mainStream.nBit_offset;

    GET_BITS_COUNT(&state->mainStream, bits)

    mp3enc_mc_encode_composite_status_info(state, &state->mainStream);

    mp3enc_mc_encode_bit_alloc(state, &state->mainStream);

    GET_BITS_COUNT(&state->mainStream, crc_mc_nbits)
    crc_mc_nbits -= bits;
    SAVE_BITSTREAM(&state->mainStream)
    bs_CRC_update(ptr, offset, crc_mc_nbits, &crc_mc);

    mp3enc_mc_encode_scale(state, &state->mainStream);

    mp3enc_mc_sample_encoding_l2(state, &state->mainStream);
  }

  GET_BITS_COUNT(&state->mainStream, bits)
  SAVE_BITSTREAM(&state->mainStream)

  if (state->mc_channel) {
    INIT_BITSTREAM_OFFSET(&state->mainStream, ptr_mc_crc, offset_mc_crc)
    PutBits(crc_mc, 16);
    SAVE_BITSTREAM(&state->mainStream)
  }

  bytes = ((bits + 7) >> 3);

  if (bytes < state->slot_size)
    ippsZero_8u(pOutputData + bytes, state->slot_size - bytes);

  if (state->header.protectionBit) {
    bs_CRC_reset(&crc);
    bs_CRC_update_ptr(pOutputData + 2, 16, &crc);
    bs_CRC_update_ptr(pOutputData + 6, crc_nbits, &crc);

    INIT_BITSTREAM(&state->mainStream, pOutputData+4)
    PutBitsDst((&state->mainStream), crc, 16);
    SAVE_BITSTREAM(&state->mainStream)
  }

  return state->slot_size;
}

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

Ipp32s mp3enc_formatBitstream_l3(MP3Enc_com *state, Ipp32s (*mdct_out)[2][576],
                                 Ipp8u *pOutputData)
{
    Ipp32s gr, ch, i, bits, si_bits;
    Ipp32s bytes;
    Ipp32u crc;
    Ipp32s crc_nbits;

    VM_ALIGN16_DECL(Ipp32s) sign[576];
    for (gr = 0; gr < state->grnum; gr++) {
      for (ch = 0; ch < state->stereo; ch++) {
        ippsRShiftC_32s(mdct_out[gr][ch], 31, sign, 576);
        for (i = 0; i < 576; i++)
          state->quant_ix[gr][ch][i] -= (state->quant_ix[gr][ch][i] << 1) & (Ipp16s)sign[i] ;
      }
    }

// si_bits - count of bits for header and sideinfo
// bits - count of bits for main data
    INIT_BITSTREAM(&state->mainStream, state->buffer_main_data)
    INIT_BITSTREAM(&state->sideStream, state->buffer_side_info)

    if (state->header.id)
      mp3enc_encodeSideInfo_m1l3(state);
    else
      mp3enc_encodeSideInfo_m2l3(state);

    GET_BITS_COUNT(&state->sideStream, si_bits)
    SAVE_BITSTREAM(&state->sideStream)

    if (state->header.protectionBit) {
      if (state->header.id == 1) {
        if (state->header.mode == 0x3)
          crc_nbits = 136;
        else
          crc_nbits = 256;
      } else {
        if (state->header.mode == 0x3)
          crc_nbits = 72;
        else
          crc_nbits = 136;
      }
      bs_CRC_reset(&crc);
      bs_CRC_update_ptr((Ipp8u*)state->buffer_side_info + 2, 16, &crc);
      bs_CRC_update_ptr((Ipp8u*)state->buffer_side_info + 6, crc_nbits, &crc);
      INIT_BITSTREAM(&state->sideStream, (Ipp8u*)state->buffer_side_info+4)
      PutBitsDst(&state->sideStream, crc, 16);
      SAVE_BITSTREAM(&state->sideStream)
    }

    mp3enc_encodeMainData_l3(state);
    GET_BITS_COUNT(&state->mainStream, bits)
    SAVE_BITSTREAM(&state->mainStream)

    bytes = mp3enc_writeFrame(state, si_bits, bits, pOutputData);

    return bytes;
}

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