00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00027 #include "avcodec.h"
00028 #include "bitstream.h"
00029 #include "mpegaudio.h"
00030
00031
00032
00033 #define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
00034
00035 #define SAMPLES_BUF_SIZE 4096
00036
00037 typedef struct MpegAudioContext {
00038 PutBitContext pb;
00039 int nb_channels;
00040 int freq, bit_rate;
00041 int lsf;
00042 int bitrate_index;
00043 int freq_index;
00044 int frame_size;
00045 int64_t nb_samples;
00046
00047 int frame_frac, frame_frac_incr, do_padding;
00048 short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE];
00049 int samples_offset[MPA_MAX_CHANNELS];
00050 int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT];
00051 unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3];
00052
00053 unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
00054 int sblimit;
00055 const unsigned char *alloc_table;
00056 } MpegAudioContext;
00057
00058
00059
00060
00061 #include "mpegaudiodata.h"
00062 #include "mpegaudiotab.h"
00063
00064 static int MPA_encode_init(AVCodecContext *avctx)
00065 {
00066 MpegAudioContext *s = avctx->priv_data;
00067 int freq = avctx->sample_rate;
00068 int bitrate = avctx->bit_rate;
00069 int channels = avctx->channels;
00070 int i, v, table;
00071 float a;
00072
00073 if (channels <= 0 || channels > 2){
00074 av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels);
00075 return -1;
00076 }
00077 bitrate = bitrate / 1000;
00078 s->nb_channels = channels;
00079 s->freq = freq;
00080 s->bit_rate = bitrate * 1000;
00081 avctx->frame_size = MPA_FRAME_SIZE;
00082
00083
00084 s->lsf = 0;
00085 for(i=0;i<3;i++) {
00086 if (ff_mpa_freq_tab[i] == freq)
00087 break;
00088 if ((ff_mpa_freq_tab[i] / 2) == freq) {
00089 s->lsf = 1;
00090 break;
00091 }
00092 }
00093 if (i == 3){
00094 av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq);
00095 return -1;
00096 }
00097 s->freq_index = i;
00098
00099
00100 for(i=0;i<15;i++) {
00101 if (ff_mpa_bitrate_tab[s->lsf][1][i] == bitrate)
00102 break;
00103 }
00104 if (i == 15){
00105 av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate);
00106 return -1;
00107 }
00108 s->bitrate_index = i;
00109
00110
00111
00112 a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
00113 s->frame_size = ((int)a) * 8;
00114
00115
00116 s->frame_frac = 0;
00117 s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
00118
00119
00120 table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
00121
00122
00123 s->sblimit = ff_mpa_sblimit_table[table];
00124 s->alloc_table = ff_mpa_alloc_tables[table];
00125
00126 #ifdef DEBUG
00127 av_log(avctx, AV_LOG_DEBUG, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
00128 bitrate, freq, s->frame_size, table, s->frame_frac_incr);
00129 #endif
00130
00131 for(i=0;i<s->nb_channels;i++)
00132 s->samples_offset[i] = 0;
00133
00134 for(i=0;i<257;i++) {
00135 int v;
00136 v = ff_mpa_enwindow[i];
00137 #if WFRAC_BITS != 16
00138 v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
00139 #endif
00140 filter_bank[i] = v;
00141 if ((i & 63) != 0)
00142 v = -v;
00143 if (i != 0)
00144 filter_bank[512 - i] = v;
00145 }
00146
00147 for(i=0;i<64;i++) {
00148 v = (int)(pow(2.0, (3 - i) / 3.0) * (1 << 20));
00149 if (v <= 0)
00150 v = 1;
00151 scale_factor_table[i] = v;
00152 #ifdef USE_FLOATS
00153 scale_factor_inv_table[i] = pow(2.0, -(3 - i) / 3.0) / (float)(1 << 20);
00154 #else
00155 #define P 15
00156 scale_factor_shift[i] = 21 - P - (i / 3);
00157 scale_factor_mult[i] = (1 << P) * pow(2.0, (i % 3) / 3.0);
00158 #endif
00159 }
00160 for(i=0;i<128;i++) {
00161 v = i - 64;
00162 if (v <= -3)
00163 v = 0;
00164 else if (v < 0)
00165 v = 1;
00166 else if (v == 0)
00167 v = 2;
00168 else if (v < 3)
00169 v = 3;
00170 else
00171 v = 4;
00172 scale_diff_table[i] = v;
00173 }
00174
00175 for(i=0;i<17;i++) {
00176 v = ff_mpa_quant_bits[i];
00177 if (v < 0)
00178 v = -v;
00179 else
00180 v = v * 3;
00181 total_quant_bits[i] = 12 * v;
00182 }
00183
00184 avctx->coded_frame= avcodec_alloc_frame();
00185 avctx->coded_frame->key_frame= 1;
00186
00187 return 0;
00188 }
00189
00190
00191 static void idct32(int *out, int *tab)
00192 {
00193 int i, j;
00194 int *t, *t1, xr;
00195 const int *xp = costab32;
00196
00197 for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
00198
00199 t = tab + 30;
00200 t1 = tab + 2;
00201 do {
00202 t[0] += t[-4];
00203 t[1] += t[1 - 4];
00204 t -= 4;
00205 } while (t != t1);
00206
00207 t = tab + 28;
00208 t1 = tab + 4;
00209 do {
00210 t[0] += t[-8];
00211 t[1] += t[1-8];
00212 t[2] += t[2-8];
00213 t[3] += t[3-8];
00214 t -= 8;
00215 } while (t != t1);
00216
00217 t = tab;
00218 t1 = tab + 32;
00219 do {
00220 t[ 3] = -t[ 3];
00221 t[ 6] = -t[ 6];
00222
00223 t[11] = -t[11];
00224 t[12] = -t[12];
00225 t[13] = -t[13];
00226 t[15] = -t[15];
00227 t += 16;
00228 } while (t != t1);
00229
00230
00231 t = tab;
00232 t1 = tab + 8;
00233 do {
00234 int x1, x2, x3, x4;
00235
00236 x3 = MUL(t[16], FIX(SQRT2*0.5));
00237 x4 = t[0] - x3;
00238 x3 = t[0] + x3;
00239
00240 x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5));
00241 x1 = MUL((t[8] - x2), xp[0]);
00242 x2 = MUL((t[8] + x2), xp[1]);
00243
00244 t[ 0] = x3 + x1;
00245 t[ 8] = x4 - x2;
00246 t[16] = x4 + x2;
00247 t[24] = x3 - x1;
00248 t++;
00249 } while (t != t1);
00250
00251 xp += 2;
00252 t = tab;
00253 t1 = tab + 4;
00254 do {
00255 xr = MUL(t[28],xp[0]);
00256 t[28] = (t[0] - xr);
00257 t[0] = (t[0] + xr);
00258
00259 xr = MUL(t[4],xp[1]);
00260 t[ 4] = (t[24] - xr);
00261 t[24] = (t[24] + xr);
00262
00263 xr = MUL(t[20],xp[2]);
00264 t[20] = (t[8] - xr);
00265 t[ 8] = (t[8] + xr);
00266
00267 xr = MUL(t[12],xp[3]);
00268 t[12] = (t[16] - xr);
00269 t[16] = (t[16] + xr);
00270 t++;
00271 } while (t != t1);
00272 xp += 4;
00273
00274 for (i = 0; i < 4; i++) {
00275 xr = MUL(tab[30-i*4],xp[0]);
00276 tab[30-i*4] = (tab[i*4] - xr);
00277 tab[ i*4] = (tab[i*4] + xr);
00278
00279 xr = MUL(tab[ 2+i*4],xp[1]);
00280 tab[ 2+i*4] = (tab[28-i*4] - xr);
00281 tab[28-i*4] = (tab[28-i*4] + xr);
00282
00283 xr = MUL(tab[31-i*4],xp[0]);
00284 tab[31-i*4] = (tab[1+i*4] - xr);
00285 tab[ 1+i*4] = (tab[1+i*4] + xr);
00286
00287 xr = MUL(tab[ 3+i*4],xp[1]);
00288 tab[ 3+i*4] = (tab[29-i*4] - xr);
00289 tab[29-i*4] = (tab[29-i*4] + xr);
00290
00291 xp += 2;
00292 }
00293
00294 t = tab + 30;
00295 t1 = tab + 1;
00296 do {
00297 xr = MUL(t1[0], *xp);
00298 t1[0] = (t[0] - xr);
00299 t[0] = (t[0] + xr);
00300 t -= 2;
00301 t1 += 2;
00302 xp++;
00303 } while (t >= tab);
00304
00305 for(i=0;i<32;i++) {
00306 out[i] = tab[bitinv32[i]];
00307 }
00308 }
00309
00310 #define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
00311
00312 static void filter(MpegAudioContext *s, int ch, short *samples, int incr)
00313 {
00314 short *p, *q;
00315 int sum, offset, i, j;
00316 int tmp[64];
00317 int tmp1[32];
00318 int *out;
00319
00320
00321
00322 offset = s->samples_offset[ch];
00323 out = &s->sb_samples[ch][0][0][0];
00324 for(j=0;j<36;j++) {
00325
00326 for(i=0;i<32;i++) {
00327 s->samples_buf[ch][offset + (31 - i)] = samples[0];
00328 samples += incr;
00329 }
00330
00331
00332 p = s->samples_buf[ch] + offset;
00333 q = filter_bank;
00334
00335 for(i=0;i<64;i++) {
00336 sum = p[0*64] * q[0*64];
00337 sum += p[1*64] * q[1*64];
00338 sum += p[2*64] * q[2*64];
00339 sum += p[3*64] * q[3*64];
00340 sum += p[4*64] * q[4*64];
00341 sum += p[5*64] * q[5*64];
00342 sum += p[6*64] * q[6*64];
00343 sum += p[7*64] * q[7*64];
00344 tmp[i] = sum;
00345 p++;
00346 q++;
00347 }
00348 tmp1[0] = tmp[16] >> WSHIFT;
00349 for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
00350 for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
00351
00352 idct32(out, tmp1);
00353
00354
00355 offset -= 32;
00356 out += 32;
00357
00358 if (offset < 0) {
00359 memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
00360 s->samples_buf[ch], (512 - 32) * 2);
00361 offset = SAMPLES_BUF_SIZE - 512;
00362 }
00363 }
00364 s->samples_offset[ch] = offset;
00365
00366
00367 }
00368
00369 static void compute_scale_factors(unsigned char scale_code[SBLIMIT],
00370 unsigned char scale_factors[SBLIMIT][3],
00371 int sb_samples[3][12][SBLIMIT],
00372 int sblimit)
00373 {
00374 int *p, vmax, v, n, i, j, k, code;
00375 int index, d1, d2;
00376 unsigned char *sf = &scale_factors[0][0];
00377
00378 for(j=0;j<sblimit;j++) {
00379 for(i=0;i<3;i++) {
00380
00381 p = &sb_samples[i][0][j];
00382 vmax = abs(*p);
00383 for(k=1;k<12;k++) {
00384 p += SBLIMIT;
00385 v = abs(*p);
00386 if (v > vmax)
00387 vmax = v;
00388 }
00389
00390 if (vmax > 0) {
00391 n = av_log2(vmax);
00392
00393
00394 index = (21 - n) * 3 - 3;
00395 if (index >= 0) {
00396 while (vmax <= scale_factor_table[index+1])
00397 index++;
00398 } else {
00399 index = 0;
00400 }
00401 } else {
00402 index = 62;
00403 }
00404
00405 #if 0
00406 printf("%2d:%d in=%x %x %d\n",
00407 j, i, vmax, scale_factor_table[index], index);
00408 #endif
00409
00410 assert(index >=0 && index <= 63);
00411 sf[i] = index;
00412 }
00413
00414
00415
00416 d1 = scale_diff_table[sf[0] - sf[1] + 64];
00417 d2 = scale_diff_table[sf[1] - sf[2] + 64];
00418
00419
00420 switch(d1 * 5 + d2) {
00421 case 0*5+0:
00422 case 0*5+4:
00423 case 3*5+4:
00424 case 4*5+0:
00425 case 4*5+4:
00426 code = 0;
00427 break;
00428 case 0*5+1:
00429 case 0*5+2:
00430 case 4*5+1:
00431 case 4*5+2:
00432 code = 3;
00433 sf[2] = sf[1];
00434 break;
00435 case 0*5+3:
00436 case 4*5+3:
00437 code = 3;
00438 sf[1] = sf[2];
00439 break;
00440 case 1*5+0:
00441 case 1*5+4:
00442 case 2*5+4:
00443 code = 1;
00444 sf[1] = sf[0];
00445 break;
00446 case 1*5+1:
00447 case 1*5+2:
00448 case 2*5+0:
00449 case 2*5+1:
00450 case 2*5+2:
00451 code = 2;
00452 sf[1] = sf[2] = sf[0];
00453 break;
00454 case 2*5+3:
00455 case 3*5+3:
00456 code = 2;
00457 sf[0] = sf[1] = sf[2];
00458 break;
00459 case 3*5+0:
00460 case 3*5+1:
00461 case 3*5+2:
00462 code = 2;
00463 sf[0] = sf[2] = sf[1];
00464 break;
00465 case 1*5+3:
00466 code = 2;
00467 if (sf[0] > sf[2])
00468 sf[0] = sf[2];
00469 sf[1] = sf[2] = sf[0];
00470 break;
00471 default:
00472 assert(0);
00473 code = 0;
00474 }
00475
00476 #if 0
00477 printf("%d: %2d %2d %2d %d %d -> %d\n", j,
00478 sf[0], sf[1], sf[2], d1, d2, code);
00479 #endif
00480 scale_code[j] = code;
00481 sf += 3;
00482 }
00483 }
00484
00485
00486
00487
00488 static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
00489 {
00490 int i;
00491
00492 for(i=0;i<s->sblimit;i++) {
00493 smr[i] = (int)(fixed_smr[i] * 10);
00494 }
00495 }
00496
00497
00498 #define SB_NOTALLOCATED 0
00499 #define SB_ALLOCATED 1
00500 #define SB_NOMORE 2
00501
00502
00503
00504
00505 static void compute_bit_allocation(MpegAudioContext *s,
00506 short smr1[MPA_MAX_CHANNELS][SBLIMIT],
00507 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
00508 int *padding)
00509 {
00510 int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size;
00511 int incr;
00512 short smr[MPA_MAX_CHANNELS][SBLIMIT];
00513 unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT];
00514 const unsigned char *alloc;
00515
00516 memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
00517 memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
00518 memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
00519
00520
00521 max_frame_size = s->frame_size;
00522 s->frame_frac += s->frame_frac_incr;
00523 if (s->frame_frac >= 65536) {
00524 s->frame_frac -= 65536;
00525 s->do_padding = 1;
00526 max_frame_size += 8;
00527 } else {
00528 s->do_padding = 0;
00529 }
00530
00531
00532 current_frame_size = 32;
00533 alloc = s->alloc_table;
00534 for(i=0;i<s->sblimit;i++) {
00535 incr = alloc[0];
00536 current_frame_size += incr * s->nb_channels;
00537 alloc += 1 << incr;
00538 }
00539 for(;;) {
00540
00541 max_sb = -1;
00542 max_ch = -1;
00543 max_smr = 0x80000000;
00544 for(ch=0;ch<s->nb_channels;ch++) {
00545 for(i=0;i<s->sblimit;i++) {
00546 if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
00547 max_smr = smr[ch][i];
00548 max_sb = i;
00549 max_ch = ch;
00550 }
00551 }
00552 }
00553 #if 0
00554 printf("current=%d max=%d max_sb=%d alloc=%d\n",
00555 current_frame_size, max_frame_size, max_sb,
00556 bit_alloc[max_sb]);
00557 #endif
00558 if (max_sb < 0)
00559 break;
00560
00561
00562
00563 alloc = s->alloc_table;
00564 for(i=0;i<max_sb;i++) {
00565 alloc += 1 << alloc[0];
00566 }
00567
00568 if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
00569
00570 incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
00571 incr += total_quant_bits[alloc[1]];
00572 } else {
00573
00574 b = bit_alloc[max_ch][max_sb];
00575 incr = total_quant_bits[alloc[b + 1]] -
00576 total_quant_bits[alloc[b]];
00577 }
00578
00579 if (current_frame_size + incr <= max_frame_size) {
00580
00581 b = ++bit_alloc[max_ch][max_sb];
00582 current_frame_size += incr;
00583
00584 smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
00585
00586 if (b == ((1 << alloc[0]) - 1))
00587 subband_status[max_ch][max_sb] = SB_NOMORE;
00588 else
00589 subband_status[max_ch][max_sb] = SB_ALLOCATED;
00590 } else {
00591
00592 subband_status[max_ch][max_sb] = SB_NOMORE;
00593 }
00594 }
00595 *padding = max_frame_size - current_frame_size;
00596 assert(*padding >= 0);
00597
00598 #if 0
00599 for(i=0;i<s->sblimit;i++) {
00600 printf("%d ", bit_alloc[i]);
00601 }
00602 printf("\n");
00603 #endif
00604 }
00605
00606
00607
00608
00609
00610 static void encode_frame(MpegAudioContext *s,
00611 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
00612 int padding)
00613 {
00614 int i, j, k, l, bit_alloc_bits, b, ch;
00615 unsigned char *sf;
00616 int q[3];
00617 PutBitContext *p = &s->pb;
00618
00619
00620
00621 put_bits(p, 12, 0xfff);
00622 put_bits(p, 1, 1 - s->lsf);
00623 put_bits(p, 2, 4-2);
00624 put_bits(p, 1, 1);
00625 put_bits(p, 4, s->bitrate_index);
00626 put_bits(p, 2, s->freq_index);
00627 put_bits(p, 1, s->do_padding);
00628 put_bits(p, 1, 0);
00629 put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
00630 put_bits(p, 2, 0);
00631 put_bits(p, 1, 0);
00632 put_bits(p, 1, 1);
00633 put_bits(p, 2, 0);
00634
00635
00636 j = 0;
00637 for(i=0;i<s->sblimit;i++) {
00638 bit_alloc_bits = s->alloc_table[j];
00639 for(ch=0;ch<s->nb_channels;ch++) {
00640 put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
00641 }
00642 j += 1 << bit_alloc_bits;
00643 }
00644
00645
00646 for(i=0;i<s->sblimit;i++) {
00647 for(ch=0;ch<s->nb_channels;ch++) {
00648 if (bit_alloc[ch][i])
00649 put_bits(p, 2, s->scale_code[ch][i]);
00650 }
00651 }
00652
00653
00654 for(i=0;i<s->sblimit;i++) {
00655 for(ch=0;ch<s->nb_channels;ch++) {
00656 if (bit_alloc[ch][i]) {
00657 sf = &s->scale_factors[ch][i][0];
00658 switch(s->scale_code[ch][i]) {
00659 case 0:
00660 put_bits(p, 6, sf[0]);
00661 put_bits(p, 6, sf[1]);
00662 put_bits(p, 6, sf[2]);
00663 break;
00664 case 3:
00665 case 1:
00666 put_bits(p, 6, sf[0]);
00667 put_bits(p, 6, sf[2]);
00668 break;
00669 case 2:
00670 put_bits(p, 6, sf[0]);
00671 break;
00672 }
00673 }
00674 }
00675 }
00676
00677
00678
00679 for(k=0;k<3;k++) {
00680 for(l=0;l<12;l+=3) {
00681 j = 0;
00682 for(i=0;i<s->sblimit;i++) {
00683 bit_alloc_bits = s->alloc_table[j];
00684 for(ch=0;ch<s->nb_channels;ch++) {
00685 b = bit_alloc[ch][i];
00686 if (b) {
00687 int qindex, steps, m, sample, bits;
00688
00689 qindex = s->alloc_table[j+b];
00690 steps = ff_mpa_quant_steps[qindex];
00691 for(m=0;m<3;m++) {
00692 sample = s->sb_samples[ch][k][l + m][i];
00693
00694 #ifdef USE_FLOATS
00695 {
00696 float a;
00697 a = (float)sample * scale_factor_inv_table[s->scale_factors[ch][i][k]];
00698 q[m] = (int)((a + 1.0) * steps * 0.5);
00699 }
00700 #else
00701 {
00702 int q1, e, shift, mult;
00703 e = s->scale_factors[ch][i][k];
00704 shift = scale_factor_shift[e];
00705 mult = scale_factor_mult[e];
00706
00707
00708 if (shift < 0)
00709 q1 = sample << (-shift);
00710 else
00711 q1 = sample >> shift;
00712 q1 = (q1 * mult) >> P;
00713 q[m] = ((q1 + (1 << P)) * steps) >> (P + 1);
00714 }
00715 #endif
00716 if (q[m] >= steps)
00717 q[m] = steps - 1;
00718 assert(q[m] >= 0 && q[m] < steps);
00719 }
00720 bits = ff_mpa_quant_bits[qindex];
00721 if (bits < 0) {
00722
00723 put_bits(p, -bits,
00724 q[0] + steps * (q[1] + steps * q[2]));
00725 #if 0
00726 printf("%d: gr1 %d\n",
00727 i, q[0] + steps * (q[1] + steps * q[2]));
00728 #endif
00729 } else {
00730 #if 0
00731 printf("%d: gr3 %d %d %d\n",
00732 i, q[0], q[1], q[2]);
00733 #endif
00734 put_bits(p, bits, q[0]);
00735 put_bits(p, bits, q[1]);
00736 put_bits(p, bits, q[2]);
00737 }
00738 }
00739 }
00740
00741 j += 1 << bit_alloc_bits;
00742 }
00743 }
00744 }
00745
00746
00747 for(i=0;i<padding;i++)
00748 put_bits(p, 1, 0);
00749
00750
00751 flush_put_bits(p);
00752 }
00753
00754 static int MPA_encode_frame(AVCodecContext *avctx,
00755 unsigned char *frame, int buf_size, void *data)
00756 {
00757 MpegAudioContext *s = avctx->priv_data;
00758 short *samples = data;
00759 short smr[MPA_MAX_CHANNELS][SBLIMIT];
00760 unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
00761 int padding, i;
00762
00763 for(i=0;i<s->nb_channels;i++) {
00764 filter(s, i, samples + i, s->nb_channels);
00765 }
00766
00767 for(i=0;i<s->nb_channels;i++) {
00768 compute_scale_factors(s->scale_code[i], s->scale_factors[i],
00769 s->sb_samples[i], s->sblimit);
00770 }
00771 for(i=0;i<s->nb_channels;i++) {
00772 psycho_acoustic_model(s, smr[i]);
00773 }
00774 compute_bit_allocation(s, smr, bit_alloc, &padding);
00775
00776 init_put_bits(&s->pb, frame, MPA_MAX_CODED_FRAME_SIZE);
00777
00778 encode_frame(s, bit_alloc, padding);
00779
00780 s->nb_samples += MPA_FRAME_SIZE;
00781 return pbBufPtr(&s->pb) - s->pb.buf;
00782 }
00783
00784 static int MPA_encode_close(AVCodecContext *avctx)
00785 {
00786 av_freep(&avctx->coded_frame);
00787 return 0;
00788 }
00789
00790 AVCodec mp2_encoder = {
00791 "mp2",
00792 CODEC_TYPE_AUDIO,
00793 CODEC_ID_MP2,
00794 sizeof(MpegAudioContext),
00795 MPA_encode_init,
00796 MPA_encode_frame,
00797 MPA_encode_close,
00798 NULL,
00799 };
00800
00801 #undef FIX