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