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