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