libavcodec.hg: ac3enc.c comparison

comparison ac3enc.c @ 6003:608c8e9ac412 libavcodec

cosmetics: rename ac3 bit allocation variables

author	jbr
date	Sun, 09 Dec 2007 03:23:04 +0000
parents	29635f7c3d9c
children	7d9dddd54817

comparison

equal deleted inserted replaced

-:29635f7c3d9c
+:608c8e9ac412
 unsigned int bsid;
 unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */
 unsigned int frame_size; /* current frame size in words */
 unsigned int bits_written;
 unsigned int samples_written;
-int halfratecod;
+int sr_shift;
 unsigned int frmsizecod;
-unsigned int fscod; /* frequency */
+unsigned int sr_code; /* frequency */
 unsigned int acmod;
 int lfe;
 unsigned int bsmod;
 short last_samples[AC3_MAX_CHANNELS][256];
 unsigned int chbwcod[AC3_MAX_CHANNELS];
 int nb_coefs[AC3_MAX_CHANNELS];
 /* bitrate allocation control */
-int sgaincod, sdecaycod, fdecaycod, dbkneecod, floorcod;
+int slow_gain_code, slow_decay_code, fast_decay_code, db_per_bit_code, floor_code;
 AC3BitAllocParameters bit_alloc;
-int csnroffst;
+int coarse_snr_offset;
-int fgaincod[AC3_MAX_CHANNELS];
+int fast_gain_code[AC3_MAX_CHANNELS];
-int fsnroffst[AC3_MAX_CHANNELS];
+int fine_snr_offset[AC3_MAX_CHANNELS];
 /* mantissa encoding */
 int mant1_cnt, mant2_cnt, mant4_cnt;
 } AC3EncodeContext;
 static int16_t costab[64];
 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50])
 {
 int blk, ch;
-int16_t bndpsd[NB_BLOCKS][AC3_MAX_CHANNELS][50];
+int16_t band_psd[NB_BLOCKS][AC3_MAX_CHANNELS][50];
 for(blk=0; blk<NB_BLOCKS; blk++) {
 for(ch=0;ch<s->nb_all_channels;ch++) {
 if(exp_strategy[blk][ch] == EXP_REUSE) {
 memcpy(psd[blk][ch], psd[blk-1][ch], (N/2)*sizeof(int16_t));
 memcpy(mask[blk][ch], mask[blk-1][ch], 50*sizeof(int16_t));
 } else {
 ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0,
 s->nb_coefs[ch],
-psd[blk][ch], bndpsd[blk][ch]);
+psd[blk][ch], band_psd[blk][ch]);
-ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, bndpsd[blk][ch],
+ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, band_psd[blk][ch],
 0, s->nb_coefs[ch],
-ff_ac3_fast_gain_tab[s->fgaincod[ch]],
+ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
 ch == s->lfe_channel,
 DBA_NONE, 0, NULL, NULL, NULL,
 mask[blk][ch]);
 }
 }
 static int bit_alloc(AC3EncodeContext *s,
 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50],
 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
 uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
-int frame_bits, int csnroffst, int fsnroffst)
+int frame_bits, int coarse_snr_offset, int fine_snr_offset)
 {
 int i, ch;
-int snroffset;
+int snr_offset;
-snroffset = (((csnroffst - 15) << 4) + fsnroffst) << 2;
+snr_offset = (((coarse_snr_offset - 15) << 4) + fine_snr_offset) << 2;
 /* compute size */
 for(i=0;i<NB_BLOCKS;i++) {
 s->mant1_cnt = 0;
 s->mant2_cnt = 0;
 s->mant4_cnt = 0;
 for(ch=0;ch<s->nb_all_channels;ch++) {
 ff_ac3_bit_alloc_calc_bap(mask[i][ch], psd[i][ch], 0,
-s->nb_coefs[ch], snroffset,
+s->nb_coefs[ch], snr_offset,
 s->bit_alloc.floor, bap[i][ch]);
 frame_bits += compute_mantissa_size(s, bap[i][ch],
 s->nb_coefs[ch]);
 }
 }
 #if 0
 printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n",
-csnroffst, fsnroffst, frame_bits,
+coarse_snr_offset, fine_snr_offset, frame_bits,
 16 * s->frame_size - ((frame_bits + 7) & ~7));
 #endif
 return 16 * s->frame_size - frame_bits;
 }
 uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
 uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
 int frame_bits)
 {
 int i, ch;
-int csnroffst, fsnroffst;
+int coarse_snr_offset, fine_snr_offset;
 uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
 int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
 int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50];
 static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
 /* init default parameters */
