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