Merge commit '284ea790d89441fa1e6b2d72d3c1ed6d61972f0b'
[ffmpeg.git] / libavcodec / wmaenc.c
1 /*
2  * WMA compatible encoder
3  * Copyright (c) 2007 Michael Niedermayer
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include "avcodec.h"
23 #include "internal.h"
24 #include "wma.h"
25 #include "libavutil/avassert.h"
26
27
28 static int encode_init(AVCodecContext * avctx){
29     WMACodecContext *s = avctx->priv_data;
30     int i, flags1, flags2, block_align;
31     uint8_t *extradata;
32
33     s->avctx = avctx;
34
35     if(avctx->channels > MAX_CHANNELS) {
36         av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
37                avctx->channels, MAX_CHANNELS);
38         return AVERROR(EINVAL);
39     }
40
41     if (avctx->sample_rate > 48000) {
42         av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz",
43                avctx->sample_rate);
44         return AVERROR(EINVAL);
45     }
46
47     if(avctx->bit_rate < 24*1000) {
48         av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
49                avctx->bit_rate);
50         return AVERROR(EINVAL);
51     }
52
53     /* extract flag infos */
54     flags1 = 0;
55     flags2 = 1;
56     if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
57         extradata= av_malloc(4);
58         avctx->extradata_size= 4;
59         AV_WL16(extradata, flags1);
60         AV_WL16(extradata+2, flags2);
61     } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
62         extradata= av_mallocz(10);
63         avctx->extradata_size= 10;
64         AV_WL32(extradata, flags1);
65         AV_WL16(extradata+4, flags2);
66     }else
67         av_assert0(0);
68     avctx->extradata= extradata;
69     s->use_exp_vlc = flags2 & 0x0001;
70     s->use_bit_reservoir = flags2 & 0x0002;
71     s->use_variable_block_len = flags2 & 0x0004;
72     if (avctx->channels == 2)
73         s->ms_stereo = 1;
74
75     ff_wma_init(avctx, flags2);
76
77     /* init MDCT */
78     for(i = 0; i < s->nb_block_sizes; i++)
79         ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
80
81     block_align        = avctx->bit_rate * (int64_t)s->frame_len /
82                          (avctx->sample_rate * 8);
83     block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
84     avctx->block_align = block_align;
85
86     avctx->frame_size = avctx->delay = s->frame_len;
87
88 #if FF_API_OLD_ENCODE_AUDIO
89     avctx->coded_frame = &s->frame;
90     avcodec_get_frame_defaults(avctx->coded_frame);
91 #endif
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->dsp.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         av_assert0(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         av_assert1(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         av_assert0(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                 av_assert0(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                     av_assert0(0); //FIXME not implemented
278 //                    encode_exp_lsp(s, ch);
279                 }
280             }
281         }
282     } else {
283         av_assert0(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                     av_assert2(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         av_assert0(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, error;
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_packet2(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)))
370         return ret;
371
372     total_gain= 128;
373     for(i=64; i; i>>=1){
374         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
375                                  total_gain - i);
376         if(error<=0)
377             total_gain-= i;
378     }
379
380     while(total_gain <= 128 && error > 0)
381         error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
382     av_assert0((put_bits_count(&s->pb) & 7) == 0);
383     i= avctx->block_align - (put_bits_count(&s->pb)+7)/8;
384     av_assert0(i>=0);
385     while(i--)
386         put_bits(&s->pb, 8, 'N');
387
388     flush_put_bits(&s->pb);
389     av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
390
391     if (frame->pts != AV_NOPTS_VALUE)
392         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
393
394     avpkt->size = avctx->block_align;
395     *got_packet_ptr = 1;
396     return 0;
397 }
398
399 #if CONFIG_WMAV1_ENCODER
400 AVCodec ff_wmav1_encoder = {
401     .name           = "wmav1",
402     .type           = AVMEDIA_TYPE_AUDIO,
403     .id             = AV_CODEC_ID_WMAV1,
404     .priv_data_size = sizeof(WMACodecContext),
405     .init           = encode_init,
406     .encode2        = encode_superframe,
407     .close          = ff_wma_end,
408     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
409                                                      AV_SAMPLE_FMT_NONE },
410     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
411 };
412 #endif
413 #if CONFIG_WMAV2_ENCODER
414 AVCodec ff_wmav2_encoder = {
415     .name           = "wmav2",
416     .type           = AVMEDIA_TYPE_AUDIO,
417     .id             = AV_CODEC_ID_WMAV2,
418     .priv_data_size = sizeof(WMACodecContext),
419     .init           = encode_init,
420     .encode2        = encode_superframe,
421     .close          = ff_wma_end,
422     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
423                                                      AV_SAMPLE_FMT_NONE },
424     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
425 };
426 #endif