-s->sdecaycod = 2;
+s->slow_decay_code = 2;
-s->fdecaycod = 1;
+s->fast_decay_code = 1;
-s->sgaincod = 1;
+s->slow_gain_code = 1;
-s->dbkneecod = 2;
+s->db_per_bit_code = 2;
-s->floorcod = 4;
+s->floor_code = 4;
 for(ch=0;ch<s->nb_all_channels;ch++)
-s->fgaincod[ch] = 4;
+s->fast_gain_code[ch] = 4;
 /* compute real values */
-s->bit_alloc.fscod = s->fscod;
+s->bit_alloc.sr_code = s->sr_code;
-s->bit_alloc.halfratecod = s->halfratecod;
+s->bit_alloc.sr_shift = s->sr_shift;
-s->bit_alloc.sdecay = ff_ac3_slow_decay_tab[s->sdecaycod] >> s->halfratecod;
+s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->sr_shift;
-s->bit_alloc.fdecay = ff_ac3_fast_decay_tab[s->fdecaycod] >> s->halfratecod;
+s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->sr_shift;
-s->bit_alloc.sgain = ff_ac3_slow_gain_tab[s->sgaincod];
+s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
-s->bit_alloc.dbknee = ff_ac3_db_per_bit_tab[s->dbkneecod];
+s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
-s->bit_alloc.floor = ff_ac3_floor_tab[s->floorcod];
+s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
 /* header size */
 frame_bits += 65;
 // if (s->acmod == 2)
 //    frame_bits += 2;
 bit_alloc_masking(s, encoded_exp, exp_strategy, psd, mask);
 /* now the big work begins : do the bit allocation. Modify the snr
 offset until we can pack everything in the requested frame size */
