FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wmaenc.c
Go to the documentation of this file.
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 
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 
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);
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 */
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)
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 
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,
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,
437 };
438 #endif