FFmpeg
vorbisdec.c
Go to the documentation of this file.
1 /**
2  * @file
3  * Vorbis I decoder
4  * @author Denes Balatoni ( dbalatoni programozo hu )
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Vorbis I decoder
26  * @author Denes Balatoni ( dbalatoni programozo hu )
27  */
28 
29 #include <inttypes.h>
30 #include <math.h>
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/float_dsp.h"
34 
35 #define BITSTREAM_READER_LE
36 #include "avcodec.h"
37 #include "codec_internal.h"
38 #include "fft.h"
39 #include "get_bits.h"
40 #include "internal.h"
41 #include "vorbis.h"
42 #include "vorbisdsp.h"
43 #include "xiph.h"
44 
45 #define V_NB_BITS 8
46 #define V_NB_BITS2 11
47 #define V_MAX_VLCS (1 << 16)
48 #define V_MAX_PARTITIONS (1 << 20)
49 
50 typedef struct vorbis_codebook {
51  uint8_t dimensions;
52  uint8_t lookup_type;
53  uint8_t maxdepth;
55  float *codevectors;
56  unsigned int nb_bits;
58 
59 typedef union vorbis_floor_u vorbis_floor_data;
60 typedef struct vorbis_floor0_s vorbis_floor0;
61 typedef struct vorbis_floor1_s vorbis_floor1;
62 struct vorbis_context_s;
63 typedef
65  (struct vorbis_context_s *, vorbis_floor_data *, float *);
66 typedef struct vorbis_floor {
67  uint8_t floor_type;
70  struct vorbis_floor0_s {
71  uint8_t order;
72  uint16_t rate;
73  uint16_t bark_map_size;
74  int32_t *map[2];
75  uint32_t map_size[2];
76  uint8_t amplitude_bits;
78  uint8_t num_books;
79  uint8_t *book_list;
80  float *lsp;
81  } t0;
82  struct vorbis_floor1_s {
83  uint8_t partitions;
84  uint8_t partition_class[32];
85  uint8_t class_dimensions[16];
86  uint8_t class_subclasses[16];
87  uint8_t class_masterbook[16];
88  int16_t subclass_books[16][8];
89  uint8_t multiplier;
90  uint16_t x_list_dim;
92  } t1;
93  } data;
94 } vorbis_floor;
95 
96 typedef struct vorbis_residue {
97  uint16_t type;
98  uint32_t begin;
99  uint32_t end;
100  unsigned partition_size;
102  uint8_t classbook;
103  int16_t books[64][8];
104  uint8_t maxpass;
105  uint16_t ptns_to_read;
106  uint8_t *classifs;
108 
109 typedef struct vorbis_mapping {
110  uint8_t submaps;
111  uint16_t coupling_steps;
112  uint8_t *magnitude;
113  uint8_t *angle;
114  uint8_t *mux;
115  uint8_t submap_floor[16];
116  uint8_t submap_residue[16];
118 
119 typedef struct vorbis_mode {
120  uint8_t blockflag;
121  uint16_t windowtype;
122  uint16_t transformtype;
123  uint8_t mapping;
124 } vorbis_mode;
125 
126 typedef struct vorbis_context_s {
131 
133  uint8_t first_frame;
134  uint32_t version;
135  uint8_t audio_channels;
137  uint32_t bitrate_maximum;
138  uint32_t bitrate_nominal;
139  uint32_t bitrate_minimum;
140  uint32_t blocksize[2];
141  const float *win[2];
142  uint16_t codebook_count;
144  uint8_t floor_count;
146  uint8_t residue_count;
148  uint8_t mapping_count;
150  uint8_t mode_count;
152  uint8_t mode_number; // mode number for the current packet
155  float *saved;
156 } vorbis_context;
157 
158 /* Helper functions */
159 
160 #define BARK(x) \
161  (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))
162 
163 static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
164 #define VALIDATE_INDEX(idx, limit) \
165  if (idx >= limit) {\
166  av_log(vc->avctx, AV_LOG_ERROR,\
167  idx_err_str,\
168  (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
169  return AVERROR_INVALIDDATA;\
170  }
171 #define GET_VALIDATED_INDEX(idx, bits, limit) \
172  {\
173  idx = get_bits(gb, bits);\
174  VALIDATE_INDEX(idx, limit)\
175  }
176 
177 static float vorbisfloat2float(unsigned val)
178 {
179  double mant = val & 0x1fffff;
180  long exp = (val & 0x7fe00000L) >> 21;
181  if (val & 0x80000000)
182  mant = -mant;
183  return ldexp(mant, exp - 20 - 768);
184 }
185 
186 
187 // Free all allocated memory -----------------------------------------
188 
189 static void vorbis_free(vorbis_context *vc)
190 {
191  int i;
192 
193  av_freep(&vc->channel_residues);
194  av_freep(&vc->saved);
195  av_freep(&vc->fdsp);
196 
197  if (vc->residues)
198  for (i = 0; i < vc->residue_count; i++)
199  av_freep(&vc->residues[i].classifs);
200  av_freep(&vc->residues);
201  av_freep(&vc->modes);
202 
203  ff_mdct_end(&vc->mdct[0]);
204  ff_mdct_end(&vc->mdct[1]);
205 
206  if (vc->codebooks)
207  for (i = 0; i < vc->codebook_count; ++i) {
208  av_freep(&vc->codebooks[i].codevectors);
209  ff_free_vlc(&vc->codebooks[i].vlc);
210  }
211  av_freep(&vc->codebooks);
212 
213  if (vc->floors)
214  for (i = 0; i < vc->floor_count; ++i) {
215  if (vc->floors[i].floor_type == 0) {
216  av_freep(&vc->floors[i].data.t0.map[0]);
217  av_freep(&vc->floors[i].data.t0.map[1]);
218  av_freep(&vc->floors[i].data.t0.book_list);
219  av_freep(&vc->floors[i].data.t0.lsp);
220  } else {
221  av_freep(&vc->floors[i].data.t1.list);
222  }
223  }
224  av_freep(&vc->floors);
225 
226  if (vc->mappings)
227  for (i = 0; i < vc->mapping_count; ++i) {
228  av_freep(&vc->mappings[i].magnitude);
229  av_freep(&vc->mappings[i].angle);
230  av_freep(&vc->mappings[i].mux);
231  }
232  av_freep(&vc->mappings);
233 }
234 
235 // Parse setup header -------------------------------------------------
236 
237 // Process codebooks part
238 
239 static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
240 {
241  unsigned cb;
242  uint8_t *tmp_vlc_bits = NULL;
243  uint32_t *tmp_vlc_codes = NULL;
244  GetBitContext *gb = &vc->gb;
245  uint16_t *codebook_multiplicands = NULL;
246  int ret = 0;
247 
248  vc->codebook_count = get_bits(gb, 8) + 1;
249 
250  ff_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);
251 
252  vc->codebooks = av_mallocz(vc->codebook_count * sizeof(*vc->codebooks));
253  tmp_vlc_bits = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_bits));
254  tmp_vlc_codes = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_codes));
255  codebook_multiplicands = av_malloc(V_MAX_VLCS * sizeof(*codebook_multiplicands));
256  if (!vc->codebooks ||
257  !tmp_vlc_bits || !tmp_vlc_codes || !codebook_multiplicands) {
258  ret = AVERROR(ENOMEM);
259  goto error;
260  }
261 
262  for (cb = 0; cb < vc->codebook_count; ++cb) {
263  vorbis_codebook *codebook_setup = &vc->codebooks[cb];
264  unsigned ordered, t, entries, used_entries = 0;
265 
266  ff_dlog(NULL, " %u. Codebook\n", cb);
267 
268  if (get_bits(gb, 24) != 0x564342) {
269  av_log(vc->avctx, AV_LOG_ERROR,
270  " %u. Codebook setup data corrupt.\n", cb);
272  goto error;
273  }
274 
275  codebook_setup->dimensions=get_bits(gb, 16);
276  if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {
277  av_log(vc->avctx, AV_LOG_ERROR,
278  " %u. Codebook's dimension is invalid (%d).\n",
279  cb, codebook_setup->dimensions);
281  goto error;
282  }
283  entries = get_bits(gb, 24);
284  if (entries > V_MAX_VLCS) {
285  av_log(vc->avctx, AV_LOG_ERROR,
286  " %u. Codebook has too many entries (%u).\n",
287  cb, entries);
289  goto error;
290  }
291 
292  ordered = get_bits1(gb);
293 
294  ff_dlog(NULL, " codebook_dimensions %d, codebook_entries %u\n",
295  codebook_setup->dimensions, entries);
296 
297  if (!ordered) {
298  unsigned ce, flag;
299  unsigned sparse = get_bits1(gb);
300 
301  ff_dlog(NULL, " not ordered \n");
302 
303  if (sparse) {
304  ff_dlog(NULL, " sparse \n");
305 
306  used_entries = 0;
307  for (ce = 0; ce < entries; ++ce) {
308  flag = get_bits1(gb);
309  if (flag) {
310  tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
311  ++used_entries;
312  } else
313  tmp_vlc_bits[ce] = 0;
314  }
315  } else {
316  ff_dlog(NULL, " not sparse \n");
317 
318  used_entries = entries;
319  for (ce = 0; ce < entries; ++ce)
320  tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
321  }
322  } else {
323  unsigned current_entry = 0;
324  unsigned current_length = get_bits(gb, 5) + 1;
325 
326  ff_dlog(NULL, " ordered, current length: %u\n", current_length); //FIXME
327 
328  used_entries = entries;
329  for (; current_entry < used_entries && current_length <= 32; ++current_length) {
330  unsigned i, number;
331 
332  ff_dlog(NULL, " number bits: %u ", ilog(entries - current_entry));
333 
334  number = get_bits(gb, ilog(entries - current_entry));
335 
336  ff_dlog(NULL, " number: %u\n", number);
337 
338  for (i = current_entry; i < number+current_entry; ++i)
339  if (i < used_entries)
340  tmp_vlc_bits[i] = current_length;
341 
342  current_entry+=number;
343  }
344  if (current_entry>used_entries) {
345  av_log(vc->avctx, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
347  goto error;
348  }
349  }
350 
351  codebook_setup->lookup_type = get_bits(gb, 4);
352 
353  ff_dlog(NULL, " lookup type: %d : %s \n", codebook_setup->lookup_type,
354  codebook_setup->lookup_type ? "vq" : "no lookup");
355 
356 // If the codebook is used for (inverse) VQ, calculate codevectors.
357 
358  if (codebook_setup->lookup_type == 1) {
359  unsigned i, j, k;
360  unsigned codebook_lookup_values = ff_vorbis_nth_root(entries, codebook_setup->dimensions);
361 
362  float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb, 32));
363  float codebook_delta_value = vorbisfloat2float(get_bits_long(gb, 32));
364  unsigned codebook_value_bits = get_bits(gb, 4) + 1;
365  unsigned codebook_sequence_p = get_bits1(gb);
366 
367  ff_dlog(NULL, " We expect %d numbers for building the codevectors. \n",
368  codebook_lookup_values);
369  ff_dlog(NULL, " delta %f minmum %f \n",
370  codebook_delta_value, codebook_minimum_value);
371 
372  for (i = 0; i < codebook_lookup_values; ++i) {
373  codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);
374 
375  ff_dlog(NULL, " multiplicands*delta+minmum : %e \n",
376  (float)codebook_multiplicands[i] * codebook_delta_value + codebook_minimum_value);
377  ff_dlog(NULL, " multiplicand %u\n", codebook_multiplicands[i]);
378  }
379 
380 // Weed out unused vlcs and build codevector vector
381  if (used_entries) {
382  codebook_setup->codevectors =
383  av_calloc(used_entries, codebook_setup->dimensions *
384  sizeof(*codebook_setup->codevectors));
385  if (!codebook_setup->codevectors) {
386  ret = AVERROR(ENOMEM);
387  goto error;
388  }
389  } else
390  codebook_setup->codevectors = NULL;
391 
392  for (j = 0, i = 0; i < entries; ++i) {
393  unsigned dim = codebook_setup->dimensions;
394 
395  if (tmp_vlc_bits[i]) {
396  float last = 0.0;
397  unsigned lookup_offset = i;
398 
399  ff_dlog(vc->avctx, "Lookup offset %u ,", i);
400 
401  for (k = 0; k < dim; ++k) {
402  unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;
403  codebook_setup->codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last;
404  if (codebook_sequence_p)
405  last = codebook_setup->codevectors[j * dim + k];
406  lookup_offset/=codebook_lookup_values;
407  }
408  tmp_vlc_bits[j] = tmp_vlc_bits[i];
409 
410  ff_dlog(vc->avctx, "real lookup offset %u, vector: ", j);
411  for (k = 0; k < dim; ++k)
412  ff_dlog(vc->avctx, " %f ",
413  codebook_setup->codevectors[j * dim + k]);
414  ff_dlog(vc->avctx, "\n");
415 
416  ++j;
417  }
418  }
419  if (j != used_entries) {
420  av_log(vc->avctx, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
422  goto error;
423  }
424  entries = used_entries;
425  } else if (codebook_setup->lookup_type >= 2) {
426  av_log(vc->avctx, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
428  goto error;
429  }
430 
431 // Initialize VLC table
432  if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) {
433  av_log(vc->avctx, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
435  goto error;
436  }
437  codebook_setup->maxdepth = 0;
438  for (t = 0; t < entries; ++t)
439  if (tmp_vlc_bits[t] >= codebook_setup->maxdepth)
440  codebook_setup->maxdepth = tmp_vlc_bits[t];
441 
442  if (codebook_setup->maxdepth > 3 * V_NB_BITS)
443  codebook_setup->nb_bits = V_NB_BITS2;
444  else
445  codebook_setup->nb_bits = V_NB_BITS;
446 
447  codebook_setup->maxdepth = (codebook_setup->maxdepth+codebook_setup->nb_bits - 1) / codebook_setup->nb_bits;
448 
449  if ((ret = init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits,
450  entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits),
451  sizeof(*tmp_vlc_bits), tmp_vlc_codes,
452  sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes),
453  INIT_VLC_LE))) {
454  av_log(vc->avctx, AV_LOG_ERROR, " Error generating vlc tables. \n");
455  goto error;
456  }
457  }
458 
459  av_free(tmp_vlc_bits);
460  av_free(tmp_vlc_codes);
461  av_free(codebook_multiplicands);
462  return 0;
463 
464 // Error:
465 error:
466  av_free(tmp_vlc_bits);
467  av_free(tmp_vlc_codes);
468  av_free(codebook_multiplicands);
469  return ret;
470 }
471 
472 // Process time domain transforms part (unused in Vorbis I)
473 
474 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
475 {
476  GetBitContext *gb = &vc->gb;
477  unsigned i, vorbis_time_count = get_bits(gb, 6) + 1;
478 
479  for (i = 0; i < vorbis_time_count; ++i) {
480  unsigned vorbis_tdtransform = get_bits(gb, 16);
481 
482  ff_dlog(NULL, " Vorbis time domain transform %u: %u\n",
483  vorbis_time_count, vorbis_tdtransform);
484 
485  if (vorbis_tdtransform) {
486  av_log(vc->avctx, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
487  return AVERROR_INVALIDDATA;
488  }
489  }
490  return 0;
491 }
492 
493 // Process floors part
494 
495 static int vorbis_floor0_decode(vorbis_context *vc,
496  vorbis_floor_data *vfu, float *vec);
497 static int create_map(vorbis_context *vc, unsigned floor_number);
498 static int vorbis_floor1_decode(vorbis_context *vc,
499  vorbis_floor_data *vfu, float *vec);
500 static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
501 {
502  GetBitContext *gb = &vc->gb;
503  int i, j, k, ret;
504 
505  vc->floor_count = get_bits(gb, 6) + 1;
506 
507  vc->floors = av_mallocz(vc->floor_count * sizeof(*vc->floors));
508  if (!vc->floors)
509  return AVERROR(ENOMEM);
510 
511  for (i = 0; i < vc->floor_count; ++i) {
512  vorbis_floor *floor_setup = &vc->floors[i];
513 
514  floor_setup->floor_type = get_bits(gb, 16);
515 
516  ff_dlog(NULL, " %d. floor type %d \n", i, floor_setup->floor_type);
517 
518  if (floor_setup->floor_type == 1) {
519  int maximum_class = -1;
520  unsigned rangebits, rangemax, floor1_values = 2;
521 
522  floor_setup->decode = vorbis_floor1_decode;
523 
524  floor_setup->data.t1.partitions = get_bits(gb, 5);
525 
526  ff_dlog(NULL, " %d.floor: %d partitions \n",
527  i, floor_setup->data.t1.partitions);
528 
529  for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
530  floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);
531  if (floor_setup->data.t1.partition_class[j] > maximum_class)
532  maximum_class = floor_setup->data.t1.partition_class[j];
533 
534  ff_dlog(NULL, " %d. floor %d partition class %d \n",
535  i, j, floor_setup->data.t1.partition_class[j]);
536 
537  }
538 
539  ff_dlog(NULL, " maximum class %d \n", maximum_class);
540 
541  for (j = 0; j <= maximum_class; ++j) {
542  floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;
543  floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);
544 
545  ff_dlog(NULL, " %d floor %d class dim: %d subclasses %d \n", i, j,
546  floor_setup->data.t1.class_dimensions[j],
547  floor_setup->data.t1.class_subclasses[j]);
548 
549  if (floor_setup->data.t1.class_subclasses[j]) {
550  GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
551 
552  ff_dlog(NULL, " masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
553  }
554 
555  for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) {
556  int16_t bits = get_bits(gb, 8) - 1;
557  if (bits != -1)
558  VALIDATE_INDEX(bits, vc->codebook_count)
559  floor_setup->data.t1.subclass_books[j][k] = bits;
560 
561  ff_dlog(NULL, " book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
562  }
563  }
564 
565  floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1;
566  floor_setup->data.t1.x_list_dim = 2;
567 
568  for (j = 0; j < floor_setup->data.t1.partitions; ++j)
569  floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
570 
571  floor_setup->data.t1.list = av_calloc(floor_setup->data.t1.x_list_dim,
572  sizeof(*floor_setup->data.t1.list));
573  if (!floor_setup->data.t1.list)
574  return AVERROR(ENOMEM);
575 
576  rangebits = get_bits(gb, 4);
577  if (!rangebits && floor_setup->data.t1.partitions) {
578  av_log(vc->avctx, AV_LOG_ERROR,
579  "A rangebits value of 0 is not compliant with the Vorbis I specification.\n");
580  return AVERROR_INVALIDDATA;
581  }
582  rangemax = (1 << rangebits);
583  if (rangemax > vc->blocksize[1] / 2) {
584  av_log(vc->avctx, AV_LOG_ERROR,
585  "Floor value is too large for blocksize: %u (%"PRIu32")\n",
586  rangemax, vc->blocksize[1] / 2);
587  return AVERROR_INVALIDDATA;
588  }
589  floor_setup->data.t1.list[0].x = 0;
590  floor_setup->data.t1.list[1].x = rangemax;
591 
592  for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
593  for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) {
594  floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits);
595 
596  ff_dlog(NULL, " %u. floor1 Y coord. %d\n", floor1_values,
597  floor_setup->data.t1.list[floor1_values].x);
598  }
599  }
600 
601 // Precalculate order of x coordinates - needed for decode
602  if (ff_vorbis_ready_floor1_list(vc->avctx,
603  floor_setup->data.t1.list,
604  floor_setup->data.t1.x_list_dim)) {
605  return AVERROR_INVALIDDATA;
606  }
607  } else if (floor_setup->floor_type == 0) {
608  unsigned max_codebook_dim = 0;
609 
610  floor_setup->decode = vorbis_floor0_decode;
611 
612  floor_setup->data.t0.order = get_bits(gb, 8);
613  if (!floor_setup->data.t0.order) {
614  av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");
615  return AVERROR_INVALIDDATA;
616  }
617  floor_setup->data.t0.rate = get_bits(gb, 16);
618  if (!floor_setup->data.t0.rate) {
619  av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");
620  return AVERROR_INVALIDDATA;
621  }
622  floor_setup->data.t0.bark_map_size = get_bits(gb, 16);
623  if (!floor_setup->data.t0.bark_map_size) {
624  av_log(vc->avctx, AV_LOG_ERROR,
625  "Floor 0 bark map size is 0.\n");
626  return AVERROR_INVALIDDATA;
627  }
628  floor_setup->data.t0.amplitude_bits = get_bits(gb, 6);
629  floor_setup->data.t0.amplitude_offset = get_bits(gb, 8);
630  floor_setup->data.t0.num_books = get_bits(gb, 4) + 1;
631 
632  /* allocate mem for booklist */
633  floor_setup->data.t0.book_list =
634  av_malloc(floor_setup->data.t0.num_books);
635  if (!floor_setup->data.t0.book_list)
636  return AVERROR(ENOMEM);
637  /* read book indexes */
638  {
639  int idx;
640  unsigned book_idx;
641  for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
642  GET_VALIDATED_INDEX(book_idx, 8, vc->codebook_count)
643  floor_setup->data.t0.book_list[idx] = book_idx;
644  if (vc->codebooks[book_idx].dimensions > max_codebook_dim)
645  max_codebook_dim = vc->codebooks[book_idx].dimensions;
646  }
647  }
648 
649  if ((ret = create_map(vc, i)) < 0)
650  return ret;
651 
652  /* codebook dim is for padding if codebook dim doesn't *
653  * divide order+1 then we need to read more data */
654  floor_setup->data.t0.lsp =
655  av_malloc_array((floor_setup->data.t0.order + 1 + max_codebook_dim),
656  sizeof(*floor_setup->data.t0.lsp));
657  if (!floor_setup->data.t0.lsp)
658  return AVERROR(ENOMEM);
659 
660  /* debug output parsed headers */
661  ff_dlog(NULL, "floor0 order: %u\n", floor_setup->data.t0.order);
662  ff_dlog(NULL, "floor0 rate: %u\n", floor_setup->data.t0.rate);
663  ff_dlog(NULL, "floor0 bark map size: %u\n",
664  floor_setup->data.t0.bark_map_size);
665  ff_dlog(NULL, "floor0 amplitude bits: %u\n",
666  floor_setup->data.t0.amplitude_bits);
667  ff_dlog(NULL, "floor0 amplitude offset: %u\n",
668  floor_setup->data.t0.amplitude_offset);
669  ff_dlog(NULL, "floor0 number of books: %u\n",
670  floor_setup->data.t0.num_books);
671  ff_dlog(NULL, "floor0 book list pointer: %p\n",
672  floor_setup->data.t0.book_list);
673  {
674  int idx;
675  for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
676  ff_dlog(NULL, " Book %d: %u\n", idx + 1,
677  floor_setup->data.t0.book_list[idx]);
678  }
679  }
680  } else {
681  av_log(vc->avctx, AV_LOG_ERROR, "Invalid floor type!\n");
682  return AVERROR_INVALIDDATA;
683  }
684  }
685  return 0;
686 }
687 
688 // Process residues part
689 
690 static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
691 {
692  GetBitContext *gb = &vc->gb;
693  unsigned i, j, k;
694 
695  vc->residue_count = get_bits(gb, 6)+1;
696  vc->residues = av_mallocz(vc->residue_count * sizeof(*vc->residues));
697  if (!vc->residues)
698  return AVERROR(ENOMEM);
699 
700  ff_dlog(NULL, " There are %d residues. \n", vc->residue_count);
701 
702  for (i = 0; i < vc->residue_count; ++i) {
703  vorbis_residue *res_setup = &vc->residues[i];
704  uint8_t cascade[64];
705  unsigned high_bits, low_bits;
706 
707  res_setup->type = get_bits(gb, 16);
708 
709  ff_dlog(NULL, " %u. residue type %d\n", i, res_setup->type);
710 
711  res_setup->begin = get_bits(gb, 24);
712  res_setup->end = get_bits(gb, 24);
713  res_setup->partition_size = get_bits(gb, 24) + 1;
714  /* Validations to prevent a buffer overflow later. */
715  if (res_setup->begin>res_setup->end ||
716  (res_setup->end-res_setup->begin) / res_setup->partition_size > FFMIN(V_MAX_PARTITIONS, 65535)) {
717  av_log(vc->avctx, AV_LOG_ERROR,
718  "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",
719  res_setup->type, res_setup->begin, res_setup->end,
720  res_setup->partition_size, vc->blocksize[1] / 2);
721  return AVERROR_INVALIDDATA;
722  }
723 
724  res_setup->classifications = get_bits(gb, 6) + 1;
725  GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)
726 
727  res_setup->ptns_to_read =
728  (res_setup->end - res_setup->begin) / res_setup->partition_size;
729  res_setup->classifs = av_malloc_array(res_setup->ptns_to_read,
730  vc->audio_channels *
731  sizeof(*res_setup->classifs));
732  if (!res_setup->classifs)
733  return AVERROR(ENOMEM);
734 
735  ff_dlog(NULL, " begin %"PRIu32" end %"PRIu32" part.size %u classif.s %"PRIu8" classbook %"PRIu8"\n",
736  res_setup->begin, res_setup->end, res_setup->partition_size,
737  res_setup->classifications, res_setup->classbook);
738 
739  for (j = 0; j < res_setup->classifications; ++j) {
740  high_bits = 0;
741  low_bits = get_bits(gb, 3);
742  if (get_bits1(gb))
743  high_bits = get_bits(gb, 5);
744  cascade[j] = (high_bits << 3) + low_bits;
745 
746  ff_dlog(NULL, " %u class cascade depth: %d\n", j, ilog(cascade[j]));
747  }
748 
749  res_setup->maxpass = 0;
750  for (j = 0; j < res_setup->classifications; ++j) {
751  for (k = 0; k < 8; ++k) {
752  if (cascade[j]&(1 << k)) {
753  GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)
754 
755  ff_dlog(NULL, " %u class cascade depth %u book: %d\n",
756  j, k, res_setup->books[j][k]);
757 
758  if (k>res_setup->maxpass)
759  res_setup->maxpass = k;
760  } else {
761  res_setup->books[j][k] = -1;
762  }
763  }
764  }
765  }
766  return 0;
767 }
768 
769 // Process mappings part
770 
771 static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
772 {
773  GetBitContext *gb = &vc->gb;
774  unsigned i, j;
775 
776  vc->mapping_count = get_bits(gb, 6)+1;
777  vc->mappings = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));
778  if (!vc->mappings)
779  return AVERROR(ENOMEM);
780 
781  ff_dlog(NULL, " There are %d mappings. \n", vc->mapping_count);
782 
783  for (i = 0; i < vc->mapping_count; ++i) {
784  vorbis_mapping *mapping_setup = &vc->mappings[i];
785 
786  if (get_bits(gb, 16)) {
787  av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
788  return AVERROR_INVALIDDATA;
789  }
790  if (get_bits1(gb)) {
791  mapping_setup->submaps = get_bits(gb, 4) + 1;
792  } else {
793  mapping_setup->submaps = 1;
794  }
795 
796  if (get_bits1(gb)) {
797  mapping_setup->coupling_steps = get_bits(gb, 8) + 1;
798  if (vc->audio_channels < 2) {
799  av_log(vc->avctx, AV_LOG_ERROR,
800  "Square polar channel mapping with less than two channels is not compliant with the Vorbis I specification.\n");
801  return AVERROR_INVALIDDATA;
802  }
803  mapping_setup->magnitude = av_mallocz(mapping_setup->coupling_steps *
804  sizeof(*mapping_setup->magnitude));
805  mapping_setup->angle = av_mallocz(mapping_setup->coupling_steps *
806  sizeof(*mapping_setup->angle));
807  if (!mapping_setup->angle || !mapping_setup->magnitude)
808  return AVERROR(ENOMEM);
809 
810  for (j = 0; j < mapping_setup->coupling_steps; ++j) {
811  GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels)
812  GET_VALIDATED_INDEX(mapping_setup->angle[j], ilog(vc->audio_channels - 1), vc->audio_channels)
813  }
814  } else {
815  mapping_setup->coupling_steps = 0;
816  }
817 
818  ff_dlog(NULL, " %u mapping coupling steps: %d\n",
819  i, mapping_setup->coupling_steps);
820 
821  if (get_bits(gb, 2)) {
822  av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);
823  return AVERROR_INVALIDDATA; // following spec.
824  }
825 
826  if (mapping_setup->submaps>1) {
827  mapping_setup->mux = av_calloc(vc->audio_channels,
828  sizeof(*mapping_setup->mux));
829  if (!mapping_setup->mux)
830  return AVERROR(ENOMEM);
831 
832  for (j = 0; j < vc->audio_channels; ++j)
833  mapping_setup->mux[j] = get_bits(gb, 4);
834  }
835 
836  for (j = 0; j < mapping_setup->submaps; ++j) {
837  skip_bits(gb, 8); // FIXME check?
838  GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8, vc->floor_count)
839  GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)
840 
841  ff_dlog(NULL, " %u mapping %u submap : floor %d, residue %d\n", i, j,
842  mapping_setup->submap_floor[j],
843  mapping_setup->submap_residue[j]);
844  }
845  }
846  return 0;
847 }
848 
849 // Process modes part
850 
851 static int create_map(vorbis_context *vc, unsigned floor_number)
852 {
853  vorbis_floor *floors = vc->floors;
854  vorbis_floor0 *vf;
855  int idx;
856  int blockflag, n;
857  int32_t *map;
858 
859  for (blockflag = 0; blockflag < 2; ++blockflag) {
860  n = vc->blocksize[blockflag] / 2;
861  floors[floor_number].data.t0.map[blockflag] =
862  av_malloc_array(n + 1, sizeof(int32_t)); // n + sentinel
863  if (!floors[floor_number].data.t0.map[blockflag])
864  return AVERROR(ENOMEM);
865 
866  map = floors[floor_number].data.t0.map[blockflag];
867  vf = &floors[floor_number].data.t0;
868 
869  for (idx = 0; idx < n; ++idx) {
870  map[idx] = floor(BARK((vf->rate * idx) / (2.0f * n)) *
871  (vf->bark_map_size / BARK(vf->rate / 2.0f)));
872  if (vf->bark_map_size-1 < map[idx])
873  map[idx] = vf->bark_map_size - 1;
874  }
875  map[n] = -1;
876  vf->map_size[blockflag] = n;
877  }
878 
879  for (idx = 0; idx <= n; ++idx) {
880  ff_dlog(NULL, "floor0 map: map at pos %d is %"PRId32"\n", idx, map[idx]);
881  }
882 
883  return 0;
884 }
885 
886 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
887 {
888  GetBitContext *gb = &vc->gb;
889  unsigned i;
890 
891  vc->mode_count = get_bits(gb, 6) + 1;
892  vc->modes = av_mallocz(vc->mode_count * sizeof(*vc->modes));
893  if (!vc->modes)
894  return AVERROR(ENOMEM);
895 
896  ff_dlog(NULL, " There are %d modes.\n", vc->mode_count);
897 
898  for (i = 0; i < vc->mode_count; ++i) {
899  vorbis_mode *mode_setup = &vc->modes[i];
900 
901  mode_setup->blockflag = get_bits1(gb);
902  mode_setup->windowtype = get_bits(gb, 16); //FIXME check
903  mode_setup->transformtype = get_bits(gb, 16); //FIXME check
904  GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
905 
906  ff_dlog(NULL, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
907  i, mode_setup->blockflag, mode_setup->windowtype,
908  mode_setup->transformtype, mode_setup->mapping);
909  }
910  return 0;
911 }
912 
913 // Process the whole setup header using the functions above
914 
915 static int vorbis_parse_setup_hdr(vorbis_context *vc)
916 {
917  GetBitContext *gb = &vc->gb;
918  int ret;
919 
920  if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
921  (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
922  (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
923  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
924  return AVERROR_INVALIDDATA;
925  }
926 
928  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
929  return ret;
930  }
932  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
933  return ret;
934  }
935  if ((ret = vorbis_parse_setup_hdr_floors(vc))) {
936  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
937  return ret;
938  }
939  if ((ret = vorbis_parse_setup_hdr_residues(vc))) {
940  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
941  return ret;
942  }
943  if ((ret = vorbis_parse_setup_hdr_mappings(vc))) {
944  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
945  return ret;
946  }
947  if ((ret = vorbis_parse_setup_hdr_modes(vc))) {
948  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
949  return ret;
950  }
951  if (!get_bits1(gb)) {
952  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
953  return AVERROR_INVALIDDATA; // framing flag bit unset error
954  }
955 
956  return 0;
957 }
958 
959 // Process the identification header
960 
961 static int vorbis_parse_id_hdr(vorbis_context *vc)
962 {
963  GetBitContext *gb = &vc->gb;
964  unsigned bl0, bl1;
965 
966  if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
967  (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
968  (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
969  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
970  return AVERROR_INVALIDDATA;
971  }
972 
973  vc->version = get_bits_long(gb, 32); //FIXME check 0
974  vc->audio_channels = get_bits(gb, 8);
975  if (vc->audio_channels <= 0) {
976  av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
977  return AVERROR_INVALIDDATA;
978  }
979  vc->audio_samplerate = get_bits_long(gb, 32);
980  if (vc->audio_samplerate <= 0) {
981  av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
982  return AVERROR_INVALIDDATA;
983  }
984  vc->bitrate_maximum = get_bits_long(gb, 32);
985  vc->bitrate_nominal = get_bits_long(gb, 32);
986  vc->bitrate_minimum = get_bits_long(gb, 32);
987  bl0 = get_bits(gb, 4);
988  bl1 = get_bits(gb, 4);
989  if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
990  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
991  return AVERROR_INVALIDDATA;
992  }
993  vc->blocksize[0] = (1 << bl0);
994  vc->blocksize[1] = (1 << bl1);
995  vc->win[0] = ff_vorbis_vwin[bl0 - 6];
996  vc->win[1] = ff_vorbis_vwin[bl1 - 6];
997 
998  if ((get_bits1(gb)) == 0) {
999  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
1000  return AVERROR_INVALIDDATA;
1001  }
1002 
1003  vc->channel_residues = av_malloc_array(vc->blocksize[1] / 2, vc->audio_channels * sizeof(*vc->channel_residues));
1004  vc->saved = av_calloc(vc->blocksize[1] / 4, vc->audio_channels * sizeof(*vc->saved));
1005  if (!vc->channel_residues || !vc->saved)
1006  return AVERROR(ENOMEM);
1007 
1008  vc->previous_window = -1;
1009 
1010  ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);
1011  ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);
1012  vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & AV_CODEC_FLAG_BITEXACT);
1013  if (!vc->fdsp)
1014  return AVERROR(ENOMEM);
1015 
1016  ff_dlog(NULL, " vorbis version %"PRIu32" \n audio_channels %"PRIu8" \n audio_samplerate %"PRIu32" \n bitrate_max %"PRIu32" \n bitrate_nom %"PRIu32" \n bitrate_min %"PRIu32" \n blk_0 %"PRIu32" blk_1 %"PRIu32" \n ",
1017  vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
1018 
1019 /*
1020  BLK = vc->blocksize[0];
1021  for (i = 0; i < BLK / 2; ++i) {
1022  vc->win[0][i] = sin(0.5*3.14159265358*(sin(((float)i + 0.5) / (float)BLK*3.14159265358))*(sin(((float)i + 0.5) / (float)BLK*3.14159265358)));
1023  }
1024 */
1025 
1026  return 0;
1027 }
1028 
1029 // Process the extradata using the functions above (identification header, setup header)
1030 
1032 {
1033  vorbis_context *vc = avctx->priv_data;
1034  uint8_t *headers = avctx->extradata;
1035  int headers_len = avctx->extradata_size;
1036  const uint8_t *header_start[3];
1037  int header_len[3];
1038  GetBitContext *gb = &vc->gb;
1039  int hdr_type, ret;
1040 
1041  vc->avctx = avctx;
1042  ff_vorbisdsp_init(&vc->dsp);
1043 
1044  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1045 
1046  if (!headers_len) {
1047  av_log(avctx, AV_LOG_ERROR, "Extradata missing.\n");
1048  return AVERROR_INVALIDDATA;
1049  }
1050 
1051  if ((ret = avpriv_split_xiph_headers(headers, headers_len, 30, header_start, header_len)) < 0) {
1052  av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
1053  return ret;
1054  }
1055 
1056  init_get_bits(gb, header_start[0], header_len[0]*8);
1057  hdr_type = get_bits(gb, 8);
1058  if (hdr_type != 1) {
1059  av_log(avctx, AV_LOG_ERROR, "First header is not the id header.\n");
1060  return AVERROR_INVALIDDATA;
1061  }
1062  if ((ret = vorbis_parse_id_hdr(vc))) {
1063  av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1064  vorbis_free(vc);
1065  return ret;
1066  }
1067 
1068  init_get_bits(gb, header_start[2], header_len[2]*8);
1069  hdr_type = get_bits(gb, 8);
1070  if (hdr_type != 5) {
1071  av_log(avctx, AV_LOG_ERROR, "Third header is not the setup header.\n");
1072  vorbis_free(vc);
1073  return AVERROR_INVALIDDATA;
1074  }
1075  if ((ret = vorbis_parse_setup_hdr(vc))) {
1076  av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1077  vorbis_free(vc);
1078  return ret;
1079  }
1080 
1082  if (vc->audio_channels > 8) {
1084  avctx->ch_layout.nb_channels = vc->audio_channels;
1085  } else {
1086  av_channel_layout_copy(&avctx->ch_layout, &ff_vorbis_ch_layouts[vc->audio_channels - 1]);
1087  }
1088 
1089  avctx->sample_rate = vc->audio_samplerate;
1090 
1091  return 0;
1092 }
1093 
1094 // Decode audiopackets -------------------------------------------------
1095 
1096 // Read and decode floor
1097 
1098 static int vorbis_floor0_decode(vorbis_context *vc,
1099  vorbis_floor_data *vfu, float *vec)
1100 {
1101  vorbis_floor0 *vf = &vfu->t0;
1102  float *lsp = vf->lsp;
1103  unsigned book_idx;
1104  uint64_t amplitude;
1105  unsigned blockflag = vc->modes[vc->mode_number].blockflag;
1106 
1107  if (!vf->amplitude_bits)
1108  return 1;
1109 
1110  amplitude = get_bits64(&vc->gb, vf->amplitude_bits);
1111  if (amplitude > 0) {
1112  float last = 0;
1113  unsigned idx, lsp_len = 0;
1115 
1116  book_idx = get_bits(&vc->gb, ilog(vf->num_books));
1117  if (book_idx >= vf->num_books) {
1118  av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");
1119  book_idx = 0;
1120  }
1121  ff_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);
1122  codebook = vc->codebooks[vf->book_list[book_idx]];
1123  /* Invalid codebook! */
1124  if (!codebook.codevectors)
1125  return AVERROR_INVALIDDATA;
1126 
1127  while (lsp_len<vf->order) {
1128  int vec_off;
1129 
1130  ff_dlog(NULL, "floor0 dec: book dimension: %d\n", codebook.dimensions);
1131  ff_dlog(NULL, "floor0 dec: maximum depth: %d\n", codebook.maxdepth);
1132  /* read temp vector */
1133  vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
1134  codebook.nb_bits, codebook.maxdepth);
1135  if (vec_off < 0)
1136  return AVERROR_INVALIDDATA;
1137  vec_off *= codebook.dimensions;
1138  ff_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);
1139  /* copy each vector component and add last to it */
1140  for (idx = 0; idx < codebook.dimensions; ++idx)
1141  lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;
1142  last = lsp[lsp_len+idx-1]; /* set last to last vector component */
1143 
1144  lsp_len += codebook.dimensions;
1145  }
1146  /* DEBUG: output lsp coeffs */
1147  {
1148  int idx;
1149  for (idx = 0; idx < lsp_len; ++idx)
1150  ff_dlog(NULL, "floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
1151  }
1152 
1153  /* synthesize floor output vector */
1154  {
1155  int i;
1156  int order = vf->order;
1157  float wstep = M_PI / vf->bark_map_size;
1158 
1159  for (i = 0; i < order; i++)
1160  lsp[i] = 2.0f * cos(lsp[i]);
1161 
1162  ff_dlog(NULL, "floor0 synth: map_size = %"PRIu32"; m = %d; wstep = %f\n",
1163  vf->map_size[blockflag], order, wstep);
1164 
1165  i = 0;
1166  while (i < vf->map_size[blockflag]) {
1167  int j, iter_cond = vf->map[blockflag][i];
1168  float p = 0.5f;
1169  float q = 0.5f;
1170  float two_cos_w = 2.0f * cos(wstep * iter_cond); // needed all times
1171 
1172  /* similar part for the q and p products */
1173  for (j = 0; j + 1 < order; j += 2) {
1174  q *= lsp[j] - two_cos_w;
1175  p *= lsp[j + 1] - two_cos_w;
1176  }
1177  if (j == order) { // even order
1178  p *= p * (2.0f - two_cos_w);
1179  q *= q * (2.0f + two_cos_w);
1180  } else { // odd order
1181  q *= two_cos_w-lsp[j]; // one more time for q
1182 
1183  /* final step and square */
1184  p *= p * (4.f - two_cos_w * two_cos_w);
1185  q *= q;
1186  }
1187 
1188  if (p + q == 0.0)
1189  return AVERROR_INVALIDDATA;
1190 
1191  /* calculate linear floor value */
1192  q = exp((((amplitude*vf->amplitude_offset) /
1193  (((1ULL << vf->amplitude_bits) - 1) * sqrt(p + q)))
1194  - vf->amplitude_offset) * .11512925f);
1195 
1196  /* fill vector */
1197  do {
1198  vec[i] = q; ++i;
1199  } while (vf->map[blockflag][i] == iter_cond);
1200  }
1201  }
1202  } else {
1203  /* this channel is unused */
1204  return 1;
1205  }
1206 
1207  ff_dlog(NULL, " Floor0 decoded\n");
1208 
1209  return 0;
1210 }
1211 
1212 static int vorbis_floor1_decode(vorbis_context *vc,
1213  vorbis_floor_data *vfu, float *vec)
1214 {
1215  vorbis_floor1 *vf = &vfu->t1;
1216  GetBitContext *gb = &vc->gb;
1217  uint16_t range_v[4] = { 256, 128, 86, 64 };
1218  unsigned range = range_v[vf->multiplier - 1];
1219  uint16_t floor1_Y[258];
1220  uint16_t floor1_Y_final[258];
1221  int floor1_flag[258];
1222  unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
1223  int book, adx, ady, dy, off, predicted, err;
1224 
1225 
1226  if (!get_bits1(gb)) // silence
1227  return 1;
1228 
1229 // Read values (or differences) for the floor's points
1230 
1231  floor1_Y[0] = get_bits(gb, ilog(range - 1));
1232  floor1_Y[1] = get_bits(gb, ilog(range - 1));
1233 
1234  ff_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1235 
1236  offset = 2;
1237  for (i = 0; i < vf->partitions; ++i) {
1238  partition_class = vf->partition_class[i];
1239  cdim = vf->class_dimensions[partition_class];
1240  cbits = vf->class_subclasses[partition_class];
1241  csub = (1 << cbits) - 1;
1242  cval = 0;
1243 
1244  ff_dlog(NULL, "Cbits %u\n", cbits);
1245 
1246  if (cbits) // this reads all subclasses for this partition's class
1247  cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
1248  vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
1249 
1250  for (j = 0; j < cdim; ++j) {
1251  book = vf->subclass_books[partition_class][cval & csub];
1252 
1253  ff_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",
1254  book, cbits, cval, get_bits_count(gb));
1255 
1256  cval = cval >> cbits;
1257  if (book > -1) {
1258  int v = get_vlc2(gb, vc->codebooks[book].vlc.table,
1259  vc->codebooks[book].nb_bits, 3);
1260  if (v < 0)
1261  return AVERROR_INVALIDDATA;
1262  floor1_Y[offset+j] = v;
1263  } else {
1264  floor1_Y[offset+j] = 0;
1265  }
1266 
1267  ff_dlog(NULL, " floor(%d) = %d \n",
1268  vf->list[offset+j].x, floor1_Y[offset+j]);
1269  }
1270  offset+=cdim;
1271  }
1272 
1273 // Amplitude calculation from the differences
1274 
1275  floor1_flag[0] = 1;
1276  floor1_flag[1] = 1;
1277  floor1_Y_final[0] = floor1_Y[0];
1278  floor1_Y_final[1] = floor1_Y[1];
1279 
1280  for (i = 2; i < vf->x_list_dim; ++i) {
1281  unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
1282 
1283  low_neigh_offs = vf->list[i].low;
1284  high_neigh_offs = vf->list[i].high;
1285  dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs]; // render_point begin
1286  adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
1287  ady = FFABS(dy);
1288  err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
1289  off = err / adx;
1290  if (dy < 0) {
1291  predicted = floor1_Y_final[low_neigh_offs] - off;
1292  } else {
1293  predicted = floor1_Y_final[low_neigh_offs] + off;
1294  } // render_point end
1295 
1296  val = floor1_Y[i];
1297  highroom = range-predicted;
1298  lowroom = predicted;
1299  if (highroom < lowroom) {
1300  room = highroom * 2;
1301  } else {
1302  room = lowroom * 2; // SPEC misspelling
1303  }
1304  if (val) {
1305  floor1_flag[low_neigh_offs] = 1;
1306  floor1_flag[high_neigh_offs] = 1;
1307  floor1_flag[i] = 1;
1308  if (val >= room) {
1309  if (highroom > lowroom) {
1310  floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
1311  } else {
1312  floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
1313  }
1314  } else {
1315  if (val & 1) {
1316  floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
1317  } else {
1318  floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
1319  }
1320  }
1321  } else {
1322  floor1_flag[i] = 0;
1323  floor1_Y_final[i] = av_clip_uint16(predicted);
1324  }
1325 
1326  ff_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
1327  vf->list[i].x, floor1_Y_final[i], val);
1328  }
1329 
1330 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1331 
1332  ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
1333 
1334  ff_dlog(NULL, " Floor decoded\n");
1335 
1336  return 0;
1337 }
1338 
1339 static av_always_inline int setup_classifs(vorbis_context *vc,
1340  vorbis_residue *vr,
1341  uint8_t *do_not_decode,
1342  unsigned ch_used,
1343  int partition_count,
1344  int ptns_to_read
1345  )
1346 {
1347  vorbis_codebook *codebook = vc->codebooks + vr->classbook;
1348  int p, j, i;
1349  unsigned c_p_c = codebook->dimensions;
1350  unsigned inverse_class = ff_inverse[vr->classifications];
1351  int temp, temp2;
1352  for (p = 0, j = 0; j < ch_used; ++j) {
1353  if (!do_not_decode[j]) {
1354  temp = get_vlc2(&vc->gb, codebook->vlc.table,
1355  codebook->nb_bits, 3);
1356 
1357  ff_dlog(NULL, "Classword: %u\n", temp);
1358 
1359  av_assert0(temp < 65536);
1360 
1361  if (temp < 0) {
1362  av_log(vc->avctx, AV_LOG_ERROR,
1363  "Invalid vlc code decoding %d channel.", j);
1364  return AVERROR_INVALIDDATA;
1365  }
1366 
1367  if (vr->classifications == 1) {
1368  for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1369  if (i < ptns_to_read)
1370  vr->classifs[p + i] = 0;
1371  }
1372  } else {
1373  for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1374  temp2 = (((uint64_t)temp) * inverse_class) >> 32;
1375 
1376  if (i < ptns_to_read)
1377  vr->classifs[p + i] = temp - temp2 * vr->classifications;
1378  temp = temp2;
1379  }
1380  }
1381  }
1382  p += ptns_to_read;
1383  }
1384  return 0;
1385 }
1386 // Read and decode residue
1387 
1388 static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
1389  vorbis_residue *vr,
1390  unsigned ch,
1391  uint8_t *do_not_decode,
1392  float *vec,
1393  unsigned vlen,
1394  unsigned ch_left,
1395  int vr_type)
1396 {
1397  GetBitContext *gb = &vc->gb;
1398  unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;
1399  uint8_t *classifs = vr->classifs;
1400  unsigned pass, ch_used, i, j, k, l;
1401  unsigned max_output = (ch - 1) * vlen;
1402  int ptns_to_read = vr->ptns_to_read;
1403  int libvorbis_bug = 0;
1404 
1405  if (vr_type == 2) {
1406  for (j = 1; j < ch; ++j)
1407  do_not_decode[0] &= do_not_decode[j]; // FIXME - clobbering input
1408  if (do_not_decode[0])
1409  return 0;
1410  ch_used = 1;
1411  max_output += vr->end / ch;
1412  } else {
1413  ch_used = ch;
1414  max_output += vr->end;
1415  }
1416 
1417  if (max_output > ch_left * vlen) {
1418  if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {
1419  ptns_to_read--;
1420  libvorbis_bug = 1;
1421  } else {
1422  av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
1423  return AVERROR_INVALIDDATA;
1424  }
1425  }
1426 
1427  ff_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);
1428 
1429  for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?
1430  int voffset, partition_count, j_times_ptns_to_read;
1431 
1432  voffset = vr->begin;
1433  for (partition_count = 0; partition_count < ptns_to_read;) { // SPEC error
1434  if (!pass) {
1435  int ret = setup_classifs(vc, vr, do_not_decode, ch_used, partition_count, ptns_to_read);
1436  if (ret < 0)
1437  return ret;
1438  }
1439  for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {
1440  for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
1441  unsigned voffs;
1442 
1443  if (!do_not_decode[j]) {
1444  unsigned vqclass = classifs[j_times_ptns_to_read + partition_count];
1445  int vqbook = vr->books[vqclass][pass];
1446 
1447  if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {
1448  int coffs;
1449  unsigned dim = vc->codebooks[vqbook].dimensions;
1450  unsigned step = FASTDIV(vr->partition_size << 1, dim << 1);
1451  vorbis_codebook codebook = vc->codebooks[vqbook];
1452 
1453  if (vr_type == 0) {
1454 
1455  voffs = voffset+j*vlen;
1456  for (k = 0; k < step; ++k) {
1457  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1458  if (coffs < 0)
1459  return coffs;
1460  coffs *= dim;
1461  for (l = 0; l < dim; ++l)
1462  vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
1463  }
1464  } else if (vr_type == 1) {
1465  voffs = voffset + j * vlen;
1466  for (k = 0; k < step; ++k) {
1467  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1468  if (coffs < 0)
1469  return coffs;
1470  coffs *= dim;
1471  for (l = 0; l < dim; ++l, ++voffs) {
1472  vec[voffs]+=codebook.codevectors[coffs+l];
1473 
1474  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1475  pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1476  }
1477  }
1478  } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized
1479  voffs = voffset >> 1;
1480 
1481  if (dim == 2) {
1482  for (k = 0; k < step; ++k) {
1483  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1484  if (coffs < 0)
1485  return coffs;
1486  coffs *= 2;
1487  vec[voffs + k ] += codebook.codevectors[coffs ];
1488  vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
1489  }
1490  } else if (dim == 4) {
1491  for (k = 0; k < step; ++k, voffs += 2) {
1492  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1493  if (coffs < 0)
1494  return coffs;
1495  coffs *= 4;
1496  vec[voffs ] += codebook.codevectors[coffs ];
1497  vec[voffs + 1 ] += codebook.codevectors[coffs + 2];
1498  vec[voffs + vlen ] += codebook.codevectors[coffs + 1];
1499  vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
1500  }
1501  } else
1502  for (k = 0; k < step; ++k) {
1503  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1504  if (coffs < 0)
1505  return coffs;
1506  coffs *= dim;
1507  for (l = 0; l < dim; l += 2, voffs++) {
1508  vec[voffs ] += codebook.codevectors[coffs + l ];
1509  vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
1510 
1511  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1512  pass, voffset / ch + (voffs % ch) * vlen,
1513  vec[voffset / ch + (voffs % ch) * vlen],
1514  codebook.codevectors[coffs + l], coffs, l);
1515  }
1516  }
1517 
1518  } else if (vr_type == 2) {
1519  unsigned voffs_div = ch == 1 ? voffset : FASTDIV(voffset, ch);
1520  unsigned voffs_mod = voffset - voffs_div * ch;
1521 
1522  for (k = 0; k < step; ++k) {
1523  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1524  if (coffs < 0)
1525  return coffs;
1526  coffs *= dim;
1527  for (l = 0; l < dim; ++l) {
1528  vec[voffs_div + voffs_mod * vlen] +=
1529  codebook.codevectors[coffs + l];
1530 
1531  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1532  pass, voffs_div + voffs_mod * vlen,
1533  vec[voffs_div + voffs_mod * vlen],
1534  codebook.codevectors[coffs + l], coffs, l);
1535 
1536  if (++voffs_mod == ch) {
1537  voffs_div++;
1538  voffs_mod = 0;
1539  }
1540  }
1541  }
1542  }
1543  }
1544  }
1545  j_times_ptns_to_read += ptns_to_read;
1546  }
1547  ++partition_count;
1548  voffset += vr->partition_size;
1549  }
1550  }
1551  if (libvorbis_bug && !pass) {
1552  for (j = 0; j < ch_used; ++j) {
1553  if (!do_not_decode[j]) {
1554  get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,
1555  vc->codebooks[vr->classbook].nb_bits, 3);
1556  }
1557  }
1558  }
1559  }
1560  return 0;
1561 }
1562 
1563 static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
1564  unsigned ch,
1565  uint8_t *do_not_decode,
1566  float *vec, unsigned vlen,
1567  unsigned ch_left)
1568 {
1569  if (vr->type == 2)
1570  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);
1571  else if (vr->type == 1)
1572  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);
1573  else if (vr->type == 0)
1574  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
1575  else {
1576  av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1577  return AVERROR_INVALIDDATA;
1578  }
1579 }
1580 
1581 void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
1582 {
1583  int i;
1584  for (i = 0; i < blocksize; i++) {
1585  if (mag[i] > 0.0) {
1586  if (ang[i] > 0.0) {
1587  ang[i] = mag[i] - ang[i];
1588  } else {
1589  float temp = ang[i];
1590  ang[i] = mag[i];
1591  mag[i] += temp;
1592  }
1593  } else {
1594  if (ang[i] > 0.0) {
1595  ang[i] += mag[i];
1596  } else {
1597  float temp = ang[i];
1598  ang[i] = mag[i];
1599  mag[i] -= temp;
1600  }
1601  }
1602  }
1603 }
1604 
1605 // Decode the audio packet using the functions above
1606 
1607 static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
1608 {
1609  GetBitContext *gb = &vc->gb;
1610  FFTContext *mdct;
1611  int previous_window = vc->previous_window;
1612  unsigned mode_number, blockflag, blocksize;
1613  int i, j;
1614  uint8_t no_residue[255];
1615  uint8_t do_not_decode[255];
1616  vorbis_mapping *mapping;
1617  float *ch_res_ptr = vc->channel_residues;
1618  uint8_t res_chan[255];
1619  unsigned res_num = 0;
1620  int retlen = 0;
1621  unsigned ch_left = vc->audio_channels;
1622  unsigned vlen;
1623 
1624  if (get_bits1(gb)) {
1625  av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1626  return AVERROR_INVALIDDATA; // packet type not audio
1627  }
1628 
1629  if (vc->mode_count == 1) {
1630  mode_number = 0;
1631  } else {
1632  GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
1633  }
1634  vc->mode_number = mode_number;
1635  mapping = &vc->mappings[vc->modes[mode_number].mapping];
1636 
1637  ff_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
1638  vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1639 
1640  blockflag = vc->modes[mode_number].blockflag;
1641  blocksize = vc->blocksize[blockflag];
1642  vlen = blocksize / 2;
1643  if (blockflag) {
1644  int code = get_bits(gb, 2);
1645  if (previous_window < 0)
1646  previous_window = code>>1;
1647  } else if (previous_window < 0)
1648  previous_window = 0;
1649 
1650  memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?
1651  for (i = 0; i < vc->audio_channels; ++i)
1652  memset(floor_ptr[i], 0, vlen * sizeof(floor_ptr[0][0])); //FIXME can this be removed ?
1653 
1654 // Decode floor
1655 
1656  for (i = 0; i < vc->audio_channels; ++i) {
1658  int ret;
1659  if (mapping->submaps > 1) {
1660  floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
1661  } else {
1662  floor = &vc->floors[mapping->submap_floor[0]];
1663  }
1664 
1665  ret = floor->decode(vc, &floor->data, floor_ptr[i]);
1666 
1667  if (ret < 0) {
1668  av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
1669  return AVERROR_INVALIDDATA;
1670  }
1671  no_residue[i] = ret;
1672  }
1673 
1674 // Nonzero vector propagate
1675 
1676  for (i = mapping->coupling_steps - 1; i >= 0; --i) {
1677  if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1678  no_residue[mapping->magnitude[i]] = 0;
1679  no_residue[mapping->angle[i]] = 0;
1680  }
1681  }
1682 
1683 // Decode residue
1684 
1685  for (i = 0; i < mapping->submaps; ++i) {
1686  vorbis_residue *residue;
1687  unsigned ch = 0;
1688  int ret;
1689 
1690  for (j = 0; j < vc->audio_channels; ++j) {
1691  if ((mapping->submaps == 1) || (i == mapping->mux[j])) {
1692  res_chan[j] = res_num;
1693  if (no_residue[j]) {
1694  do_not_decode[ch] = 1;
1695  } else {
1696  do_not_decode[ch] = 0;
1697  }
1698  ++ch;
1699  ++res_num;
1700  }
1701  }
1702  residue = &vc->residues[mapping->submap_residue[i]];
1703  if (ch_left < ch) {
1704  av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
1705  return AVERROR_INVALIDDATA;
1706  }
1707  if (ch) {
1708  ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);
1709  if (ret < 0)
1710  return ret;
1711  }
1712 
1713  ch_res_ptr += ch * vlen;
1714  ch_left -= ch;
1715  }
1716 
1717  if (ch_left > 0)
1718  return AVERROR_INVALIDDATA;
1719 
1720 // Inverse coupling
1721 
1722  for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed
1723  float *mag, *ang;
1724 
1725  mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
1726  ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;
1727  vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
1728  }
1729 
1730 // Dotproduct, MDCT
1731 
1732  mdct = &vc->mdct[blockflag];
1733 
1734  for (j = vc->audio_channels-1;j >= 0; j--) {
1735  ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
1736  vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1737  mdct->imdct_half(mdct, ch_res_ptr, floor_ptr[j]);
1738  }
1739 
1740 // Overlap/add, save data for next overlapping
1741 
1742  retlen = (blocksize + vc->blocksize[previous_window]) / 4;
1743  for (j = 0; j < vc->audio_channels; j++) {
1744  unsigned bs0 = vc->blocksize[0];
1745  unsigned bs1 = vc->blocksize[1];
1746  float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;
1747  float *saved = vc->saved + j * bs1 / 4;
1748  float *ret = floor_ptr[j];
1749  float *buf = residue;
1750  const float *win = vc->win[blockflag & previous_window];
1751 
1752  if (blockflag == previous_window) {
1753  vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);
1754  } else if (blockflag > previous_window) {
1755  vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);
1756  memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) * sizeof(float));
1757  } else {
1758  memcpy(ret, saved, ((bs1 - bs0) / 4) * sizeof(float));
1759  vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);
1760  }
1761  memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));
1762  }
1763 
1764  vc->previous_window = blockflag;
1765  return retlen;
1766 }
1767 
1768 // Return the decoded audio packet through the standard api
1769 
1771  int *got_frame_ptr, AVPacket *avpkt)
1772 {
1773  const uint8_t *buf = avpkt->data;
1774  int buf_size = avpkt->size;
1775  vorbis_context *vc = avctx->priv_data;
1776  GetBitContext *gb = &vc->gb;
1777  float *channel_ptrs[255];
1778  int i, len, ret;
1779 
1780  ff_dlog(NULL, "packet length %d \n", buf_size);
1781 
1782  if (*buf == 1 && buf_size > 7) {
1783  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1784  return ret;
1785 
1786  vorbis_free(vc);
1787  if ((ret = vorbis_parse_id_hdr(vc))) {
1788  av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1789  vorbis_free(vc);
1790  return ret;
1791  }
1792 
1794  if (vc->audio_channels > 8) {
1796  avctx->ch_layout.nb_channels = vc->audio_channels;
1797  } else {
1798  av_channel_layout_copy(&avctx->ch_layout, &ff_vorbis_ch_layouts[vc->audio_channels - 1]);
1799  }
1800 
1801  avctx->sample_rate = vc->audio_samplerate;
1802  return buf_size;
1803  }
1804 
1805  if (*buf == 3 && buf_size > 7) {
1806  av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");
1807  return buf_size;
1808  }
1809 
1810  if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
1811  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1812  return ret;
1813 
1814  if ((ret = vorbis_parse_setup_hdr(vc))) {
1815  av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1816  vorbis_free(vc);
1817  return ret;
1818  }
1819  return buf_size;
1820  }
1821 
1822  if (!vc->channel_residues || !vc->modes) {
1823  av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");
1824  return AVERROR_INVALIDDATA;
1825  }
1826 
1827  /* get output buffer */
1828  frame->nb_samples = vc->blocksize[1] / 2;
1829  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1830  return ret;
1831 
1832  if (vc->audio_channels > 8) {
1833  for (i = 0; i < vc->audio_channels; i++)
1834  channel_ptrs[i] = (float *)frame->extended_data[i];
1835  } else {
1836  for (i = 0; i < vc->audio_channels; i++) {
1837  int ch = ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];
1838  channel_ptrs[ch] = (float *)frame->extended_data[i];
1839  }
1840  }
1841 
1842  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
1843  return ret;
1844 
1845  if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
1846  return len;
1847 
1848  if (!vc->first_frame) {
1849  vc->first_frame = 1;
1850  *got_frame_ptr = 0;
1852  return buf_size;
1853  }
1854 
1855  ff_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1856  get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
1857 
1858  frame->nb_samples = len;
1859  *got_frame_ptr = 1;
1860 
1861  return buf_size;
1862 }
1863 
1864 // Close decoder
1865 
1867 {
1868  vorbis_context *vc = avctx->priv_data;
1869 
1870  vorbis_free(vc);
1871 
1872  return 0;
1873 }
1874 
1876 {
1877  vorbis_context *vc = avctx->priv_data;
1878 
1879  if (vc->saved) {
1880  memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *
1881  sizeof(*vc->saved));
1882  }
1883  vc->previous_window = -1;
1884  vc->first_frame = 0;
1885 }
1886 
1888  .p.name = "vorbis",
1889  .p.long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
1890  .p.type = AVMEDIA_TYPE_AUDIO,
1891  .p.id = AV_CODEC_ID_VORBIS,
1892  .priv_data_size = sizeof(vorbis_context),
1894  .close = vorbis_decode_close,
1896  .flush = vorbis_decode_flush,
1897  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1898  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1899 #if FF_API_OLD_CHANNEL_LAYOUT
1900  .p.channel_layouts = ff_vorbis_channel_layouts,
1901 #endif
1902  .p.ch_layouts = ff_vorbis_ch_layouts,
1903  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1905 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
ff_vorbis_decoder
const FFCodec ff_vorbis_decoder
Definition: vorbisdec.c:1887
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
BARK
#define BARK(x)
Definition: vorbisdec.c:160
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::bark_map_size
uint16_t bark_map_size
Definition: vorbisdec.c:73
create_map
static int create_map(vorbis_context *vc, unsigned floor_number)
Definition: vorbisdec.c:851
vorbis_mapping::angle
uint8_t * angle
Definition: vorbisdec.c:113
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
vorbis_floor::floor_type
uint8_t floor_type
Definition: vorbisdec.c:67
vorbis_decode_close
static av_cold int vorbis_decode_close(AVCodecContext *avctx)
Definition: vorbisdec.c:1866
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
vorbis_mode
Definition: vorbisdec.c:119
vorbis_context_s::codebook_count
uint16_t codebook_count
Definition: vorbisdec.c:142
vorbis_mapping::submaps
uint8_t submaps
Definition: vorbisdec.c:110
vorbis_residue::maxpass
uint8_t maxpass
Definition: vorbisdec.c:104
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
vorbis_floor::vorbis_floor_u::t0
struct vorbis_floor::vorbis_floor_u::vorbis_floor0_s t0
vorbis_context_s::residue_count
uint8_t residue_count
Definition: vorbisdec.c:146
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
vorbis_context_s::fdsp
AVFloatDSPContext * fdsp
Definition: vorbisdec.c:130
vorbis_context_s::version
uint32_t version
Definition: vorbisdec.c:134
vorbis_floor::vorbis_floor_u
Definition: vorbisdec.c:69
vorbis_mode::transformtype
uint16_t transformtype
Definition: vorbisdec.c:122
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::map
int32_t * map[2]
Definition: vorbisdec.c:74
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
ff_vorbis_vwin
const float *const ff_vorbis_vwin[8]
Definition: vorbis_data.c:2198
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
GET_VALIDATED_INDEX
#define GET_VALIDATED_INDEX(idx, bits, limit)
Definition: vorbisdec.c:171
data
const char data[16]
Definition: mxf.c:146
vorbisfloat2float
static float vorbisfloat2float(unsigned val)
Definition: vorbisdec.c:177
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
idx_err_str
static const char idx_err_str[]
Definition: vorbisdec.c:163
vorbis_floor1
struct vorbis_floor1_s vorbis_floor1
Definition: vorbisdec.c:61
vorbis_context_s::previous_window
int8_t previous_window
Definition: vorbisdec.c:153
FFCodec
Definition: codec_internal.h:118
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_subclasses
uint8_t class_subclasses[16]
Definition: vorbisdec.c:86
vorbis_residue_decode
static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left)
Definition: vorbisdec.c:1563
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
vorbis_residue::books
int16_t books[64][8]
Definition: vorbisdec.c:103
INIT_VLC_LE
#define INIT_VLC_LE
Definition: vlc.h:99
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
ff_inverse
const uint32_t ff_inverse[257]
Definition: mathtables.c:27
vorbis_floor1_entry::x
uint16_t x
Definition: vorbis.h:35
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
ff_vorbis_nth_root
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
Definition: vorbis.c:38
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:637
vorbis_free
static void vorbis_free(vorbis_context *vc)
Definition: vorbisdec.c:189
xiph.h
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
init
static int init
Definition: av_tx.c:47
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
GetBitContext
Definition: get_bits.h:61
ff_vorbis_floor1_render_list
void ff_vorbis_floor1_render_list(vorbis_floor1_entry *list, int values, uint16_t *y_list, int *flag, int multiplier, float *out, int samples)
Definition: vorbis.c:196
val
static double val(void *priv, double ch)
Definition: aeval.c:77
vorbis_floor::data
union vorbis_floor::vorbis_floor_u data
vorbis_floor_decode_func
int(* vorbis_floor_decode_func)(struct vorbis_context_s *, vorbis_floor_data *, float *)
Definition: vorbisdec.c:65
vorbis_parse_id_hdr
static int vorbis_parse_id_hdr(vorbis_context *vc)
Definition: vorbisdec.c:961
VorbisDSPContext
Definition: vorbisdsp.h:24
vorbis_context_s::gb
GetBitContext gb
Definition: vorbisdec.c:128
avassert.h
vorbis_residue::classbook
uint8_t classbook
Definition: vorbisdec.c:102
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::partition_class
uint8_t partition_class[32]
Definition: vorbisdec.c:84
V_MAX_PARTITIONS
#define V_MAX_PARTITIONS
Definition: vorbisdec.c:48
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
vorbis_floor1_entry
Definition: vorbis.h:34
vorbis_context_s::mode_number
uint8_t mode_number
Definition: vorbisdec.c:152
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
vorbis_context_s::audio_samplerate
uint32_t audio_samplerate
Definition: vorbisdec.c:136
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:106
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::lsp
float * lsp
Definition: vorbisdec.c:80
vorbis_parse_setup_hdr_tdtransforms
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
Definition: vorbisdec.c:474
vorbis_codebook::nb_bits
unsigned int nb_bits
Definition: vorbisdec.c:56
vorbis_parse_audio_packet
static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
Definition: vorbisdec.c:1607
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_vorbis_len2vlc
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
Definition: vorbis.c:56
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::partitions
uint8_t partitions
Definition: vorbisdec.c:83
vorbis_mode::windowtype
uint16_t windowtype
Definition: vorbisdec.c:121
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
vorbis_context_s::bitrate_nominal
uint32_t bitrate_nominal
Definition: vorbisdec.c:138
vorbis_context_s::blocksize
uint32_t blocksize[2]
Definition: vorbisdec.c:140
vorbis_context_s::floors
vorbis_floor * floors
Definition: vorbisdec.c:145
pass
#define pass
Definition: fft_template.c:608
vorbis_codebook::codevectors
float * codevectors
Definition: vorbisdec.c:55
vorbis_parse_setup_hdr_residues
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
Definition: vorbisdec.c:690
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
vorbis_residue::ptns_to_read
uint16_t ptns_to_read
Definition: vorbisdec.c:105
NULL
#define NULL
Definition: coverity.c:32
ff_vorbis_ch_layouts
const AVChannelLayout ff_vorbis_ch_layouts[9]
Definition: vorbis_data.c:51
vorbis_mapping::mux
uint8_t * mux
Definition: vorbisdec.c:114
vorbis_context_s::audio_channels
uint8_t audio_channels
Definition: vorbisdec.c:135
VALIDATE_INDEX
#define VALIDATE_INDEX(idx, limit)
Definition: vorbisdec.c:164
vorbis_context_s::win
const float * win[2]
Definition: vorbisdec.c:141
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
vorbis_floor0_decode
static int vorbis_floor0_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
Definition: vorbisdec.c:1098
vorbis_context_s::modes
vorbis_mode * modes
Definition: vorbisdec.c:151
ff_vorbis_channel_layout_offsets
const uint8_t ff_vorbis_channel_layout_offsets[8][8]
Definition: vorbis_data.c:26
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:204
vorbis_floor_data
union vorbis_floor_u vorbis_floor_data
Definition: vorbisdec.c:59
vorbis_parse_setup_hdr
static int vorbis_parse_setup_hdr(vorbis_context *vc)
Definition: vorbisdec.c:915
exp
int8_t exp
Definition: eval.c:72
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
vorbis_mapping
Definition: vorbisdec.c:109
float_dsp.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
vorbis_floor0
struct vorbis_floor0_s vorbis_floor0
Definition: vorbisdec.c:60
vorbis_mapping::coupling_steps
uint16_t coupling_steps
Definition: vorbisdec.c:111
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:95
vorbis_decode_init
static av_cold int vorbis_decode_init(AVCodecContext *avctx)
Definition: vorbisdec.c:1031
vorbis_floor
Definition: vorbisdec.c:66
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
vorbis_mapping::submap_residue
uint8_t submap_residue[16]
Definition: vorbisdec.c:116
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
vorbis_decode_frame
static int vorbis_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: vorbisdec.c:1770
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::amplitude_bits
uint8_t amplitude_bits
Definition: vorbisdec.c:76
ff_vorbis_ready_floor1_list
int ff_vorbis_ready_floor1_list(AVCodecContext *avctx, vorbis_floor1_entry *list, int values)
Definition: vorbis.c:106
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
vorbis_mode::blockflag
uint8_t blockflag
Definition: vorbisdec.c:120
AVPacket::size
int size
Definition: packet.h:375
vorbis_parse_setup_hdr_floors
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
Definition: vorbisdec.c:500
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::map_size
uint32_t map_size[2]
Definition: vorbisdec.c:75
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ff_vorbisdsp_init
av_cold void ff_vorbisdsp_init(VorbisDSPContext *dsp)
Definition: vorbisdsp.c:24
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:154
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::multiplier
uint8_t multiplier
Definition: vorbisdec.c:89
vorbisdsp.h
vorbis_codebook::vlc
VLC vlc
Definition: vorbisdec.c:54
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_dimensions
uint8_t class_dimensions[16]
Definition: vorbisdec.c:85
AVFloatDSPContext
Definition: float_dsp.h:24
vorbis_context_s::bitrate_minimum
uint32_t bitrate_minimum
Definition: vorbisdec.c:139
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::x_list_dim
uint16_t x_list_dim
Definition: vorbisdec.c:90
vorbis_mode::mapping
uint8_t mapping
Definition: vorbisdec.c:123
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_masterbook
uint8_t class_masterbook[16]
Definition: vorbisdec.c:87
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::subclass_books
int16_t subclass_books[16][8]
Definition: vorbisdec.c:88
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
vorbis_codebook::maxdepth
uint8_t maxdepth
Definition: vorbisdec.c:53
vorbis_floor1_decode
static int vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
Definition: vorbisdec.c:1212
vorbis_residue
Definition: vorbisdec.c:96
vorbis_residue::end
uint32_t end
Definition: vorbisdec.c:99
ff_vorbis_inverse_coupling
void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
Definition: vorbisdec.c:1581
M_PI
#define M_PI
Definition: mathematics.h:52
vorbis_context_s::dsp
VorbisDSPContext dsp
Definition: vorbisdec.c:129
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
flag
#define flag(name)
Definition: cbs_av1.c:553
vorbis_residue::type
uint16_t type
Definition: vorbisdec.c:97
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
vorbis.h
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
vorbis_context_s::floor_count
uint8_t floor_count
Definition: vorbisdec.c:144
vorbis_context_s::codebooks
vorbis_codebook * codebooks
Definition: vorbisdec.c:143
vorbis_residue_decode_internal
static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left, int vr_type)
Definition: vorbisdec.c:1388
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
V_MAX_VLCS
#define V_MAX_VLCS
Definition: vorbisdec.c:47
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
vorbis_context_s
Definition: vorbisdec.c:126
av_always_inline
#define av_always_inline
Definition: attributes.h:49
vorbis_parse_setup_hdr_mappings
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
Definition: vorbisdec.c:771
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
vorbis_context_s::residues
vorbis_residue * residues
Definition: vorbisdec.c:147
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
vorbis_residue::classifications
uint8_t classifications
Definition: vorbisdec.c:101
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
len
int len
Definition: vorbis_enc_data.h:426
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
vorbis_mapping::submap_floor
uint8_t submap_floor[16]
Definition: vorbisdec.c:115
avcodec.h
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::list
vorbis_floor1_entry * list
Definition: vorbisdec.c:91
dim
int dim
Definition: vorbis_enc_data.h:425
V_NB_BITS
#define V_NB_BITS
Definition: vorbisdec.c:45
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
vorbis_residue::begin
uint32_t begin
Definition: vorbisdec.c:98
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:398
ilog
#define ilog(i)
Definition: vorbis.h:50
V_NB_BITS2
#define V_NB_BITS2
Definition: vorbisdec.c:46
setup_classifs
static av_always_inline int setup_classifs(vorbis_context *vc, vorbis_residue *vr, uint8_t *do_not_decode, unsigned ch_used, int partition_count, int ptns_to_read)
Definition: vorbisdec.c:1339
vorbis_context_s::avctx
AVCodecContext * avctx
Definition: vorbisdec.c:127
VLC
Definition: vlc.h:31
vorbis_context_s::channel_residues
float * channel_residues
Definition: vorbisdec.c:154
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
vorbis_mapping::magnitude
uint8_t * magnitude
Definition: vorbisdec.c:112
vorbis_context_s::mappings
vorbis_mapping * mappings
Definition: vorbisdec.c:149
temp
else temp
Definition: vf_mcdeint.c:248
L
#define L(x)
Definition: vpx_arith.h:36
vorbis_codebook
Definition: vorbisdec.c:50
avpriv_split_xiph_headers
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use.
Definition: xiph.c:26
av_clip_uint16
#define av_clip_uint16
Definition: common.h:107
vorbis_context_s::mode_count
uint8_t mode_count
Definition: vorbisdec.c:150
vorbis_codebook::lookup_type
uint8_t lookup_type
Definition: vorbisdec.c:52
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
vorbis_context_s::mapping_count
uint8_t mapping_count
Definition: vorbisdec.c:148
vorbis_parse_setup_hdr_codebooks
static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
Definition: vorbisdec.c:239
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::order
uint8_t order
Definition: vorbisdec.c:71
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::book_list
uint8_t * book_list
Definition: vorbisdec.c:79
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
vorbis_floor::vorbis_floor_u::vorbis_floor1_s
Definition: vorbisdec.c:82
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
vorbis_context_s::bitrate_maximum
uint32_t bitrate_maximum
Definition: vorbisdec.c:137
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::amplitude_offset
uint8_t amplitude_offset
Definition: vorbisdec.c:77
int32_t
int32_t
Definition: audioconvert.c:56
vorbis_floor::vorbis_floor_u::vorbis_floor0_s
Definition: vorbisdec.c:70
vorbis_context_s::saved
float * saved
Definition: vorbisdec.c:155
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:434
vorbis_residue::classifs
uint8_t * classifs
Definition: vorbisdec.c:106
vorbis_context_s::mdct
FFTContext mdct[2]
Definition: vorbisdec.c:132
vorbis_context_s::first_frame
uint8_t first_frame
Definition: vorbisdec.c:133
vorbis_floor::decode
vorbis_floor_decode_func decode
Definition: vorbisdec.c:68
vorbis_decode_flush
static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
Definition: vorbisdec.c:1875
int
int
Definition: ffmpeg_filter.c:155
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::rate
uint16_t rate
Definition: vorbisdec.c:72
vorbis_parse_setup_hdr_modes
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
Definition: vorbisdec.c:886
vorbis_floor::vorbis_floor_u::t1
struct vorbis_floor::vorbis_floor_u::vorbis_floor1_s t1
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::num_books
uint8_t num_books
Definition: vorbisdec.c:78
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
vorbis_residue::partition_size
unsigned partition_size
Definition: vorbisdec.c:100
vorbis_codebook::dimensions
uint8_t dimensions
Definition: vorbisdec.c:51