-csnroffst = s->csnroffst;
+coarse_snr_offset = s->coarse_snr_offset;
-while (csnroffst >= 0 &&
+while (coarse_snr_offset >= 0 &&
-bit_alloc(s, mask, psd, bap, frame_bits, csnroffst, 0) < 0)
+bit_alloc(s, mask, psd, bap, frame_bits, coarse_snr_offset, 0) < 0)
-csnroffst -= SNR_INC1;
+coarse_snr_offset -= SNR_INC1;
-if (csnroffst < 0) {
+if (coarse_snr_offset < 0) {
 av_log(NULL, AV_LOG_ERROR, "Bit allocation failed, try increasing the bitrate, -ab 384k for example!\n");
 return -1;
 }
-while ((csnroffst + SNR_INC1) <= 63 &&
+while ((coarse_snr_offset + SNR_INC1) <= 63 &&
 bit_alloc(s, mask, psd, bap1, frame_bits,
-csnroffst + SNR_INC1, 0) >= 0) {
+coarse_snr_offset + SNR_INC1, 0) >= 0) {
-csnroffst += SNR_INC1;
+coarse_snr_offset += SNR_INC1;
 memcpy(bap, bap1, sizeof(bap1));
 }
-while ((csnroffst + 1) <= 63 &&
+while ((coarse_snr_offset + 1) <= 63 &&
-bit_alloc(s, mask, psd, bap1, frame_bits, csnroffst + 1, 0) >= 0) {
+bit_alloc(s, mask, psd, bap1, frame_bits, coarse_snr_offset + 1, 0) >= 0) {
-csnroffst++;
+coarse_snr_offset++;
 memcpy(bap, bap1, sizeof(bap1));
 }
-fsnroffst = 0;
+fine_snr_offset = 0;
-while ((fsnroffst + SNR_INC1) <= 15 &&
+while ((fine_snr_offset + SNR_INC1) <= 15 &&
 bit_alloc(s, mask, psd, bap1, frame_bits,
-csnroffst, fsnroffst + SNR_INC1) >= 0) {
+coarse_snr_offset, fine_snr_offset + SNR_INC1) >= 0) {
-fsnroffst += SNR_INC1;
+fine_snr_offset += SNR_INC1;
 memcpy(bap, bap1, sizeof(bap1));
 }
-while ((fsnroffst + 1) <= 15 &&
+while ((fine_snr_offset + 1) <= 15 &&
 bit_alloc(s, mask, psd, bap1, frame_bits,
-csnroffst, fsnroffst + 1) >= 0) {
+coarse_snr_offset, fine_snr_offset + 1) >= 0) {
-fsnroffst++;
+fine_snr_offset++;
 memcpy(bap, bap1, sizeof(bap1));
 }
-s->csnroffst = csnroffst;
+s->coarse_snr_offset = coarse_snr_offset;
 for(ch=0;ch<s->nb_all_channels;ch++)
-s->fsnroffst[ch] = fsnroffst;
+s->fine_snr_offset[ch] = fine_snr_offset;
 #if defined(DEBUG_BITALLOC)
 {
 int j;
 for(i=0;i<6;i++) {
 goto found;
 }
 return -1;
 found:
 s->sample_rate = freq;
-s->halfratecod = i;
+s->sr_shift = i;
-s->fscod = j;
+s->sr_code = j;
-s->bsid = 8 + s->halfratecod;
+s->bsid = 8 + s->sr_shift;
 s->bsmod = 0; /* complete main audio service */
 /* bitrate & frame size */
 bitrate /= 1000;
 for(i=0;i<19;i++) {
-if ((ff_ac3_bitrate_tab[i] >> s->halfratecod) == bitrate)
+if ((ff_ac3_bitrate_tab[i] >> s->sr_shift) == bitrate)
 break;
 }
 if (i == 19)
 return -1;
 s->bit_rate = bitrate;
 s->frmsizecod = i << 1;
-s->frame_size_min = ff_ac3_frame_size_tab[s->frmsizecod][s->fscod];
+s->frame_size_min = ff_ac3_frame_size_tab[s->frmsizecod][s->sr_code];
 s->bits_written = 0;
 s->samples_written = 0;
 s->frame_size = s->frame_size_min;
 /* bit allocation init */
 }
 if (s->lfe) {
 s->nb_coefs[s->lfe_channel] = 7; /* fixed */
 }
 /* initial snr offset */
-s->csnroffst = 40;
+s->coarse_snr_offset = 40;
 /* mdct init */
 fft_init(MDCT_NBITS - 2);
 for(i=0;i<N/4;i++) {
 alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N;
 {
 init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
 put_bits(&s->pb, 16, 0x0b77); /* frame header */
 put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
-put_bits(&s->pb, 2, s->fscod);
+put_bits(&s->pb, 2, s->sr_code);
 put_bits(&s->pb, 6, s->frmsizecod + (s->frame_size - s->frame_size_min));
 put_bits(&s->pb, 5, s->bsid);
 put_bits(&s->pb, 3, s->bsmod);
 put_bits(&s->pb, 3, s->acmod);
 if ((s->acmod & 0x01) && s->acmod != AC3_ACMOD_MONO)
 /* bit allocation info */
 baie = (block_num == 0);
 put_bits(&s->pb, 1, baie);
 if (baie) {
-put_bits(&s->pb, 2, s->sdecaycod);
+put_bits(&s->pb, 2, s->slow_decay_code);
-put_bits(&s->pb, 2, s->fdecaycod);
+put_bits(&s->pb, 2, s->fast_decay_code);
-put_bits(&s->pb, 2, s->sgaincod);
+put_bits(&s->pb, 2, s->slow_gain_code);
-put_bits(&s->pb, 2, s->dbkneecod);
+put_bits(&s->pb, 2, s->db_per_bit_code);
-put_bits(&s->pb, 3, s->floorcod);
+put_bits(&s->pb, 3, s->floor_code);
 }
 /* snr offset */
 put_bits(&s->pb, 1, baie); /* always present with bai */
 if (baie) {
-put_bits(&s->pb, 6, s->csnroffst);
+put_bits(&s->pb, 6, s->coarse_snr_offset);
 for(ch=0;ch<s->nb_all_channels;ch++) {
-put_bits(&s->pb, 4, s->fsnroffst[ch]);
+put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
-put_bits(&s->pb, 3, s->fgaincod[ch]);
+put_bits(&s->pb, 3, s->fast_gain_code[ch]);
 }
 }
 put_bits(&s->pb, 1, 0); /* no delta bit allocation */
 put_bits(&s->pb, 1, 0); /* no data to skip */

Mercurial > libavcodec.hg

comparison ac3enc.c @ 6003:608c8e9ac412 libavcodec