开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mpegaudio.c
资源名称：ffmpeg-0.3.4.tar.gz　[点击查看]
上传用户：jxp0626
上传日期：2007-01-08
资源大小：102k
文件大小：22k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

mpegaudio.c：源码内容
  1. /*
  2.  * The simplest mpeg audio layer 2 encoder
  3.  * Copyright (c) 2000 Gerard Lantau.
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19. #include <stdlib.h>
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <netinet/in.h>
  23. #include <math.h>
  24. #include "avcodec.h"
  25. #include "mpegaudio.h"
  27. #define NDEBUG
  28. #include <assert.h>
  30. /* define it to use floats in quantization (I don't like floats !) */
  31. //#define USE_FLOATS
  33. #define MPA_STEREO  0
  34. #define MPA_JSTEREO 1
  35. #define MPA_DUAL    2
  36. #define MPA_MONO    3
  38. #include "mpegaudiotab.h"
  40. int MPA_encode_init(AVEncodeContext *avctx)
  41. {
  42.     MpegAudioContext *s = avctx->priv_data;
  43.     int freq = avctx->rate;
  44.     int bitrate = avctx->bit_rate;
  45.     int channels = avctx->channels;
  46.     int i, v, table, ch_bitrate;
  47.     float a;
  49.     if (channels > 2)
  50.         return -1;
  51.     bitrate = bitrate / 1000;
  52.     s->nb_channels = channels;
  53.     s->freq = freq;
  54.     s->bit_rate = bitrate * 1000;
  55.     avctx->frame_size = MPA_FRAME_SIZE;
  56.     avctx->key_frame = 1; /* always key frame */
  58.     /* encoding freq */
  59.     s->lsf = 0;
  60.     for(i=0;i<3;i++) {
  61.         if (freq_tab[i] == freq) 
  62.             break;
  63.         if ((freq_tab[i] / 2) == freq) {
  64.             s->lsf = 1;
  65.             break;
  66.         }
  67.     }
  68.     if (i == 3)
  69.         return -1;
  70.     s->freq_index = i;
  72.     /* encoding bitrate & frequency */
  73.     for(i=0;i<15;i++) {
  74.         if (bitrate_tab[1-s->lsf][i] == bitrate) 
  75.             break;
  76.     }
  77.     if (i == 15)
  78.         return -1;
  79.     s->bitrate_index = i;
  81.     /* compute total header size & pad bit */
  82.     
  83.     a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
  84.     s->frame_size = ((int)a) * 8;
  86.     /* frame fractional size to compute padding */
  87.     s->frame_frac = 0;
  88.     s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
  89.     
  90.     /* select the right allocation table */
  91.     ch_bitrate = bitrate / s->nb_channels;
  92.     if (!s->lsf) {
  93.         if ((freq == 48000 && ch_bitrate >= 56) ||
  94.             (ch_bitrate >= 56 && ch_bitrate <= 80)) 
  95.             table = 0;
  96.         else if (freq != 48000 && ch_bitrate >= 96) 
  97.             table = 1;
  98.         else if (freq != 32000 && ch_bitrate <= 48) 
  99.             table = 2;
  100.         else 
  101.             table = 3;
  102.     } else {
  103.         table = 4;
  104.     }
  105.     /* number of used subbands */
  106.     s->sblimit = sblimit_table[table];
  107.     s->alloc_table = alloc_tables[table];
  109. #ifdef DEBUG
  110.     printf("%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%xn", 
  111.            bitrate, freq, s->frame_size, table, s->frame_frac_incr);
  112. #endif
  114.     for(i=0;i<s->nb_channels;i++)
  115.         s->samples_offset[i] = 0;
  117.     for(i=0;i<512;i++) {
  118.         float a = enwindow[i] * 32768.0 * 16.0;
  119.         filter_bank[i] = (int)(a);
  120.     }
  121.     for(i=0;i<64;i++) {
  122.         v = (int)(pow(2.0, (3 - i) / 3.0) * (1 << 20));
  123.         if (v <= 0)
  124.             v = 1;
  125.         scale_factor_table[i] = v;
  126. #ifdef USE_FLOATS
  127.         scale_factor_inv_table[i] = pow(2.0, -(3 - i) / 3.0) / (float)(1 << 20);
  128. #else
  129. #define P 15
  130.         scale_factor_shift[i] = 21 - P - (i / 3);
  131.         scale_factor_mult[i] = (1 << P) * pow(2.0, (i % 3) / 3.0);
  132. #endif
  133.     }
  134.     for(i=0;i<128;i++) {
  135.         v = i - 64;
  136.         if (v <= -3)
  137.             v = 0;
  138.         else if (v < 0)
  139.             v = 1;
  140.         else if (v == 0)
  141.             v = 2;
  142.         else if (v < 3)
  143.             v = 3;
  144.         else 
  145.             v = 4;
  146.         scale_diff_table[i] = v;
  147.     }
  149.     for(i=0;i<17;i++) {
  150.         v = quant_bits[i];
  151.         if (v < 0) 
  152.             v = -v;
  153.         else
  154.             v = v * 3;
  155.         total_quant_bits[i] = 12 * v;
  156.     }
  158.     return 0;
  159. }
  161. /* 32 point floating point IDCT */
  162. static void idct32(int *out, int *tab, int sblimit, int left_shift)
  163. {
  164.     int i, j;
  165.     int *t, *t1, xr;
  166.     const int *xp = costab32;
  168.     for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
  169.     
  170.     t = tab + 30;
  171.     t1 = tab + 2;
  172.     do {
  173.         t[0] += t[-4];
  174.         t[1] += t[1 - 4];
  175.         t -= 4;
  176.     } while (t != t1);
  178.     t = tab + 28;
  179.     t1 = tab + 4;
  180.     do {
  181.         t[0] += t[-8];
  182.         t[1] += t[1-8];
  183.         t[2] += t[2-8];
  184.         t[3] += t[3-8];
  185.         t -= 8;
  186.     } while (t != t1);
  187.     
  188.     t = tab;
  189.     t1 = tab + 32;
  190.     do {
  191.         t[ 3] = -t[ 3];    
  192.         t[ 6] = -t[ 6];    
  193.         
  194.         t[11] = -t[11];    
  195.         t[12] = -t[12];    
  196.         t[13] = -t[13];    
  197.         t[15] = -t[15]; 
  198.         t += 16;
  199.     } while (t != t1);
  201.     
  202.     t = tab;
  203.     t1 = tab + 8;
  204.     do {
  205.         int x1, x2, x3, x4;
  206.         
  207.         x3 = MUL(t[16], FIX(SQRT2*0.5));
  208.         x4 = t[0] - x3;
  209.         x3 = t[0] + x3;
  210.         
  211.         x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5));
  212.         x1 = MUL((t[8] - x2), xp[0]);
  213.         x2 = MUL((t[8] + x2), xp[1]);
  215.         t[ 0] = x3 + x1;
  216.         t[ 8] = x4 - x2;
  217.         t[16] = x4 + x2;
  218.         t[24] = x3 - x1;
  219.         t++;
  220.     } while (t != t1);
  222.     xp += 2;
  223.     t = tab;
  224.     t1 = tab + 4;
  225.     do {
  226.         xr = MUL(t[28],xp[0]);
  227.         t[28] = (t[0] - xr);
  228.         t[0] = (t[0] + xr);
  230.         xr = MUL(t[4],xp[1]);
  231.         t[ 4] = (t[24] - xr);
  232.         t[24] = (t[24] + xr);
  233.         
  234.         xr = MUL(t[20],xp[2]);
  235.         t[20] = (t[8] - xr);
  236.         t[ 8] = (t[8] + xr);
  237.             
  238.         xr = MUL(t[12],xp[3]);
  239.         t[12] = (t[16] - xr);
  240.         t[16] = (t[16] + xr);
  241.         t++;
  242.     } while (t != t1);
  243.     xp += 4;
  245.     for (i = 0; i < 4; i++) {
  246.         xr = MUL(tab[30-i*4],xp[0]);
  247.         tab[30-i*4] = (tab[i*4] - xr);
  248.         tab[   i*4] = (tab[i*4] + xr);
  249.         
  250.         xr = MUL(tab[ 2+i*4],xp[1]);
  251.         tab[ 2+i*4] = (tab[28-i*4] - xr);
  252.         tab[28-i*4] = (tab[28-i*4] + xr);
  253.         
  254.         xr = MUL(tab[31-i*4],xp[0]);
  255.         tab[31-i*4] = (tab[1+i*4] - xr);
  256.         tab[ 1+i*4] = (tab[1+i*4] + xr);
  257.         
  258.         xr = MUL(tab[ 3+i*4],xp[1]);
  259.         tab[ 3+i*4] = (tab[29-i*4] - xr);
  260.         tab[29-i*4] = (tab[29-i*4] + xr);
  261.         
  262.         xp += 2;
  263.     }
  265.     t = tab + 30;
  266.     t1 = tab + 1;
  267.     do {
  268.         xr = MUL(t1[0], *xp);
  269.         t1[0] = (t[0] - xr);
  270.         t[0] = (t[0] + xr);
  271.         t -= 2;
  272.         t1 += 2;
  273.         xp++;
  274.     } while (t >= tab);
  276.     for(i=0;i<32;i++) {
  277.         out[i] = tab[bitinv32[i]] << left_shift;
  278.     }
  279. }
  281. static void filter(MpegAudioContext *s, int ch, short *samples, int incr)
  282. {
  283.     short *p, *q;
  284.     int sum, offset, i, j, norm, n;
  285.     short tmp[64];
  286.     int tmp1[32];
  287.     int *out;
  289.     //    print_pow1(samples, 1152);
  291.     offset = s->samples_offset[ch];
  292.     out = &s->sb_samples[ch][0][0][0];
  293.     for(j=0;j<36;j++) {
  294.         /* 32 samples at once */
  295.         for(i=0;i<32;i++) {
  296.             s->samples_buf[ch][offset + (31 - i)] = samples[0];
  297.             samples += incr;
  298.         }
  300.         /* filter */
  301.         p = s->samples_buf[ch] + offset;
  302.         q = filter_bank;
  303.         /* maxsum = 23169 */
  304.         for(i=0;i<64;i++) {
  305.             sum = p[0*64] * q[0*64];
  306.             sum += p[1*64] * q[1*64];
  307.             sum += p[2*64] * q[2*64];
  308.             sum += p[3*64] * q[3*64];
  309.             sum += p[4*64] * q[4*64];
  310.             sum += p[5*64] * q[5*64];
  311.             sum += p[6*64] * q[6*64];
  312.             sum += p[7*64] * q[7*64];
  313.             tmp[i] = sum >> 14;
  314.             p++;
  315.             q++;
  316.         }
  317.         tmp1[0] = tmp[16];
  318.         for( i=1; i<=16; i++ ) tmp1[i] = tmp[i+16]+tmp[16-i];
  319.         for( i=17; i<=31; i++ ) tmp1[i] = tmp[i+16]-tmp[80-i];
  321.         /* integer IDCT 32 with normalization. XXX: There may be some
  322.            overflow left */
  323.         norm = 0;
  324.         for(i=0;i<32;i++) {
  325.             norm |= abs(tmp1[i]);
  326.         }
  327.         n = log2(norm) - 12;
  328.         if (n > 0) {
  329.             for(i=0;i<32;i++) 
  330.                 tmp1[i] >>= n;
  331.         } else {
  332.             n = 0;
  333.         }
  335.         idct32(out, tmp1, s->sblimit, n);
  337.         /* advance of 32 samples */
  338.         offset -= 32;
  339.         out += 32;
  340.         /* handle the wrap around */
  341.         if (offset < 0) {
  342.             memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32), 
  343.                     s->samples_buf[ch], (512 - 32) * 2);
  344.             offset = SAMPLES_BUF_SIZE - 512;
  345.         }
  346.     }
  347.     s->samples_offset[ch] = offset;
  349.     //    print_pow(s->sb_samples, 1152);
  350. }
  352. static void compute_scale_factors(unsigned char scale_code[SBLIMIT],
  353.                                   unsigned char scale_factors[SBLIMIT][3], 
  354.                                   int sb_samples[3][12][SBLIMIT],
  355.                                   int sblimit)
  356. {
  357.     int *p, vmax, v, n, i, j, k, code;
  358.     int index, d1, d2;
  359.     unsigned char *sf = &scale_factors[0][0];
  360.     
  361.     for(j=0;j<sblimit;j++) {
  362.         for(i=0;i<3;i++) {
  363.             /* find the max absolute value */
  364.             p = &sb_samples[i][0][j];
  365.             vmax = abs(*p);
  366.             for(k=1;k<12;k++) {
  367.                 p += SBLIMIT;
  368.                 v = abs(*p);
  369.                 if (v > vmax)
  370.                     vmax = v;
  371.             }
  372.             /* compute the scale factor index using log 2 computations */
  373.             if (vmax > 0) {
  374.                 n = log2(vmax);
  375.                 /* n is the position of the MSB of vmax. now 
  376.                    use at most 2 compares to find the index */
  377.                 index = (21 - n) * 3 - 3;
  378.                 if (index >= 0) {
  379.                     while (vmax <= scale_factor_table[index+1])
  380.                         index++;
  381.                 } else {
  382.                     index = 0; /* very unlikely case of overflow */
  383.                 }
  384.             } else {
  385.                 index = 63;
  386.             }
  387.             
  388. #if 0
  389.             printf("%2d:%d in=%x %x %dn", 
  390.                    j, i, vmax, scale_factor_table[index], index);
  391. #endif
  392.             /* store the scale factor */
  393.             assert(index >=0 && index <= 63);
  394.             sf[i] = index;
  395.         }
  397.         /* compute the transmission factor : look if the scale factors
  398.            are close enough to each other */
  399.         d1 = scale_diff_table[sf[0] - sf[1] + 64];
  400.         d2 = scale_diff_table[sf[1] - sf[2] + 64];
  401.         
  402.         /* handle the 25 cases */
  403.         switch(d1 * 5 + d2) {
  404.         case 0*5+0:
  405.         case 0*5+4:
  406.         case 3*5+4:
  407.         case 4*5+0:
  408.         case 4*5+4:
  409.             code = 0;
  410.             break;
  411.         case 0*5+1:
  412.         case 0*5+2:
  413.         case 4*5+1:
  414.         case 4*5+2:
  415.             code = 3;
  416.             sf[2] = sf[1];
  417.             break;
  418.         case 0*5+3:
  419.         case 4*5+3:
  420.             code = 3;
  421.             sf[1] = sf[2];
  422.             break;
  423.         case 1*5+0:
  424.         case 1*5+4:
  425.         case 2*5+4:
  426.             code = 1;
  427.             sf[1] = sf[0];
  428.             break;
  429.         case 1*5+1:
  430.         case 1*5+2:
  431.         case 2*5+0:
  432.         case 2*5+1:
  433.         case 2*5+2:
  434.             code = 2;
  435.             sf[1] = sf[2] = sf[0];
  436.             break;
  437.         case 2*5+3:
  438.         case 3*5+3:
  439.             code = 2;
  440.             sf[0] = sf[1] = sf[2];
  441.             break;
  442.         case 3*5+0:
  443.         case 3*5+1:
  444.         case 3*5+2:
  445.             code = 2;
  446.             sf[0] = sf[2] = sf[1];
  447.             break;
  448.         case 1*5+3:
  449.             code = 2;
  450.             if (sf[0] > sf[2])
  451.               sf[0] = sf[2];
  452.             sf[1] = sf[2] = sf[0];
  453.             break;
  454.         default:
  455.             abort();
  456.         }
  457.         
  458. #if 0
  459.         printf("%d: %2d %2d %2d %d %d -> %dn", j, 
  460.                sf[0], sf[1], sf[2], d1, d2, code);
  461. #endif
  462.         scale_code[j] = code;
  463.         sf += 3;
  464.     }
  465. }
  467. /* The most important function : psycho acoustic module. In this
  468.    encoder there is basically none, so this is the worst you can do,
  469.    but also this is the simpler. */
  470. static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
  471. {
  472.     int i;
  474.     for(i=0;i<s->sblimit;i++) {
  475.         smr[i] = (int)(fixed_smr[i] * 10);
  476.     }
  477. }
  480. #define SB_NOTALLOCATED  0
  481. #define SB_ALLOCATED     1
  482. #define SB_NOMORE        2
  484. /* Try to maximize the smr while using a number of bits inferior to
  485.    the frame size. I tried to make the code simpler, faster and
  486.    smaller than other encoders :-) */
  487. static void compute_bit_allocation(MpegAudioContext *s, 
  488.                                    short smr1[MPA_MAX_CHANNELS][SBLIMIT],
  489.                                    unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
  490.                                    int *padding)
  491. {
  492.     int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size;
  493.     int incr;
  494.     short smr[MPA_MAX_CHANNELS][SBLIMIT];
  495.     unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT];
  496.     const unsigned char *alloc;
  498.     memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
  499.     memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
  500.     memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
  501.     
  502.     /* compute frame size and padding */
  503.     max_frame_size = s->frame_size;
  504.     s->frame_frac += s->frame_frac_incr;
  505.     if (s->frame_frac >= 65536) {
  506.         s->frame_frac -= 65536;
  507.         s->do_padding = 1;
  508.         max_frame_size += 8;
  509.     } else {
  510.         s->do_padding = 0;
  511.     }
  513.     /* compute the header + bit alloc size */
  514.     current_frame_size = 32;
  515.     alloc = s->alloc_table;
  516.     for(i=0;i<s->sblimit;i++) {
  517.         incr = alloc[0];
  518.         current_frame_size += incr * s->nb_channels;
  519.         alloc += 1 << incr;
  520.     }
  521.     for(;;) {
  522.         /* look for the subband with the largest signal to mask ratio */
  523.         max_sb = -1;
  524.         max_ch = -1;
  525.         max_smr = 0x80000000;
  526.         for(ch=0;ch<s->nb_channels;ch++) {
  527.             for(i=0;i<s->sblimit;i++) {
  528.                 if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
  529.                     max_smr = smr[ch][i];
  530.                     max_sb = i;
  531.                     max_ch = ch;
  532.                 }
  533.             }
  534.         }
  535. #if 0
  536.         printf("current=%d max=%d max_sb=%d alloc=%dn", 
  537.                current_frame_size, max_frame_size, max_sb,
  538.                bit_alloc[max_sb]);
  539. #endif        
  540.         if (max_sb < 0)
  541.             break;
  542.         
  543.         /* find alloc table entry (XXX: not optimal, should use
  544.            pointer table) */
  545.         alloc = s->alloc_table;
  546.         for(i=0;i<max_sb;i++) {
  547.             alloc += 1 << alloc[0];
  548.         }
  550.         if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
  551.             /* nothing was coded for this band: add the necessary bits */
  552.             incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
  553.             incr += total_quant_bits[alloc[1]];
  554.         } else {
  555.             /* increments bit allocation */
  556.             b = bit_alloc[max_ch][max_sb];
  557.             incr = total_quant_bits[alloc[b + 1]] - 
  558.                 total_quant_bits[alloc[b]];
  559.         }
  561.         if (current_frame_size + incr <= max_frame_size) {
  562.             /* can increase size */
  563.             b = ++bit_alloc[max_ch][max_sb];
  564.             current_frame_size += incr;
  565.             /* decrease smr by the resolution we added */
  566.             smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
  567.             /* max allocation size reached ? */
  568.             if (b == ((1 << alloc[0]) - 1))
  569.                 subband_status[max_ch][max_sb] = SB_NOMORE;
  570.             else
  571.                 subband_status[max_ch][max_sb] = SB_ALLOCATED;
  572.         } else {
  573.             /* cannot increase the size of this subband */
  574.             subband_status[max_ch][max_sb] = SB_NOMORE;
  575.         }
  576.     }
  577.     *padding = max_frame_size - current_frame_size;
  578.     assert(*padding >= 0);
  580. #if 0
  581.     for(i=0;i<s->sblimit;i++) {
  582.         printf("%d ", bit_alloc[i]);
  583.     }
  584.     printf("n");
  585. #endif
  586. }
  588. /*
  589.  * Output the mpeg audio layer 2 frame. Note how the code is small
  590.  * compared to other encoders :-)
  591.  */
  592. static void encode_frame(MpegAudioContext *s,
  593.                          unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
  594.                          int padding)
  595. {
  596.     int i, j, k, l, bit_alloc_bits, b, ch;
  597.     unsigned char *sf;
  598.     int q[3];
  599.     PutBitContext *p = &s->pb;
  601.     /* header */
  603.     put_bits(p, 12, 0xfff);
  604.     put_bits(p, 1, 1 - s->lsf); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */
  605.     put_bits(p, 2, 4-2);  /* layer 2 */
  606.     put_bits(p, 1, 1); /* no error protection */
  607.     put_bits(p, 4, s->bitrate_index);
  608.     put_bits(p, 2, s->freq_index);
  609.     put_bits(p, 1, s->do_padding); /* use padding */
  610.     put_bits(p, 1, 0);             /* private_bit */
  611.     put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
  612.     put_bits(p, 2, 0); /* mode_ext */
  613.     put_bits(p, 1, 0); /* no copyright */
  614.     put_bits(p, 1, 1); /* original */
  615.     put_bits(p, 2, 0); /* no emphasis */
  617.     /* bit allocation */
  618.     j = 0;
  619.     for(i=0;i<s->sblimit;i++) {
  620.         bit_alloc_bits = s->alloc_table[j];
  621.         for(ch=0;ch<s->nb_channels;ch++) {
  622.             put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
  623.         }
  624.         j += 1 << bit_alloc_bits;
  625.     }
  626.     
  627.     /* scale codes */
  628.     for(i=0;i<s->sblimit;i++) {
  629.         for(ch=0;ch<s->nb_channels;ch++) {
  630.             if (bit_alloc[ch][i]) 
  631.                 put_bits(p, 2, s->scale_code[ch][i]);
  632.         }
  633.     }
  635.     /* scale factors */
  636.     for(i=0;i<s->sblimit;i++) {
  637.         for(ch=0;ch<s->nb_channels;ch++) {
  638.             if (bit_alloc[ch][i]) {
  639.                 sf = &s->scale_factors[ch][i][0];
  640.                 switch(s->scale_code[ch][i]) {
  641.                 case 0:
  642.                     put_bits(p, 6, sf[0]);
  643.                     put_bits(p, 6, sf[1]);
  644.                     put_bits(p, 6, sf[2]);
  645.                     break;
  646.                 case 3:
  647.                 case 1:
  648.                     put_bits(p, 6, sf[0]);
  649.                     put_bits(p, 6, sf[2]);
  650.                     break;
  651.                 case 2:
  652.                     put_bits(p, 6, sf[0]);
  653.                     break;
  654.                 }
  655.             }
  656.         }
  657.     }
  658.     
  659.     /* quantization & write sub band samples */
  661.     for(k=0;k<3;k++) {
  662.         for(l=0;l<12;l+=3) {
  663.             j = 0;
  664.             for(i=0;i<s->sblimit;i++) {
  665.                 bit_alloc_bits = s->alloc_table[j];
  666.                 for(ch=0;ch<s->nb_channels;ch++) {
  667.                     b = bit_alloc[ch][i];
  668.                     if (b) {
  669.                         int qindex, steps, m, sample, bits;
  670.                         /* we encode 3 sub band samples of the same sub band at a time */
  671.                         qindex = s->alloc_table[j+b];
  672.                         steps = quant_steps[qindex];
  673.                         for(m=0;m<3;m++) {
  674.                             sample = s->sb_samples[ch][k][l + m][i];
  675.                             /* divide by scale factor */
  676. #ifdef USE_FLOATS
  677.                             {
  678.                                 float a;
  679.                                 a = (float)sample * scale_factor_inv_table[s->scale_factors[ch][i][k]];
  680.                                 q[m] = (int)((a + 1.0) * steps * 0.5);
  681.                             }
  682. #else
  683.                             {
  684.                                 int q1, e, shift, mult;
  685.                                 e = s->scale_factors[ch][i][k];
  686.                                 shift = scale_factor_shift[e];
  687.                                 mult = scale_factor_mult[e];
  688.                                 
  689.                                 /* normalize to P bits */
  690.                                 if (shift < 0)
  691.                                     q1 = sample << (-shift);
  692.                                 else
  693.                                     q1 = sample >> shift;
  694.                                 q1 = (q1 * mult) >> P;
  695.                                 q[m] = ((q1 + (1 << P)) * steps) >> (P + 1);
  696.                             }
  697. #endif
  698.                             if (q[m] >= steps)
  699.                                 q[m] = steps - 1;
  700.                             assert(q[m] >= 0 && q[m] < steps);
  701.                         }
  702.                         bits = quant_bits[qindex];
  703.                         if (bits < 0) {
  704.                             /* group the 3 values to save bits */
  705.                             put_bits(p, -bits, 
  706.                                      q[0] + steps * (q[1] + steps * q[2]));
  707. #if 0
  708.                             printf("%d: gr1 %dn", 
  709.                                    i, q[0] + steps * (q[1] + steps * q[2]));
  710. #endif
  711.                         } else {
  712. #if 0
  713.                             printf("%d: gr3 %d %d %dn", 
  714.                                    i, q[0], q[1], q[2]);
  715. #endif                               
  716.                             put_bits(p, bits, q[0]);
  717.                             put_bits(p, bits, q[1]);
  718.                             put_bits(p, bits, q[2]);
  719.                         }
  720.                     }
  721.                 }
  722.                 /* next subband in alloc table */
  723.                 j += 1 << bit_alloc_bits; 
  724.             }
  725.         }
  726.     }
  728.     /* padding */
  729.     for(i=0;i<padding;i++)
  730.         put_bits(p, 1, 0);
  732.     /* flush */
  733.     flush_put_bits(p);
  734. }
  736. int MPA_encode_frame(AVEncodeContext *avctx,
  737.                      unsigned char *frame, int buf_size, void *data)
  738. {
  739.     MpegAudioContext *s = avctx->priv_data;
  740.     short *samples = data;
  741.     short smr[MPA_MAX_CHANNELS][SBLIMIT];
  742.     unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
  743.     int padding, i;
  745.     for(i=0;i<s->nb_channels;i++) {
  746.         filter(s, i, samples + i, s->nb_channels);
  747.     }
  749.     for(i=0;i<s->nb_channels;i++) {
  750.         compute_scale_factors(s->scale_code[i], s->scale_factors[i], 
  751.                               s->sb_samples[i], s->sblimit);
  752.     }
  753.     for(i=0;i<s->nb_channels;i++) {
  754.         psycho_acoustic_model(s, smr[i]);
  755.     }
  756.     compute_bit_allocation(s, smr, bit_alloc, &padding);
  758.     init_put_bits(&s->pb, frame, MPA_MAX_CODED_FRAME_SIZE, NULL, NULL);
  760.     encode_frame(s, bit_alloc, padding);
  761.     
  762.     s->nb_samples += MPA_FRAME_SIZE;
  763.     return s->pb.buf_ptr - s->pb.buf;
  764. }
  767. AVEncoder mp2_encoder = {
  768.     "mp2",
  769.     CODEC_TYPE_AUDIO,
  770.     CODEC_ID_MP2,
  771.     sizeof(MpegAudioContext),
  772.     MPA_encode_init,
  773.     MPA_encode_frame,
  774.     NULL,
  775. };