FFmpeg
oggenc.c
Go to the documentation of this file.
1 /*
2  * Ogg muxer
3  * Copyright (c) 2007 Baptiste Coudurier <baptiste dot coudurier at free dot fr>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "libavutil/crc.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/random_seed.h"
28 #include "libavcodec/xiph.h"
29 #include "libavcodec/bytestream.h"
30 #include "libavcodec/flac.h"
31 #include "avformat.h"
32 #include "avio_internal.h"
33 #include "internal.h"
34 #include "vorbiscomment.h"
35 
36 #define MAX_PAGE_SIZE 65025
37 
38 typedef struct OGGPage {
39  int64_t start_granule;
40  int64_t granule;
46  uint16_t size;
47 } OGGPage;
48 
49 typedef struct OGGStreamContext {
50  unsigned page_counter;
52  int header_len[3];
53  /** for theora granule */
54  int kfgshift;
55  int64_t last_kf_pts;
56  int vrev;
57  /* for VP8 granule */
58  int isvp8;
59  int eos;
60  unsigned page_count; ///< number of page buffered
61  OGGPage page; ///< current page
62  unsigned serial_num; ///< serial number
63  int64_t last_granule; ///< last packet granule
65 
66 typedef struct OGGPageList {
68  struct OGGPageList *next;
69 } OGGPageList;
70 
71 typedef struct OGGContext {
72  const AVClass *class;
74  int pref_size; ///< preferred page size (0 => fill all segments)
75  int64_t pref_duration; ///< preferred page duration (0 => fill all segments)
77 } OGGContext;
78 
79 #define OFFSET(x) offsetof(OGGContext, x)
80 #define PARAM AV_OPT_FLAG_ENCODING_PARAM
81 
82 static const AVOption options[] = {
83  { "serial_offset", "serial number offset",
84  OFFSET(serial_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, PARAM },
85  { "oggpagesize", "Set preferred Ogg page size.",
86  OFFSET(pref_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, MAX_PAGE_SIZE, PARAM},
87  { "pagesize", "preferred page size in bytes (deprecated)",
88  OFFSET(pref_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MAX_PAGE_SIZE, PARAM },
89  { "page_duration", "preferred page duration, in microseconds",
90  OFFSET(pref_duration), AV_OPT_TYPE_INT64, { .i64 = 1000000 }, 0, INT64_MAX, PARAM },
91  { NULL },
92 };
93 
94 #define OGG_CLASS(flavor, name)\
95 static const AVClass flavor ## _muxer_class = {\
96  .class_name = #name " muxer",\
97  .item_name = av_default_item_name,\
98  .option = options,\
99  .version = LIBAVUTIL_VERSION_INT,\
100 };
101 
102 static void ogg_update_checksum(AVFormatContext *s, AVIOContext *pb, int64_t crc_offset)
103 {
104  int64_t pos = avio_tell(pb);
105  uint32_t checksum = ffio_get_checksum(pb);
106  avio_seek(pb, crc_offset, SEEK_SET);
107  avio_wb32(pb, checksum);
108  avio_seek(pb, pos, SEEK_SET);
109 }
110 
111 static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
112 {
113  OGGStreamContext *oggstream = s->streams[page->stream_index]->priv_data;
114  AVIOContext *pb;
115  int64_t crc_offset;
116  int ret, size;
117  uint8_t *buf;
118 
119  ret = avio_open_dyn_buf(&pb);
120  if (ret < 0)
121  return ret;
123  ffio_wfourcc(pb, "OggS");
124  avio_w8(pb, 0);
125  avio_w8(pb, page->flags | extra_flags);
126  avio_wl64(pb, page->granule);
127  avio_wl32(pb, oggstream->serial_num);
128  avio_wl32(pb, oggstream->page_counter++);
129  crc_offset = avio_tell(pb);
130  avio_wl32(pb, 0); // crc
131  avio_w8(pb, page->segments_count);
132  avio_write(pb, page->segments, page->segments_count);
133  avio_write(pb, page->data, page->size);
134 
135  ogg_update_checksum(s, pb, crc_offset);
136  avio_flush(pb);
137 
138  size = avio_close_dyn_buf(pb, &buf);
139  if (size < 0)
140  return size;
141 
142  avio_write(s->pb, buf, size);
143  avio_flush(s->pb);
144  av_free(buf);
145  oggstream->page_count--;
146  return 0;
147 }
148 
149 static int ogg_key_granule(OGGStreamContext *oggstream, int64_t granule)
150 {
151  return (oggstream->kfgshift && !(granule & ((1<<oggstream->kfgshift)-1))) ||
152  (oggstream->isvp8 && !((granule >> 3) & 0x07ffffff));
153 }
154 
155 static int64_t ogg_granule_to_timestamp(OGGStreamContext *oggstream, int64_t granule)
156 {
157  if (oggstream->kfgshift)
158  return (granule>>oggstream->kfgshift) +
159  (granule & ((1<<oggstream->kfgshift)-1));
160  else if (oggstream->isvp8)
161  return granule >> 32;
162  else
163  return granule;
164 }
165 
167 {
168  AVStream *st2 = s->streams[next->stream_index];
169  AVStream *st = s->streams[page->stream_index];
170  int64_t next_granule, cur_granule;
171 
172  if (next->granule == -1 || page->granule == -1)
173  return 0;
174 
175  next_granule = av_rescale_q(ogg_granule_to_timestamp(st2->priv_data, next->granule),
176  st2->time_base, AV_TIME_BASE_Q);
177  cur_granule = av_rescale_q(ogg_granule_to_timestamp(st->priv_data, page->granule),
178  st ->time_base, AV_TIME_BASE_Q);
179  return next_granule > cur_granule;
180 }
181 
182 static int ogg_reset_cur_page(OGGStreamContext *oggstream)
183 {
184  oggstream->page.granule = -1;
185  oggstream->page.flags = 0;
186  oggstream->page.segments_count = 0;
187  oggstream->page.size = 0;
188  return 0;
189 }
190 
192 {
193  OGGContext *ogg = s->priv_data;
194  OGGPageList **p = &ogg->page_list;
195  OGGPageList *l = av_mallocz(sizeof(*l));
196 
197  if (!l)
198  return AVERROR(ENOMEM);
199  l->page = oggstream->page;
200 
201  oggstream->page.start_granule = ogg_granule_to_timestamp(oggstream, oggstream->page.granule);
202  oggstream->page_count++;
203  ogg_reset_cur_page(oggstream);
204 
205  while (*p) {
206  if (ogg_compare_granule(s, &(*p)->page, &l->page))
207  break;
208  p = &(*p)->next;
209  }
210  l->next = *p;
211  *p = l;
212 
213  return 0;
214 }
215 
217  uint8_t *data, unsigned size, int64_t granule,
218  int header)
219 {
220  OGGStreamContext *oggstream = st->priv_data;
221  OGGContext *ogg = s->priv_data;
222  int total_segments = size / 255 + 1;
223  uint8_t *p = data;
224  int i, segments, len, flush = 0;
225 
226  // Handles VFR by flushing page because this frame needs to have a timestamp
227  // For theora and VP8, keyframes also need to have a timestamp to correctly mark
228  // them as such, otherwise seeking will not work correctly at the very
229  // least with old libogg versions.
230  // Do not try to flush header packets though, that will create broken files.
231  if ((st->codecpar->codec_id == AV_CODEC_ID_THEORA || st->codecpar->codec_id == AV_CODEC_ID_VP8) && !header &&
232  (ogg_granule_to_timestamp(oggstream, granule) >
233  ogg_granule_to_timestamp(oggstream, oggstream->last_granule) + 1 ||
234  ogg_key_granule(oggstream, granule))) {
235  if (oggstream->page.granule != -1)
236  ogg_buffer_page(s, oggstream);
237  flush = 1;
238  }
239 
240  // avoid a continued page
241  if (!header && oggstream->page.size > 0 &&
242  MAX_PAGE_SIZE - oggstream->page.size < size) {
243  ogg_buffer_page(s, oggstream);
244  }
245 
246  for (i = 0; i < total_segments; ) {
247  OGGPage *page = &oggstream->page;
248 
249  segments = FFMIN(total_segments - i, 255 - page->segments_count);
250 
251  if (i && !page->segments_count)
252  page->flags |= 1; // continued packet
253 
254  memset(page->segments+page->segments_count, 255, segments - 1);
255  page->segments_count += segments - 1;
256 
257  len = FFMIN(size, segments*255);
258  page->segments[page->segments_count++] = len - (segments-1)*255;
259  memcpy(page->data+page->size, p, len);
260  p += len;
261  size -= len;
262  i += segments;
263  page->size += len;
264 
265  if (i == total_segments)
266  page->granule = granule;
267 
268  {
269  AVStream *st = s->streams[page->stream_index];
270 
271  int64_t start = av_rescale_q(page->start_granule, st->time_base,
273  int64_t next = av_rescale_q(ogg_granule_to_timestamp(oggstream, page->granule),
275 
276  if (page->segments_count == 255) {
277  ogg_buffer_page(s, oggstream);
278  } else if (!header) {
279  if ((ogg->pref_size > 0 && page->size >= ogg->pref_size) ||
280  (ogg->pref_duration > 0 && next - start >= ogg->pref_duration)) {
281  ogg_buffer_page(s, oggstream);
282  }
283  }
284  }
285  }
286 
287  if (flush && oggstream->page.granule != -1)
288  ogg_buffer_page(s, oggstream);
289 
290  return 0;
291 }
292 
293 static uint8_t *ogg_write_vorbiscomment(int64_t offset, int bitexact,
294  int *header_len, AVDictionary **m, int framing_bit,
295  AVChapter **chapters, unsigned int nb_chapters)
296 {
297  const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;
298  int64_t size;
299  uint8_t *p, *p0;
300 
302 
303  size = offset + ff_vorbiscomment_length(*m, vendor, chapters, nb_chapters) + framing_bit;
304  if (size > INT_MAX)
305  return NULL;
306  p = av_mallocz(size);
307  if (!p)
308  return NULL;
309  p0 = p;
310 
311  p += offset;
312  ff_vorbiscomment_write(&p, m, vendor, chapters, nb_chapters);
313  if (framing_bit)
314  bytestream_put_byte(&p, 1);
315 
316  *header_len = size;
317  return p0;
318 }
319 
321  OGGStreamContext *oggstream, int bitexact,
322  AVDictionary **m)
323 {
324  uint8_t *p;
325 
327  return AVERROR(EINVAL);
328 
329  // first packet: STREAMINFO
330  oggstream->header_len[0] = 51;
331  oggstream->header[0] = av_mallocz(51); // per ogg flac specs
332  p = oggstream->header[0];
333  if (!p)
334  return AVERROR(ENOMEM);
335  bytestream_put_byte(&p, 0x7F);
336  bytestream_put_buffer(&p, "FLAC", 4);
337  bytestream_put_byte(&p, 1); // major version
338  bytestream_put_byte(&p, 0); // minor version
339  bytestream_put_be16(&p, 1); // headers packets without this one
340  bytestream_put_buffer(&p, "fLaC", 4);
341  bytestream_put_byte(&p, 0x00); // streaminfo
342  bytestream_put_be24(&p, 34);
344 
345  // second packet: VorbisComment
346  p = ogg_write_vorbiscomment(4, bitexact, &oggstream->header_len[1], m, 0, NULL, 0);
347  if (!p)
348  return AVERROR(ENOMEM);
349  oggstream->header[1] = p;
350  bytestream_put_byte(&p, 0x84); // last metadata block and vorbis comment
351  bytestream_put_be24(&p, oggstream->header_len[1] - 4);
352 
353  return 0;
354 }
355 
356 #define SPEEX_HEADER_SIZE 80
357 
359  OGGStreamContext *oggstream, int bitexact,
360  AVDictionary **m)
361 {
362  uint8_t *p;
363 
365  return AVERROR_INVALIDDATA;
366 
367  // first packet: Speex header
369  if (!p)
370  return AVERROR(ENOMEM);
371  oggstream->header[0] = p;
372  oggstream->header_len[0] = SPEEX_HEADER_SIZE;
374  AV_WL32(&oggstream->header[0][68], 0); // set extra_headers to 0
375 
376  // second packet: VorbisComment
377  p = ogg_write_vorbiscomment(0, bitexact, &oggstream->header_len[1], m, 0, NULL, 0);
378  if (!p)
379  return AVERROR(ENOMEM);
380  oggstream->header[1] = p;
381 
382  return 0;
383 }
384 
385 #define OPUS_HEADER_SIZE 19
386 
388  OGGStreamContext *oggstream, int bitexact,
389  AVDictionary **m, AVChapter **chapters,
390  unsigned int nb_chapters)
391 {
392  uint8_t *p;
393 
394  if (par->extradata_size < OPUS_HEADER_SIZE)
395  return AVERROR_INVALIDDATA;
396 
397  /* first packet: Opus header */
398  p = av_mallocz(par->extradata_size);
399  if (!p)
400  return AVERROR(ENOMEM);
401  oggstream->header[0] = p;
402  oggstream->header_len[0] = par->extradata_size;
404 
405  /* second packet: VorbisComment */
406  p = ogg_write_vorbiscomment(8, bitexact, &oggstream->header_len[1], m, 0, chapters, nb_chapters);
407  if (!p)
408  return AVERROR(ENOMEM);
409  oggstream->header[1] = p;
410  bytestream_put_buffer(&p, "OpusTags", 8);
411 
412  return 0;
413 }
414 
415 #define VP8_HEADER_SIZE 26
416 
418  OGGStreamContext *oggstream, int bitexact)
419 {
420  AVCodecParameters *par = st->codecpar;
421  uint8_t *p;
422 
423  /* first packet: VP8 header */
425  if (!p)
426  return AVERROR(ENOMEM);
427  oggstream->header[0] = p;
428  oggstream->header_len[0] = VP8_HEADER_SIZE;
429  bytestream_put_byte(&p, 0x4f); // HDRID
430  bytestream_put_buffer(&p, "VP80", 4); // Identifier
431  bytestream_put_byte(&p, 1); // HDRTYP
432  bytestream_put_byte(&p, 1); // VMAJ
433  bytestream_put_byte(&p, 0); // VMIN
434  bytestream_put_be16(&p, par->width);
435  bytestream_put_be16(&p, par->height);
436  bytestream_put_be24(&p, par->sample_aspect_ratio.num);
437  bytestream_put_be24(&p, par->sample_aspect_ratio.den);
438  if (st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0) {
439  // OggVP8 requires pts to increase by 1 per visible frame, so use the least common
440  // multiple framerate if available.
441  av_log(s, AV_LOG_DEBUG, "Changing time base from %d/%d to %d/%d\n",
442  st->time_base.num, st->time_base.den,
443  st->r_frame_rate.den, st->r_frame_rate.num);
445  }
446  bytestream_put_be32(&p, st->time_base.den);
447  bytestream_put_be32(&p, st->time_base.num);
448 
449  /* optional second packet: VorbisComment */
451  p = ogg_write_vorbiscomment(7, bitexact, &oggstream->header_len[1], &st->metadata, 0, NULL, 0);
452  if (!p)
453  return AVERROR(ENOMEM);
454  oggstream->header[1] = p;
455  bytestream_put_byte(&p, 0x4f); // HDRID
456  bytestream_put_buffer(&p, "VP80", 4); // Identifier
457  bytestream_put_byte(&p, 2); // HDRTYP
458  bytestream_put_byte(&p, 0x20);
459  }
460 
461  oggstream->isvp8 = 1;
462 
463  return 0;
464 }
465 
467 {
468  OGGContext *ogg = s->priv_data;
469  OGGPageList *next, *p;
470 
471  if (!ogg->page_list)
472  return;
473 
474  for (p = ogg->page_list; p; ) {
475  OGGStreamContext *oggstream =
477  if (oggstream->page_count < 2 && !flush)
478  break;
479  ogg_write_page(s, &p->page,
480  flush == 1 && oggstream->page_count == 1 ? 4 : 0); // eos
481  next = p->next;
482  av_freep(&p);
483  p = next;
484  }
485  ogg->page_list = p;
486 }
487 
489 {
490  OGGContext *ogg = s->priv_data;
491  OGGStreamContext *oggstream = NULL;
492  int i, j;
493 
494  if (ogg->pref_size)
495  av_log(s, AV_LOG_WARNING, "The pagesize option is deprecated\n");
496 
497  for (i = 0; i < s->nb_streams; i++) {
498  AVStream *st = s->streams[i];
499  unsigned serial_num = i + ogg->serial_offset;
500 
501  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
502  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS)
503  /* Opus requires a fixed 48kHz clock */
504  avpriv_set_pts_info(st, 64, 1, 48000);
505  else
506  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
507  }
508 
509  if (st->codecpar->codec_id != AV_CODEC_ID_VORBIS &&
515  av_log(s, AV_LOG_ERROR, "Unsupported codec id in stream %d\n", i);
516  return AVERROR(EINVAL);
517  }
518 
519  if ((!st->codecpar->extradata || !st->codecpar->extradata_size) &&
521  av_log(s, AV_LOG_ERROR, "No extradata present\n");
522  return AVERROR_INVALIDDATA;
523  }
524  oggstream = av_mallocz(sizeof(*oggstream));
525  if (!oggstream)
526  return AVERROR(ENOMEM);
527 
528  oggstream->page.stream_index = i;
529 
530  if (!(s->flags & AVFMT_FLAG_BITEXACT))
531  do {
532  serial_num = av_get_random_seed();
533  for (j = 0; j < i; j++) {
534  OGGStreamContext *sc = s->streams[j]->priv_data;
535  if (serial_num == sc->serial_num)
536  break;
537  }
538  } while (j < i);
539  oggstream->serial_num = serial_num;
540 
542 
543  st->priv_data = oggstream;
544  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC) {
545  int err = ogg_build_flac_headers(st->codecpar, oggstream,
547  &st->metadata);
548  if (err) {
549  av_log(s, AV_LOG_ERROR, "Error writing FLAC headers\n");
550  av_freep(&st->priv_data);
551  return err;
552  }
553  } else if (st->codecpar->codec_id == AV_CODEC_ID_SPEEX) {
554  int err = ogg_build_speex_headers(st->codecpar, oggstream,
556  &st->metadata);
557  if (err) {
558  av_log(s, AV_LOG_ERROR, "Error writing Speex headers\n");
559  av_freep(&st->priv_data);
560  return err;
561  }
562  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
563  int err = ogg_build_opus_headers(st->codecpar, oggstream,
565  &st->metadata, s->chapters, s->nb_chapters);
566  if (err) {
567  av_log(s, AV_LOG_ERROR, "Error writing Opus headers\n");
568  av_freep(&st->priv_data);
569  return err;
570  }
571  } else if (st->codecpar->codec_id == AV_CODEC_ID_VP8) {
572  int err = ogg_build_vp8_headers(s, st, oggstream,
574  if (err) {
575  av_log(s, AV_LOG_ERROR, "Error writing VP8 headers\n");
576  av_freep(&st->priv_data);
577  return err;
578  }
579  } else {
580  uint8_t *p;
581  const char *cstr = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? "vorbis" : "theora";
582  int header_type = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 3 : 0x81;
583  int framing_bit = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 1 : 0;
584 
586  st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 30 : 42,
587  (const uint8_t**)oggstream->header, oggstream->header_len) < 0) {
588  av_log(s, AV_LOG_ERROR, "Extradata corrupted\n");
589  av_freep(&st->priv_data);
590  return AVERROR_INVALIDDATA;
591  }
592 
594  &oggstream->header_len[1], &st->metadata,
595  framing_bit, NULL, 0);
596  oggstream->header[1] = p;
597  if (!p)
598  return AVERROR(ENOMEM);
599 
600  bytestream_put_byte(&p, header_type);
601  bytestream_put_buffer(&p, cstr, 6);
602 
603  if (st->codecpar->codec_id == AV_CODEC_ID_THEORA) {
604  int den = AV_RB32(oggstream->header[0] + 22), num = AV_RB32(oggstream->header[0] + 26);
605  /* Make sure to use time base stored in the Theora stream header to write
606  correct timestamps */
607  if (st->time_base.num != num || st->time_base.den != den) {
608  av_log(s, AV_LOG_DEBUG, "Changing time base from %d/%d to %d/%d\n",
609  st->time_base.num, st->time_base.den, num, den);
610  avpriv_set_pts_info(st, 64, num, den);
611  }
612  /** KFGSHIFT is the width of the less significant section of the granule position
613  The less significant section is the frame count since the last keyframe */
614  oggstream->kfgshift = ((oggstream->header[0][40]&3)<<3)|(oggstream->header[0][41]>>5);
615  oggstream->vrev = oggstream->header[0][9];
616  av_log(s, AV_LOG_DEBUG, "theora kfgshift %d, vrev %d\n",
617  oggstream->kfgshift, oggstream->vrev);
618  }
619  }
620  }
621 
622  return 0;
623 }
624 
626 {
627  OGGStreamContext *oggstream = NULL;
628  int i, j;
629 
630  for (j = 0; j < s->nb_streams; j++) {
631  oggstream = s->streams[j]->priv_data;
632  ogg_buffer_data(s, s->streams[j], oggstream->header[0],
633  oggstream->header_len[0], 0, 1);
634  oggstream->page.flags |= 2; // bos
635  ogg_buffer_page(s, oggstream);
636  }
637  for (j = 0; j < s->nb_streams; j++) {
638  AVStream *st = s->streams[j];
639  oggstream = st->priv_data;
640  for (i = 1; i < 3; i++) {
641  if (oggstream->header_len[i])
642  ogg_buffer_data(s, st, oggstream->header[i],
643  oggstream->header_len[i], 0, 1);
644  }
645  ogg_buffer_page(s, oggstream);
646  }
647 
648  oggstream->page.start_granule = AV_NOPTS_VALUE;
649 
650  ogg_write_pages(s, 2);
651 
652  return 0;
653 }
654 
656 {
657  AVStream *st = s->streams[pkt->stream_index];
658  OGGStreamContext *oggstream = st->priv_data;
659  int ret;
660  int64_t granule;
661 
662  if (st->codecpar->codec_id == AV_CODEC_ID_THEORA) {
663  int64_t pts = oggstream->vrev < 1 ? pkt->pts : pkt->pts + pkt->duration;
664  int pframe_count;
665  if (pkt->flags & AV_PKT_FLAG_KEY)
666  oggstream->last_kf_pts = pts;
667  pframe_count = pts - oggstream->last_kf_pts;
668  // prevent frame count from overflow if key frame flag is not set
669  if (pframe_count >= (1<<oggstream->kfgshift)) {
670  oggstream->last_kf_pts += pframe_count;
671  pframe_count = 0;
672  }
673  granule = (oggstream->last_kf_pts<<oggstream->kfgshift) | pframe_count;
674  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS)
675  granule = pkt->pts + pkt->duration +
677  (AVRational){ 1, st->codecpar->sample_rate },
678  st->time_base);
679  else if (st->codecpar->codec_id == AV_CODEC_ID_VP8) {
680  int64_t pts, invcnt, dist;
681  int visible;
682 
683  visible = (pkt->data[0] >> 4) & 1;
684  pts = pkt->pts + pkt->duration;
685  invcnt = (oggstream->last_granule >> 30) & 3;
686  invcnt = visible ? 3 : (invcnt == 3 ? 0 : invcnt + 1);
687  dist = (pkt->flags & AV_PKT_FLAG_KEY) ? 0 : ((oggstream->last_granule >> 3) & 0x07ffffff) + 1;
688 
689  granule = (pts << 32) | (invcnt << 30) | (dist << 3);
690  } else
691  granule = pkt->pts + pkt->duration;
692 
693  if (oggstream->page.start_granule == AV_NOPTS_VALUE)
694  oggstream->page.start_granule = pkt->pts;
695 
696  ret = ogg_buffer_data(s, st, pkt->data, pkt->size, granule, 0);
697  if (ret < 0)
698  return ret;
699 
700  ogg_write_pages(s, 0);
701 
702  oggstream->last_granule = granule;
703 
704  return 0;
705 }
706 
708 {
709  int i;
710 
711  if (pkt)
712  return ogg_write_packet_internal(s, pkt);
713 
714  for (i = 0; i < s->nb_streams; i++) {
715  OGGStreamContext *oggstream = s->streams[i]->priv_data;
716  if (oggstream->page.segments_count)
717  ogg_buffer_page(s, oggstream);
718  }
719 
720  ogg_write_pages(s, 2);
721  return 1;
722 }
723 
725 {
726  int i;
727 
728  /* flush current page if needed */
729  for (i = 0; i < s->nb_streams; i++) {
730  OGGStreamContext *oggstream = s->streams[i]->priv_data;
731 
732  if (oggstream->page.size > 0)
733  ogg_buffer_page(s, oggstream);
734  }
735 
736  ogg_write_pages(s, 1);
737 
738  return 0;
739 }
740 
742 {
743  int i;
744 
745  for (i = 0; i < s->nb_streams; i++) {
746  AVStream *st = s->streams[i];
747  OGGStreamContext *oggstream = st->priv_data;
748  if (!oggstream)
749  continue;
750  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC ||
754  av_freep(&oggstream->header[0]);
755  }
756  av_freep(&oggstream->header[1]);
757  av_freep(&st->priv_data);
758  }
759 }
760 
761 #if CONFIG_OGG_MUXER
762 OGG_CLASS(ogg, Ogg)
764  .name = "ogg",
765  .long_name = NULL_IF_CONFIG_SMALL("Ogg"),
766  .mime_type = "application/ogg",
767  .extensions = "ogg"
768 #if !CONFIG_OGV_MUXER
769  ",ogv"
770 #endif
771 #if !CONFIG_SPX_MUXER
772  ",spx"
773 #endif
774 #if !CONFIG_OPUS_MUXER
775  ",opus"
776 #endif
777  ,
778  .priv_data_size = sizeof(OGGContext),
779  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
781  .video_codec = AV_CODEC_ID_THEORA,
782  .init = ogg_init,
786  .deinit = ogg_free,
788  .priv_class = &ogg_muxer_class,
789 };
790 #endif
791 
792 #if CONFIG_OGA_MUXER
793 OGG_CLASS(oga, Ogg audio)
795  .name = "oga",
796  .long_name = NULL_IF_CONFIG_SMALL("Ogg Audio"),
797  .mime_type = "audio/ogg",
798  .extensions = "oga",
799  .priv_data_size = sizeof(OGGContext),
800  .audio_codec = AV_CODEC_ID_FLAC,
801  .init = ogg_init,
805  .deinit = ogg_free,
807  .priv_class = &oga_muxer_class,
808 };
809 #endif
810 
811 #if CONFIG_OGV_MUXER
812 OGG_CLASS(ogv, Ogg video)
814  .name = "ogv",
815  .long_name = NULL_IF_CONFIG_SMALL("Ogg Video"),
816  .mime_type = "video/ogg",
817  .extensions = "ogv",
818  .priv_data_size = sizeof(OGGContext),
819  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
821  .video_codec = CONFIG_LIBTHEORA_ENCODER ?
823  .init = ogg_init,
827  .deinit = ogg_free,
829  .priv_class = &ogv_muxer_class,
830 };
831 #endif
832 
833 #if CONFIG_SPX_MUXER
834 OGG_CLASS(spx, Ogg Speex)
836  .name = "spx",
837  .long_name = NULL_IF_CONFIG_SMALL("Ogg Speex"),
838  .mime_type = "audio/ogg",
839  .extensions = "spx",
840  .priv_data_size = sizeof(OGGContext),
841  .audio_codec = AV_CODEC_ID_SPEEX,
842  .init = ogg_init,
846  .deinit = ogg_free,
848  .priv_class = &spx_muxer_class,
849 };
850 #endif
851 
852 #if CONFIG_OPUS_MUXER
853 OGG_CLASS(opus, Ogg Opus)
855  .name = "opus",
856  .long_name = NULL_IF_CONFIG_SMALL("Ogg Opus"),
857  .mime_type = "audio/ogg",
858  .extensions = "opus",
859  .priv_data_size = sizeof(OGGContext),
860  .audio_codec = AV_CODEC_ID_OPUS,
861  .init = ogg_init,
865  .deinit = ogg_free,
867  .priv_class = &opus_muxer_class,
868 };
869 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1587
int header_len[3]
Definition: oggenc.c:52
static int ogg_write_header(AVFormatContext *s)
Definition: oggenc.c:625
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
#define NULL
Definition: coverity.c:32
int64_t granule
Definition: oggenc.c:40
int64_t last_granule
last packet granule
Definition: oggenc.c:63
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1459
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
unsigned page_count
number of page buffered
Definition: oggenc.c:60
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4892
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4033
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
uint8_t data[MAX_PAGE_SIZE]
Definition: oggenc.c:45
OGGPage page
Definition: oggenc.c:67
void * priv_data
Definition: avformat.h:896
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
OGGPage page
current page
Definition: oggenc.c:61
static AVPacket pkt
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:476
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
#define OPUS_HEADER_SIZE
Definition: oggenc.c:385
static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
Definition: oggenc.c:111
Format I/O context.
Definition: avformat.h:1358
static void ogg_update_checksum(AVFormatContext *s, AVIOContext *pb, int64_t crc_offset)
Definition: oggenc.c:102
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:372
uint8_t
static void ogg_free(AVFormatContext *s)
Definition: oggenc.c:741
int width
Video only.
Definition: avcodec.h:4023
AVOptions.
uint16_t size
Definition: oggenc.c:46
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
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
#define MAX_PAGE_SIZE
Definition: oggenc.c:36
uint8_t segments_count
Definition: oggenc.c:43
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
static int ogg_build_speex_headers(AVCodecParameters *par, OGGStreamContext *oggstream, int bitexact, AVDictionary **m)
Definition: oggenc.c:358
int64_t last_kf_pts
Definition: oggenc.c:55
Public header for CRC hash function implementation.
int initial_padding
Audio only.
Definition: avcodec.h:4086
AVOutputFormat ff_spx_muxer
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
uint8_t * data
Definition: avcodec.h:1477
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
Definition: oggenc.c:38
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
static const AVOption options[]
Definition: oggenc.c:82
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
static int ogg_build_flac_headers(AVCodecParameters *par, OGGStreamContext *oggstream, int bitexact, AVDictionary **m)
Definition: oggenc.c:320
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:460
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
unsigned page_counter
Definition: oggenc.c:50
const AVMetadataConv ff_vorbiscomment_metadata_conv[]
VorbisComment metadata conversion mapping.
Definition: vorbiscomment.c:33
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
static int ogg_buffer_data(AVFormatContext *s, AVStream *st, uint8_t *data, unsigned size, int64_t granule, int header)
Definition: oggenc.c:216
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
int64_t start_granule
Definition: oggenc.c:39
struct OGGPageList * next
Definition: oggenc.c:68
int pref_size
preferred page size (0 => fill all segments)
Definition: oggenc.c:74
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVChapter ** chapters
Definition: avformat.h:1588
AVOutputFormat ff_ogv_muxer
int ff_vorbiscomment_write(uint8_t **p, AVDictionary **m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Write a VorbisComment into a buffer.
Definition: vorbiscomment.c:65
uint8_t flags
Definition: oggenc.c:42
static int ogg_reset_cur_page(OGGStreamContext *oggstream)
Definition: oggenc.c:182
static int64_t ogg_granule_to_timestamp(OGGStreamContext *oggstream, int64_t granule)
Definition: oggenc.c:155
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
static int ogg_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
Definition: oggenc.c:655
#define VP8_HEADER_SIZE
Definition: oggenc.c:415
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
static int ogg_write_trailer(AVFormatContext *s)
Definition: oggenc.c:724
#define LIBAVFORMAT_IDENT
Definition: version.h:46
void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)
Definition: aviobuf.c:629
static int ogg_build_opus_headers(AVCodecParameters *par, OGGStreamContext *oggstream, int bitexact, AVDictionary **m, AVChapter **chapters, unsigned int nb_chapters)
Definition: oggenc.c:387
#define FFMIN(a, b)
Definition: common.h:96
int serial_offset
Definition: oggenc.c:76
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:603
int64_t ff_vorbiscomment_length(AVDictionary *m, const char *vendor_string, AVChapter **chapters, unsigned int nb_chapters)
Calculate the length in bytes of a VorbisComment.
Definition: vorbiscomment.c:41
const char * name
Definition: avformat.h:505
static int ogg_compare_granule(AVFormatContext *s, OGGPage *next, OGGPage *page)
Definition: oggenc.c:166
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
#define s(width, name)
Definition: cbs_vp9.c:257
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
AVDictionary * metadata
Definition: avformat.h:945
static volatile int checksum
Definition: adler32.c:30
uint8_t * header[3]
Definition: oggenc.c:51
#define SPEEX_HEADER_SIZE
Definition: oggenc.c:356
Stream structure.
Definition: avformat.h:881
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
static int ogg_buffer_page(AVFormatContext *s, OGGStreamContext *oggstream)
Definition: oggenc.c:191
void * buf
Definition: avisynth_c.h:766
int stream_index
Definition: oggenc.c:41
static int ogg_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: oggenc.c:707
Describe the class of an AVClass context structure.
Definition: log.h:67
#define OGG_CLASS(flavor, name)
Definition: oggenc.c:94
Rational number (pair of numerator and denominator).
Definition: rational.h:58
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:621
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
unsigned serial_num
serial number
Definition: oggenc.c:62
#define PARAM
Definition: oggenc.c:80
static int64_t pts
OGGPageList * page_list
Definition: oggenc.c:73
static int ogg_init(AVFormatContext *s)
Definition: oggenc.c:488
int sample_rate
Audio only.
Definition: avcodec.h:4067
Main libavformat public API header.
AVOutputFormat ff_oga_muxer
AVOutputFormat ff_ogg_muxer
#define OFFSET(x)
Definition: oggenc.c:79
static int ogg_key_granule(OGGStreamContext *oggstream, int64_t granule)
Definition: oggenc.c:149
int kfgshift
for theora granule
Definition: oggenc.c:54
int den
Denominator.
Definition: rational.h:60
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
A Quick Description Of Rate Distortion Theory We want to encode a video
#define av_free(p)
Definition: oggdec.h:101
int len
void * priv_data
Format private data.
Definition: avformat.h:1386
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
AVOutputFormat ff_opus_muxer
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:380
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
uint8_t segments[255]
Definition: oggenc.c:44
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int stream_index
Definition: avcodec.h:1479
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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
int64_t pref_duration
preferred page duration (0 => fill all segments)
Definition: oggenc.c:75
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:482
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
static void ogg_write_pages(AVFormatContext *s, int flush)
Definition: oggenc.c:466
This structure stores compressed data.
Definition: avcodec.h:1454
static uint8_t * ogg_write_vorbiscomment(int64_t offset, int bitexact, int *header_len, AVDictionary **m, int framing_bit, AVChapter **chapters, unsigned int nb_chapters)
Definition: oggenc.c:293
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
static int ogg_build_vp8_headers(AVFormatContext *s, AVStream *st, OGGStreamContext *oggstream, int bitexact)
Definition: oggenc.c:417
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define AV_WL32(p, v)
Definition: intreadwrite.h:426