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