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