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 {
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;
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 
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;
155 } vorbis_context;
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 
192  av_freep(&vc->channel_residues);
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 
238 static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
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) {
268  av_log(vc->avctx, AV_LOG_ERROR,
269  " %u. Codebook setup data corrupt.\n", cb);
271  goto error;
272  }
273 
274  codebook_setup->dimensions=get_bits(gb, 16);
275  if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {
276  av_log(vc->avctx, AV_LOG_ERROR,
277  " %u. Codebook's dimension is invalid (%d).\n",
278  cb, codebook_setup->dimensions);
280  goto error;
281  }
282  entries = get_bits(gb, 24);
283  if (entries > V_MAX_VLCS) {
284  av_log(vc->avctx, AV_LOG_ERROR,
285  " %u. Codebook has too many entries (%u).\n",
286  cb, entries);
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");
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");
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");
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");
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 
473 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
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);
499 static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
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]) {
549  GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
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) {
577  av_log(vc->avctx, AV_LOG_ERROR,
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) {
583  av_log(vc->avctx, AV_LOG_ERROR,
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
601  if (ff_vorbis_ready_floor1_list(vc->avctx,
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) {
623  av_log(vc->avctx, AV_LOG_ERROR,
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 
689 static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
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)) {
716  av_log(vc->avctx, AV_LOG_ERROR,
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 
770 static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
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) {
798  av_log(vc->avctx, AV_LOG_ERROR,
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 
885 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
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 
914 static int vorbis_parse_setup_hdr(vorbis_context *vc)
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 
927  av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
928  return ret;
929  }
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 
960 static int vorbis_parse_id_hdr(vorbis_context *vc)
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);
1011  vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & AV_CODEC_FLAG_BITEXACT);
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 ",
1016  vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
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
1083  avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
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 
1095 static int vorbis_floor0_decode(vorbis_context *vc,
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 
1209 static int vorbis_floor1_decode(vorbis_context *vc,
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 
1336 static av_always_inline int setup_classifs(vorbis_context *vc,
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 
1385 static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
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  int 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);
1455  if (coffs < 0)
1456  return coffs;
1457  coffs *= dim;
1458  for (l = 0; l < dim; ++l)
1459  vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
1460  }
1461  } else if (vr_type == 1) {
1462  voffs = voffset + j * vlen;
1463  for (k = 0; k < step; ++k) {
1464  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1465  if (coffs < 0)
1466  return coffs;
1467  coffs *= dim;
1468  for (l = 0; l < dim; ++l, ++voffs) {
1469  vec[voffs]+=codebook.codevectors[coffs+l];
1470 
1471  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",
1472  pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1473  }
1474  }
1475  } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized
1476  voffs = voffset >> 1;
1477 
1478  if (dim == 2) {
1479  for (k = 0; k < step; ++k) {
1480  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1481  if (coffs < 0)
1482  return coffs;
1483  coffs *= 2;
1484  vec[voffs + k ] += codebook.codevectors[coffs ];
1485  vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
1486  }
1487  } else if (dim == 4) {
1488  for (k = 0; k < step; ++k, voffs += 2) {
1489  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1490  if (coffs < 0)
1491  return coffs;
1492  coffs *= 4;
1493  vec[voffs ] += codebook.codevectors[coffs ];
1494  vec[voffs + 1 ] += codebook.codevectors[coffs + 2];
1495  vec[voffs + vlen ] += codebook.codevectors[coffs + 1];
1496  vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
1497  }
1498  } else
1499  for (k = 0; k < step; ++k) {
1500  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1501  if (coffs < 0)
1502  return coffs;
1503  coffs *= dim;
1504  for (l = 0; l < dim; l += 2, voffs++) {
1505  vec[voffs ] += codebook.codevectors[coffs + l ];
1506  vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
1507 
1508  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1509  pass, voffset / ch + (voffs % ch) * vlen,
1510  vec[voffset / ch + (voffs % ch) * vlen],
1511  codebook.codevectors[coffs + l], coffs, l);
1512  }
1513  }
1514 
1515  } else if (vr_type == 2) {
1516  unsigned voffs_div = ch == 1 ? voffset : FASTDIV(voffset, ch);
1517  unsigned voffs_mod = voffset - voffs_div * ch;
1518 
1519  for (k = 0; k < step; ++k) {
1520  coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1521  if (coffs < 0)
1522  return coffs;
1523  coffs *= dim;
1524  for (l = 0; l < dim; ++l) {
1525  vec[voffs_div + voffs_mod * vlen] +=
1526  codebook.codevectors[coffs + l];
1527 
1528  ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",
1529  pass, voffs_div + voffs_mod * vlen,
1530  vec[voffs_div + voffs_mod * vlen],
1531  codebook.codevectors[coffs + l], coffs, l);
1532 
1533  if (++voffs_mod == ch) {
1534  voffs_div++;
1535  voffs_mod = 0;
1536  }
1537  }
1538  }
1539  }
1540  }
1541  }
1542  j_times_ptns_to_read += ptns_to_read;
1543  }
1544  ++partition_count;
1545  voffset += vr->partition_size;
1546  }
1547  }
1548  if (libvorbis_bug && !pass) {
1549  for (j = 0; j < ch_used; ++j) {
1550  if (!do_not_decode[j]) {
1551  get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,
1552  vc->codebooks[vr->classbook].nb_bits, 3);
1553  }
1554  }
1555  }
1556  }
1557  return 0;
1558 }
1559 
1560 static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
1561  unsigned ch,
1562  uint8_t *do_not_decode,
1563  float *vec, unsigned vlen,
1564  unsigned ch_left)
1565 {
1566  if (vr->type == 2)
1567  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);
1568  else if (vr->type == 1)
1569  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);
1570  else if (vr->type == 0)
1571  return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
1572  else {
1573  av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1574  return AVERROR_INVALIDDATA;
1575  }
1576 }
1577 
1578 void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
1579 {
1580  int i;
1581  for (i = 0; i < blocksize; i++) {
1582  if (mag[i] > 0.0) {
1583  if (ang[i] > 0.0) {
1584  ang[i] = mag[i] - ang[i];
1585  } else {
1586  float temp = ang[i];
1587  ang[i] = mag[i];
1588  mag[i] += temp;
1589  }
1590  } else {
1591  if (ang[i] > 0.0) {
1592  ang[i] += mag[i];
1593  } else {
1594  float temp = ang[i];
1595  ang[i] = mag[i];
1596  mag[i] -= temp;
1597  }
1598  }
1599  }
1600 }
1601 
1602 // Decode the audio packet using the functions above
1603 
1604 static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
1605 {
1606  GetBitContext *gb = &vc->gb;
1607  FFTContext *mdct;
1608  int previous_window = vc->previous_window;
1609  unsigned mode_number, blockflag, blocksize;
1610  int i, j;
1611  uint8_t no_residue[255];
1612  uint8_t do_not_decode[255];
1613  vorbis_mapping *mapping;
1614  float *ch_res_ptr = vc->channel_residues;
1615  uint8_t res_chan[255];
1616  unsigned res_num = 0;
1617  int retlen = 0;
1618  unsigned ch_left = vc->audio_channels;
1619  unsigned vlen;
1620 
1621  if (get_bits1(gb)) {
1622  av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1623  return AVERROR_INVALIDDATA; // packet type not audio
1624  }
1625 
1626  if (vc->mode_count == 1) {
1627  mode_number = 0;
1628  } else {
1629  GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
1630  }
1631  vc->mode_number = mode_number;
1632  mapping = &vc->mappings[vc->modes[mode_number].mapping];
1633 
1634  ff_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
1635  vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1636 
1637  blockflag = vc->modes[mode_number].blockflag;
1638  blocksize = vc->blocksize[blockflag];
1639  vlen = blocksize / 2;
1640  if (blockflag) {
1641  int code = get_bits(gb, 2);
1642  if (previous_window < 0)
1643  previous_window = code>>1;
1644  } else if (previous_window < 0)
1645  previous_window = 0;
1646 
1647  memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?
1648  for (i = 0; i < vc->audio_channels; ++i)
1649  memset(floor_ptr[i], 0, vlen * sizeof(floor_ptr[0][0])); //FIXME can this be removed ?
1650 
1651 // Decode floor
1652 
1653  for (i = 0; i < vc->audio_channels; ++i) {
1654  vorbis_floor *floor;
1655  int ret;
1656  if (mapping->submaps > 1) {
1657  floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
1658  } else {
1659  floor = &vc->floors[mapping->submap_floor[0]];
1660  }
1661 
1662  ret = floor->decode(vc, &floor->data, floor_ptr[i]);
1663 
1664  if (ret < 0) {
1665  av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
1666  return AVERROR_INVALIDDATA;
1667  }
1668  no_residue[i] = ret;
1669  }
1670 
1671 // Nonzero vector propagate
1672 
1673  for (i = mapping->coupling_steps - 1; i >= 0; --i) {
1674  if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1675  no_residue[mapping->magnitude[i]] = 0;
1676  no_residue[mapping->angle[i]] = 0;
1677  }
1678  }
1679 
1680 // Decode residue
1681 
1682  for (i = 0; i < mapping->submaps; ++i) {
1683  vorbis_residue *residue;
1684  unsigned ch = 0;
1685  int ret;
1686 
1687  for (j = 0; j < vc->audio_channels; ++j) {
1688  if ((mapping->submaps == 1) || (i == mapping->mux[j])) {
1689  res_chan[j] = res_num;
1690  if (no_residue[j]) {
1691  do_not_decode[ch] = 1;
1692  } else {
1693  do_not_decode[ch] = 0;
1694  }
1695  ++ch;
1696  ++res_num;
1697  }
1698  }
1699  residue = &vc->residues[mapping->submap_residue[i]];
1700  if (ch_left < ch) {
1701  av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
1702  return AVERROR_INVALIDDATA;
1703  }
1704  if (ch) {
1705  ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);
1706  if (ret < 0)
1707  return ret;
1708  }
1709 
1710  ch_res_ptr += ch * vlen;
1711  ch_left -= ch;
1712  }
1713 
1714  if (ch_left > 0)
1715  return AVERROR_INVALIDDATA;
1716 
1717 // Inverse coupling
1718 
1719  for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed
1720  float *mag, *ang;
1721 
1722  mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
1723  ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;
1724  vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
1725  }
1726 
1727 // Dotproduct, MDCT
1728 
1729  mdct = &vc->mdct[blockflag];
1730 
1731  for (j = vc->audio_channels-1;j >= 0; j--) {
1732  ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;
1733  vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1734  mdct->imdct_half(mdct, ch_res_ptr, floor_ptr[j]);
1735  }
1736 
1737 // Overlap/add, save data for next overlapping
1738 
1739  retlen = (blocksize + vc->blocksize[previous_window]) / 4;
1740  for (j = 0; j < vc->audio_channels; j++) {
1741  unsigned bs0 = vc->blocksize[0];
1742  unsigned bs1 = vc->blocksize[1];
1743  float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;
1744  float *saved = vc->saved + j * bs1 / 4;
1745  float *ret = floor_ptr[j];
1746  float *buf = residue;
1747  const float *win = vc->win[blockflag & previous_window];
1748 
1749  if (blockflag == previous_window) {
1750  vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);
1751  } else if (blockflag > previous_window) {
1752  vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);
1753  memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) * sizeof(float));
1754  } else {
1755  memcpy(ret, saved, ((bs1 - bs0) / 4) * sizeof(float));
1756  vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);
1757  }
1758  memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));
1759  }
1760 
1761  vc->previous_window = blockflag;
1762  return retlen;
1763 }
1764 
1765 // Return the decoded audio packet through the standard api
1766 
1767 static int vorbis_decode_frame(AVCodecContext *avctx, void *data,
1768  int *got_frame_ptr, AVPacket *avpkt)
1769 {
1770  const uint8_t *buf = avpkt->data;
1771  int buf_size = avpkt->size;
1772  vorbis_context *vc = avctx->priv_data;
1773  AVFrame *frame = data;
1774  GetBitContext *gb = &vc->gb;
1775  float *channel_ptrs[255];
1776  int i, len, ret;
1777 
1778  ff_dlog(NULL, "packet length %d \n", buf_size);
1779 
1780  if (*buf == 1 && buf_size > 7) {
1781  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1782  return ret;
1783 
1784  vorbis_free(vc);
1785  if ((ret = vorbis_parse_id_hdr(vc))) {
1786  av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1787  vorbis_free(vc);
1788  return ret;
1789  }
1790 
1791  if (vc->audio_channels > 8)
1792  avctx->channel_layout = 0;
1793  else
1794  avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
1795 
1796  avctx->channels = vc->audio_channels;
1797  avctx->sample_rate = vc->audio_samplerate;
1798  return buf_size;
1799  }
1800 
1801  if (*buf == 3 && buf_size > 7) {
1802  av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");
1803  return buf_size;
1804  }
1805 
1806  if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
1807  if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1808  return ret;
1809 
1810  if ((ret = vorbis_parse_setup_hdr(vc))) {
1811  av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1812  vorbis_free(vc);
1813  return ret;
1814  }
1815  return buf_size;
1816  }
1817 
1818  if (!vc->channel_residues || !vc->modes) {
1819  av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");
1820  return AVERROR_INVALIDDATA;
1821  }
1822 
1823  /* get output buffer */
1824  frame->nb_samples = vc->blocksize[1] / 2;
1825  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1826  return ret;
1827 
1828  if (vc->audio_channels > 8) {
1829  for (i = 0; i < vc->audio_channels; i++)
1830  channel_ptrs[i] = (float *)frame->extended_data[i];
1831  } else {
1832  for (i = 0; i < vc->audio_channels; i++) {
1833  int ch = ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];
1834  channel_ptrs[ch] = (float *)frame->extended_data[i];
1835  }
1836  }
1837 
1838  if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
1839  return ret;
1840 
1841  if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
1842  return len;
1843 
1844  if (!vc->first_frame) {
1845  vc->first_frame = 1;
1846  *got_frame_ptr = 0;
1848  return buf_size;
1849  }
1850 
1851  ff_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1852  get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
1853 
1854  frame->nb_samples = len;
1855  *got_frame_ptr = 1;
1856 
1857  return buf_size;
1858 }
1859 
1860 // Close decoder
1861 
1863 {
1864  vorbis_context *vc = avctx->priv_data;
1865 
1866  vorbis_free(vc);
1867 
1868  return 0;
1869 }
1870 
1872 {
1873  vorbis_context *vc = avctx->priv_data;
1874 
1875  if (vc->saved) {
1876  memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *
1877  sizeof(*vc->saved));
1878  }
1879  vc->previous_window = -1;
1880  vc->first_frame = 0;
1881 }
1882 
1884  .name = "vorbis",
1885  .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
1886  .type = AVMEDIA_TYPE_AUDIO,
1887  .id = AV_CODEC_ID_VORBIS,
1888  .priv_data_size = sizeof(vorbis_context),
1890  .close = vorbis_decode_close,
1893  .capabilities = AV_CODEC_CAP_DR1,
1894  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1896  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1898 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AVCodec
AVCodec.
Definition: codec.h:190
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
BARK
#define BARK(x)
Definition: vorbisdec.c:159
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::bark_map_size
uint16_t bark_map_size
Definition: vorbisdec.c:72
create_map
static int create_map(vorbis_context *vc, unsigned floor_number)
Definition: vorbisdec.c:850
vorbis_mapping::angle
uint8_t * angle
Definition: vorbisdec.c:112
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
vorbis_floor::floor_type
uint8_t floor_type
Definition: vorbisdec.c:66
vorbis_decode_close
static av_cold int vorbis_decode_close(AVCodecContext *avctx)
Definition: vorbisdec.c:1862
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
vorbis_mode
Definition: vorbisdec.c:118
vorbis_context_s::codebook_count
uint16_t codebook_count
Definition: vorbisdec.c:141
vorbis_mapping::submaps
uint8_t submaps
Definition: vorbisdec.c:109
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
vorbis_residue::maxpass
uint8_t maxpass
Definition: vorbisdec.c:103
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
vorbis_floor::vorbis_floor_u::t0
struct vorbis_floor::vorbis_floor_u::vorbis_floor0_s t0
vorbis_context_s::residue_count
uint8_t residue_count
Definition: vorbisdec.c:145
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
vorbis_context_s::fdsp
AVFloatDSPContext * fdsp
Definition: vorbisdec.c:129
vorbis_context_s::version
uint32_t version
Definition: vorbisdec.c:133
vorbis_floor::vorbis_floor_u
Definition: vorbisdec.c:68
vorbis_mode::transformtype
uint16_t transformtype
Definition: vorbisdec.c:121
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::map
int32_t * map[2]
Definition: vorbisdec.c:73
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
ff_vorbis_vwin
const float *const ff_vorbis_vwin[8]
Definition: vorbis_data.c:2190
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
GET_VALIDATED_INDEX
#define GET_VALIDATED_INDEX(idx, bits, limit)
Definition: vorbisdec.c:170
data
const char data[16]
Definition: mxf.c:91
vorbisfloat2float
static float vorbisfloat2float(unsigned val)
Definition: vorbisdec.c:176
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
idx_err_str
static const char idx_err_str[]
Definition: vorbisdec.c:162
vorbis_floor1
struct vorbis_floor1_s vorbis_floor1
Definition: vorbisdec.c:60
vorbis_context_s::previous_window
int8_t previous_window
Definition: vorbisdec.c:152
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
get_vlc2
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
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_subclasses
uint8_t class_subclasses[16]
Definition: vorbisdec.c:85
vorbis_residue_decode
static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left)
Definition: vorbisdec.c:1560
vorbis_residue::books
int16_t books[64][8]
Definition: vorbisdec.c:102
INIT_VLC_LE
#define INIT_VLC_LE
Definition: vlc.h:54
ff_inverse
const uint32_t ff_inverse[257]
Definition: mathtables.c:27
vorbis_floor1_entry::x
uint16_t x
Definition: vorbis.h:33
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
ff_vorbis_nth_root
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
Definition: vorbis.c:38
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
vorbis_free
static void vorbis_free(vorbis_context *vc)
Definition: vorbisdec.c:188
xiph.h
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
GetBitContext
Definition: get_bits.h:61
ff_vorbis_floor1_render_list
void ff_vorbis_floor1_render_list(vorbis_floor1_entry *list, int values, uint16_t *y_list, int *flag, int multiplier, float *out, int samples)
Definition: vorbis.c:196
val
static double val(void *priv, double ch)
Definition: aeval.c:76
vorbis_floor::data
union vorbis_floor::vorbis_floor_u data
vorbis_floor_decode_func
int(* vorbis_floor_decode_func)(struct vorbis_context_s *, vorbis_floor_data *, float *)
Definition: vorbisdec.c:64
vorbis_parse_id_hdr
static int vorbis_parse_id_hdr(vorbis_context *vc)
Definition: vorbisdec.c:960
VorbisDSPContext
Definition: vorbisdsp.h:24
vorbis_context_s::gb
GetBitContext gb
Definition: vorbisdec.c:127
avassert.h
vorbis_residue::classbook
uint8_t classbook
Definition: vorbisdec.c:101
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::partition_class
uint8_t partition_class[32]
Definition: vorbisdec.c:83
V_MAX_PARTITIONS
#define V_MAX_PARTITIONS
Definition: vorbisdec.c:47
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
vorbis_floor1_entry
Definition: vorbis.h:32
vorbis_context_s::mode_number
uint8_t mode_number
Definition: vorbisdec.c:151
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
vorbis_context_s::audio_samplerate
uint32_t audio_samplerate
Definition: vorbisdec.c:135
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::lsp
float * lsp
Definition: vorbisdec.c:79
vorbis_parse_setup_hdr_tdtransforms
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
Definition: vorbisdec.c:473
vorbis_codebook::nb_bits
unsigned int nb_bits
Definition: vorbisdec.c:55
vorbis_parse_audio_packet
static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
Definition: vorbisdec.c:1604
bits
uint8_t bits
Definition: vp3data.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_vorbis_len2vlc
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
Definition: vorbis.c:56
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::partitions
uint8_t partitions
Definition: vorbisdec.c:82
vorbis_mode::windowtype
uint16_t windowtype
Definition: vorbisdec.c:120
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
get_bits.h
vorbis_context_s::bitrate_nominal
uint32_t bitrate_nominal
Definition: vorbisdec.c:137
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
vorbis_context_s::blocksize
uint32_t blocksize[2]
Definition: vorbisdec.c:139
vorbis_context_s::floors
vorbis_floor * floors
Definition: vorbisdec.c:144
f
#define f(width, name)
Definition: cbs_vp9.c:255
pass
#define pass
Definition: fft_template.c:609
vorbis_codebook::codevectors
float * codevectors
Definition: vorbisdec.c:54
vorbis_parse_setup_hdr_residues
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
Definition: vorbisdec.c:689
int32_t
int32_t
Definition: audio_convert.c:194
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
vorbis_residue::ptns_to_read
uint16_t ptns_to_read
Definition: vorbisdec.c:104
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
vorbis_mapping::mux
uint8_t * mux
Definition: vorbisdec.c:113
vorbis_context_s::audio_channels
uint8_t audio_channels
Definition: vorbisdec.c:134
VALIDATE_INDEX
#define VALIDATE_INDEX(idx, limit)
Definition: vorbisdec.c:163
vorbis_context_s::win
const float * win[2]
Definition: vorbisdec.c:140
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
vorbis_floor0_decode
static int vorbis_floor0_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
Definition: vorbisdec.c:1095
vorbis_context_s::modes
vorbis_mode * modes
Definition: vorbisdec.c:150
ff_vorbis_channel_layout_offsets
const uint8_t ff_vorbis_channel_layout_offsets[8][8]
Definition: vorbis_data.c:25
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:202
vorbis_floor_data
union vorbis_floor_u vorbis_floor_data
Definition: vorbisdec.c:58
vorbis_parse_setup_hdr
static int vorbis_parse_setup_hdr(vorbis_context *vc)
Definition: vorbisdec.c:914
exp
int8_t exp
Definition: eval.c:72
vorbis_mapping
Definition: vorbisdec.c:108
float_dsp.h
vorbis_floor0
struct vorbis_floor0_s vorbis_floor0
Definition: vorbisdec.c:59
vorbis_mapping::coupling_steps
uint16_t coupling_steps
Definition: vorbisdec.c:110
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
vorbis_decode_init
static av_cold int vorbis_decode_init(AVCodecContext *avctx)
Definition: vorbisdec.c:1030
vorbis_floor
Definition: vorbisdec.c:65
vorbis_mapping::submap_residue
uint8_t submap_residue[16]
Definition: vorbisdec.c:115
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::amplitude_bits
uint8_t amplitude_bits
Definition: vorbisdec.c:75
ff_vorbis_ready_floor1_list
int ff_vorbis_ready_floor1_list(AVCodecContext *avctx, vorbis_floor1_entry *list, int values)
Definition: vorbis.c:106
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
vorbis_mode::blockflag
uint8_t blockflag
Definition: vorbisdec.c:119
AVPacket::size
int size
Definition: packet.h:356
vorbis_parse_setup_hdr_floors
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
Definition: vorbisdec.c:499
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::map_size
uint32_t map_size[2]
Definition: vorbisdec.c:74
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_vorbisdsp_init
av_cold void ff_vorbisdsp_init(VorbisDSPContext *dsp)
Definition: vorbisdsp.c:24
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:170
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::multiplier
uint8_t multiplier
Definition: vorbisdec.c:88
vorbisdsp.h
vorbis_codebook::vlc
VLC vlc
Definition: vorbisdec.c:53
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_dimensions
uint8_t class_dimensions[16]
Definition: vorbisdec.c:84
AVFloatDSPContext
Definition: float_dsp.h:24
vorbis_context_s::bitrate_minimum
uint32_t bitrate_minimum
Definition: vorbisdec.c:138
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::x_list_dim
uint16_t x_list_dim
Definition: vorbisdec.c:89
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
vorbis_mode::mapping
uint8_t mapping
Definition: vorbisdec.c:122
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::class_masterbook
uint8_t class_masterbook[16]
Definition: vorbisdec.c:86
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::subclass_books
int16_t subclass_books[16][8]
Definition: vorbisdec.c:87
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
vorbis_codebook::maxdepth
uint8_t maxdepth
Definition: vorbisdec.c:52
vorbis_floor1_decode
static int vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec)
Definition: vorbisdec.c:1209
vorbis_residue
Definition: vorbisdec.c:95
vorbis_residue::end
uint32_t end
Definition: vorbisdec.c:98
ff_vorbis_inverse_coupling
void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
Definition: vorbisdec.c:1578
M_PI
#define M_PI
Definition: mathematics.h:52
vorbis_context_s::dsp
VorbisDSPContext dsp
Definition: vorbisdec.c:128
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:572
flag
#define flag(name)
Definition: cbs_av1.c:557
vorbis_residue::type
uint16_t type
Definition: vorbisdec.c:96
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
vorbis.h
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
vorbis_context_s::floor_count
uint8_t floor_count
Definition: vorbisdec.c:143
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
vorbis_context_s::codebooks
vorbis_codebook * codebooks
Definition: vorbisdec.c:142
vorbis_residue_decode_internal
static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc, vorbis_residue *vr, unsigned ch, uint8_t *do_not_decode, float *vec, unsigned vlen, unsigned ch_left, int vr_type)
Definition: vorbisdec.c:1385
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
V_MAX_VLCS
#define V_MAX_VLCS
Definition: vorbisdec.c:46
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
vorbis_context_s
Definition: vorbisdec.c:125
av_always_inline
#define av_always_inline
Definition: attributes.h:49
vorbis_parse_setup_hdr_mappings
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
Definition: vorbisdec.c:770
vorbis_context_s::residues
vorbis_residue * residues
Definition: vorbisdec.c:146
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
vorbis_residue::classifications
uint8_t classifications
Definition: vorbisdec.c:100
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
len
int len
Definition: vorbis_enc_data.h:452
vorbis_mapping::submap_floor
uint8_t submap_floor[16]
Definition: vorbisdec.c:114
avcodec.h
vorbis_floor::vorbis_floor_u::vorbis_floor1_s::list
vorbis_floor1_entry * list
Definition: vorbisdec.c:90
dim
int dim
Definition: vorbis_enc_data.h:451
V_NB_BITS
#define V_NB_BITS
Definition: vorbisdec.c:44
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
L
#define L(x)
Definition: vp56_arith.h:36
vorbis_residue::begin
uint32_t begin
Definition: vorbisdec.c:97
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:526
ilog
#define ilog(i)
Definition: vorbis.h:48
V_NB_BITS2
#define V_NB_BITS2
Definition: vorbisdec.c:45
setup_classifs
static av_always_inline int setup_classifs(vorbis_context *vc, vorbis_residue *vr, uint8_t *do_not_decode, unsigned ch_used, int partition_count, int ptns_to_read)
Definition: vorbisdec.c:1336
vorbis_context_s::avctx
AVCodecContext * avctx
Definition: vorbisdec.c:126
VLC
Definition: vlc.h:26
vorbis_context_s::channel_residues
float * channel_residues
Definition: vorbisdec.c:153
ff_vorbis_decoder
AVCodec ff_vorbis_decoder
Definition: vorbisdec.c:1883
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
vorbis_mapping::magnitude
uint8_t * magnitude
Definition: vorbisdec.c:111
vorbis_context_s::mappings
vorbis_mapping * mappings
Definition: vorbisdec.c:148
temp
else temp
Definition: vf_mcdeint.c:256
vorbis_codebook
Definition: vorbisdec.c:49
vorbis_decode_frame
static int vorbis_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: vorbisdec.c:1767
avpriv_split_xiph_headers
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use.
Definition: xiph.c:24
vorbis_context_s::mode_count
uint8_t mode_count
Definition: vorbisdec.c:149
vorbis_codebook::lookup_type
uint8_t lookup_type
Definition: vorbisdec.c:51
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
vorbis_context_s::mapping_count
uint8_t mapping_count
Definition: vorbisdec.c:147
vorbis_parse_setup_hdr_codebooks
static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
Definition: vorbisdec.c:238
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::order
uint8_t order
Definition: vorbisdec.c:70
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:85
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::book_list
uint8_t * book_list
Definition: vorbisdec.c:78
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
vorbis_floor::vorbis_floor_u::vorbis_floor1_s
Definition: vorbisdec.c:81
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
vorbis_context_s::bitrate_maximum
uint32_t bitrate_maximum
Definition: vorbisdec.c:136
ff_vorbis_channel_layouts
const uint64_t ff_vorbis_channel_layouts[9]
Definition: vorbis_data.c:47
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::amplitude_offset
uint8_t amplitude_offset
Definition: vorbisdec.c:76
vorbis_floor::vorbis_floor_u::vorbis_floor0_s
Definition: vorbisdec.c:69
vorbis_context_s::saved
float * saved
Definition: vorbisdec.c:154
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:415
vorbis_residue::classifs
uint8_t * classifs
Definition: vorbisdec.c:105
vorbis_context_s::mdct
FFTContext mdct[2]
Definition: vorbisdec.c:131
vorbis_context_s::first_frame
uint8_t first_frame
Definition: vorbisdec.c:132
vorbis_floor::decode
vorbis_floor_decode_func decode
Definition: vorbisdec.c:67
vorbis_decode_flush
static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
Definition: vorbisdec.c:1871
int
int
Definition: ffmpeg_filter.c:192
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::rate
uint16_t rate
Definition: vorbisdec.c:71
vorbis_parse_setup_hdr_modes
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
Definition: vorbisdec.c:885
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
vorbis_floor::vorbis_floor_u::t1
struct vorbis_floor::vorbis_floor_u::vorbis_floor1_s t1
vorbis_floor::vorbis_floor_u::vorbis_floor0_s::num_books
uint8_t num_books
Definition: vorbisdec.c:77
vorbis_residue::partition_size
unsigned partition_size
Definition: vorbisdec.c:99
vorbis_codebook::dimensions
uint8_t dimensions
Definition: vorbisdec.c:50