FFmpeg  4.4.6
wma.c
Go to the documentation of this file.
1 /*
2  * WMA compatible codec
3  * Copyright (c) 2002-2007 The FFmpeg Project
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 "sinewin.h"
27 #include "wma.h"
28 #include "wma_common.h"
29 #include "wma_freqs.h"
30 #include "wmadata.h"
31 
32 /* XXX: use same run/length optimization as mpeg decoders */
33 // FIXME maybe split decode / encode or pass flag
34 static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table,
35  float **plevel_table, uint16_t **pint_table,
36  const CoefVLCTable *vlc_table)
37 {
38  int n = vlc_table->n;
39  const uint8_t *table_bits = vlc_table->huffbits;
40  const uint32_t *table_codes = vlc_table->huffcodes;
41  const uint16_t *levels_table = vlc_table->levels;
42  uint16_t *run_table, *int_table;
43  float *flevel_table;
44  int i, l, j, k, level;
45 
46  init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
47 
48  run_table = av_malloc_array(n, sizeof(uint16_t));
49  flevel_table = av_malloc_array(n, sizeof(*flevel_table));
50  int_table = av_malloc_array(n, sizeof(uint16_t));
51  if (!run_table || !flevel_table || !int_table) {
52  av_freep(&run_table);
53  av_freep(&flevel_table);
54  av_freep(&int_table);
55  return AVERROR(ENOMEM);
56  }
57  i = 2;
58  level = 1;
59  k = 0;
60  while (i < n) {
61  int_table[k] = i;
62  l = levels_table[k++];
63  for (j = 0; j < l; j++) {
64  run_table[i] = j;
65  flevel_table[i] = level;
66  i++;
67  }
68  level++;
69  }
70  *prun_table = run_table;
71  *plevel_table = flevel_table;
72  *pint_table = int_table;
73 
74  return 0;
75 }
76 
77 av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
78 {
79  WMACodecContext *s = avctx->priv_data;
80  int i, ret;
81  float bps1, high_freq;
82  volatile float bps;
83  int sample_rate1;
84  int coef_vlc_table;
85 
86  if (avctx->sample_rate <= 0 || avctx->sample_rate > 50000 ||
87  avctx->channels <= 0 || avctx->channels > 2 ||
88  avctx->bit_rate <= 0)
89  return -1;
90 
91 
92  if (avctx->codec->id == AV_CODEC_ID_WMAV1)
93  s->version = 1;
94  else
95  s->version = 2;
96 
97  /* compute MDCT block size */
98  s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
99  s->version, 0);
100  s->next_block_len_bits = s->frame_len_bits;
101  s->prev_block_len_bits = s->frame_len_bits;
102  s->block_len_bits = s->frame_len_bits;
103 
104  s->frame_len = 1 << s->frame_len_bits;
105  if (s->use_variable_block_len) {
106  int nb_max, nb;
107  nb = ((flags2 >> 3) & 3) + 1;
108  if ((avctx->bit_rate / avctx->channels) >= 32000)
109  nb += 2;
110  nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
111  if (nb > nb_max)
112  nb = nb_max;
113  s->nb_block_sizes = nb + 1;
114  } else
115  s->nb_block_sizes = 1;
116 
117  /* init rate dependent parameters */
118  s->use_noise_coding = 1;
119  high_freq = avctx->sample_rate * 0.5;
120 
121  /* if version 2, then the rates are normalized */
122  sample_rate1 = avctx->sample_rate;
123  if (s->version == 2) {
124  if (sample_rate1 >= 44100)
125  sample_rate1 = 44100;
126  else if (sample_rate1 >= 22050)
127  sample_rate1 = 22050;
128  else if (sample_rate1 >= 16000)
129  sample_rate1 = 16000;
130  else if (sample_rate1 >= 11025)
131  sample_rate1 = 11025;
132  else if (sample_rate1 >= 8000)
133  sample_rate1 = 8000;
134  }
135 
136  bps = (float) avctx->bit_rate /
137  (float) (avctx->channels * avctx->sample_rate);
138  s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
139  if (s->byte_offset_bits + 3 > MIN_CACHE_BITS) {
140  av_log(avctx, AV_LOG_ERROR, "byte_offset_bits %d is too large\n", s->byte_offset_bits);
141  return AVERROR_PATCHWELCOME;
142  }
143 
144  /* compute high frequency value and choose if noise coding should
145  * be activated */
146  bps1 = bps;
147  if (avctx->channels == 2)
148  bps1 = bps * 1.6;
149  if (sample_rate1 == 44100) {
150  if (bps1 >= 0.61)
151  s->use_noise_coding = 0;
152  else
153  high_freq = high_freq * 0.4;
154  } else if (sample_rate1 == 22050) {
155  if (bps1 >= 1.16)
156  s->use_noise_coding = 0;
157  else if (bps1 >= 0.72)
158  high_freq = high_freq * 0.7;
159  else
160  high_freq = high_freq * 0.6;
161  } else if (sample_rate1 == 16000) {
162  if (bps > 0.5)
163  high_freq = high_freq * 0.5;
164  else
165  high_freq = high_freq * 0.3;
166  } else if (sample_rate1 == 11025)
167  high_freq = high_freq * 0.7;
168  else if (sample_rate1 == 8000) {
169  if (bps <= 0.625)
170  high_freq = high_freq * 0.5;
171  else if (bps > 0.75)
172  s->use_noise_coding = 0;
173  else
174  high_freq = high_freq * 0.65;
175  } else {
176  if (bps >= 0.8)
177  high_freq = high_freq * 0.75;
178  else if (bps >= 0.6)
179  high_freq = high_freq * 0.6;
180  else
181  high_freq = high_freq * 0.5;
182  }
183  ff_dlog(s->avctx, "flags2=0x%x\n", flags2);
184  ff_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%"PRId64" block_align=%d\n",
185  s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
186  avctx->block_align);
187  ff_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
188  bps, bps1, high_freq, s->byte_offset_bits);
189  ff_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
190  s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
191 
192  /* compute the scale factor band sizes for each MDCT block size */
193  {
194  int a, b, pos, lpos, k, block_len, i, j, n;
195  const uint8_t *table;
196 
197  if (s->version == 1)
198  s->coefs_start = 3;
199  else
200  s->coefs_start = 0;
201  for (k = 0; k < s->nb_block_sizes; k++) {
202  block_len = s->frame_len >> k;
203 
204  if (s->version == 1) {
205  lpos = 0;
206  for (i = 0; i < 25; i++) {
208  b = avctx->sample_rate;
209  pos = ((block_len * 2 * a) + (b >> 1)) / b;
210  if (pos > block_len)
211  pos = block_len;
212  s->exponent_bands[0][i] = pos - lpos;
213  if (pos >= block_len) {
214  i++;
215  break;
216  }
217  lpos = pos;
218  }
219  s->exponent_sizes[0] = i;
220  } else {
221  /* hardcoded tables */
222  table = NULL;
223  a = s->frame_len_bits - BLOCK_MIN_BITS - k;
224  if (a < 3) {
225  if (avctx->sample_rate >= 44100)
227  else if (avctx->sample_rate >= 32000)
229  else if (avctx->sample_rate >= 22050)
231  }
232  if (table) {
233  n = *table++;
234  for (i = 0; i < n; i++)
235  s->exponent_bands[k][i] = table[i];
236  s->exponent_sizes[k] = n;
237  } else {
238  j = 0;
239  lpos = 0;
240  for (i = 0; i < 25; i++) {
242  b = avctx->sample_rate;
243  pos = ((block_len * 2 * a) + (b << 1)) / (4 * b);
244  pos <<= 2;
245  if (pos > block_len)
246  pos = block_len;
247  if (pos > lpos)
248  s->exponent_bands[k][j++] = pos - lpos;
249  if (pos >= block_len)
250  break;
251  lpos = pos;
252  }
253  s->exponent_sizes[k] = j;
254  }
255  }
256 
257  /* max number of coefs */
258  s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
259  /* high freq computation */
260  s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /
261  avctx->sample_rate + 0.5);
262  n = s->exponent_sizes[k];
263  j = 0;
264  pos = 0;
265  for (i = 0; i < n; i++) {
266  int start, end;
267  start = pos;
268  pos += s->exponent_bands[k][i];
269  end = pos;
270  if (start < s->high_band_start[k])
271  start = s->high_band_start[k];
272  if (end > s->coefs_end[k])
273  end = s->coefs_end[k];
274  if (end > start)
275  s->exponent_high_bands[k][j++] = end - start;
276  }
277  s->exponent_high_sizes[k] = j;
278  }
279  }
280 
281 #ifdef TRACE
282  {
283  int i, j;
284  for (i = 0; i < s->nb_block_sizes; i++) {
285  ff_tlog(s->avctx, "%5d: n=%2d:",
286  s->frame_len >> i,
287  s->exponent_sizes[i]);
288  for (j = 0; j < s->exponent_sizes[i]; j++)
289  ff_tlog(s->avctx, " %d", s->exponent_bands[i][j]);
290  ff_tlog(s->avctx, "\n");
291  }
292  }
293 #endif /* TRACE */
294 
295  /* init MDCT windows : simple sine window */
296  for (i = 0; i < s->nb_block_sizes; i++) {
297  ff_init_ff_sine_windows(s->frame_len_bits - i);
298  s->windows[i] = ff_sine_windows[s->frame_len_bits - i];
299  }
300 
301  s->reset_block_lengths = 1;
302 
303  if (s->use_noise_coding) {
304  /* init the noise generator */
305  if (s->use_exp_vlc)
306  s->noise_mult = 0.02;
307  else
308  s->noise_mult = 0.04;
309 
310 #ifdef TRACE
311  for (i = 0; i < NOISE_TAB_SIZE; i++)
312  s->noise_table[i] = 1.0 * s->noise_mult;
313 #else
314  {
315  unsigned int seed;
316  float norm;
317  seed = 1;
318  norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;
319  for (i = 0; i < NOISE_TAB_SIZE; i++) {
320  seed = seed * 314159 + 1;
321  s->noise_table[i] = (float) ((int) seed) * norm;
322  }
323  }
324 #endif /* TRACE */
325  }
326 
327  s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
328  if (!s->fdsp)
329  return AVERROR(ENOMEM);
330 
331  /* choose the VLC tables for the coefficients */
332  coef_vlc_table = 2;
333  if (avctx->sample_rate >= 32000) {
334  if (bps1 < 0.72)
335  coef_vlc_table = 0;
336  else if (bps1 < 1.16)
337  coef_vlc_table = 1;
338  }
339  s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
340  s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
341  ret = init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
342  &s->int_table[0], s->coef_vlcs[0]);
343  if (ret < 0)
344  return ret;
345 
346  return init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
347  &s->int_table[1], s->coef_vlcs[1]);
348 }
349 
350 int ff_wma_total_gain_to_bits(int total_gain)
351 {
352  if (total_gain < 15)
353  return 13;
354  else if (total_gain < 32)
355  return 12;
356  else if (total_gain < 40)
357  return 11;
358  else if (total_gain < 45)
359  return 10;
360  else
361  return 9;
362 }
363 
365 {
366  WMACodecContext *s = avctx->priv_data;
367  int i;
368 
369  for (i = 0; i < s->nb_block_sizes; i++)
370  ff_mdct_end(&s->mdct_ctx[i]);
371 
372  if (s->use_exp_vlc)
373  ff_free_vlc(&s->exp_vlc);
374  if (s->use_noise_coding)
375  ff_free_vlc(&s->hgain_vlc);
376  for (i = 0; i < 2; i++) {
377  ff_free_vlc(&s->coef_vlc[i]);
378  av_freep(&s->run_table[i]);
379  av_freep(&s->level_table[i]);
380  av_freep(&s->int_table[i]);
381  }
382  av_freep(&s->fdsp);
383 
384  return 0;
385 }
386 
387 /**
388  * Decode an uncompressed coefficient.
389  * @param gb GetBitContext
390  * @return the decoded coefficient
391  */
393 {
394  /** consumes up to 34 bits */
395  int n_bits = 8;
396  /** decode length */
397  if (get_bits1(gb)) {
398  n_bits += 8;
399  if (get_bits1(gb)) {
400  n_bits += 8;
401  if (get_bits1(gb))
402  n_bits += 7;
403  }
404  }
405  return get_bits_long(gb, n_bits);
406 }
407 
408 /**
409  * Decode run level compressed coefficients.
410  * @param avctx codec context
411  * @param gb bitstream reader context
412  * @param vlc vlc table for get_vlc2
413  * @param level_table level codes
414  * @param run_table run codes
415  * @param version 0 for wma1,2 1 for wmapro
416  * @param ptr output buffer
417  * @param offset offset in the output buffer
418  * @param num_coefs number of input coefficients
419  * @param block_len input buffer length (2^n)
420  * @param frame_len_bits number of bits for escaped run codes
421  * @param coef_nb_bits number of bits for escaped level codes
422  * @return 0 on success, -1 otherwise
423  */
425  VLC *vlc, const float *level_table,
426  const uint16_t *run_table, int version,
427  WMACoef *ptr, int offset, int num_coefs,
428  int block_len, int frame_len_bits,
429  int coef_nb_bits)
430 {
431  int code, level, sign;
432  const uint32_t *ilvl = (const uint32_t *) level_table;
433  uint32_t *iptr = (uint32_t *) ptr;
434  const unsigned int coef_mask = block_len - 1;
435  for (; offset < num_coefs; offset++) {
436  code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX);
437  if (code > 1) {
438  /** normal code */
439  offset += run_table[code];
440  sign = get_bits1(gb) - 1;
441  iptr[offset & coef_mask] = ilvl[code] ^ (sign & 0x80000000);
442  } else if (code == 1) {
443  /** EOB */
444  break;
445  } else {
446  /** escape */
447  if (!version) {
448  level = get_bits(gb, coef_nb_bits);
449  /** NOTE: this is rather suboptimal. reading
450  * block_len_bits would be better */
451  offset += get_bits(gb, frame_len_bits);
452  } else {
454  /** escape decode */
455  if (get_bits1(gb)) {
456  if (get_bits1(gb)) {
457  if (get_bits1(gb)) {
458  av_log(avctx, AV_LOG_ERROR,
459  "broken escape sequence\n");
460  return AVERROR_INVALIDDATA;
461  } else
462  offset += get_bits(gb, frame_len_bits) + 4;
463  } else
464  offset += get_bits(gb, 2) + 1;
465  }
466  }
467  sign = get_bits1(gb) - 1;
468  ptr[offset & coef_mask] = (level ^ sign) - sign;
469  }
470  }
471  /** NOTE: EOB can be omitted */
472  if (offset > num_coefs) {
473  av_log(avctx, AV_LOG_ERROR,
474  "overflow (%d > %d) in spectral RLE, ignoring\n",
475  offset,
476  num_coefs
477  );
478  return AVERROR_INVALIDDATA;
479  }
480 
481  return 0;
482 }
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
#define s(width, name)
Definition: cbs_vp9.c:257
#define NULL
Definition: coverity.c:32
int
#define ff_mdct_end
Definition: fft.h:162
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define MIN_CACHE_BITS
Definition: get_bits.h:128
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:431
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int i
Definition: input.c:407
#define av_log2
Definition: intmath.h:83
#define ff_tlog(ctx,...)
Definition: internal.h:96
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
common internal API header
version
Definition: libkvazaar.c:326
unsigned bps
Definition: movenc.c:1612
static const uint16_t table[]
Definition: prosumer.c:206
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
const uint8_t * code
Definition: spdifenc.c:413
unsigned int pos
Definition: spdifenc.c:412
main external API structure.
Definition: avcodec.h:536
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
const struct AVCodec * codec
Definition: avcodec.h:545
int sample_rate
samples per second
Definition: avcodec.h:1196
int channels
number of audio channels
Definition: avcodec.h:1197
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1233
void * priv_data
Definition: avcodec.h:563
enum AVCodecID id
Definition: codec.h:211
const uint32_t * huffcodes
VLC bit values.
Definition: wma.h:63
const uint8_t * huffbits
VLC bit size.
Definition: wma.h:64
int n
total number of codes
Definition: wma.h:61
const uint16_t * levels
table to build run/level tables
Definition: wma.h:65
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
uint8_t level
Definition: svq3.c:206
#define av_malloc_array(a, b)
#define ff_dlog(a,...)
#define av_freep(p)
#define av_log(a,...)
const char * b
Definition: vf_curves.c:118
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
static unsigned int seed
Definition: videogen.c:78
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:350
static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table, float **plevel_table, uint16_t **pint_table, const CoefVLCTable *vlc_table)
Definition: wma.c:34
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:77
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)
Decode run level compressed coefficients.
Definition: wma.c:424
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
Definition: wma.c:392
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:364
#define BLOCK_MIN_BITS
Definition: wma.h:34
#define VLCBITS
Definition: wma.h:55
#define NOISE_TAB_SIZE
Definition: wma.h:50
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:58
#define VLCMAX
Definition: wma.h:56
av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version, unsigned int decode_flags)
Get the samples per frame for this stream.
Definition: wma_common.c:32
const uint16_t ff_wma_critical_freqs[25]
Definition: wma_freqs.c:23
Various WMA tables.
static const uint8_t exponent_band_32000[3][25]
Definition: wmadata.h:42
static const uint8_t exponent_band_22050[3][25]
Definition: wmadata.h:35
static const CoefVLCTable coef_vlcs[6]
Definition: wmadata.h:1371
static const uint8_t exponent_band_44100[3][25]
Definition: wmadata.h:48