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 book_idx;
1101  uint64_t amplitude;
1102  unsigned blockflag = vc->modes[vc->mode_number].blockflag;
1103 
1104  if (!vf->amplitude_bits)
1105  return 1;
1106 
1107  amplitude = get_bits64(&vc->gb, vf->amplitude_bits);
1108  if (amplitude > 0) {
1109  float last = 0;
1110  unsigned idx, lsp_len = 0;
1111  vorbis_codebook codebook;
1112 
1113  book_idx = get_bits(&vc->gb, ilog(vf->num_books));
1114  if (book_idx >= vf->num_books) {
1115  av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");
1116  book_idx = 0;
1117  }
1118  ff_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);
1119  codebook = vc->codebooks[vf->book_list[book_idx]];
1120  /* Invalid codebook! */
1121  if (!codebook.codevectors)
1122  return AVERROR_INVALIDDATA;
1123 
1124  while (lsp_len<vf->order) {
1125  int vec_off;
1126 
1127  ff_dlog(NULL, "floor0 dec: book dimension: %d\n", codebook.dimensions);
1128  ff_dlog(NULL, "floor0 dec: maximum depth: %d\n", codebook.maxdepth);
1129  /* read temp vector */
1130  vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
1131  codebook.nb_bits, codebook.maxdepth);
1132  if (vec_off < 0)
1133  return AVERROR_INVALIDDATA;
1134  vec_off *= codebook.dimensions;
1135  ff_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);
1136  /* copy each vector component and add last to it */
1137  for (idx = 0; idx < codebook.dimensions; ++idx)
1138  lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;
1139  last = lsp[lsp_len+idx-1]; /* set last to last vector component */
1140 
1141  lsp_len += codebook.dimensions;
1142  }
1143  /* DEBUG: output lsp coeffs */
1144  {
1145  int idx;
1146  for (idx = 0; idx < lsp_len; ++idx)
1147  ff_dlog(NULL, "floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
1148  }
1149 
1150  /* synthesize floor output vector */
1151  {
1152  int i;
1153  int order = vf->order;
1154  float wstep = M_PI / vf->bark_map_size;
1155 
1156  for (i = 0; i < order; i++)
1157  lsp[i] = 2.0f * cos(lsp[i]);
1158 
1159  ff_dlog(NULL, "floor0 synth: map_size = %"PRIu32"; m = %d; wstep = %f\n",
1160  vf->map_size[blockflag], order, wstep);
1161 
1162  i = 0;
1163  while (i < vf->map_size[blockflag]) {
1164  int j, iter_cond = vf->map[blockflag][i];
1165  float p = 0.5f;
1166  float q = 0.5f;
1167  float two_cos_w = 2.0f * cos(wstep * iter_cond); // needed all times
1168 
1169  /* similar part for the q and p products */
1170  for (j = 0; j + 1 < order; j += 2) {
1171  q *= lsp[j] - two_cos_w;
1172  p *= lsp[j + 1] - two_cos_w;
1173  }
1174  if (j == order) { // even order
1175  p *= p * (2.0f - two_cos_w);
1176  q *= q * (2.0f + two_cos_w);
1177  } else { // odd order
1178  q *= two_cos_w-lsp[j]; // one more time for q
1179 
1180  /* final step and square */
1181  p *= p * (4.f - two_cos_w * two_cos_w);
1182  q *= q;
1183  }
1184 
1185  if (p + q == 0.0)
1186  return AVERROR_INVALIDDATA;
1187 
1188  /* calculate linear floor value */
1189  q = exp((((amplitude*vf->amplitude_offset) /
1190  (((1ULL << vf->amplitude_bits) - 1) * sqrt(p + q)))
1191  - vf->amplitude_offset) * .11512925f);
1192 
1193  /* fill vector */
1194  do {
1195  vec[i] = q; ++i;
1196  } while (vf->map[blockflag][i] == iter_cond);
1197  }
1198  }
1199  } else {
1200  /* this channel is unused */
1201  return 1;
1202  }
1203 
1204  ff_dlog(NULL, " Floor0 decoded\n");
1205 
1206  return 0;
1207 }
1208 
1210  vorbis_floor_data *vfu, float *vec)
1211 {
1212  vorbis_floor1 *vf = &vfu->t1;
1213  GetBitContext *gb = &vc->gb;
1214  uint16_t range_v[4] = { 256, 128, 86, 64 };
1215  unsigned range = range_v[vf->multiplier - 1];
1216  uint16_t floor1_Y[258];
1217  uint16_t floor1_Y_final[258];
1218  int floor1_flag[258];
1219  unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
1220  int book, adx, ady, dy, off, predicted, err;
1221 
1222 
1223  if (!get_bits1(gb)) // silence
1224  return 1;
1225 
1226 // Read values (or differences) for the floor's points
1227 
1228  floor1_Y[0] = get_bits(gb, ilog(range - 1));
1229  floor1_Y[1] = get_bits(gb, ilog(range - 1));
1230 
1231  ff_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1232 
1233  offset = 2;
1234  for (i = 0; i < vf->partitions; ++i) {
1235  partition_class = vf->partition_class[i];
1236  cdim = vf->class_dimensions[partition_class];
1237  cbits = vf->class_subclasses[partition_class];
1238  csub = (1 << cbits) - 1;
1239  cval = 0;
1240 
1241  ff_dlog(NULL, "Cbits %u\n", cbits);
1242 
1243  if (cbits) // this reads all subclasses for this partition's class
1244  cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
1245  vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
1246 
1247  for (j = 0; j < cdim; ++j) {
1248  book = vf->subclass_books[partition_class][cval & csub];
1249 
1250  ff_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",
1251  book, cbits, cval, get_bits_count(gb));
1252 
1253  cval = cval >> cbits;
1254  if (book > -1) {
1255  int v = get_vlc2(gb, vc->codebooks[book].vlc.table,
1256  vc->codebooks[book].nb_bits, 3);
1257  if (v < 0)
1258  return AVERROR_INVALIDDATA;
1259  floor1_Y[offset+j] = v;
1260  } else {
1261  floor1_Y[offset+j] = 0;
1262  }
1263 
1264  ff_dlog(NULL, " floor(%d) = %d \n",
1265  vf->list[offset+j].x, floor1_Y[offset+j]);
1266  }
1267  offset+=cdim;
1268  }
1269 
1270 // Amplitude calculation from the differences
1271 
1272  floor1_flag[0] = 1;
1273  floor1_flag[1] = 1;
1274  floor1_Y_final[0] = floor1_Y[0];
1275  floor1_Y_final[1] = floor1_Y[1];
1276 
1277  for (i = 2; i < vf->x_list_dim; ++i) {
1278  unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
1279 
1280  low_neigh_offs = vf->list[i].low;
1281  high_neigh_offs = vf->list[i].high;
1282  dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs]; // render_point begin
1283  adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
1284  ady = FFABS(dy);
1285  err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
1286  off = err / adx;
1287  if (dy < 0) {
1288  predicted = floor1_Y_final[low_neigh_offs] - off;
1289  } else {
1290  predicted = floor1_Y_final[low_neigh_offs] + off;
1291  } // render_point end
1292 
1293  val = floor1_Y[i];
1294  highroom = range-predicted;
1295  lowroom = predicted;
1296  if (highroom < lowroom) {
1297  room = highroom * 2;
1298  } else {
1299  room = lowroom * 2; // SPEC misspelling
1300  }
1301  if (val) {
1302  floor1_flag[low_neigh_offs] = 1;
1303  floor1_flag[high_neigh_offs] = 1;
1304  floor1_flag[i] = 1;
1305  if (val >= room) {
1306  if (highroom > lowroom) {
1307  floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
1308  } else {
1309  floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
1310  }
1311  } else {
1312  if (val & 1) {
1313  floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
1314  } else {
1315  floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
1316  }
1317  }
1318  } else {
1319  floor1_flag[i] = 0;
1320  floor1_Y_final[i] = av_clip_uint16(predicted);
1321  }
1322 
1323  ff_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
1324  vf->list[i].x, floor1_Y_final[i], val);
1325  }
1326 
1327 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1328 
1329  ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
1330 
1331  ff_dlog(NULL, " Floor decoded\n");
1332 
1333  return 0;
1334 }
1335 
1337  vorbis_residue *vr,
1338  uint8_t *do_not_decode,
1339  unsigned ch_used,
1340  int partition_count,
1341  int ptns_to_read
1342  )
1343 {
1344  vorbis_codebook *codebook = vc->codebooks + vr->classbook;
1345  int p, j, i;
1346  unsigned c_p_c = codebook->dimensions;
1347  unsigned inverse_class = ff_inverse[vr->classifications];
1348  int temp, temp2;
1349  for (p = 0, j = 0; j < ch_used; ++j) {
1350  if (!do_not_decode[j]) {
1351  temp = get_vlc2(&vc->gb, codebook->vlc.table,
1352  codebook->nb_bits, 3);
1353 
1354  ff_dlog(NULL, "Classword: %u\n", temp);
1355 
1356  av_assert0(temp < 65536);
1357 
1358  if (temp < 0) {
1359  av_log(vc->avctx, AV_LOG_ERROR,
1360  "Invalid vlc code decoding %d channel.", j);
1361  return AVERROR_INVALIDDATA;
1362  }
1363 
1364  if (vr->classifications == 1) {
1365  for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1366  if (i < ptns_to_read)
1367  vr->classifs[p + i] = 0;
1368  }
1369  } else {
1370  for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1371  temp2 = (((uint64_t)temp) * inverse_class) >> 32;
1372 
1373  if (i < ptns_to_read)
1374  vr->classifs[p + i] = temp - temp2 * vr->classifications;
1375  temp = temp2;
1376  }
1377  }
1378  }
1379  p += ptns_to_read;
1380  }
1381  return 0;
1382 }
1383 // Read and decode residue
1384 
1386  vorbis_residue *vr,
1387  unsigned ch,
1388  uint8_t *do_not_decode,
1389  float *vec,
1390  unsigned vlen,
1391  unsigned ch_left,
1392  int vr_type)
1393 {
1394  GetBitContext *gb = &vc->gb;
1395  unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;
1396  uint8_t *classifs = vr->classifs;
1397  unsigned pass, ch_used, i, j, k, l;
1398  unsigned max_output = (ch - 1) * vlen;
1399  int ptns_to_read = vr->ptns_to_read;
1400  int libvorbis_bug = 0;
1401 
1402  if (vr_type == 2) {
1403  for (j = 1; j < ch; ++j)
1404  do_not_decode[0] &= do_not_decode[j]; // FIXME - clobbering input
1405  if (do_not_decode[0])
1406  return 0;
1407  ch_used = 1;
1408  max_output += vr->end / ch;
1409  } else {
1410  ch_used = ch;
1411  max_output += vr->end;
1412  }
1413 
1414  if (max_output > ch_left * vlen) {
1415  if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {
1416  ptns_to_read--;
1417  libvorbis_bug = 1;
1418  } else {
1419  av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
1420  return AVERROR_INVALIDDATA;
1421  }
1422  }
1423 
1424  ff_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);
1425 
1426  for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?
1427  int voffset, partition_count, j_times_ptns_to_read;
1428 
1429  voffset = vr->begin;
1430  for (partition_count = 0; partition_count < ptns_to_read;) { // SPEC error
1431  if (!pass) {
1432  int ret = setup_classifs(vc, vr, do_not_decode, ch_used, partition_count, ptns_to_read);
1433  if (ret < 0)
1434  return ret;
1435  }
1436  for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {
1437  for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
1438  unsigned voffs;
1439 
1440  if (!do_not_decode[j]) {
1441  unsigned vqclass = classifs[j_times_ptns_to_read + partition_count];
1442  int vqbook = vr->books[vqclass][pass];
1443 
1444  if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {
1445  unsigned coffs;
1446  unsigned dim = vc->codebooks[vqbook].dimensions;
1447  unsigned step = FASTDIV(vr->partition_size << 1, dim << 1);
1448  vorbis_codebook codebook = vc->codebooks[vqbook];
1449 
1450  if (vr_type == 0) {
1451 
1452  voffs = voffset+j*vlen;
1453  for (k = 0; k < step; ++k) {
1454  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
1455  for (l = 0; l < dim; ++l)
1456  vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
1457  }
1458  } else if (vr_type == 1) {
1459  voffs = voffset + j * vlen;
1460  for (k = 0; k < step; ++k) {
1461  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
1462  for (l = 0; l < dim; ++l, ++voffs) {
1463  vec[voffs]+=codebook.codevectors[coffs+l];
1464 
1465  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1466  pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1467  }
1468  }
1469  } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized
1470  voffs = voffset >> 1;
1471 
1472  if (dim == 2) {
1473  for (k = 0; k < step; ++k) {
1474  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 2;
1475  vec[voffs + k ] += codebook.codevectors[coffs ];
1476  vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
1477  }
1478  } else if (dim == 4) {
1479  for (k = 0; k < step; ++k, voffs += 2) {
1480  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 4;
1481  vec[voffs ] += codebook.codevectors[coffs ];
1482  vec[voffs + 1 ] += codebook.codevectors[coffs + 2];
1483  vec[voffs + vlen ] += codebook.codevectors[coffs + 1];
1484  vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
1485  }
1486  } else
1487  for (k = 0; k < step; ++k) {
1488  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
1489  for (l = 0; l < dim; l += 2, voffs++) {
1490  vec[voffs ] += codebook.codevectors[coffs + l ];
1491  vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
1492 
1493  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1494  pass, voffset / ch + (voffs % ch) * vlen,
1495  vec[voffset / ch + (voffs % ch) * vlen],
1496  codebook.codevectors[coffs + l], coffs, l);
1497  }
1498  }
1499 
1500  } else if (vr_type == 2) {
1501  unsigned voffs_div = FASTDIV(voffset << 1, ch <<1);
1502  unsigned voffs_mod = voffset - voffs_div * ch;
1503 
1504  for (k = 0; k < step; ++k) {
1505  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;
1506  for (l = 0; l < dim; ++l) {
1507  vec[voffs_div + voffs_mod * vlen] +=
1508  codebook.codevectors[coffs + l];
1509 
1510  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1511  pass, voffs_div + voffs_mod * vlen,
1512  vec[voffs_div + voffs_mod * vlen],
1513  codebook.codevectors[coffs + l], coffs, l);
1514 
1515  if (++voffs_mod == ch) {
1516  voffs_div++;
1517  voffs_mod = 0;
1518  }
1519  }
1520  }
1521  }
1522  }
1523  }
1524  j_times_ptns_to_read += ptns_to_read;
1525  }
1526  ++partition_count;
1527  voffset += vr->partition_size;
1528  }
1529  }
1530  if (libvorbis_bug && !pass) {
1531  for (j = 0; j < ch_used; ++j) {
1532  if (!do_not_decode[j]) {
1533  get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,
1534  vc->codebooks[vr->classbook].nb_bits, 3);
1535  }
1536  }
1537  }
1538  }
1539  return 0;
1540 }
1541 
1543  unsigned ch,
1544  uint8_t *do_not_decode,
1545  float *vec, unsigned vlen,
1546  unsigned ch_left)
1547 {
1548  if (vr->type == 2)
1549  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);
1550  else if (vr->type == 1)
1551  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);
1552  else if (vr->type == 0)
1553  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
1554  else {
1555  av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1556  return AVERROR_INVALIDDATA;
1557  }
1558 }
1559 
1560 void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
1561 {
1562  int i;
1563  for (i = 0; i < blocksize; i++) {
1564  if (mag[i] > 0.0) {
1565  if (ang[i] > 0.0) {
1566  ang[i] = mag[i] - ang[i];
1567  } else {
1568  float temp = ang[i];
1569  ang[i] = mag[i];
1570  mag[i] += temp;
1571  }
1572  } else {
1573  if (ang[i] > 0.0) {
1574  ang[i] += mag[i];
1575  } else {
1576  float temp = ang[i];
1577  ang[i] = mag[i];
1578  mag[i] -= temp;
1579  }
1580  }
1581  }
1582 }
1583 
1584 // Decode the audio packet using the functions above
1585 
1586 static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
1587 {
1588  GetBitContext *gb = &vc->gb;
1589  FFTContext *mdct;
1590  int previous_window = vc->previous_window;
1591  unsigned mode_number, blockflag, blocksize;
1592  int i, j;
1593  uint8_t no_residue[255];
1594  uint8_t do_not_decode[255];
1595  vorbis_mapping *mapping;
1596  float *ch_res_ptr = vc->channel_residues;
1597  uint8_t res_chan[255];
1598  unsigned res_num = 0;
1599  int retlen = 0;
1600  unsigned ch_left = vc->audio_channels;
1601  unsigned vlen;
1602 
1603  if (get_bits1(gb)) {
1604  av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1605  return AVERROR_INVALIDDATA; // packet type not audio
1606  }
1607 
1608  if (vc->mode_count == 1) {
1609  mode_number = 0;
1610  } else {
1611  GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
1612  }
1613  vc->mode_number = mode_number;
1614  mapping = &vc->mappings[vc->modes[mode_number].mapping];
1615 
1616  ff_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
1617  vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1618 
1619  blockflag = vc->modes[mode_number].blockflag;
1620  blocksize = vc->blocksize[blockflag];
1621  vlen = blocksize / 2;
1622  if (blockflag) {
1623  int code = get_bits(gb, 2);
1624  if (previous_window < 0)
1625  previous_window = code>>1;
1626  } else if (previous_window < 0)
1627  previous_window = 0;
1628 
1629  memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?
1630  for (i = 0; i < vc->audio_channels; ++i)
1631  memset(floor_ptr[i], 0, vlen * sizeof(floor_ptr[0][0])); //FIXME can this be removed ?
1632 
1633 // Decode floor
1634 
1635  for (i = 0; i < vc->audio_channels; ++i) {
1636  vorbis_floor *floor;
1637  int ret;
1638  if (mapping->submaps > 1) {
1639  floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
1640  } else {
1641  floor = &vc->floors[mapping->submap_floor[0]];
1642  }
1643 
1644  ret = floor->decode(vc, &floor->data, floor_ptr[i]);
1645 
1646  if (ret < 0) {
1647  av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
1648  return AVERROR_INVALIDDATA;
1649  }
1650  no_residue[i] = ret;
1651  }
1652 
1653 // Nonzero vector propagate
1654 
1655  for (i = mapping->coupling_steps - 1; i >= 0; --i) {
1656  if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1657  no_residue[mapping->magnitude[i]] = 0;
1658  no_residue[mapping->angle[i]] = 0;
1659  }
1660  }
1661 
1662 // Decode residue
1663 
1664  for (i = 0; i < mapping->submaps; ++i) {
1665  vorbis_residue *residue;
1666  unsigned ch = 0;
1667  int ret;
1668 
1669  for (j = 0; j < vc->audio_channels; ++j) {
1670  if ((mapping->submaps == 1) || (i == mapping->mux[j])) {
1671  res_chan[j] = res_num;
1672  if (no_residue[j]) {
1673  do_not_decode[ch] = 1;
1674  } else {
1675  do_not_decode[ch] = 0;
1676  }
1677  ++ch;
1678  ++res_num;
1679  }
1680  }
1681  residue = &vc->residues[mapping->submap_residue[i]];
1682  if (ch_left < ch) {
1683  av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
1684  return AVERROR_INVALIDDATA;
1685  }
1686  if (ch) {
1687  ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);
1688  if (ret < 0)
1689  return ret;
1690  }
1691 
1692  ch_res_ptr += ch * vlen;
1693  ch_left -= ch;
1694  }
1695 
1696  if (ch_left > 0)
1697  return AVERROR_INVALIDDATA;
1698 
1699 // Inverse coupling
1700 
1701  for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed
1702  float *mag, *ang;
1703 
1704  mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
1705  ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;
1706  vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
1707  }
1708 
1709 // Dotproduct, MDCT
1710 
1711  mdct = &vc->mdct[blockflag];
1712 
1713  for (j = vc->audio_channels-1;j >= 0; j--) {
1714  ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
1715  vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1716  mdct->imdct_half(mdct, ch_res_ptr, floor_ptr[j]);
1717  }
1718 
1719 // Overlap/add, save data for next overlapping
1720 
1721  retlen = (blocksize + vc->blocksize[previous_window]) / 4;
1722  for (j = 0; j < vc->audio_channels; j++) {
1723  unsigned bs0 = vc->blocksize[0];
1724  unsigned bs1 = vc->blocksize[1];
1725  float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;
1726  float *saved = vc->saved + j * bs1 / 4;
1727  float *ret = floor_ptr[j];
1728  float *buf = residue;
1729  const float *win = vc->win[blockflag & previous_window];
1730 
1731  if (blockflag == previous_window) {
1732  vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);
1733  } else if (blockflag > previous_window) {
1734  vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);
1735  memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) * sizeof(float));
1736  } else {
1737  memcpy(ret, saved, ((bs1 - bs0) / 4) * sizeof(float));
1738  vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);
1739  }
1740  memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));
1741  }
1742 
1743  vc->previous_window = blockflag;
1744  return retlen;
1745 }
1746 
1747 // Return the decoded audio packet through the standard api
1748 
1749 static int vorbis_decode_frame(AVCodecContext *avctx, void *data,
1750  int *got_frame_ptr, AVPacket *avpkt)
1751 {
1752  const uint8_t *buf = avpkt->data;
1753  int buf_size = avpkt->size;
1754  vorbis_context *vc = avctx->priv_data;
1755  AVFrame *frame = data;
1756  GetBitContext *gb = &vc->gb;
1757  float *channel_ptrs[255];
1758  int i, len, ret;
1759 
1760  ff_dlog(NULL, "packet length %d \n", buf_size);
1761 
1762  if (*buf == 1 && buf_size > 7) {
1763  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1764  return ret;
1765 
1766  vorbis_free(vc);
1767  if ((ret = vorbis_parse_id_hdr(vc))) {
1768  av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1769  vorbis_free(vc);
1770  return ret;
1771  }
1772 
1773  if (vc->audio_channels > 8)
1774  avctx->channel_layout = 0;
1775  else
1777 
1778  avctx->channels = vc->audio_channels;
1779  avctx->sample_rate = vc->audio_samplerate;
1780  return buf_size;
1781  }
1782 
1783  if (*buf == 3 && buf_size > 7) {
1784  av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");
1785  return buf_size;
1786  }
1787 
1788  if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
1789  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1790  return ret;
1791 
1792  if ((ret = vorbis_parse_setup_hdr(vc))) {
1793  av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1794  vorbis_free(vc);
1795  return ret;
1796  }
1797  return buf_size;
1798  }
1799 
1800  if (!vc->channel_residues || !vc->modes) {
1801  av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");
1802  return AVERROR_INVALIDDATA;
1803  }
1804 
1805  /* get output buffer */
1806  frame->nb_samples = vc->blocksize[1] / 2;
1807  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1808  return ret;
1809 
1810  if (vc->audio_channels > 8) {
1811  for (i = 0; i < vc->audio_channels; i++)
1812  channel_ptrs[i] = (float *)frame->extended_data[i];
1813  } else {
1814  for (i = 0; i < vc->audio_channels; i++) {
1816  channel_ptrs[ch] = (float *)frame->extended_data[i];
1817  }
1818  }
1819 
1820  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
1821  return ret;
1822 
1823  if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
1824  return len;
1825 
1826  if (!vc->first_frame) {
1827  vc->first_frame = 1;
1828  *got_frame_ptr = 0;
1829  av_frame_unref(frame);
1830  return buf_size;
1831  }
1832 
1833  ff_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1834  get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
1835 
1836  frame->nb_samples = len;
1837  *got_frame_ptr = 1;
1838 
1839  return buf_size;
1840 }
1841 
1842 // Close decoder
1843 
1845 {
1846  vorbis_context *vc = avctx->priv_data;
1847 
1848  vorbis_free(vc);
1849 
1850  return 0;
1851 }
1852 
1854 {
1855  vorbis_context *vc = avctx->priv_data;
1856 
1857  if (vc->saved) {
1858  memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *
1859  sizeof(*vc->saved));
1860  }
1861  vc->previous_window = -1;
1862  vc->first_frame = 0;
1863 }
1864 
1866  .name = "vorbis",
1867  .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
1868  .type = AVMEDIA_TYPE_AUDIO,
1869  .id = AV_CODEC_ID_VORBIS,
1870  .priv_data_size = sizeof(vorbis_context),
1872  .close = vorbis_decode_close,
1875  .capabilities = AV_CODEC_CAP_DR1,
1876  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1878  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1880 };
#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:295
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:1560
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:1844
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:3481
#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:1385
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:2233
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
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
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:259
#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:1209
#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:3488
uint8_t bits
Definition: vp3data.h:202
AVCodec ff_vorbis_decoder
Definition: vorbisdec.c:1865
#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:2276
#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:1336
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:1749
int sample_rate
samples per second
Definition: avcodec.h:2225
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:1963
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:1542
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:2226
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:342
static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
Definition: vorbisdec.c:1853
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:1586
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#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