2 * The simplest mpeg audio layer 2 encoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * The simplest mpeg audio layer 2 encoder.
30 #undef CONFIG_MPEGAUDIO_HP
31 #define CONFIG_MPEGAUDIO_HP 0
32 #include "mpegaudio.h"
34 /* currently, cannot change these constants (need to modify
35 quantization stage) */
36 #define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
38 #define SAMPLES_BUF_SIZE 4096
40 typedef struct MpegAudioContext
{
44 int lsf
; /* 1 if mpeg2 low bitrate selected */
45 int bitrate_index
; /* bit rate */
47 int frame_size
; /* frame size, in bits, without padding */
48 int64_t nb_samples
; /* total number of samples encoded */
49 /* padding computation */
50 int frame_frac
, frame_frac_incr
, do_padding
;
51 short samples_buf
[MPA_MAX_CHANNELS
][SAMPLES_BUF_SIZE
]; /* buffer for filter */
52 int samples_offset
[MPA_MAX_CHANNELS
]; /* offset in samples_buf */
53 int sb_samples
[MPA_MAX_CHANNELS
][3][12][SBLIMIT
];
54 unsigned char scale_factors
[MPA_MAX_CHANNELS
][SBLIMIT
][3]; /* scale factors */
55 /* code to group 3 scale factors */
56 unsigned char scale_code
[MPA_MAX_CHANNELS
][SBLIMIT
];
57 int sblimit
; /* number of used subbands */
58 const unsigned char *alloc_table
;
61 /* define it to use floats in quantization (I don't like floats !) */
64 #include "mpegaudiodata.h"
65 #include "mpegaudiotab.h"
67 static av_cold
int MPA_encode_init(AVCodecContext
*avctx
)
69 MpegAudioContext
*s
= avctx
->priv_data
;
70 int freq
= avctx
->sample_rate
;
71 int bitrate
= avctx
->bit_rate
;
72 int channels
= avctx
->channels
;
76 if (channels
<= 0 || channels
> 2){
77 av_log(avctx
, AV_LOG_ERROR
, "encoding %d channel(s) is not allowed in mp2\n", channels
);
80 bitrate
= bitrate
/ 1000;
81 s
->nb_channels
= channels
;
83 s
->bit_rate
= bitrate
* 1000;
84 avctx
->frame_size
= MPA_FRAME_SIZE
;
89 if (ff_mpa_freq_tab
[i
] == freq
)
91 if ((ff_mpa_freq_tab
[i
] / 2) == freq
) {
97 av_log(avctx
, AV_LOG_ERROR
, "Sampling rate %d is not allowed in mp2\n", freq
);
102 /* encoding bitrate & frequency */
104 if (ff_mpa_bitrate_tab
[s
->lsf
][1][i
] == bitrate
)
108 av_log(avctx
, AV_LOG_ERROR
, "bitrate %d is not allowed in mp2\n", bitrate
);
111 s
->bitrate_index
= i
;
113 /* compute total header size & pad bit */
115 a
= (float)(bitrate
* 1000 * MPA_FRAME_SIZE
) / (freq
* 8.0);
116 s
->frame_size
= ((int)a
) * 8;
118 /* frame fractional size to compute padding */
120 s
->frame_frac_incr
= (int)((a
- floor(a
)) * 65536.0);
122 /* select the right allocation table */
123 table
= ff_mpa_l2_select_table(bitrate
, s
->nb_channels
, freq
, s
->lsf
);
125 /* number of used subbands */
126 s
->sblimit
= ff_mpa_sblimit_table
[table
];
127 s
->alloc_table
= ff_mpa_alloc_tables
[table
];
129 dprintf(avctx
, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
130 bitrate
, freq
, s
->frame_size
, table
, s
->frame_frac_incr
);
132 for(i
=0;i
<s
->nb_channels
;i
++)
133 s
->samples_offset
[i
] = 0;
137 v
= ff_mpa_enwindow
[i
];
139 v
= (v
+ (1 << (16 - WFRAC_BITS
- 1))) >> (16 - WFRAC_BITS
);
145 filter_bank
[512 - i
] = v
;
149 v
= (int)(pow(2.0, (3 - i
) / 3.0) * (1 << 20));
152 scale_factor_table
[i
] = v
;
154 scale_factor_inv_table
[i
] = pow(2.0, -(3 - i
) / 3.0) / (float)(1 << 20);
157 scale_factor_shift
[i
] = 21 - P
- (i
/ 3);
158 scale_factor_mult
[i
] = (1 << P
) * pow(2.0, (i
% 3) / 3.0);
173 scale_diff_table
[i
] = v
;
177 v
= ff_mpa_quant_bits
[i
];
182 total_quant_bits
[i
] = 12 * v
;
185 avctx
->coded_frame
= avcodec_alloc_frame();
186 avctx
->coded_frame
->key_frame
= 1;
191 /* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */
192 static void idct32(int *out
, int *tab
)
196 const int *xp
= costab32
;
198 for(j
=31;j
>=3;j
-=2) tab
[j
] += tab
[j
- 2];
237 x3
= MUL(t
[16], FIX(SQRT2
*0.5));
241 x2
= MUL(-(t
[24] + t
[8]), FIX(SQRT2
*0.5));
242 x1
= MUL((t
[8] - x2
), xp
[0]);
243 x2
= MUL((t
[8] + x2
), xp
[1]);
256 xr
= MUL(t
[28],xp
[0]);
260 xr
= MUL(t
[4],xp
[1]);
261 t
[ 4] = (t
[24] - xr
);
262 t
[24] = (t
[24] + xr
);
264 xr
= MUL(t
[20],xp
[2]);
268 xr
= MUL(t
[12],xp
[3]);
269 t
[12] = (t
[16] - xr
);
270 t
[16] = (t
[16] + xr
);
275 for (i
= 0; i
< 4; i
++) {
276 xr
= MUL(tab
[30-i
*4],xp
[0]);
277 tab
[30-i
*4] = (tab
[i
*4] - xr
);
278 tab
[ i
*4] = (tab
[i
*4] + xr
);
280 xr
= MUL(tab
[ 2+i
*4],xp
[1]);
281 tab
[ 2+i
*4] = (tab
[28-i
*4] - xr
);
282 tab
[28-i
*4] = (tab
[28-i
*4] + xr
);
284 xr
= MUL(tab
[31-i
*4],xp
[0]);
285 tab
[31-i
*4] = (tab
[1+i
*4] - xr
);
286 tab
[ 1+i
*4] = (tab
[1+i
*4] + xr
);
288 xr
= MUL(tab
[ 3+i
*4],xp
[1]);
289 tab
[ 3+i
*4] = (tab
[29-i
*4] - xr
);
290 tab
[29-i
*4] = (tab
[29-i
*4] + xr
);
298 xr
= MUL(t1
[0], *xp
);
307 out
[i
] = tab
[bitinv32
[i
]];
311 #define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
313 static void filter(MpegAudioContext
*s
, int ch
, short *samples
, int incr
)
316 int sum
, offset
, i
, j
;
321 // print_pow1(samples, 1152);
323 offset
= s
->samples_offset
[ch
];
324 out
= &s
->sb_samples
[ch
][0][0][0];
326 /* 32 samples at once */
328 s
->samples_buf
[ch
][offset
+ (31 - i
)] = samples
[0];
333 p
= s
->samples_buf
[ch
] + offset
;
337 sum
= p
[0*64] * q
[0*64];
338 sum
+= p
[1*64] * q
[1*64];
339 sum
+= p
[2*64] * q
[2*64];
340 sum
+= p
[3*64] * q
[3*64];
341 sum
+= p
[4*64] * q
[4*64];
342 sum
+= p
[5*64] * q
[5*64];
343 sum
+= p
[6*64] * q
[6*64];
344 sum
+= p
[7*64] * q
[7*64];
349 tmp1
[0] = tmp
[16] >> WSHIFT
;
350 for( i
=1; i
<=16; i
++ ) tmp1
[i
] = (tmp
[i
+16]+tmp
[16-i
]) >> WSHIFT
;
351 for( i
=17; i
<=31; i
++ ) tmp1
[i
] = (tmp
[i
+16]-tmp
[80-i
]) >> WSHIFT
;
355 /* advance of 32 samples */
358 /* handle the wrap around */
360 memmove(s
->samples_buf
[ch
] + SAMPLES_BUF_SIZE
- (512 - 32),
361 s
->samples_buf
[ch
], (512 - 32) * 2);
362 offset
= SAMPLES_BUF_SIZE
- 512;
365 s
->samples_offset
[ch
] = offset
;
367 // print_pow(s->sb_samples, 1152);
370 static void compute_scale_factors(unsigned char scale_code
[SBLIMIT
],
371 unsigned char scale_factors
[SBLIMIT
][3],
372 int sb_samples
[3][12][SBLIMIT
],
375 int *p
, vmax
, v
, n
, i
, j
, k
, code
;
377 unsigned char *sf
= &scale_factors
[0][0];
379 for(j
=0;j
<sblimit
;j
++) {
381 /* find the max absolute value */
382 p
= &sb_samples
[i
][0][j
];
390 /* compute the scale factor index using log 2 computations */
393 /* n is the position of the MSB of vmax. now
394 use at most 2 compares to find the index */
395 index
= (21 - n
) * 3 - 3;
397 while (vmax
<= scale_factor_table
[index
+1])
400 index
= 0; /* very unlikely case of overflow */
403 index
= 62; /* value 63 is not allowed */
407 printf("%2d:%d in=%x %x %d\n",
408 j
, i
, vmax
, scale_factor_table
[index
], index
);
410 /* store the scale factor */
411 assert(index
>=0 && index
<= 63);
415 /* compute the transmission factor : look if the scale factors
416 are close enough to each other */
417 d1
= scale_diff_table
[sf
[0] - sf
[1] + 64];
418 d2
= scale_diff_table
[sf
[1] - sf
[2] + 64];
420 /* handle the 25 cases */
421 switch(d1
* 5 + d2
) {
453 sf
[1] = sf
[2] = sf
[0];
458 sf
[0] = sf
[1] = sf
[2];
464 sf
[0] = sf
[2] = sf
[1];
470 sf
[1] = sf
[2] = sf
[0];
473 assert(0); //cannot happen
474 code
= 0; /* kill warning */
478 printf("%d: %2d %2d %2d %d %d -> %d\n", j
,
479 sf
[0], sf
[1], sf
[2], d1
, d2
, code
);
481 scale_code
[j
] = code
;
486 /* The most important function : psycho acoustic module. In this
487 encoder there is basically none, so this is the worst you can do,
488 but also this is the simpler. */
489 static void psycho_acoustic_model(MpegAudioContext
*s
, short smr
[SBLIMIT
])
493 for(i
=0;i
<s
->sblimit
;i
++) {
494 smr
[i
] = (int)(fixed_smr
[i
] * 10);
499 #define SB_NOTALLOCATED 0
500 #define SB_ALLOCATED 1
503 /* Try to maximize the smr while using a number of bits inferior to
504 the frame size. I tried to make the code simpler, faster and
505 smaller than other encoders :-) */
506 static void compute_bit_allocation(MpegAudioContext
*s
,
507 short smr1
[MPA_MAX_CHANNELS
][SBLIMIT
],
508 unsigned char bit_alloc
[MPA_MAX_CHANNELS
][SBLIMIT
],
511 int i
, ch
, b
, max_smr
, max_ch
, max_sb
, current_frame_size
, max_frame_size
;
513 short smr
[MPA_MAX_CHANNELS
][SBLIMIT
];
514 unsigned char subband_status
[MPA_MAX_CHANNELS
][SBLIMIT
];
515 const unsigned char *alloc
;
517 memcpy(smr
, smr1
, s
->nb_channels
* sizeof(short) * SBLIMIT
);
518 memset(subband_status
, SB_NOTALLOCATED
, s
->nb_channels
* SBLIMIT
);
519 memset(bit_alloc
, 0, s
->nb_channels
* SBLIMIT
);
521 /* compute frame size and padding */
522 max_frame_size
= s
->frame_size
;
523 s
->frame_frac
+= s
->frame_frac_incr
;
524 if (s
->frame_frac
>= 65536) {
525 s
->frame_frac
-= 65536;
532 /* compute the header + bit alloc size */
533 current_frame_size
= 32;
534 alloc
= s
->alloc_table
;
535 for(i
=0;i
<s
->sblimit
;i
++) {
537 current_frame_size
+= incr
* s
->nb_channels
;
541 /* look for the subband with the largest signal to mask ratio */
545 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
546 for(i
=0;i
<s
->sblimit
;i
++) {
547 if (smr
[ch
][i
] > max_smr
&& subband_status
[ch
][i
] != SB_NOMORE
) {
548 max_smr
= smr
[ch
][i
];
555 printf("current=%d max=%d max_sb=%d alloc=%d\n",
556 current_frame_size
, max_frame_size
, max_sb
,
562 /* find alloc table entry (XXX: not optimal, should use
564 alloc
= s
->alloc_table
;
565 for(i
=0;i
<max_sb
;i
++) {
566 alloc
+= 1 << alloc
[0];
569 if (subband_status
[max_ch
][max_sb
] == SB_NOTALLOCATED
) {
570 /* nothing was coded for this band: add the necessary bits */
571 incr
= 2 + nb_scale_factors
[s
->scale_code
[max_ch
][max_sb
]] * 6;
572 incr
+= total_quant_bits
[alloc
[1]];
574 /* increments bit allocation */
575 b
= bit_alloc
[max_ch
][max_sb
];
576 incr
= total_quant_bits
[alloc
[b
+ 1]] -
577 total_quant_bits
[alloc
[b
]];
580 if (current_frame_size
+ incr
<= max_frame_size
) {
581 /* can increase size */
582 b
= ++bit_alloc
[max_ch
][max_sb
];
583 current_frame_size
+= incr
;
584 /* decrease smr by the resolution we added */
585 smr
[max_ch
][max_sb
] = smr1
[max_ch
][max_sb
] - quant_snr
[alloc
[b
]];
586 /* max allocation size reached ? */
587 if (b
== ((1 << alloc
[0]) - 1))
588 subband_status
[max_ch
][max_sb
] = SB_NOMORE
;
590 subband_status
[max_ch
][max_sb
] = SB_ALLOCATED
;
592 /* cannot increase the size of this subband */
593 subband_status
[max_ch
][max_sb
] = SB_NOMORE
;
596 *padding
= max_frame_size
- current_frame_size
;
597 assert(*padding
>= 0);
600 for(i
=0;i
<s
->sblimit
;i
++) {
601 printf("%d ", bit_alloc
[i
]);
608 * Output the mpeg audio layer 2 frame. Note how the code is small
609 * compared to other encoders :-)
611 static void encode_frame(MpegAudioContext
*s
,
612 unsigned char bit_alloc
[MPA_MAX_CHANNELS
][SBLIMIT
],
615 int i
, j
, k
, l
, bit_alloc_bits
, b
, ch
;
618 PutBitContext
*p
= &s
->pb
;
622 put_bits(p
, 12, 0xfff);
623 put_bits(p
, 1, 1 - s
->lsf
); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */
624 put_bits(p
, 2, 4-2); /* layer 2 */
625 put_bits(p
, 1, 1); /* no error protection */
626 put_bits(p
, 4, s
->bitrate_index
);
627 put_bits(p
, 2, s
->freq_index
);
628 put_bits(p
, 1, s
->do_padding
); /* use padding */
629 put_bits(p
, 1, 0); /* private_bit */
630 put_bits(p
, 2, s
->nb_channels
== 2 ? MPA_STEREO
: MPA_MONO
);
631 put_bits(p
, 2, 0); /* mode_ext */
632 put_bits(p
, 1, 0); /* no copyright */
633 put_bits(p
, 1, 1); /* original */
634 put_bits(p
, 2, 0); /* no emphasis */
638 for(i
=0;i
<s
->sblimit
;i
++) {
639 bit_alloc_bits
= s
->alloc_table
[j
];
640 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
641 put_bits(p
, bit_alloc_bits
, bit_alloc
[ch
][i
]);
643 j
+= 1 << bit_alloc_bits
;
647 for(i
=0;i
<s
->sblimit
;i
++) {
648 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
649 if (bit_alloc
[ch
][i
])
650 put_bits(p
, 2, s
->scale_code
[ch
][i
]);
655 for(i
=0;i
<s
->sblimit
;i
++) {
656 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
657 if (bit_alloc
[ch
][i
]) {
658 sf
= &s
->scale_factors
[ch
][i
][0];
659 switch(s
->scale_code
[ch
][i
]) {
661 put_bits(p
, 6, sf
[0]);
662 put_bits(p
, 6, sf
[1]);
663 put_bits(p
, 6, sf
[2]);
667 put_bits(p
, 6, sf
[0]);
668 put_bits(p
, 6, sf
[2]);
671 put_bits(p
, 6, sf
[0]);
678 /* quantization & write sub band samples */
683 for(i
=0;i
<s
->sblimit
;i
++) {
684 bit_alloc_bits
= s
->alloc_table
[j
];
685 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
686 b
= bit_alloc
[ch
][i
];
688 int qindex
, steps
, m
, sample
, bits
;
689 /* we encode 3 sub band samples of the same sub band at a time */
690 qindex
= s
->alloc_table
[j
+b
];
691 steps
= ff_mpa_quant_steps
[qindex
];
693 sample
= s
->sb_samples
[ch
][k
][l
+ m
][i
];
694 /* divide by scale factor */
698 a
= (float)sample
* scale_factor_inv_table
[s
->scale_factors
[ch
][i
][k
]];
699 q
[m
] = (int)((a
+ 1.0) * steps
* 0.5);
703 int q1
, e
, shift
, mult
;
704 e
= s
->scale_factors
[ch
][i
][k
];
705 shift
= scale_factor_shift
[e
];
706 mult
= scale_factor_mult
[e
];
708 /* normalize to P bits */
710 q1
= sample
<< (-shift
);
712 q1
= sample
>> shift
;
713 q1
= (q1
* mult
) >> P
;
714 q
[m
] = ((q1
+ (1 << P
)) * steps
) >> (P
+ 1);
719 assert(q
[m
] >= 0 && q
[m
] < steps
);
721 bits
= ff_mpa_quant_bits
[qindex
];
723 /* group the 3 values to save bits */
725 q
[0] + steps
* (q
[1] + steps
* q
[2]));
727 printf("%d: gr1 %d\n",
728 i
, q
[0] + steps
* (q
[1] + steps
* q
[2]));
732 printf("%d: gr3 %d %d %d\n",
733 i
, q
[0], q
[1], q
[2]);
735 put_bits(p
, bits
, q
[0]);
736 put_bits(p
, bits
, q
[1]);
737 put_bits(p
, bits
, q
[2]);
741 /* next subband in alloc table */
742 j
+= 1 << bit_alloc_bits
;
748 for(i
=0;i
<padding
;i
++)
755 static int MPA_encode_frame(AVCodecContext
*avctx
,
756 unsigned char *frame
, int buf_size
, void *data
)
758 MpegAudioContext
*s
= avctx
->priv_data
;
759 short *samples
= data
;
760 short smr
[MPA_MAX_CHANNELS
][SBLIMIT
];
761 unsigned char bit_alloc
[MPA_MAX_CHANNELS
][SBLIMIT
];
764 for(i
=0;i
<s
->nb_channels
;i
++) {
765 filter(s
, i
, samples
+ i
, s
->nb_channels
);
768 for(i
=0;i
<s
->nb_channels
;i
++) {
769 compute_scale_factors(s
->scale_code
[i
], s
->scale_factors
[i
],
770 s
->sb_samples
[i
], s
->sblimit
);
772 for(i
=0;i
<s
->nb_channels
;i
++) {
773 psycho_acoustic_model(s
, smr
[i
]);
775 compute_bit_allocation(s
, smr
, bit_alloc
, &padding
);
777 init_put_bits(&s
->pb
, frame
, MPA_MAX_CODED_FRAME_SIZE
);
779 encode_frame(s
, bit_alloc
, padding
);
781 s
->nb_samples
+= MPA_FRAME_SIZE
;
782 return put_bits_ptr(&s
->pb
) - s
->pb
.buf
;
785 static av_cold
int MPA_encode_close(AVCodecContext
*avctx
)
787 av_freep(&avctx
->coded_frame
);
791 AVCodec mp2_encoder
= {
795 sizeof(MpegAudioContext
),
800 .sample_fmts
= (const enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
801 .supported_samplerates
= (const int[]){44100, 48000, 32000, 22050, 24000, 16000, 0},
802 .long_name
= NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),