Rename CONFIG_FFT_FLOAT ---> FFT_FLOAT
[ffmpeg.git] / libavcodec / wmaenc.c
1 /*
2  * WMA compatible encoder
3  * Copyright (c) 2007 Michael Niedermayer
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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.
11  *
12  * Libav 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.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/attributes.h"
23 #include "avcodec.h"
24 #include "internal.h"
25 #include "wma.h"
26
27 #undef NDEBUG
28 #include <assert.h>
29
30
31 static av_cold int encode_init(AVCodecContext *avctx)
32 {
33     WMACodecContext *s = avctx->priv_data;
34     int i, flags1, flags2, block_align;
35     uint8_t *extradata;
36
37     s->avctx = avctx;
38
39     if(avctx->channels > MAX_CHANNELS) {
40         av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
41                avctx->channels, MAX_CHANNELS);
42         return AVERROR(EINVAL);
43     }
44
45     if (avctx->sample_rate > 48000) {
46         av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz",
47                avctx->sample_rate);
48         return AVERROR(EINVAL);
49     }
50
51     if(avctx->bit_rate < 24*1000) {
52         av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
53                avctx->bit_rate);
54         return AVERROR(EINVAL);
55     }
56
57     /* extract flag infos */
58     flags1 = 0;
59     flags2 = 1;
60     if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
61         extradata= av_malloc(4);
62         avctx->extradata_size= 4;
63         AV_WL16(extradata, flags1);
64         AV_WL16(extradata+2, flags2);
65     } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
66         extradata= av_mallocz(10);
67         avctx->extradata_size= 10;
68         AV_WL32(extradata, flags1);
69         AV_WL16(extradata+4, flags2);
70     }else
71         assert(0);
72     avctx->extradata= extradata;
73     s->use_exp_vlc = flags2 & 0x0001;
74     s->use_bit_reservoir = flags2 & 0x0002;
75     s->use_variable_block_len = flags2 & 0x0004;
76     if (avctx->channels == 2)
77         s->ms_stereo = 1;
78
79     ff_wma_init(avctx, flags2);
80
81     /* init MDCT */
82     for(i = 0; i < s->nb_block_sizes; i++)
83         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
84
85     block_align        = avctx->bit_rate * (int64_t)s->frame_len /
86                          (avctx->sample_rate * 8);
87     block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
88     avctx->block_align = block_align;
89     avctx->bit_rate    = avctx->block_align * 8LL * avctx->sample_rate /
90                          s->frame_len;
91     avctx->frame_size = avctx->delay = s->frame_len;
92
93     return 0;
94 }
95
96
97 static void apply_window_and_mdct(AVCodecContext * avctx, const AVFrame *frame)
98 {
99     WMACodecContext *s = avctx->priv_data;
100     float **audio      = (float **)frame->extended_data;
101     int len            = frame->nb_samples;
102     int window_index= s->frame_len_bits - s->block_len_bits;
103     FFTContext *mdct = &s->mdct_ctx[window_index];
104     int ch;
105     const float * win = s->windows[window_index];
106     int window_len = 1 << s->block_len_bits;
107     float n = 2.0 * 32768.0 / window_len;
108
109     for (ch = 0; ch < avctx->channels; ch++) {
110         memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
111         s->fdsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
112         s->fdsp.vector_fmul_reverse(&s->output[window_len], s->frame_out[ch], win, len);
113         s->fdsp.vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
114         mdct->mdct_calc(mdct, s->coefs[ch], s->output);
115     }
116 }
117
118 //FIXME use for decoding too
119 static void init_exp(WMACodecContext *s, int ch, const int *exp_param){
120     int n;
121     const uint16_t *ptr;
122     float v, *q, max_scale, *q_end;
123
124     ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
125     q = s->exponents[ch];
126     q_end = q + s->block_len;
127     max_scale = 0;
128     while (q < q_end) {
129         /* XXX: use a table */
130         v = pow(10, *exp_param++ * (1.0 / 16.0));
131         max_scale= FFMAX(max_scale, v);
132         n = *ptr++;
133         do {
134             *q++ = v;
135         } while (--n);
136     }
137     s->max_exponent[ch] = max_scale;
138 }
139
140 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param){
141     int last_exp;
142     const uint16_t *ptr;
143     float *q, *q_end;
144
145     ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
146     q = s->exponents[ch];
147     q_end = q + s->block_len;
148     if (s->version == 1) {
149         last_exp= *exp_param++;
150         assert(last_exp-10 >= 0 && last_exp-10 < 32);
151         put_bits(&s->pb, 5, last_exp - 10);
152         q+= *ptr++;
153     }else
154         last_exp = 36;
155     while (q < q_end) {
156         int exp = *exp_param++;
157         int code = exp - last_exp + 60;
158         assert(code >= 0 && code < 120);
159         put_bits(&s->pb, ff_aac_scalefactor_bits[code], ff_aac_scalefactor_code[code]);
160         /* XXX: use a table */
161         q+= *ptr++;
162         last_exp= exp;
163     }
164 }
165
166 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], int total_gain){
167     int v, bsize, ch, coef_nb_bits, parse_exponents;
168     float mdct_norm;
169     int nb_coefs[MAX_CHANNELS];
170     static const int fixed_exp[25]={20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20};
171
172     //FIXME remove duplication relative to decoder
173     if (s->use_variable_block_len) {
174         assert(0); //FIXME not implemented
175     }else{
176         /* fixed block len */
177         s->next_block_len_bits = s->frame_len_bits;
178         s->prev_block_len_bits = s->frame_len_bits;
179         s->block_len_bits = s->frame_len_bits;
180     }
181
182     s->block_len = 1 << s->block_len_bits;
183 //     assert((s->block_pos + s->block_len) <= s->frame_len);
184     bsize = s->frame_len_bits - s->block_len_bits;
185
186     //FIXME factor
187     v = s->coefs_end[bsize] - s->coefs_start;
188     for (ch = 0; ch < s->avctx->channels; ch++)
189         nb_coefs[ch] = v;
190     {
191         int n4 = s->block_len / 2;
192         mdct_norm = 1.0 / (float)n4;
193         if (s->version == 1) {
194             mdct_norm *= sqrt(n4);
195         }
196     }
197
198     if (s->avctx->channels == 2) {
199         put_bits(&s->pb, 1, !!s->ms_stereo);
200     }
201
202     for (ch = 0; ch < s->avctx->channels; ch++) {
203         s->channel_coded[ch] = 1; //FIXME only set channel_coded when needed, instead of always
204         if (s->channel_coded[ch]) {
205             init_exp(s, ch, fixed_exp);
206         }
207     }
208
209     for (ch = 0; ch < s->avctx->channels; ch++) {
210         if (s->channel_coded[ch]) {
211             WMACoef *coefs1;
212             float *coefs, *exponents, mult;
213             int i, n;
214
215             coefs1 = s->coefs1[ch];
216             exponents = s->exponents[ch];
217             mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
218             mult *= mdct_norm;
219             coefs = src_coefs[ch];
220             if (s->use_noise_coding && 0) {
221                 assert(0); //FIXME not implemented
222             } else {
223                 coefs += s->coefs_start;
224                 n = nb_coefs[ch];
225                 for(i = 0;i < n; i++){
226                     double t= *coefs++ / (exponents[i] * mult);
227                     if(t<-32768 || t>32767)
228                         return -1;
229
230                     coefs1[i] = lrint(t);
231                 }
232             }
233         }
234     }
235
236     v = 0;
237     for (ch = 0; ch < s->avctx->channels; ch++) {
238         int a = s->channel_coded[ch];
239         put_bits(&s->pb, 1, a);
240         v |= a;
241     }
242
243     if (!v)
244         return 1;
245
246     for(v= total_gain-1; v>=127; v-= 127)
247         put_bits(&s->pb, 7, 127);
248     put_bits(&s->pb, 7, v);
249
250     coef_nb_bits= ff_wma_total_gain_to_bits(total_gain);
251
252     if (s->use_noise_coding) {
253         for (ch = 0; ch < s->avctx->channels; ch++) {
254             if (s->channel_coded[ch]) {
255                 int i, n;
256                 n = s->exponent_high_sizes[bsize];
257                 for(i=0;i<n;i++) {
258                     put_bits(&s->pb, 1, s->high_band_coded[ch][i]= 0);
259                     if (0)
260                         nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
261                 }
262             }
263         }
264     }
265
266     parse_exponents = 1;
267     if (s->block_len_bits != s->frame_len_bits) {
268         put_bits(&s->pb, 1, parse_exponents);
269     }
270
271     if (parse_exponents) {
272         for (ch = 0; ch < s->avctx->channels; ch++) {
273             if (s->channel_coded[ch]) {
274                 if (s->use_exp_vlc) {
275                     encode_exp_vlc(s, ch, fixed_exp);
276                 } else {
277                     assert(0); //FIXME not implemented
278 //                    encode_exp_lsp(s, ch);
279                 }
280             }
281         }
282     } else {
283         assert(0); //FIXME not implemented
284     }
285
286     for (ch = 0; ch < s->avctx->channels; ch++) {
287         if (s->channel_coded[ch]) {
288             int run, tindex;
289             WMACoef *ptr, *eptr;
290             tindex = (ch == 1 && s->ms_stereo);
291             ptr = &s->coefs1[ch][0];
292             eptr = ptr + nb_coefs[ch];
293
294             run=0;
295             for(;ptr < eptr; ptr++){
296                 if(*ptr){
297                     int level= *ptr;
298                     int abs_level= FFABS(level);
299                     int code= 0;
300                     if(abs_level <= s->coef_vlcs[tindex]->max_level){
301                         if(run < s->coef_vlcs[tindex]->levels[abs_level-1])
302                             code= run + s->int_table[tindex][abs_level-1];
303                     }
304
305                     assert(code < s->coef_vlcs[tindex]->n);
306                     put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]);
307
308                     if(code == 0){
309                         if(1<<coef_nb_bits <= abs_level)
310                             return -1;
311
312                         put_bits(&s->pb, coef_nb_bits, abs_level);
313                         put_bits(&s->pb, s->frame_len_bits, run);
314                     }
315                     put_bits(&s->pb, 1, level < 0); //FIXME the sign is fliped somewhere
316                     run=0;
317                 }else{
318                     run++;
319                 }
320             }
321             if(run)
322                 put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1], s->coef_vlcs[tindex]->huffcodes[1]);
323         }
324         if (s->version == 1 && s->avctx->channels >= 2) {
325             avpriv_align_put_bits(&s->pb);
326         }
327     }
328     return 0;
329 }
330
331 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){
332     init_put_bits(&s->pb, buf, buf_size);
333
334     if (s->use_bit_reservoir) {
335         assert(0);//FIXME not implemented
336     }else{
337         if(encode_block(s, src_coefs, total_gain) < 0)
338             return INT_MAX;
339     }
340
341     avpriv_align_put_bits(&s->pb);
342
343     return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
344 }
345
346 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
347                              const AVFrame *frame, int *got_packet_ptr)
348 {
349     WMACodecContext *s = avctx->priv_data;
350     int i, total_gain, ret;
351
352     s->block_len_bits= s->frame_len_bits; //required by non variable block len
353     s->block_len = 1 << s->block_len_bits;
354
355     apply_window_and_mdct(avctx, frame);
356
357     if (s->ms_stereo) {
358         float a, b;
359         int i;
360
361         for(i = 0; i < s->block_len; i++) {
362             a = s->coefs[0][i]*0.5;
363             b = s->coefs[1][i]*0.5;
364             s->coefs[0][i] = a + b;
365             s->coefs[1][i] = a - b;
366         }
367     }
368
369     if ((ret = ff_alloc_packet(avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE))) {
370         av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
371         return ret;
372     }
373
374 #if 1
375     total_gain= 128;
376     for(i=64; i; i>>=1){
377         int error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
378                                  total_gain - i);
379         if(error<0)
380             total_gain-= i;
381     }
382 #else
383     total_gain= 90;
384     best = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain);
385     for(i=32; i; i>>=1){
386         int scoreL = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain - i);
387         int scoreR = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain + i);
388         av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain);
389         if(scoreL < FFMIN(best, scoreR)){
390             best = scoreL;
391             total_gain -= i;
392         }else if(scoreR < best){
393             best = scoreR;
394             total_gain += i;
395         }
396     }
397 #endif
398
399     if ((i = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain)) >= 0) {
400         av_log(avctx, AV_LOG_ERROR, "required frame size too large. please "
401                "use a higher bit rate.\n");
402         return AVERROR(EINVAL);
403     }
404     assert((put_bits_count(&s->pb) & 7) == 0);
405     while (i++)
406         put_bits(&s->pb, 8, 'N');
407
408     flush_put_bits(&s->pb);
409
410     if (frame->pts != AV_NOPTS_VALUE)
411         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
412
413     avpkt->size = avctx->block_align;
414     *got_packet_ptr = 1;
415     return 0;
416 }
417
418 AVCodec ff_wmav1_encoder = {
419     .name           = "wmav1",
420     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
421     .type           = AVMEDIA_TYPE_AUDIO,
422     .id             = AV_CODEC_ID_WMAV1,
423     .priv_data_size = sizeof(WMACodecContext),
424     .init           = encode_init,
425     .encode2        = encode_superframe,
426     .close          = ff_wma_end,
427     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
428                                                      AV_SAMPLE_FMT_NONE },
429 };
430
431 AVCodec ff_wmav2_encoder = {
432     .name           = "wmav2",
433     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
434     .type           = AVMEDIA_TYPE_AUDIO,
435     .id             = AV_CODEC_ID_WMAV2,
436     .priv_data_size = sizeof(WMACodecContext),
437     .init           = encode_init,
438     .encode2        = encode_superframe,
439     .close          = ff_wma_end,
440     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
441                                                      AV_SAMPLE_FMT_NONE },
442 };