FFmpeg
vorbisenc.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Native Vorbis encoder.
24  * @author Oded Shimon <ods15@ods15.dyndns.org>
25  */
26 
27 #include <float.h>
28 #include "libavutil/float_dsp.h"
29 
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "fft.h"
33 #include "mathops.h"
34 #include "vorbis.h"
35 #include "vorbis_enc_data.h"
36 
37 #include "audio_frame_queue.h"
38 #include "libavfilter/bufferqueue.h"
39 
40 #define BITSTREAM_WRITER_LE
41 #include "put_bits.h"
42 
43 #undef NDEBUG
44 #include <assert.h>
45 
46 typedef struct vorbis_enc_codebook {
47  int nentries;
48  uint8_t *lens;
49  uint32_t *codewords;
50  int ndimensions;
51  float min;
52  float delta;
53  int seq_p;
54  int lookup;
55  int *quantlist;
56  float *dimensions;
57  float *pow2;
58 } vorbis_enc_codebook;
59 
60 typedef struct vorbis_enc_floor_class {
61  int dim;
62  int subclass;
63  int masterbook;
64  int *books;
65 } vorbis_enc_floor_class;
66 
67 typedef struct vorbis_enc_floor {
68  int partitions;
69  int *partition_to_class;
70  int nclasses;
71  vorbis_enc_floor_class *classes;
72  int multiplier;
73  int rangebits;
74  int values;
75  vorbis_floor1_entry *list;
76 } vorbis_enc_floor;
77 
78 typedef struct vorbis_enc_residue {
79  int type;
80  int begin;
81  int end;
82  int partition_size;
83  int classifications;
84  int classbook;
85  int8_t (*books)[8];
86  float (*maxes)[2];
87 } vorbis_enc_residue;
88 
89 typedef struct vorbis_enc_mapping {
90  int submaps;
91  int *mux;
92  int *floor;
93  int *residue;
94  int coupling_steps;
95  int *magnitude;
96  int *angle;
97 } vorbis_enc_mapping;
98 
99 typedef struct vorbis_enc_mode {
100  int blockflag;
101  int mapping;
102 } vorbis_enc_mode;
103 
104 typedef struct vorbis_enc_context {
105  int channels;
106  int sample_rate;
107  int log2_blocksize[2];
108  FFTContext mdct[2];
109  const float *win[2];
110  int have_saved;
111  float *saved;
112  float *samples;
113  float *floor; // also used for tmp values for mdct
114  float *coeffs; // also used for residue after floor
115  float *scratch; // used for tmp values for psy model
116  float quality;
117 
118  AudioFrameQueue afq;
119  struct FFBufQueue bufqueue;
120 
121  int ncodebooks;
122  vorbis_enc_codebook *codebooks;
123 
124  int nfloors;
125  vorbis_enc_floor *floors;
126 
127  int nresidues;
128  vorbis_enc_residue *residues;
129 
130  int nmappings;
131  vorbis_enc_mapping *mappings;
132 
133  int nmodes;
134  vorbis_enc_mode *modes;
135 
136  int64_t next_pts;
137 
138  AVFloatDSPContext *fdsp;
139 } vorbis_enc_context;
140 
141 #define MAX_CHANNELS 2
142 #define MAX_CODEBOOK_DIM 8
143 
144 #define MAX_FLOOR_CLASS_DIM 4
145 #define NUM_FLOOR_PARTITIONS 8
146 #define MAX_FLOOR_VALUES (MAX_FLOOR_CLASS_DIM*NUM_FLOOR_PARTITIONS+2)
147 
148 #define RESIDUE_SIZE 1600
149 #define RESIDUE_PART_SIZE 32
150 #define NUM_RESIDUE_PARTITIONS (RESIDUE_SIZE/RESIDUE_PART_SIZE)
151 
152 static inline int put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb,
153  int entry)
154 {
155  av_assert2(entry >= 0);
156  av_assert2(entry < cb->nentries);
157  av_assert2(cb->lens[entry]);
158  if (pb->size_in_bits - put_bits_count(pb) < cb->lens[entry])
159  return AVERROR(EINVAL);
160  put_bits(pb, cb->lens[entry], cb->codewords[entry]);
161  return 0;
162 }
163 
164 static int cb_lookup_vals(int lookup, int dimensions, int entries)
165 {
166  if (lookup == 1)
167  return ff_vorbis_nth_root(entries, dimensions);
168  else if (lookup == 2)
169  return dimensions *entries;
170  return 0;
171 }
172 
173 static int ready_codebook(vorbis_enc_codebook *cb)
174 {
175  int i;
176 
177  ff_vorbis_len2vlc(cb->lens, cb->codewords, cb->nentries);
178 
179  if (!cb->lookup) {
180  cb->pow2 = cb->dimensions = NULL;
181  } else {
182  int vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries);
183  cb->dimensions = av_malloc_array(cb->nentries, sizeof(float) * cb->ndimensions);
184  cb->pow2 = av_mallocz_array(cb->nentries, sizeof(float));
185  if (!cb->dimensions || !cb->pow2)
186  return AVERROR(ENOMEM);
187  for (i = 0; i < cb->nentries; i++) {
188  float last = 0;
189  int j;
190  int div = 1;
191  for (j = 0; j < cb->ndimensions; j++) {
192  int off;
193  if (cb->lookup == 1)
194  off = (i / div) % vals; // lookup type 1
195  else
196  off = i * cb->ndimensions + j; // lookup type 2
197 
198  cb->dimensions[i * cb->ndimensions + j] = last + cb->min + cb->quantlist[off] * cb->delta;
199  if (cb->seq_p)
200  last = cb->dimensions[i * cb->ndimensions + j];
201  cb->pow2[i] += cb->dimensions[i * cb->ndimensions + j] * cb->dimensions[i * cb->ndimensions + j];
202  div *= vals;
203  }
204  cb->pow2[i] /= 2.0;
205  }
206  }
207  return 0;
208 }
209 
210 static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc)
211 {
212  int i;
213  av_assert0(rc->type == 2);
214  rc->maxes = av_mallocz_array(rc->classifications, sizeof(float[2]));
215  if (!rc->maxes)
216  return AVERROR(ENOMEM);
217  for (i = 0; i < rc->classifications; i++) {
218  int j;
219  vorbis_enc_codebook * cb;
220  for (j = 0; j < 8; j++)
221  if (rc->books[i][j] != -1)
222  break;
223  if (j == 8) // zero
224  continue;
225  cb = &venc->codebooks[rc->books[i][j]];
226  assert(cb->ndimensions >= 2);
227  assert(cb->lookup);
228 
229  for (j = 0; j < cb->nentries; j++) {
230  float a;
231  if (!cb->lens[j])
232  continue;
233  a = fabs(cb->dimensions[j * cb->ndimensions]);
234  if (a > rc->maxes[i][0])
235  rc->maxes[i][0] = a;
236  a = fabs(cb->dimensions[j * cb->ndimensions + 1]);
237  if (a > rc->maxes[i][1])
238  rc->maxes[i][1] = a;
239  }
240  }
241  // small bias
242  for (i = 0; i < rc->classifications; i++) {
243  rc->maxes[i][0] += 0.8;
244  rc->maxes[i][1] += 0.8;
245  }
246  return 0;
247 }
248 
249 static av_cold int dsp_init(AVCodecContext *avctx, vorbis_enc_context *venc)
250 {
251  int ret = 0;
252 
253  venc->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
254  if (!venc->fdsp)
255  return AVERROR(ENOMEM);
256 
257  // init windows
258  venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6];
259  venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6];
260 
261  if ((ret = ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0, 1.0)) < 0)
262  return ret;
263  if ((ret = ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0)) < 0)
264  return ret;
265 
266  return 0;
267 }
268 
269 static int create_vorbis_context(vorbis_enc_context *venc,
270  AVCodecContext *avctx)
271 {
272  vorbis_enc_floor *fc;
273  vorbis_enc_residue *rc;
274  vorbis_enc_mapping *mc;
275  int i, book, ret;
276 
277  venc->channels = avctx->channels;
278  venc->sample_rate = avctx->sample_rate;
279  venc->log2_blocksize[0] = venc->log2_blocksize[1] = 11;
280 
281  venc->ncodebooks = FF_ARRAY_ELEMS(cvectors);
282  venc->codebooks = av_malloc(sizeof(vorbis_enc_codebook) * venc->ncodebooks);
283  if (!venc->codebooks)
284  return AVERROR(ENOMEM);
285 
286  // codebook 0..14 - floor1 book, values 0..255
287  // codebook 15 residue masterbook
288  // codebook 16..29 residue
289  for (book = 0; book < venc->ncodebooks; book++) {
290  vorbis_enc_codebook *cb = &venc->codebooks[book];
291  int vals;
292  cb->ndimensions = cvectors[book].dim;
293  cb->nentries = cvectors[book].real_len;
294  cb->min = cvectors[book].min;
295  cb->delta = cvectors[book].delta;
296  cb->lookup = cvectors[book].lookup;
297  cb->seq_p = 0;
298 
299  cb->lens = av_malloc_array(cb->nentries, sizeof(uint8_t));
300  cb->codewords = av_malloc_array(cb->nentries, sizeof(uint32_t));
301  if (!cb->lens || !cb->codewords)
302  return AVERROR(ENOMEM);
303  memcpy(cb->lens, cvectors[book].clens, cvectors[book].len);
304  memset(cb->lens + cvectors[book].len, 0, cb->nentries - cvectors[book].len);
305 
306  if (cb->lookup) {
307  vals = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries);
308  cb->quantlist = av_malloc_array(vals, sizeof(int));
309  if (!cb->quantlist)
310  return AVERROR(ENOMEM);
311  for (i = 0; i < vals; i++)
312  cb->quantlist[i] = cvectors[book].quant[i];
313  } else {
314  cb->quantlist = NULL;
315  }
316  if ((ret = ready_codebook(cb)) < 0)
317  return ret;
318  }
319 
320  venc->nfloors = 1;
321  venc->floors = av_malloc(sizeof(vorbis_enc_floor) * venc->nfloors);
322  if (!venc->floors)
323  return AVERROR(ENOMEM);
324 
325  // just 1 floor
326  fc = &venc->floors[0];
327  fc->partitions = NUM_FLOOR_PARTITIONS;
328  fc->partition_to_class = av_malloc(sizeof(int) * fc->partitions);
329  if (!fc->partition_to_class)
330  return AVERROR(ENOMEM);
331  fc->nclasses = 0;
332  for (i = 0; i < fc->partitions; i++) {
333  static const int a[] = {0, 1, 2, 2, 3, 3, 4, 4};
334  fc->partition_to_class[i] = a[i];
335  fc->nclasses = FFMAX(fc->nclasses, fc->partition_to_class[i]);
336  }
337  fc->nclasses++;
338  fc->classes = av_malloc_array(fc->nclasses, sizeof(vorbis_enc_floor_class));
339  if (!fc->classes)
340  return AVERROR(ENOMEM);
341  for (i = 0; i < fc->nclasses; i++) {
342  vorbis_enc_floor_class * c = &fc->classes[i];
343  int j, books;
344  c->dim = floor_classes[i].dim;
345  c->subclass = floor_classes[i].subclass;
346  c->masterbook = floor_classes[i].masterbook;
347  books = (1 << c->subclass);
348  c->books = av_malloc_array(books, sizeof(int));
349  if (!c->books)
350  return AVERROR(ENOMEM);
351  for (j = 0; j < books; j++)
352  c->books[j] = floor_classes[i].nbooks[j];
353  }
354  fc->multiplier = 2;
355  fc->rangebits = venc->log2_blocksize[1] - 1;
356 
357  fc->values = 2;
358  for (i = 0; i < fc->partitions; i++)
359  fc->values += fc->classes[fc->partition_to_class[i]].dim;
360 
361  fc->list = av_malloc_array(fc->values, sizeof(vorbis_floor1_entry));
362  if (!fc->list)
363  return AVERROR(ENOMEM);
364  fc->list[0].x = 0;
365  fc->list[1].x = 1 << fc->rangebits;
366  for (i = 2; i < fc->values; i++) {
367  static const int a[] = {
368  93, 23,372, 6, 46,186,750, 14, 33, 65,
369  130,260,556, 3, 10, 18, 28, 39, 55, 79,
370  111,158,220,312,464,650,850
371  };
372  fc->list[i].x = a[i - 2];
373  }
374  if (ff_vorbis_ready_floor1_list(avctx, fc->list, fc->values))
375  return AVERROR_BUG;
376 
377  venc->nresidues = 1;
378  venc->residues = av_malloc(sizeof(vorbis_enc_residue) * venc->nresidues);
379  if (!venc->residues)
380  return AVERROR(ENOMEM);
381 
382  // single residue
383  rc = &venc->residues[0];
384  rc->type = 2;
385  rc->begin = 0;
386  rc->end = 1600;
387  rc->partition_size = 32;
388  rc->classifications = 10;
389  rc->classbook = 15;
390  rc->books = av_malloc(sizeof(*rc->books) * rc->classifications);
391  if (!rc->books)
392  return AVERROR(ENOMEM);
393  {
394  static const int8_t a[10][8] = {
395  { -1, -1, -1, -1, -1, -1, -1, -1, },
396  { -1, -1, 16, -1, -1, -1, -1, -1, },
397  { -1, -1, 17, -1, -1, -1, -1, -1, },
398  { -1, -1, 18, -1, -1, -1, -1, -1, },
399  { -1, -1, 19, -1, -1, -1, -1, -1, },
400  { -1, -1, 20, -1, -1, -1, -1, -1, },
401  { -1, -1, 21, -1, -1, -1, -1, -1, },
402  { 22, 23, -1, -1, -1, -1, -1, -1, },
403  { 24, 25, -1, -1, -1, -1, -1, -1, },
404  { 26, 27, 28, -1, -1, -1, -1, -1, },
405  };
406  memcpy(rc->books, a, sizeof a);
407  }
408  if ((ret = ready_residue(rc, venc)) < 0)
409  return ret;
410 
411  venc->nmappings = 1;
412  venc->mappings = av_malloc(sizeof(vorbis_enc_mapping) * venc->nmappings);
413  if (!venc->mappings)
414  return AVERROR(ENOMEM);
415 
416  // single mapping
417  mc = &venc->mappings[0];
418  mc->submaps = 1;
419  mc->mux = av_malloc(sizeof(int) * venc->channels);
420  if (!mc->mux)
421  return AVERROR(ENOMEM);
422  for (i = 0; i < venc->channels; i++)
423  mc->mux[i] = 0;
424  mc->floor = av_malloc(sizeof(int) * mc->submaps);
425  mc->residue = av_malloc(sizeof(int) * mc->submaps);
426  if (!mc->floor || !mc->residue)
427  return AVERROR(ENOMEM);
428  for (i = 0; i < mc->submaps; i++) {
429  mc->floor[i] = 0;
430  mc->residue[i] = 0;
431  }
432  mc->coupling_steps = venc->channels == 2 ? 1 : 0;
433  mc->magnitude = av_malloc(sizeof(int) * mc->coupling_steps);
434  mc->angle = av_malloc(sizeof(int) * mc->coupling_steps);
435  if (!mc->magnitude || !mc->angle)
436  return AVERROR(ENOMEM);
437  if (mc->coupling_steps) {
438  mc->magnitude[0] = 0;
439  mc->angle[0] = 1;
440  }
441 
442  venc->nmodes = 2;
443  venc->modes = av_malloc(sizeof(vorbis_enc_mode) * venc->nmodes);
444  if (!venc->modes)
445  return AVERROR(ENOMEM);
446 
447  // Short block
448  venc->modes[0].blockflag = 0;
449  venc->modes[0].mapping = 0;
450  // Long block
451  venc->modes[1].blockflag = 1;
452  venc->modes[1].mapping = 0;
453 
454  venc->have_saved = 0;
455  venc->saved = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
456  venc->samples = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]));
457  venc->floor = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
458  venc->coeffs = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
459  venc->scratch = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]));
460 
461  if (!venc->saved || !venc->samples || !venc->floor || !venc->coeffs || !venc->scratch)
462  return AVERROR(ENOMEM);
463 
464  if ((ret = dsp_init(avctx, venc)) < 0)
465  return ret;
466 
467  return 0;
468 }
469 
470 static void put_float(PutBitContext *pb, float f)
471 {
472  int exp, mant;
473  uint32_t res = 0;
474  mant = (int)ldexp(frexp(f, &exp), 20);
475  exp += 788 - 20;
476  if (mant < 0) {
477  res |= (1U << 31);
478  mant = -mant;
479  }
480  res |= mant | (exp << 21);
481  put_bits32(pb, res);
482 }
483 
484 static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb)
485 {
486  int i;
487  int ordered = 0;
488 
489  put_bits(pb, 24, 0x564342); //magic
490  put_bits(pb, 16, cb->ndimensions);
491  put_bits(pb, 24, cb->nentries);
492 
493  for (i = 1; i < cb->nentries; i++)
494  if (cb->lens[i] < cb->lens[i-1])
495  break;
496  if (i == cb->nentries)
497  ordered = 1;
498 
499  put_bits(pb, 1, ordered);
500  if (ordered) {
501  int len = cb->lens[0];
502  put_bits(pb, 5, len - 1);
503  i = 0;
504  while (i < cb->nentries) {
505  int j;
506  for (j = 0; j+i < cb->nentries; j++)
507  if (cb->lens[j+i] != len)
508  break;
509  put_bits(pb, ilog(cb->nentries - i), j);
510  i += j;
511  len++;
512  }
513  } else {
514  int sparse = 0;
515  for (i = 0; i < cb->nentries; i++)
516  if (!cb->lens[i])
517  break;
518  if (i != cb->nentries)
519  sparse = 1;
520  put_bits(pb, 1, sparse);
521 
522  for (i = 0; i < cb->nentries; i++) {
523  if (sparse)
524  put_bits(pb, 1, !!cb->lens[i]);
525  if (cb->lens[i])
526  put_bits(pb, 5, cb->lens[i] - 1);
527  }
528  }
529 
530  put_bits(pb, 4, cb->lookup);
531  if (cb->lookup) {
532  int tmp = cb_lookup_vals(cb->lookup, cb->ndimensions, cb->nentries);
533  int bits = ilog(cb->quantlist[0]);
534 
535  for (i = 1; i < tmp; i++)
536  bits = FFMAX(bits, ilog(cb->quantlist[i]));
537 
538  put_float(pb, cb->min);
539  put_float(pb, cb->delta);
540 
541  put_bits(pb, 4, bits - 1);
542  put_bits(pb, 1, cb->seq_p);
543 
544  for (i = 0; i < tmp; i++)
545  put_bits(pb, bits, cb->quantlist[i]);
546  }
547 }
548 
549 static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc)
550 {
551  int i;
552 
553  put_bits(pb, 16, 1); // type, only floor1 is supported
554 
555  put_bits(pb, 5, fc->partitions);
556 
557  for (i = 0; i < fc->partitions; i++)
558  put_bits(pb, 4, fc->partition_to_class[i]);
559 
560  for (i = 0; i < fc->nclasses; i++) {
561  int j, books;
562 
563  put_bits(pb, 3, fc->classes[i].dim - 1);
564  put_bits(pb, 2, fc->classes[i].subclass);
565 
566  if (fc->classes[i].subclass)
567  put_bits(pb, 8, fc->classes[i].masterbook);
568 
569  books = (1 << fc->classes[i].subclass);
570 
571  for (j = 0; j < books; j++)
572  put_bits(pb, 8, fc->classes[i].books[j] + 1);
573  }
574 
575  put_bits(pb, 2, fc->multiplier - 1);
576  put_bits(pb, 4, fc->rangebits);
577 
578  for (i = 2; i < fc->values; i++)
579  put_bits(pb, fc->rangebits, fc->list[i].x);
580 }
581 
582 static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc)
583 {
584  int i;
585 
586  put_bits(pb, 16, rc->type);
587 
588  put_bits(pb, 24, rc->begin);
589  put_bits(pb, 24, rc->end);
590  put_bits(pb, 24, rc->partition_size - 1);
591  put_bits(pb, 6, rc->classifications - 1);
592  put_bits(pb, 8, rc->classbook);
593 
594  for (i = 0; i < rc->classifications; i++) {
595  int j, tmp = 0;
596  for (j = 0; j < 8; j++)
597  tmp |= (rc->books[i][j] != -1) << j;
598 
599  put_bits(pb, 3, tmp & 7);
600  put_bits(pb, 1, tmp > 7);
601 
602  if (tmp > 7)
603  put_bits(pb, 5, tmp >> 3);
604  }
605 
606  for (i = 0; i < rc->classifications; i++) {
607  int j;
608  for (j = 0; j < 8; j++)
609  if (rc->books[i][j] != -1)
610  put_bits(pb, 8, rc->books[i][j]);
611  }
612 }
613 
614 static int put_main_header(vorbis_enc_context *venc, uint8_t **out)
615 {
616  int i;
617  PutBitContext pb;
618  int len, hlens[3];
619  int buffer_len = 50000;
620  uint8_t *buffer = av_mallocz(buffer_len), *p = buffer;
621  if (!buffer)
622  return AVERROR(ENOMEM);
623 
624  // identification header
625  init_put_bits(&pb, p, buffer_len);
626  put_bits(&pb, 8, 1); //magic
627  for (i = 0; "vorbis"[i]; i++)
628  put_bits(&pb, 8, "vorbis"[i]);
629  put_bits32(&pb, 0); // version
630  put_bits(&pb, 8, venc->channels);
631  put_bits32(&pb, venc->sample_rate);
632  put_bits32(&pb, 0); // bitrate
633  put_bits32(&pb, 0); // bitrate
634  put_bits32(&pb, 0); // bitrate
635  put_bits(&pb, 4, venc->log2_blocksize[0]);
636  put_bits(&pb, 4, venc->log2_blocksize[1]);
637  put_bits(&pb, 1, 1); // framing
638 
639  flush_put_bits(&pb);
640  hlens[0] = put_bits_count(&pb) >> 3;
641  buffer_len -= hlens[0];
642  p += hlens[0];
643 
644  // comment header
645  init_put_bits(&pb, p, buffer_len);
646  put_bits(&pb, 8, 3); //magic
647  for (i = 0; "vorbis"[i]; i++)
648  put_bits(&pb, 8, "vorbis"[i]);
649  put_bits32(&pb, 0); // vendor length TODO
650  put_bits32(&pb, 0); // amount of comments
651  put_bits(&pb, 1, 1); // framing
652 
653  flush_put_bits(&pb);
654  hlens[1] = put_bits_count(&pb) >> 3;
655  buffer_len -= hlens[1];
656  p += hlens[1];
657 
658  // setup header
659  init_put_bits(&pb, p, buffer_len);
660  put_bits(&pb, 8, 5); //magic
661  for (i = 0; "vorbis"[i]; i++)
662  put_bits(&pb, 8, "vorbis"[i]);
663 
664  // codebooks
665  put_bits(&pb, 8, venc->ncodebooks - 1);
666  for (i = 0; i < venc->ncodebooks; i++)
667  put_codebook_header(&pb, &venc->codebooks[i]);
668 
669  // time domain, reserved, zero
670  put_bits(&pb, 6, 0);
671  put_bits(&pb, 16, 0);
672 
673  // floors
674  put_bits(&pb, 6, venc->nfloors - 1);
675  for (i = 0; i < venc->nfloors; i++)
676  put_floor_header(&pb, &venc->floors[i]);
677 
678  // residues
679  put_bits(&pb, 6, venc->nresidues - 1);
680  for (i = 0; i < venc->nresidues; i++)
681  put_residue_header(&pb, &venc->residues[i]);
682 
683  // mappings
684  put_bits(&pb, 6, venc->nmappings - 1);
685  for (i = 0; i < venc->nmappings; i++) {
686  vorbis_enc_mapping *mc = &venc->mappings[i];
687  int j;
688  put_bits(&pb, 16, 0); // mapping type
689 
690  put_bits(&pb, 1, mc->submaps > 1);
691  if (mc->submaps > 1)
692  put_bits(&pb, 4, mc->submaps - 1);
693 
694  put_bits(&pb, 1, !!mc->coupling_steps);
695  if (mc->coupling_steps) {
696  put_bits(&pb, 8, mc->coupling_steps - 1);
697  for (j = 0; j < mc->coupling_steps; j++) {
698  put_bits(&pb, ilog(venc->channels - 1), mc->magnitude[j]);
699  put_bits(&pb, ilog(venc->channels - 1), mc->angle[j]);
700  }
701  }
702 
703  put_bits(&pb, 2, 0); // reserved
704 
705  if (mc->submaps > 1)
706  for (j = 0; j < venc->channels; j++)
707  put_bits(&pb, 4, mc->mux[j]);
708 
709  for (j = 0; j < mc->submaps; j++) {
710  put_bits(&pb, 8, 0); // reserved time configuration
711  put_bits(&pb, 8, mc->floor[j]);
712  put_bits(&pb, 8, mc->residue[j]);
713  }
714  }
715 
716  // modes
717  put_bits(&pb, 6, venc->nmodes - 1);
718  for (i = 0; i < venc->nmodes; i++) {
719  put_bits(&pb, 1, venc->modes[i].blockflag);
720  put_bits(&pb, 16, 0); // reserved window type
721  put_bits(&pb, 16, 0); // reserved transform type
722  put_bits(&pb, 8, venc->modes[i].mapping);
723  }
724 
725  put_bits(&pb, 1, 1); // framing
726 
727  flush_put_bits(&pb);
728  hlens[2] = put_bits_count(&pb) >> 3;
729 
730  len = hlens[0] + hlens[1] + hlens[2];
731  p = *out = av_mallocz(64 + len + len/255);
732  if (!p)
733  return AVERROR(ENOMEM);
734 
735  *p++ = 2;
736  p += av_xiphlacing(p, hlens[0]);
737  p += av_xiphlacing(p, hlens[1]);
738  buffer_len = 0;
739  for (i = 0; i < 3; i++) {
740  memcpy(p, buffer + buffer_len, hlens[i]);
741  p += hlens[i];
742  buffer_len += hlens[i];
743  }
744 
745  av_freep(&buffer);
746  return p - *out;
747 }
748 
749 static float get_floor_average(vorbis_enc_floor * fc, float *coeffs, int i)
750 {
751  int begin = fc->list[fc->list[FFMAX(i-1, 0)].sort].x;
752  int end = fc->list[fc->list[FFMIN(i+1, fc->values - 1)].sort].x;
753  int j;
754  float average = 0;
755 
756  for (j = begin; j < end; j++)
757  average += fabs(coeffs[j]);
758  return average / (end - begin);
759 }
760 
761 static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc,
762  float *coeffs, uint16_t *posts, int samples)
763 {
764  int range = 255 / fc->multiplier + 1;
765  int i;
766  float tot_average = 0.0;
767  float averages[MAX_FLOOR_VALUES];
768  for (i = 0; i < fc->values; i++) {
769  averages[i] = get_floor_average(fc, coeffs, i);
770  tot_average += averages[i];
771  }
772  tot_average /= fc->values;
773  tot_average /= venc->quality;
774 
775  for (i = 0; i < fc->values; i++) {
776  int position = fc->list[fc->list[i].sort].x;
777  float average = averages[i];
778  int j;
779 
780  average = sqrt(tot_average * average) * pow(1.25f, position*0.005f); // MAGIC!
781  for (j = 0; j < range - 1; j++)
782  if (ff_vorbis_floor1_inverse_db_table[j * fc->multiplier] > average)
783  break;
784  posts[fc->list[i].sort] = j;
785  }
786 }
787 
788 static int render_point(int x0, int y0, int x1, int y1, int x)
789 {
790  return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
791 }
792 
793 static int floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc,
794  PutBitContext *pb, uint16_t *posts,
795  float *floor, int samples)
796 {
797  int range = 255 / fc->multiplier + 1;
798  int coded[MAX_FLOOR_VALUES]; // first 2 values are unused
799  int i, counter;
800 
801  if (pb->size_in_bits - put_bits_count(pb) < 1 + 2 * ilog(range - 1))
802  return AVERROR(EINVAL);
803  put_bits(pb, 1, 1); // non zero
804  put_bits(pb, ilog(range - 1), posts[0]);
805  put_bits(pb, ilog(range - 1), posts[1]);
806  coded[0] = coded[1] = 1;
807 
808  for (i = 2; i < fc->values; i++) {
809  int predicted = render_point(fc->list[fc->list[i].low].x,
810  posts[fc->list[i].low],
811  fc->list[fc->list[i].high].x,
812  posts[fc->list[i].high],
813  fc->list[i].x);
814  int highroom = range - predicted;
815  int lowroom = predicted;
816  int room = FFMIN(highroom, lowroom);
817  if (predicted == posts[i]) {
818  coded[i] = 0; // must be used later as flag!
819  continue;
820  } else {
821  if (!coded[fc->list[i].low ])
822  coded[fc->list[i].low ] = -1;
823  if (!coded[fc->list[i].high])
824  coded[fc->list[i].high] = -1;
825  }
826  if (posts[i] > predicted) {
827  if (posts[i] - predicted > room)
828  coded[i] = posts[i] - predicted + lowroom;
829  else
830  coded[i] = (posts[i] - predicted) << 1;
831  } else {
832  if (predicted - posts[i] > room)
833  coded[i] = predicted - posts[i] + highroom - 1;
834  else
835  coded[i] = ((predicted - posts[i]) << 1) - 1;
836  }
837  }
838 
839  counter = 2;
840  for (i = 0; i < fc->partitions; i++) {
841  vorbis_enc_floor_class * c = &fc->classes[fc->partition_to_class[i]];
842  int k, cval = 0, csub = 1<<c->subclass;
843  if (c->subclass) {
844  vorbis_enc_codebook * book = &venc->codebooks[c->masterbook];
845  int cshift = 0;
846  for (k = 0; k < c->dim; k++) {
847  int l;
848  for (l = 0; l < csub; l++) {
849  int maxval = 1;
850  if (c->books[l] != -1)
851  maxval = venc->codebooks[c->books[l]].nentries;
852  // coded could be -1, but this still works, cause that is 0
853  if (coded[counter + k] < maxval)
854  break;
855  }
856  assert(l != csub);
857  cval |= l << cshift;
858  cshift += c->subclass;
859  }
860  if (put_codeword(pb, book, cval))
861  return AVERROR(EINVAL);
862  }
863  for (k = 0; k < c->dim; k++) {
864  int book = c->books[cval & (csub-1)];
865  int entry = coded[counter++];
866  cval >>= c->subclass;
867  if (book == -1)
868  continue;
869  if (entry == -1)
870  entry = 0;
871  if (put_codeword(pb, &venc->codebooks[book], entry))
872  return AVERROR(EINVAL);
873  }
874  }
875 
876  ff_vorbis_floor1_render_list(fc->list, fc->values, posts, coded,
877  fc->multiplier, floor, samples);
878 
879  return 0;
880 }
881 
882 static float *put_vector(vorbis_enc_codebook *book, PutBitContext *pb,
883  float *num)
884 {
885  int i, entry = -1;
886  float distance = FLT_MAX;
887  assert(book->dimensions);
888  for (i = 0; i < book->nentries; i++) {
889  float * vec = book->dimensions + i * book->ndimensions, d = book->pow2[i];
890  int j;
891  if (!book->lens[i])
892  continue;
893  for (j = 0; j < book->ndimensions; j++)
894  d -= vec[j] * num[j];
895  if (distance > d) {
896  entry = i;
897  distance = d;
898  }
899  }
900  if (put_codeword(pb, book, entry))
901  return NULL;
902  return &book->dimensions[entry * book->ndimensions];
903 }
904 
905 static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc,
906  PutBitContext *pb, float *coeffs, int samples,
907  int real_ch)
908 {
909  int pass, i, j, p, k;
910  int psize = rc->partition_size;
911  int partitions = (rc->end - rc->begin) / psize;
912  int channels = (rc->type == 2) ? 1 : real_ch;
913  int classes[MAX_CHANNELS][NUM_RESIDUE_PARTITIONS];
914  int classwords = venc->codebooks[rc->classbook].ndimensions;
915 
916  av_assert0(rc->type == 2);
917  av_assert0(real_ch == 2);
918  for (p = 0; p < partitions; p++) {
919  float max1 = 0.0, max2 = 0.0;
920  int s = rc->begin + p * psize;
921  for (k = s; k < s + psize; k += 2) {
922  max1 = FFMAX(max1, fabs(coeffs[ k / real_ch]));
923  max2 = FFMAX(max2, fabs(coeffs[samples + k / real_ch]));
924  }
925 
926  for (i = 0; i < rc->classifications - 1; i++)
927  if (max1 < rc->maxes[i][0] && max2 < rc->maxes[i][1])
928  break;
929  classes[0][p] = i;
930  }
931 
932  for (pass = 0; pass < 8; pass++) {
933  p = 0;
934  while (p < partitions) {
935  if (pass == 0)
936  for (j = 0; j < channels; j++) {
937  vorbis_enc_codebook * book = &venc->codebooks[rc->classbook];
938  int entry = 0;
939  for (i = 0; i < classwords; i++) {
940  entry *= rc->classifications;
941  entry += classes[j][p + i];
942  }
943  if (put_codeword(pb, book, entry))
944  return AVERROR(EINVAL);
945  }
946  for (i = 0; i < classwords && p < partitions; i++, p++) {
947  for (j = 0; j < channels; j++) {
948  int nbook = rc->books[classes[j][p]][pass];
949  vorbis_enc_codebook * book = &venc->codebooks[nbook];
950  float *buf = coeffs + samples*j + rc->begin + p*psize;
951  if (nbook == -1)
952  continue;
953 
954  assert(rc->type == 0 || rc->type == 2);
955  assert(!(psize % book->ndimensions));
956 
957  if (rc->type == 0) {
958  for (k = 0; k < psize; k += book->ndimensions) {
959  int l;
960  float *a = put_vector(book, pb, &buf[k]);
961  if (!a)
962  return AVERROR(EINVAL);
963  for (l = 0; l < book->ndimensions; l++)
964  buf[k + l] -= a[l];
965  }
966  } else {
967  int s = rc->begin + p * psize, a1, b1;
968  a1 = (s % real_ch) * samples;
969  b1 = s / real_ch;
970  s = real_ch * samples;
971  for (k = 0; k < psize; k += book->ndimensions) {
972  int dim, a2 = a1, b2 = b1;
973  float vec[MAX_CODEBOOK_DIM], *pv = vec;
974  for (dim = book->ndimensions; dim--; ) {
975  *pv++ = coeffs[a2 + b2];
976  if ((a2 += samples) == s) {
977  a2 = 0;
978  b2++;
979  }
980  }
981  pv = put_vector(book, pb, vec);
982  if (!pv)
983  return AVERROR(EINVAL);
984  for (dim = book->ndimensions; dim--; ) {
985  coeffs[a1 + b1] -= *pv++;
986  if ((a1 += samples) == s) {
987  a1 = 0;
988  b1++;
989  }
990  }
991  }
992  }
993  }
994  }
995  }
996  }
997  return 0;
998 }
999 
1000 static int apply_window_and_mdct(vorbis_enc_context *venc)
1001 {
1002  int channel;
1003  const float * win = venc->win[1];
1004  int window_len = 1 << (venc->log2_blocksize[1] - 1);
1005  float n = (float)(1 << venc->log2_blocksize[1]) / 4.0;
1006  AVFloatDSPContext *fdsp = venc->fdsp;
1007 
1008  for (channel = 0; channel < venc->channels; channel++) {
1009  float *offset = venc->samples + channel * window_len * 2;
1010 
1011  fdsp->vector_fmul(offset, offset, win, window_len);
1012  fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len);
1013 
1014  offset += window_len;
1015 
1016  fdsp->vector_fmul_reverse(offset, offset, win, window_len);
1017  fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len);
1018 
1019  venc->mdct[1].mdct_calc(&venc->mdct[1], venc->coeffs + channel * window_len,
1020  venc->samples + channel * window_len * 2);
1021  }
1022  return 1;
1023 }
1024 
1025 /* Used for padding the last encoded packet */
1026 static AVFrame *spawn_empty_frame(AVCodecContext *avctx, int channels)
1027 {
1028  AVFrame *f = av_frame_alloc();
1029  int ch;
1030 
1031  if (!f)
1032  return NULL;
1033 
1034  f->format = avctx->sample_fmt;
1035  f->nb_samples = avctx->frame_size;
1036  f->channel_layout = avctx->channel_layout;
1037 
1038  if (av_frame_get_buffer(f, 4)) {
1039  av_frame_free(&f);
1040  return NULL;
1041  }
1042 
1043  for (ch = 0; ch < channels; ch++) {
1044  size_t bps = av_get_bytes_per_sample(f->format);
1045  memset(f->extended_data[ch], 0, bps * f->nb_samples);
1046  }
1047  return f;
1048 }
1049 
1050 /* Set up audio samples for psy analysis and window/mdct */
1051 static void move_audio(vorbis_enc_context *venc, int sf_size)
1052 {
1053  AVFrame *cur = NULL;
1054  int frame_size = 1 << (venc->log2_blocksize[1] - 1);
1055  int subframes = frame_size / sf_size;
1056  int sf, ch;
1057 
1058  /* Copy samples from last frame into current frame */
1059  if (venc->have_saved)
1060  for (ch = 0; ch < venc->channels; ch++)
1061  memcpy(venc->samples + 2 * ch * frame_size,
1062  venc->saved + ch * frame_size, sizeof(float) * frame_size);
1063  else
1064  for (ch = 0; ch < venc->channels; ch++)
1065  memset(venc->samples + 2 * ch * frame_size, 0, sizeof(float) * frame_size);
1066 
1067  for (sf = 0; sf < subframes; sf++) {
1068  cur = ff_bufqueue_get(&venc->bufqueue);
1069 
1070  for (ch = 0; ch < venc->channels; ch++) {
1071  float *offset = venc->samples + 2 * ch * frame_size + frame_size;
1072  float *save = venc->saved + ch * frame_size;
1073  const float *input = (float *) cur->extended_data[ch];
1074  const size_t len = cur->nb_samples * sizeof(float);
1075 
1076  memcpy(offset + sf*sf_size, input, len);
1077  memcpy(save + sf*sf_size, input, len); // Move samples for next frame
1078  }
1079  av_frame_free(&cur);
1080  }
1081  venc->have_saved = 1;
1082  memcpy(venc->scratch, venc->samples, 2 * venc->channels * frame_size);
1083 }
1084 
1085 static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1086  const AVFrame *frame, int *got_packet_ptr)
1087 {
1088  vorbis_enc_context *venc = avctx->priv_data;
1089  int i, ret, need_more;
1090  int frame_size = 1 << (venc->log2_blocksize[1] - 1);
1091  vorbis_enc_mode *mode;
1092  vorbis_enc_mapping *mapping;
1093  PutBitContext pb;
1094 
1095  if (frame) {
1096  AVFrame *clone;
1097  if ((ret = ff_af_queue_add(&venc->afq, frame)) < 0)
1098  return ret;
1099  clone = av_frame_clone(frame);
1100  if (!clone)
1101  return AVERROR(ENOMEM);
1102  ff_bufqueue_add(avctx, &venc->bufqueue, clone);
1103  } else
1104  if (!venc->afq.remaining_samples)
1105  return 0;
1106 
1107  need_more = venc->bufqueue.available * avctx->frame_size < frame_size;
1108  need_more = frame && need_more;
1109  if (need_more)
1110  return 0;
1111 
1112  /* Pad the bufqueue with empty frames for encoding the last packet. */
1113  if (!frame) {
1114  if (venc->bufqueue.available * avctx->frame_size < frame_size) {
1115  int frames_needed = (frame_size/avctx->frame_size) - venc->bufqueue.available;
1116  int i;
1117 
1118  for (i = 0; i < frames_needed; i++) {
1119  AVFrame *empty = spawn_empty_frame(avctx, venc->channels);
1120  if (!empty)
1121  return AVERROR(ENOMEM);
1122 
1123  ff_bufqueue_add(avctx, &venc->bufqueue, empty);
1124  }
1125  }
1126  }
1127 
1128  move_audio(venc, avctx->frame_size);
1129 
1130  if (!apply_window_and_mdct(venc))
1131  return 0;
1132 
1133  if ((ret = ff_alloc_packet2(avctx, avpkt, 8192, 0)) < 0)
1134  return ret;
1135 
1136  init_put_bits(&pb, avpkt->data, avpkt->size);
1137 
1138  if (pb.size_in_bits - put_bits_count(&pb) < 1 + ilog(venc->nmodes - 1)) {
1139  av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
1140  return AVERROR(EINVAL);
1141  }
1142 
1143  put_bits(&pb, 1, 0); // magic bit
1144 
1145  put_bits(&pb, ilog(venc->nmodes - 1), 1); // Mode for current frame
1146 
1147  mode = &venc->modes[1];
1148  mapping = &venc->mappings[mode->mapping];
1149  if (mode->blockflag) {
1150  put_bits(&pb, 1, 1); // Previous windowflag
1151  put_bits(&pb, 1, 1); // Next windowflag
1152  }
1153 
1154  for (i = 0; i < venc->channels; i++) {
1155  vorbis_enc_floor *fc = &venc->floors[mapping->floor[mapping->mux[i]]];
1156  uint16_t posts[MAX_FLOOR_VALUES];
1157  floor_fit(venc, fc, &venc->coeffs[i * frame_size], posts, frame_size);
1158  if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * frame_size], frame_size)) {
1159  av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
1160  return AVERROR(EINVAL);
1161  }
1162  }
1163 
1164  for (i = 0; i < venc->channels * frame_size; i++)
1165  venc->coeffs[i] /= venc->floor[i];
1166 
1167  for (i = 0; i < mapping->coupling_steps; i++) {
1168  float *mag = venc->coeffs + mapping->magnitude[i] * frame_size;
1169  float *ang = venc->coeffs + mapping->angle[i] * frame_size;
1170  int j;
1171  for (j = 0; j < frame_size; j++) {
1172  float a = ang[j];
1173  ang[j] -= mag[j];
1174  if (mag[j] > 0)
1175  ang[j] = -ang[j];
1176  if (ang[j] < 0)
1177  mag[j] = a;
1178  }
1179  }
1180 
1181  if (residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]],
1182  &pb, venc->coeffs, frame_size, venc->channels)) {
1183  av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
1184  return AVERROR(EINVAL);
1185  }
1186 
1187  flush_put_bits(&pb);
1188  avpkt->size = put_bits_count(&pb) >> 3;
1189 
1190  ff_af_queue_remove(&venc->afq, frame_size, &avpkt->pts, &avpkt->duration);
1191 
1192  if (frame_size > avpkt->duration) {
1193  uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1194  if (!side)
1195  return AVERROR(ENOMEM);
1196  AV_WL32(&side[4], frame_size - avpkt->duration);
1197  }
1198 
1199  *got_packet_ptr = 1;
1200  return 0;
1201 }
1202 
1203 
1204 static av_cold int vorbis_encode_close(AVCodecContext *avctx)
1205 {
1206  vorbis_enc_context *venc = avctx->priv_data;
1207  int i;
1208 
1209  if (venc->codebooks)
1210  for (i = 0; i < venc->ncodebooks; i++) {
1211  av_freep(&venc->codebooks[i].lens);
1212  av_freep(&venc->codebooks[i].codewords);
1213  av_freep(&venc->codebooks[i].quantlist);
1214  av_freep(&venc->codebooks[i].dimensions);
1215  av_freep(&venc->codebooks[i].pow2);
1216  }
1217  av_freep(&venc->codebooks);
1218 
1219  if (venc->floors)
1220  for (i = 0; i < venc->nfloors; i++) {
1221  int j;
1222  if (venc->floors[i].classes)
1223  for (j = 0; j < venc->floors[i].nclasses; j++)
1224  av_freep(&venc->floors[i].classes[j].books);
1225  av_freep(&venc->floors[i].classes);
1226  av_freep(&venc->floors[i].partition_to_class);
1227  av_freep(&venc->floors[i].list);
1228  }
1229  av_freep(&venc->floors);
1230 
1231  if (venc->residues)
1232  for (i = 0; i < venc->nresidues; i++) {
1233  av_freep(&venc->residues[i].books);
1234  av_freep(&venc->residues[i].maxes);
1235  }
1236  av_freep(&venc->residues);
1237 
1238  if (venc->mappings)
1239  for (i = 0; i < venc->nmappings; i++) {
1240  av_freep(&venc->mappings[i].mux);
1241  av_freep(&venc->mappings[i].floor);
1242  av_freep(&venc->mappings[i].residue);
1243  av_freep(&venc->mappings[i].magnitude);
1244  av_freep(&venc->mappings[i].angle);
1245  }
1246  av_freep(&venc->mappings);
1247 
1248  av_freep(&venc->modes);
1249 
1250  av_freep(&venc->saved);
1251  av_freep(&venc->samples);
1252  av_freep(&venc->floor);
1253  av_freep(&venc->coeffs);
1254  av_freep(&venc->scratch);
1255  av_freep(&venc->fdsp);
1256 
1257  ff_mdct_end(&venc->mdct[0]);
1258  ff_mdct_end(&venc->mdct[1]);
1259  ff_af_queue_close(&venc->afq);
1260  ff_bufqueue_discard_all(&venc->bufqueue);
1261 
1262  av_freep(&avctx->extradata);
1263 
1264  return 0 ;
1265 }
1266 
1267 static av_cold int vorbis_encode_init(AVCodecContext *avctx)
1268 {
1269  vorbis_enc_context *venc = avctx->priv_data;
1270  int ret;
1271 
1272  if (avctx->channels != 2) {
1273  av_log(avctx, AV_LOG_ERROR, "Current FFmpeg Vorbis encoder only supports 2 channels.\n");
1274  return -1;
1275  }
1276 
1277  if ((ret = create_vorbis_context(venc, avctx)) < 0)
1278  goto error;
1279 
1280  avctx->bit_rate = 0;
1281  if (avctx->flags & AV_CODEC_FLAG_QSCALE)
1282  venc->quality = avctx->global_quality / (float)FF_QP2LAMBDA;
1283  else
1284  venc->quality = 8;
1285  venc->quality *= venc->quality;
1286 
1287  if ((ret = put_main_header(venc, (uint8_t**)&avctx->extradata)) < 0)
1288  goto error;
1289  avctx->extradata_size = ret;
1290 
1291  avctx->frame_size = 64;
1292 
1293  ff_af_queue_init(avctx, &venc->afq);
1294 
1295  return 0;
1296 error:
1297  vorbis_encode_close(avctx);
1298  return ret;
1299 }
1300 
1301 AVCodec ff_vorbis_encoder = {
1302  .name = "vorbis",
1303  .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
1304  .type = AVMEDIA_TYPE_AUDIO,
1305  .id = AV_CODEC_ID_VORBIS,
1306  .priv_data_size = sizeof(vorbis_enc_context),
1307  .init = vorbis_encode_init,
1308  .encode2 = vorbis_encode_frame,
1309  .close = vorbis_encode_close,
1310  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
1311  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1312  AV_SAMPLE_FMT_NONE },
1313 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
put_codebook_header
static void put_codebook_header(PutBitContext *pb, vorbis_enc_codebook *cb)
Definition: vorbisenc.c:484
AVCodec
AVCodec.
Definition: codec.h:190
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
vorbis_enc_codebook
Definition: vorbisenc.c:46
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1827
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
out
FILE * out
Definition: movenc.c:54
put_residue_header
static void put_residue_header(PutBitContext *pb, vorbis_enc_residue *rc)
Definition: vorbisenc.c:582
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:325
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
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
vorbis_encode_init
static av_cold int vorbis_encode_init(AVCodecContext *avctx)
Definition: vorbisenc.c:1267
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:716
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
vorbis_enc_floor::multiplier
int multiplier
Definition: vorbisenc.c:72
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
AVFloatDSPContext::vector_fmul_reverse
void(* vector_fmul_reverse)(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:154
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
FFTContext::mdct_calc
void(* mdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:109
vorbis_enc_codebook::pow2
float * pow2
Definition: vorbisenc.c:57
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
ff_vorbis_vwin
const float *const ff_vorbis_vwin[8]
Definition: vorbis_data.c:2190
vorbis_enc_context::channels
int channels
Definition: vorbisenc.c:105
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
vorbis_enc_codebook::lens
uint8_t * lens
Definition: vorbisenc.c:48
vorbis_enc_mapping::magnitude
int * magnitude
Definition: vorbisenc.c:95
vorbis_enc_context::quality
float quality
Definition: vorbisenc.c:116
vorbis_enc_mode
Definition: vorbisenc.c:99
vorbis_enc_residue
Definition: vorbisenc.c:78
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
vorbis_enc_floor_class
Definition: vorbisenc.c:60
vorbis_enc_context::have_saved
int have_saved
Definition: vorbisenc.c:110
vorbis_enc_mapping::angle
int * angle
Definition: vorbisenc.c:96
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
float.h
vorbis_enc_codebook::quantlist
int * quantlist
Definition: vorbisenc.c:55
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:555
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
NUM_FLOOR_PARTITIONS
#define NUM_FLOOR_PARTITIONS
Definition: vorbisenc.c:145
put_floor_header
static void put_floor_header(PutBitContext *pb, vorbis_enc_floor *fc)
Definition: vorbisenc.c:549
vorbis_enc_context::sample_rate
int sample_rate
Definition: vorbisenc.c:106
vorbis_enc_codebook::dimensions
float * dimensions
Definition: vorbisenc.c:56
ff_vorbis_nth_root
unsigned int ff_vorbis_nth_root(unsigned int x, unsigned int n)
Definition: vorbis.c:38
ff_bufqueue_get
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
Definition: bufferqueue.h:98
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
vorbis_encode_close
static av_cold int vorbis_encode_close(AVCodecContext *avctx)
Definition: vorbisenc.c:1204
vorbis_enc_mapping::floor
int * floor
Definition: vorbisenc.c:92
vorbis_enc_floor_class::masterbook
int masterbook
Definition: vorbisenc.c:63
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
vorbis_enc_floor::list
vorbis_floor1_entry * list
Definition: vorbisenc.c:75
put_vector
static float * put_vector(vorbis_enc_codebook *book, PutBitContext *pb, float *num)
Definition: vorbisenc.c:882
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1332
U
#define U(x)
Definition: vp56_arith.h:37
spawn_empty_frame
static AVFrame * spawn_empty_frame(AVCodecContext *avctx, int channels)
Definition: vorbisenc.c:1026
PutBitContext::size_in_bits
int size_in_bits
Definition: put_bits.h:39
vorbis_enc_context::ncodebooks
int ncodebooks
Definition: vorbisenc.c:121
audio_frame_queue.h
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
vorbis_enc_floor::partition_to_class
int * partition_to_class
Definition: vorbisenc.c:69
vorbis_enc_context::afq
AudioFrameQueue afq
Definition: vorbisenc.c:118
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
vorbis_enc_floor_class::dim
int dim
Definition: vorbisenc.c:61
vorbis_enc_residue::maxes
float(* maxes)[2]
Definition: vorbisenc.c:86
vorbis_enc_context::mdct
FFTContext mdct[2]
Definition: vorbisenc.c:108
cvectors
static const struct @164 cvectors[]
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
a1
#define a1
Definition: regdef.h:47
vorbis_enc_context::coeffs
float * coeffs
Definition: vorbisenc.c:114
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
put_float
static void put_float(PutBitContext *pb, float f)
Definition: vorbisenc.c:470
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:98
av_cold
#define av_cold
Definition: attributes.h:90
vorbis_enc_context::saved
float * saved
Definition: vorbisenc.c:111
vorbis_floor1_entry
Definition: vorbis.h:32
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
vorbis_enc_residue::classbook
int classbook
Definition: vorbisenc.c:84
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
put_main_header
static int put_main_header(vorbis_enc_context *venc, uint8_t **out)
Definition: vorbisenc.c:614
ff_vorbis_encoder
AVCodec ff_vorbis_encoder
Definition: vorbisenc.c:1301
dsp_init
static av_cold int dsp_init(AVCodecContext *avctx, vorbis_enc_context *venc)
Definition: vorbisenc.c:249
frame_size
int frame_size
Definition: mxfenc.c:2137
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
vorbis_encode_frame
static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: vorbisenc.c:1085
AudioFrameQueue::remaining_samples
int remaining_samples
Definition: audio_frame_queue.h:35
bits
uint8_t bits
Definition: vp3data.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AudioFrameQueue
Definition: audio_frame_queue.h:32
ff_vorbis_len2vlc
int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
Definition: vorbis.c:56
vorbis_enc_context::residues
vorbis_enc_residue * residues
Definition: vorbisenc.c:128
vorbis_enc_floor::classes
vorbis_enc_floor_class * classes
Definition: vorbisenc.c:71
channels
channels
Definition: aptx.h:33
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
vorbis_enc_mapping
Definition: vorbisenc.c:89
vorbis_enc_floor_class::subclass
int subclass
Definition: vorbisenc.c:62
vorbis_enc_residue::begin
int begin
Definition: vorbisenc.c:80
vorbis_enc_residue::end
int end
Definition: vorbisenc.c:81
vorbis_enc_context::nfloors
int nfloors
Definition: vorbisenc.c:124
f
#define f(width, name)
Definition: cbs_vp9.c:255
pass
#define pass
Definition: fft_template.c:609
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
PutBitContext
Definition: put_bits.h:35
get_floor_average
static float get_floor_average(vorbis_enc_floor *fc, float *coeffs, int i)
Definition: vorbisenc.c:749
vorbis_enc_codebook::codewords
uint32_t * codewords
Definition: vorbisenc.c:49
NULL
#define NULL
Definition: coverity.c:32
residue_encode
static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc, PutBitContext *pb, float *coeffs, int samples, int real_ch)
Definition: vorbisenc.c:905
AVFloatDSPContext::vector_fmul_scalar
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
vorbis_enc_context::nresidues
int nresidues
Definition: vorbisenc.c:127
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
vorbis_enc_residue::classifications
int classifications
Definition: vorbisenc.c:83
ff_bufqueue_discard_all
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
Definition: bufferqueue.h:111
mathops.h
vorbis_enc_context::fdsp
AVFloatDSPContext * fdsp
Definition: vorbisenc.c:138
floor_fit
static void floor_fit(vorbis_enc_context *venc, vorbis_enc_floor *fc, float *coeffs, uint16_t *posts, int samples)
Definition: vorbisenc.c:761
floor_encode
static int floor_encode(vorbis_enc_context *venc, vorbis_enc_floor *fc, PutBitContext *pb, uint16_t *posts, float *floor, int samples)
Definition: vorbisenc.c:793
vorbis_enc_residue::books
int8_t(* books)[8]
Definition: vorbisenc.c:85
vorbis_enc_codebook::nentries
int nentries
Definition: vorbisenc.c:47
vorbis_enc_floor::partitions
int partitions
Definition: vorbisenc.c:68
exp
int8_t exp
Definition: eval.c:72
vorbis_enc_codebook::min
float min
Definition: vorbisenc.c:51
vorbis_enc_context::floor
float * floor
Definition: vorbisenc.c:113
vorbis_enc_floor::nclasses
int nclasses
Definition: vorbisenc.c:70
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
float_dsp.h
vorbis_enc_context::win
const float * win[2]
Definition: vorbisenc.c:109
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
put_codeword
static int put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb, int entry)
Definition: vorbisenc.c:152
bufferqueue.h
ff_vorbis_ready_floor1_list
int ff_vorbis_ready_floor1_list(AVCodecContext *avctx, vorbis_floor1_entry *list, int values)
Definition: vorbis.c:106
MAX_CODEBOOK_DIM
#define MAX_CODEBOOK_DIM
Definition: vorbisenc.c:142
vorbis_enc_context::nmodes
int nmodes
Definition: vorbisenc.c:133
AVPacket::size
int size
Definition: packet.h:356
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
AVFloatDSPContext::vector_fmul
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
render_point
static int render_point(int x0, int y0, int x1, int y1, int x)
Definition: vorbisenc.c:788
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
bps
unsigned bps
Definition: movenc.c:1533
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_mdct_end
#define ff_mdct_end
Definition: fft.h:170
apply_window_and_mdct
static int apply_window_and_mdct(vorbis_enc_context *venc)
Definition: vorbisenc.c:1000
vorbis_enc_mode::blockflag
int blockflag
Definition: vorbisenc.c:100
move_audio
static void move_audio(vorbis_enc_context *venc, int sf_size)
Definition: vorbisenc.c:1051
AVFloatDSPContext
Definition: float_dsp.h:24
vorbis_enc_codebook::lookup
int lookup
Definition: vorbisenc.c:54
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:1333
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
vorbis_enc_floor::values
int values
Definition: vorbisenc.c:74
vorbis_enc_codebook::ndimensions
int ndimensions
Definition: vorbisenc.c:50
ready_residue
static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc)
Definition: vorbisenc.c:210
vorbis_enc_context::floors
vorbis_enc_floor * floors
Definition: vorbisenc.c:125
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
ff_bufqueue_add
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
Definition: bufferqueue.h:71
vorbis_enc_mapping::submaps
int submaps
Definition: vorbisenc.c:90
input
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 input
Definition: filter_design.txt:172
vorbis_enc_context::mappings
vorbis_enc_mapping * mappings
Definition: vorbisenc.c:131
vorbis_enc_codebook::seq_p
int seq_p
Definition: vorbisenc.c:53
vorbis_enc_residue::type
int type
Definition: vorbisenc.c:79
vorbis_enc_codebook::delta
float delta
Definition: vorbisenc.c:52
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
vorbis_enc_residue::partition_size
int partition_size
Definition: vorbisenc.c:82
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:366
FFTContext
Definition: fft.h:88
ready_codebook
static int ready_codebook(vorbis_enc_codebook *cb)
Definition: vorbisenc.c:173
vorbis_enc_floor_class::books
int * books
Definition: vorbisenc.c:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
create_vorbis_context
static int create_vorbis_context(vorbis_enc_context *venc, AVCodecContext *avctx)
Definition: vorbisenc.c:269
vorbis.h
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
FFBufQueue
Structure holding the queue.
Definition: bufferqueue.h:49
lookup
int lookup
Definition: vorbis_enc_data.h:455
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
vorbis_enc_mapping::coupling_steps
int coupling_steps
Definition: vorbisenc.c:94
vorbis_enc_mapping::residue
int * residue
Definition: vorbisenc.c:93
FFBufQueue::available
unsigned short available
number of available buffers
Definition: bufferqueue.h:52
a2
#define a2
Definition: regdef.h:48
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
uint8_t
uint8_t
Definition: audio_convert.c:194
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
vorbis_enc_data.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:156
len
int len
Definition: vorbis_enc_data.h:452
vorbis_enc_floor
Definition: vorbisenc.c:67
vorbis_enc_context::scratch
float * scratch
Definition: vorbisenc.c:115
avcodec.h
vorbis_enc_context::next_pts
int64_t next_pts
Definition: vorbisenc.c:136
pv
#define pv
Definition: regdef.h:60
vorbis_enc_context::log2_blocksize
int log2_blocksize[2]
Definition: vorbisenc.c:107
dim
int dim
Definition: vorbis_enc_data.h:451
floor_classes
static const struct @165 floor_classes[]
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
vorbis_enc_context::samples
float * samples
Definition: vorbisenc.c:112
ff_vorbis_floor1_inverse_db_table
const float ff_vorbis_floor1_inverse_db_table[256]
Definition: vorbis_data.c:2123
vorbis_enc_context::modes
vorbis_enc_mode * modes
Definition: vorbisenc.c:134
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:526
ilog
#define ilog(i)
Definition: vorbis.h:48
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
mode
mode
Definition: ebur128.h:83
vorbis_enc_context
Definition: vorbisenc.c:104
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:75
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
vorbis_enc_mapping::mux
int * mux
Definition: vorbisenc.c:91
MAX_FLOOR_VALUES
#define MAX_FLOOR_VALUES
Definition: vorbisenc.c:146
vorbis_enc_context::bufqueue
struct FFBufQueue bufqueue
Definition: vorbisenc.c:119
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
vorbis_enc_context::codebooks
vorbis_enc_codebook * codebooks
Definition: vorbisenc.c:122
NUM_RESIDUE_PARTITIONS
#define NUM_RESIDUE_PARTITIONS
Definition: vorbisenc.c:150
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_enc_context::nmappings
int nmappings
Definition: vorbisenc.c:130
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:234
MAX_CHANNELS
#define MAX_CHANNELS
Definition: vorbisenc.c:141
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:415
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
int
int
Definition: ffmpeg_filter.c:192
put_bits.h
vorbis_enc_floor::rangebits
int rangebits
Definition: vorbisenc.c:73
vorbis_enc_mode::mapping
int mapping
Definition: vorbisenc.c:101
cb_lookup_vals
static int cb_lookup_vals(int lookup, int dimensions, int entries)
Definition: vorbisenc.c:164
channel
channel
Definition: ebur128.h:39
mc
#define mc
Definition: vf_colormatrix.c:102
Generated on Wed Aug 24 2022 21:31:38 for FFmpeg by   doxygen 1.8.17