2007-11-10 19:27:03 +01:00
|
|
|
/*
|
|
|
|
* Ogg muxer
|
|
|
|
* Copyright (c) 2007 Baptiste Coudurier <baptiste dot coudurier at free dot fr>
|
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
2013-11-23 21:32:55 +01:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2008-05-09 13:56:36 +02:00
|
|
|
#include "libavutil/crc.h"
|
2011-06-04 13:58:23 +02:00
|
|
|
#include "libavutil/mathematics.h"
|
2011-01-27 10:14:21 +01:00
|
|
|
#include "libavutil/opt.h"
|
2010-05-25 01:37:33 +02:00
|
|
|
#include "libavutil/random_seed.h"
|
2008-05-09 13:56:36 +02:00
|
|
|
#include "libavcodec/xiph.h"
|
|
|
|
#include "libavcodec/bytestream.h"
|
2009-02-26 03:29:24 +01:00
|
|
|
#include "libavcodec/flac.h"
|
2007-11-10 19:27:03 +01:00
|
|
|
#include "avformat.h"
|
2011-02-24 07:36:02 +01:00
|
|
|
#include "avio_internal.h"
|
2009-02-08 22:14:46 +01:00
|
|
|
#include "internal.h"
|
2010-03-20 14:39:22 +01:00
|
|
|
#include "vorbiscomment.h"
|
2007-11-10 19:27:03 +01:00
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
#define MAX_PAGE_SIZE 65025
|
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct OGGPage {
|
2012-12-30 23:00:00 +01:00
|
|
|
int64_t start_granule;
|
2010-05-21 23:38:54 +02:00
|
|
|
int64_t granule;
|
|
|
|
int stream_index;
|
|
|
|
uint8_t flags;
|
|
|
|
uint8_t segments_count;
|
|
|
|
uint8_t segments[255];
|
|
|
|
uint8_t data[MAX_PAGE_SIZE];
|
|
|
|
uint16_t size;
|
|
|
|
} OGGPage;
|
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct OGGStreamContext {
|
2007-11-10 19:27:03 +01:00
|
|
|
unsigned page_counter;
|
|
|
|
uint8_t *header[3];
|
|
|
|
int header_len[3];
|
|
|
|
/** for theora granule */
|
|
|
|
int kfgshift;
|
|
|
|
int64_t last_kf_pts;
|
|
|
|
int vrev;
|
2008-02-05 02:16:47 +01:00
|
|
|
int eos;
|
2010-05-21 23:38:54 +02:00
|
|
|
unsigned page_count; ///< number of page buffered
|
|
|
|
OGGPage page; ///< current page
|
2010-05-25 01:37:33 +02:00
|
|
|
unsigned serial_num; ///< serial number
|
2011-01-05 20:32:45 +01:00
|
|
|
int64_t last_granule; ///< last packet granule
|
2007-11-10 19:27:03 +01:00
|
|
|
} OGGStreamContext;
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
typedef struct OGGPageList {
|
|
|
|
OGGPage page;
|
|
|
|
struct OGGPageList *next;
|
|
|
|
} OGGPageList;
|
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct OGGContext {
|
2011-01-27 10:14:21 +01:00
|
|
|
const AVClass *class;
|
2010-05-21 23:38:54 +02:00
|
|
|
OGGPageList *page_list;
|
2011-01-27 10:14:21 +01:00
|
|
|
int pref_size; ///< preferred page size (0 => fill all segments)
|
2012-12-30 23:00:00 +01:00
|
|
|
int64_t pref_duration; ///< preferred page duration (0 => fill all segments)
|
2015-01-30 17:29:22 +01:00
|
|
|
int serial_offset;
|
2010-05-21 23:38:54 +02:00
|
|
|
} OGGContext;
|
|
|
|
|
2011-01-27 10:14:21 +01:00
|
|
|
#define OFFSET(x) offsetof(OGGContext, x)
|
|
|
|
#define PARAM AV_OPT_FLAG_ENCODING_PARAM
|
2011-01-27 10:14:21 +01:00
|
|
|
|
|
|
|
static const AVOption options[] = {
|
2015-01-30 17:29:22 +01:00
|
|
|
{ "serial_offset", "serial number offset",
|
|
|
|
OFFSET(serial_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, PARAM },
|
2011-01-27 10:14:21 +01:00
|
|
|
{ "oggpagesize", "Set preferred Ogg page size.",
|
2015-02-01 14:35:15 +01:00
|
|
|
OFFSET(pref_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, MAX_PAGE_SIZE, PARAM},
|
2012-12-30 23:00:00 +01:00
|
|
|
{ "pagesize", "preferred page size in bytes (deprecated)",
|
2012-08-31 12:22:31 +02:00
|
|
|
OFFSET(pref_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MAX_PAGE_SIZE, PARAM },
|
2012-12-30 23:00:00 +01:00
|
|
|
{ "page_duration", "preferred page duration, in microseconds",
|
2013-04-13 20:23:01 +02:00
|
|
|
OFFSET(pref_duration), AV_OPT_TYPE_INT64, { .i64 = 1000000 }, 0, INT64_MAX, PARAM },
|
2011-01-27 10:14:21 +01:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
2014-08-23 21:39:14 +02:00
|
|
|
#define OGG_CLASS(flavor, name)\
|
2014-08-23 02:42:18 +02:00
|
|
|
static const AVClass flavor ## _muxer_class = {\
|
2014-08-23 21:39:14 +02:00
|
|
|
.class_name = #name " muxer",\
|
2014-08-23 02:42:18 +02:00
|
|
|
.item_name = av_default_item_name,\
|
|
|
|
.option = options,\
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,\
|
2011-01-27 10:14:21 +01:00
|
|
|
};
|
|
|
|
|
2011-02-20 11:04:12 +01:00
|
|
|
static void ogg_update_checksum(AVFormatContext *s, AVIOContext *pb, int64_t crc_offset)
|
2007-11-10 19:27:03 +01:00
|
|
|
{
|
2011-03-03 20:11:45 +01:00
|
|
|
int64_t pos = avio_tell(pb);
|
2011-03-17 13:04:38 +01:00
|
|
|
uint32_t checksum = ffio_get_checksum(pb);
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, crc_offset, SEEK_SET);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(pb, checksum);
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, pos, SEEK_SET);
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
|
|
|
|
2010-07-15 01:21:18 +02:00
|
|
|
static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
|
2007-11-10 19:27:03 +01:00
|
|
|
{
|
2010-05-21 23:38:54 +02:00
|
|
|
OGGStreamContext *oggstream = s->streams[page->stream_index]->priv_data;
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb;
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t crc_offset;
|
2010-07-15 01:21:18 +02:00
|
|
|
int ret, size;
|
|
|
|
uint8_t *buf;
|
2007-11-10 19:27:03 +01:00
|
|
|
|
2011-03-17 08:13:34 +01:00
|
|
|
ret = avio_open_dyn_buf(&pb);
|
2010-07-15 01:21:18 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-03-17 12:56:25 +01:00
|
|
|
ffio_init_checksum(pb, ff_crc04C11DB7_update, 0);
|
2011-02-24 07:36:02 +01:00
|
|
|
ffio_wfourcc(pb, "OggS");
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0);
|
|
|
|
avio_w8(pb, page->flags | extra_flags);
|
|
|
|
avio_wl64(pb, page->granule);
|
|
|
|
avio_wl32(pb, oggstream->serial_num);
|
|
|
|
avio_wl32(pb, oggstream->page_counter++);
|
2011-03-03 20:11:45 +01:00
|
|
|
crc_offset = avio_tell(pb);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wl32(pb, 0); // crc
|
|
|
|
avio_w8(pb, page->segments_count);
|
|
|
|
avio_write(pb, page->segments, page->segments_count);
|
|
|
|
avio_write(pb, page->data, page->size);
|
2010-07-15 01:21:18 +02:00
|
|
|
|
|
|
|
ogg_update_checksum(s, pb, crc_offset);
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(pb);
|
2010-07-15 01:21:18 +02:00
|
|
|
|
2011-03-17 08:16:07 +01:00
|
|
|
size = avio_close_dyn_buf(pb, &buf);
|
2010-07-15 01:21:18 +02:00
|
|
|
if (size < 0)
|
|
|
|
return size;
|
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(s->pb, buf, size);
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(s->pb);
|
2010-07-17 00:36:01 +02:00
|
|
|
av_free(buf);
|
2010-05-21 23:38:54 +02:00
|
|
|
oggstream->page_count--;
|
2010-07-15 01:21:18 +02:00
|
|
|
return 0;
|
2010-05-21 23:38:54 +02:00
|
|
|
}
|
|
|
|
|
2012-02-12 10:52:42 +01:00
|
|
|
static int ogg_key_granule(OGGStreamContext *oggstream, int64_t granule)
|
|
|
|
{
|
|
|
|
return oggstream->kfgshift && !(granule & ((1<<oggstream->kfgshift)-1));
|
|
|
|
}
|
|
|
|
|
2011-01-05 20:32:45 +01:00
|
|
|
static int64_t ogg_granule_to_timestamp(OGGStreamContext *oggstream, int64_t granule)
|
2010-05-21 23:38:54 +02:00
|
|
|
{
|
|
|
|
if (oggstream->kfgshift)
|
2011-01-05 20:32:45 +01:00
|
|
|
return (granule>>oggstream->kfgshift) +
|
|
|
|
(granule & ((1<<oggstream->kfgshift)-1));
|
2010-05-21 23:38:54 +02:00
|
|
|
else
|
2011-01-05 20:32:45 +01:00
|
|
|
return granule;
|
2010-05-21 23:38:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ogg_compare_granule(AVFormatContext *s, OGGPage *next, OGGPage *page)
|
|
|
|
{
|
|
|
|
AVStream *st2 = s->streams[next->stream_index];
|
|
|
|
AVStream *st = s->streams[page->stream_index];
|
|
|
|
int64_t next_granule, cur_granule;
|
|
|
|
|
|
|
|
if (next->granule == -1 || page->granule == -1)
|
|
|
|
return 0;
|
|
|
|
|
2011-01-05 20:32:45 +01:00
|
|
|
next_granule = av_rescale_q(ogg_granule_to_timestamp(st2->priv_data, next->granule),
|
2010-05-21 23:38:54 +02:00
|
|
|
st2->time_base, AV_TIME_BASE_Q);
|
2011-01-05 20:32:45 +01:00
|
|
|
cur_granule = av_rescale_q(ogg_granule_to_timestamp(st->priv_data, page->granule),
|
2010-05-21 23:38:54 +02:00
|
|
|
st ->time_base, AV_TIME_BASE_Q);
|
|
|
|
return next_granule > cur_granule;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ogg_reset_cur_page(OGGStreamContext *oggstream)
|
|
|
|
{
|
|
|
|
oggstream->page.granule = -1;
|
|
|
|
oggstream->page.flags = 0;
|
|
|
|
oggstream->page.segments_count = 0;
|
|
|
|
oggstream->page.size = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ogg_buffer_page(AVFormatContext *s, OGGStreamContext *oggstream)
|
|
|
|
{
|
|
|
|
OGGContext *ogg = s->priv_data;
|
|
|
|
OGGPageList **p = &ogg->page_list;
|
|
|
|
OGGPageList *l = av_mallocz(sizeof(*l));
|
|
|
|
|
|
|
|
if (!l)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
l->page = oggstream->page;
|
|
|
|
|
2012-12-30 23:00:00 +01:00
|
|
|
oggstream->page.start_granule = oggstream->page.granule;
|
2010-05-21 23:38:54 +02:00
|
|
|
oggstream->page_count++;
|
|
|
|
ogg_reset_cur_page(oggstream);
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
if (ogg_compare_granule(s, &(*p)->page, &l->page))
|
|
|
|
break;
|
|
|
|
p = &(*p)->next;
|
|
|
|
}
|
|
|
|
l->next = *p;
|
|
|
|
*p = l;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ogg_buffer_data(AVFormatContext *s, AVStream *st,
|
2012-02-18 21:21:20 +01:00
|
|
|
uint8_t *data, unsigned size, int64_t granule,
|
|
|
|
int header)
|
2010-05-21 23:38:54 +02:00
|
|
|
{
|
|
|
|
OGGStreamContext *oggstream = st->priv_data;
|
2011-01-27 10:14:21 +01:00
|
|
|
OGGContext *ogg = s->priv_data;
|
2010-05-21 23:38:54 +02:00
|
|
|
int total_segments = size / 255 + 1;
|
|
|
|
uint8_t *p = data;
|
2011-01-05 20:32:45 +01:00
|
|
|
int i, segments, len, flush = 0;
|
|
|
|
|
|
|
|
// Handles VFR by flushing page because this frame needs to have a timestamp
|
2012-02-12 10:52:42 +01:00
|
|
|
// For theora, keyframes also need to have a timestamp to correctly mark
|
|
|
|
// them as such, otherwise seeking will not work correctly at the very
|
|
|
|
// least with old libogg versions.
|
2012-02-18 21:21:20 +01:00
|
|
|
// Do not try to flush header packets though, that will create broken files.
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_THEORA && !header &&
|
2012-02-12 10:52:42 +01:00
|
|
|
(ogg_granule_to_timestamp(oggstream, granule) >
|
|
|
|
ogg_granule_to_timestamp(oggstream, oggstream->last_granule) + 1 ||
|
|
|
|
ogg_key_granule(oggstream, granule))) {
|
2011-01-05 20:32:45 +01:00
|
|
|
if (oggstream->page.granule != -1)
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
flush = 1;
|
|
|
|
}
|
2010-05-21 23:38:54 +02:00
|
|
|
|
2012-12-30 23:00:00 +01:00
|
|
|
// avoid a continued page
|
|
|
|
if (!header && oggstream->page.size > 0 &&
|
|
|
|
MAX_PAGE_SIZE - oggstream->page.size < size) {
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
}
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
for (i = 0; i < total_segments; ) {
|
|
|
|
OGGPage *page = &oggstream->page;
|
|
|
|
|
|
|
|
segments = FFMIN(total_segments - i, 255 - page->segments_count);
|
|
|
|
|
|
|
|
if (i && !page->segments_count)
|
|
|
|
page->flags |= 1; // continued packet
|
|
|
|
|
|
|
|
memset(page->segments+page->segments_count, 255, segments - 1);
|
|
|
|
page->segments_count += segments - 1;
|
|
|
|
|
|
|
|
len = FFMIN(size, segments*255);
|
|
|
|
page->segments[page->segments_count++] = len - (segments-1)*255;
|
|
|
|
memcpy(page->data+page->size, p, len);
|
|
|
|
p += len;
|
|
|
|
size -= len;
|
|
|
|
i += segments;
|
|
|
|
page->size += len;
|
|
|
|
|
|
|
|
if (i == total_segments)
|
|
|
|
page->granule = granule;
|
|
|
|
|
2015-08-27 04:08:42 +02:00
|
|
|
{
|
2012-12-30 23:00:00 +01:00
|
|
|
AVStream *st = s->streams[page->stream_index];
|
|
|
|
|
|
|
|
int64_t start = av_rescale_q(page->start_granule, st->time_base,
|
|
|
|
AV_TIME_BASE_Q);
|
|
|
|
int64_t next = av_rescale_q(page->granule, st->time_base,
|
|
|
|
AV_TIME_BASE_Q);
|
|
|
|
|
2015-08-27 04:08:42 +02:00
|
|
|
if (page->segments_count == 255) {
|
2012-12-30 23:00:00 +01:00
|
|
|
ogg_buffer_page(s, oggstream);
|
2015-08-27 04:08:42 +02:00
|
|
|
} else if (!header) {
|
|
|
|
if ((ogg->pref_size > 0 && page->size >= ogg->pref_size) ||
|
|
|
|
(ogg->pref_duration > 0 && next - start >= ogg->pref_duration)) {
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
}
|
2012-12-30 23:00:00 +01:00
|
|
|
}
|
2010-05-21 23:38:54 +02:00
|
|
|
}
|
|
|
|
}
|
2011-01-05 20:32:45 +01:00
|
|
|
|
|
|
|
if (flush && oggstream->page.granule != -1)
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
return 0;
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
|
|
|
|
2015-05-11 15:34:28 +02:00
|
|
|
static uint8_t *ogg_write_vorbiscomment(int64_t offset, int bitexact,
|
2011-05-22 12:46:29 +02:00
|
|
|
int *header_len, AVDictionary **m, int framing_bit)
|
2009-10-13 03:46:19 +02:00
|
|
|
{
|
|
|
|
const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;
|
2015-05-11 15:34:28 +02:00
|
|
|
int64_t size;
|
2009-10-13 03:46:19 +02:00
|
|
|
uint8_t *p, *p0;
|
|
|
|
|
2010-10-27 07:02:29 +02:00
|
|
|
ff_metadata_conv(m, ff_vorbiscomment_metadata_conv, NULL);
|
|
|
|
|
2014-05-26 13:30:10 +02:00
|
|
|
size = offset + ff_vorbiscomment_length(*m, vendor) + framing_bit;
|
2015-05-11 15:34:28 +02:00
|
|
|
if (size > INT_MAX)
|
|
|
|
return NULL;
|
2009-10-13 03:46:19 +02:00
|
|
|
p = av_mallocz(size);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
p0 = p;
|
|
|
|
|
|
|
|
p += offset;
|
2014-05-26 13:30:10 +02:00
|
|
|
ff_vorbiscomment_write(&p, m, vendor);
|
2010-09-03 21:30:27 +02:00
|
|
|
if (framing_bit)
|
|
|
|
bytestream_put_byte(&p, 1);
|
2009-10-13 03:46:19 +02:00
|
|
|
|
|
|
|
*header_len = size;
|
|
|
|
return p0;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
static int ogg_build_flac_headers(AVCodecParameters *par,
|
2010-03-20 14:39:22 +01:00
|
|
|
OGGStreamContext *oggstream, int bitexact,
|
2011-05-22 12:46:29 +02:00
|
|
|
AVDictionary **m)
|
2007-11-10 19:27:03 +01:00
|
|
|
{
|
|
|
|
uint8_t *p;
|
2009-06-21 22:14:58 +02:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (par->extradata_size < FLAC_STREAMINFO_SIZE)
|
2014-08-28 20:51:51 +02:00
|
|
|
return AVERROR(EINVAL);
|
2009-06-21 22:14:58 +02:00
|
|
|
|
|
|
|
// first packet: STREAMINFO
|
2008-03-30 05:40:03 +02:00
|
|
|
oggstream->header_len[0] = 51;
|
|
|
|
oggstream->header[0] = av_mallocz(51); // per ogg flac specs
|
2007-11-10 19:27:03 +01:00
|
|
|
p = oggstream->header[0];
|
2009-06-21 22:13:54 +02:00
|
|
|
if (!p)
|
2010-04-03 16:15:00 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2007-11-10 19:27:03 +01:00
|
|
|
bytestream_put_byte(&p, 0x7F);
|
|
|
|
bytestream_put_buffer(&p, "FLAC", 4);
|
|
|
|
bytestream_put_byte(&p, 1); // major version
|
|
|
|
bytestream_put_byte(&p, 0); // minor version
|
|
|
|
bytestream_put_be16(&p, 1); // headers packets without this one
|
|
|
|
bytestream_put_buffer(&p, "fLaC", 4);
|
|
|
|
bytestream_put_byte(&p, 0x00); // streaminfo
|
|
|
|
bytestream_put_be24(&p, 34);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
bytestream_put_buffer(&p, par->extradata, FLAC_STREAMINFO_SIZE);
|
2009-06-21 22:14:58 +02:00
|
|
|
|
|
|
|
// second packet: VorbisComment
|
2010-09-03 21:30:27 +02:00
|
|
|
p = ogg_write_vorbiscomment(4, bitexact, &oggstream->header_len[1], m, 0);
|
2009-06-21 22:13:54 +02:00
|
|
|
if (!p)
|
2010-04-03 16:15:00 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2009-10-13 03:46:19 +02:00
|
|
|
oggstream->header[1] = p;
|
2007-11-10 19:27:03 +01:00
|
|
|
bytestream_put_byte(&p, 0x84); // last metadata block and vorbis comment
|
|
|
|
bytestream_put_be24(&p, oggstream->header_len[1] - 4);
|
2009-10-13 03:46:19 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SPEEX_HEADER_SIZE 80
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
static int ogg_build_speex_headers(AVCodecParameters *par,
|
2010-03-20 14:39:22 +01:00
|
|
|
OGGStreamContext *oggstream, int bitexact,
|
2011-05-22 12:46:29 +02:00
|
|
|
AVDictionary **m)
|
2009-10-13 03:46:19 +02:00
|
|
|
{
|
|
|
|
uint8_t *p;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (par->extradata_size < SPEEX_HEADER_SIZE)
|
2014-12-03 00:35:51 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2009-10-13 03:46:19 +02:00
|
|
|
|
|
|
|
// first packet: Speex header
|
|
|
|
p = av_mallocz(SPEEX_HEADER_SIZE);
|
|
|
|
if (!p)
|
2010-04-03 16:15:00 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2009-10-13 03:46:19 +02:00
|
|
|
oggstream->header[0] = p;
|
|
|
|
oggstream->header_len[0] = SPEEX_HEADER_SIZE;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
bytestream_put_buffer(&p, par->extradata, SPEEX_HEADER_SIZE);
|
2009-10-13 03:46:19 +02:00
|
|
|
AV_WL32(&oggstream->header[0][68], 0); // set extra_headers to 0
|
|
|
|
|
|
|
|
// second packet: VorbisComment
|
2010-09-03 21:30:27 +02:00
|
|
|
p = ogg_write_vorbiscomment(0, bitexact, &oggstream->header_len[1], m, 0);
|
2009-10-13 03:46:19 +02:00
|
|
|
if (!p)
|
2010-04-03 16:15:00 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2009-10-13 03:46:19 +02:00
|
|
|
oggstream->header[1] = p;
|
2009-06-21 22:14:58 +02:00
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-27 10:21:56 +02:00
|
|
|
#define OPUS_HEADER_SIZE 19
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
static int ogg_build_opus_headers(AVCodecParameters *par,
|
2012-09-27 10:21:56 +02:00
|
|
|
OGGStreamContext *oggstream, int bitexact,
|
|
|
|
AVDictionary **m)
|
|
|
|
{
|
|
|
|
uint8_t *p;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (par->extradata_size < OPUS_HEADER_SIZE)
|
2014-12-03 00:35:51 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2012-09-27 10:21:56 +02:00
|
|
|
|
|
|
|
/* first packet: Opus header */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
p = av_mallocz(par->extradata_size);
|
2012-09-27 10:21:56 +02:00
|
|
|
if (!p)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
oggstream->header[0] = p;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
oggstream->header_len[0] = par->extradata_size;
|
|
|
|
bytestream_put_buffer(&p, par->extradata, par->extradata_size);
|
2012-09-27 10:21:56 +02:00
|
|
|
|
|
|
|
/* second packet: VorbisComment */
|
|
|
|
p = ogg_write_vorbiscomment(8, bitexact, &oggstream->header_len[1], m, 0);
|
|
|
|
if (!p)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
oggstream->header[1] = p;
|
|
|
|
bytestream_put_buffer(&p, "OpusTags", 8);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-26 06:04:19 +02:00
|
|
|
static void ogg_write_pages(AVFormatContext *s, int flush)
|
|
|
|
{
|
|
|
|
OGGContext *ogg = s->priv_data;
|
|
|
|
OGGPageList *next, *p;
|
|
|
|
|
|
|
|
if (!ogg->page_list)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (p = ogg->page_list; p; ) {
|
|
|
|
OGGStreamContext *oggstream =
|
|
|
|
s->streams[p->page.stream_index]->priv_data;
|
|
|
|
if (oggstream->page_count < 2 && !flush)
|
|
|
|
break;
|
|
|
|
ogg_write_page(s, &p->page,
|
2014-05-28 01:06:26 +02:00
|
|
|
flush == 1 && oggstream->page_count == 1 ? 4 : 0); // eos
|
2014-05-26 06:04:19 +02:00
|
|
|
next = p->next;
|
|
|
|
av_freep(&p);
|
|
|
|
p = next;
|
|
|
|
}
|
|
|
|
ogg->page_list = p;
|
|
|
|
}
|
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
static int ogg_write_header(AVFormatContext *s)
|
|
|
|
{
|
2012-12-30 23:00:00 +01:00
|
|
|
OGGContext *ogg = s->priv_data;
|
2013-01-29 15:57:15 +01:00
|
|
|
OGGStreamContext *oggstream = NULL;
|
2007-11-10 19:27:03 +01:00
|
|
|
int i, j;
|
2010-05-25 01:37:33 +02:00
|
|
|
|
2012-12-30 23:00:00 +01:00
|
|
|
if (ogg->pref_size)
|
|
|
|
av_log(s, AV_LOG_WARNING, "The pagesize option is deprecated\n");
|
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
AVStream *st = s->streams[i];
|
2015-01-30 17:29:22 +01:00
|
|
|
unsigned serial_num = i + ogg->serial_offset;
|
2010-05-25 01:37:33 +02:00
|
|
|
|
2016-04-10 21:58:15 +02:00
|
|
|
if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_OPUS)
|
2012-09-27 10:21:56 +02:00
|
|
|
/* Opus requires a fixed 48kHz clock */
|
|
|
|
avpriv_set_pts_info(st, 64, 1, 48000);
|
|
|
|
else
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
|
2014-06-18 18:18:25 +02:00
|
|
|
}
|
2014-05-18 12:12:59 +02:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id != AV_CODEC_ID_VORBIS &&
|
|
|
|
st->codecpar->codec_id != AV_CODEC_ID_THEORA &&
|
|
|
|
st->codecpar->codec_id != AV_CODEC_ID_SPEEX &&
|
|
|
|
st->codecpar->codec_id != AV_CODEC_ID_FLAC &&
|
|
|
|
st->codecpar->codec_id != AV_CODEC_ID_OPUS) {
|
2007-11-10 19:27:03 +01:00
|
|
|
av_log(s, AV_LOG_ERROR, "Unsupported codec id in stream %d\n", i);
|
2014-12-03 00:35:51 +01:00
|
|
|
return AVERROR(EINVAL);
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (!st->codecpar->extradata || !st->codecpar->extradata_size) {
|
2007-11-10 19:27:03 +01:00
|
|
|
av_log(s, AV_LOG_ERROR, "No extradata present\n");
|
2014-12-03 00:35:51 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
|
|
|
oggstream = av_mallocz(sizeof(*oggstream));
|
2014-04-04 08:19:59 +02:00
|
|
|
if (!oggstream)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
oggstream->page.stream_index = i;
|
2010-05-25 01:37:33 +02:00
|
|
|
|
2014-05-01 10:43:10 +02:00
|
|
|
if (!(s->flags & AVFMT_FLAG_BITEXACT))
|
2010-05-25 01:37:33 +02:00
|
|
|
do {
|
|
|
|
serial_num = av_get_random_seed();
|
|
|
|
for (j = 0; j < i; j++) {
|
|
|
|
OGGStreamContext *sc = s->streams[j]->priv_data;
|
|
|
|
if (serial_num == sc->serial_num)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (j < i);
|
|
|
|
oggstream->serial_num = serial_num;
|
|
|
|
|
2013-07-18 09:18:24 +02:00
|
|
|
av_dict_copy(&st->metadata, s->metadata, AV_DICT_DONT_OVERWRITE);
|
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
st->priv_data = oggstream;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_FLAC) {
|
|
|
|
int err = ogg_build_flac_headers(st->codecpar, oggstream,
|
2014-05-01 10:43:10 +02:00
|
|
|
s->flags & AVFMT_FLAG_BITEXACT,
|
2013-07-18 09:18:24 +02:00
|
|
|
&st->metadata);
|
2009-06-21 22:16:48 +02:00
|
|
|
if (err) {
|
2009-06-21 22:18:29 +02:00
|
|
|
av_log(s, AV_LOG_ERROR, "Error writing FLAC headers\n");
|
2007-11-10 19:27:03 +01:00
|
|
|
av_freep(&st->priv_data);
|
2009-06-21 22:16:48 +02:00
|
|
|
return err;
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_SPEEX) {
|
|
|
|
int err = ogg_build_speex_headers(st->codecpar, oggstream,
|
2014-05-01 10:43:10 +02:00
|
|
|
s->flags & AVFMT_FLAG_BITEXACT,
|
2013-07-18 09:18:24 +02:00
|
|
|
&st->metadata);
|
2009-10-13 03:46:19 +02:00
|
|
|
if (err) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Error writing Speex headers\n");
|
|
|
|
av_freep(&st->priv_data);
|
|
|
|
return err;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
|
|
|
|
int err = ogg_build_opus_headers(st->codecpar, oggstream,
|
2014-05-01 10:43:10 +02:00
|
|
|
s->flags & AVFMT_FLAG_BITEXACT,
|
2013-07-18 09:18:24 +02:00
|
|
|
&st->metadata);
|
2012-09-27 10:21:56 +02:00
|
|
|
if (err) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Error writing Opus headers\n");
|
|
|
|
av_freep(&st->priv_data);
|
|
|
|
return err;
|
|
|
|
}
|
2007-11-10 19:27:03 +01:00
|
|
|
} else {
|
2010-09-03 21:30:27 +02:00
|
|
|
uint8_t *p;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
const char *cstr = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? "vorbis" : "theora";
|
|
|
|
int header_type = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 3 : 0x81;
|
|
|
|
int framing_bit = st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 1 : 0;
|
2010-09-03 21:30:27 +02:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (avpriv_split_xiph_headers(st->codecpar->extradata, st->codecpar->extradata_size,
|
|
|
|
st->codecpar->codec_id == AV_CODEC_ID_VORBIS ? 30 : 42,
|
2014-12-12 14:46:19 +01:00
|
|
|
(const uint8_t**)oggstream->header, oggstream->header_len) < 0) {
|
2007-11-10 19:27:03 +01:00
|
|
|
av_log(s, AV_LOG_ERROR, "Extradata corrupted\n");
|
|
|
|
av_freep(&st->priv_data);
|
2014-12-03 00:35:51 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
2010-09-03 21:30:27 +02:00
|
|
|
|
2014-05-01 10:43:10 +02:00
|
|
|
p = ogg_write_vorbiscomment(7, s->flags & AVFMT_FLAG_BITEXACT,
|
2013-07-18 09:18:24 +02:00
|
|
|
&oggstream->header_len[1], &st->metadata,
|
2010-09-03 21:30:27 +02:00
|
|
|
framing_bit);
|
2012-02-23 01:31:40 +01:00
|
|
|
oggstream->header[1] = p;
|
2010-09-03 21:30:27 +02:00
|
|
|
if (!p)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
bytestream_put_byte(&p, header_type);
|
|
|
|
bytestream_put_buffer(&p, cstr, 6);
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_THEORA) {
|
2016-07-12 03:09:34 +02:00
|
|
|
int den = AV_RB32(oggstream->header[0] + 22), num = AV_RB32(oggstream->header[0] + 26);
|
|
|
|
/* Make sure to use time base stored in the Theora stream header to write
|
|
|
|
correct timestamps */
|
|
|
|
if (st->time_base.num != num || st->time_base.den != den) {
|
|
|
|
av_log(s, AV_LOG_DEBUG, "Changing time base from %d/%d to %d/%d\n",
|
|
|
|
st->time_base.num, st->time_base.den, num, den);
|
|
|
|
avpriv_set_pts_info(st, 64, num, den);
|
|
|
|
}
|
2007-11-10 19:27:03 +01:00
|
|
|
/** KFGSHIFT is the width of the less significant section of the granule position
|
|
|
|
The less significant section is the frame count since the last keyframe */
|
|
|
|
oggstream->kfgshift = ((oggstream->header[0][40]&3)<<3)|(oggstream->header[0][41]>>5);
|
|
|
|
oggstream->vrev = oggstream->header[0][9];
|
|
|
|
av_log(s, AV_LOG_DEBUG, "theora kfgshift %d, vrev %d\n",
|
|
|
|
oggstream->kfgshift, oggstream->vrev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-21 23:38:54 +02:00
|
|
|
|
|
|
|
for (j = 0; j < s->nb_streams; j++) {
|
|
|
|
OGGStreamContext *oggstream = s->streams[j]->priv_data;
|
|
|
|
ogg_buffer_data(s, s->streams[j], oggstream->header[0],
|
2012-02-18 21:21:20 +01:00
|
|
|
oggstream->header_len[0], 0, 1);
|
2010-05-21 23:38:54 +02:00
|
|
|
oggstream->page.flags |= 2; // bos
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
}
|
|
|
|
for (j = 0; j < s->nb_streams; j++) {
|
|
|
|
AVStream *st = s->streams[j];
|
|
|
|
OGGStreamContext *oggstream = st->priv_data;
|
|
|
|
for (i = 1; i < 3; i++) {
|
2012-11-04 21:58:35 +01:00
|
|
|
if (oggstream->header_len[i])
|
2010-05-21 23:38:54 +02:00
|
|
|
ogg_buffer_data(s, st, oggstream->header[i],
|
2012-02-18 21:21:20 +01:00
|
|
|
oggstream->header_len[i], 0, 1);
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
2010-05-21 23:38:54 +02:00
|
|
|
ogg_buffer_page(s, oggstream);
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
2012-12-30 23:00:00 +01:00
|
|
|
|
|
|
|
oggstream->page.start_granule = AV_NOPTS_VALUE;
|
|
|
|
|
2014-05-28 01:06:26 +02:00
|
|
|
ogg_write_pages(s, 2);
|
2014-05-26 06:04:19 +02:00
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-29 16:39:28 +02:00
|
|
|
static int ogg_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
|
2007-11-10 19:27:03 +01:00
|
|
|
{
|
|
|
|
AVStream *st = s->streams[pkt->stream_index];
|
|
|
|
OGGStreamContext *oggstream = st->priv_data;
|
2010-05-21 23:38:54 +02:00
|
|
|
int ret;
|
2007-11-10 19:27:03 +01:00
|
|
|
int64_t granule;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_THEORA) {
|
2007-11-10 19:27:03 +01:00
|
|
|
int64_t pts = oggstream->vrev < 1 ? pkt->pts : pkt->pts + pkt->duration;
|
|
|
|
int pframe_count;
|
2010-03-31 14:29:58 +02:00
|
|
|
if (pkt->flags & AV_PKT_FLAG_KEY)
|
2007-11-10 19:27:03 +01:00
|
|
|
oggstream->last_kf_pts = pts;
|
|
|
|
pframe_count = pts - oggstream->last_kf_pts;
|
|
|
|
// prevent frame count from overflow if key frame flag is not set
|
|
|
|
if (pframe_count >= (1<<oggstream->kfgshift)) {
|
|
|
|
oggstream->last_kf_pts += pframe_count;
|
|
|
|
pframe_count = 0;
|
|
|
|
}
|
|
|
|
granule = (oggstream->last_kf_pts<<oggstream->kfgshift) | pframe_count;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS)
|
2014-08-23 15:12:51 +02:00
|
|
|
granule = pkt->pts + pkt->duration +
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
av_rescale_q(st->codecpar->initial_padding,
|
|
|
|
(AVRational){ 1, st->codecpar->sample_rate },
|
2014-08-23 15:12:51 +02:00
|
|
|
st->time_base);
|
2012-09-27 10:21:56 +02:00
|
|
|
else
|
2007-11-10 19:27:03 +01:00
|
|
|
granule = pkt->pts + pkt->duration;
|
|
|
|
|
2012-12-30 23:00:00 +01:00
|
|
|
if (oggstream->page.start_granule == AV_NOPTS_VALUE)
|
|
|
|
oggstream->page.start_granule = pkt->pts;
|
|
|
|
|
2012-02-18 21:21:20 +01:00
|
|
|
ret = ogg_buffer_data(s, st, pkt->data, pkt->size, granule, 0);
|
2010-05-21 23:38:54 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2007-11-10 19:27:03 +01:00
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
ogg_write_pages(s, 0);
|
2009-01-31 07:08:42 +01:00
|
|
|
|
2011-01-05 20:32:45 +01:00
|
|
|
oggstream->last_granule = granule;
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
return 0;
|
2009-01-31 07:08:42 +01:00
|
|
|
}
|
|
|
|
|
2014-05-29 16:39:28 +02:00
|
|
|
static int ogg_write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (pkt)
|
|
|
|
return ogg_write_packet_internal(s, pkt);
|
|
|
|
|
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
OGGStreamContext *oggstream = s->streams[i]->priv_data;
|
|
|
|
if (oggstream->page.segments_count)
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
}
|
|
|
|
|
|
|
|
ogg_write_pages(s, 2);
|
2015-06-09 18:42:55 +02:00
|
|
|
return 1;
|
2014-05-29 16:39:28 +02:00
|
|
|
}
|
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
static int ogg_write_trailer(AVFormatContext *s)
|
2008-02-05 02:16:47 +01:00
|
|
|
{
|
2010-05-21 23:38:54 +02:00
|
|
|
int i;
|
2010-01-29 07:38:00 +01:00
|
|
|
|
2012-12-30 23:00:00 +01:00
|
|
|
/* flush current page if needed */
|
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
OGGStreamContext *oggstream = s->streams[i]->priv_data;
|
|
|
|
|
|
|
|
if (oggstream->page.size > 0)
|
|
|
|
ogg_buffer_page(s, oggstream);
|
|
|
|
}
|
2009-09-16 22:04:04 +02:00
|
|
|
|
2010-05-21 23:38:54 +02:00
|
|
|
ogg_write_pages(s, 1);
|
2009-09-16 22:04:04 +02:00
|
|
|
|
2007-11-10 19:27:03 +01:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
AVStream *st = s->streams[i];
|
|
|
|
OGGStreamContext *oggstream = st->priv_data;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_FLAC ||
|
|
|
|
st->codecpar->codec_id == AV_CODEC_ID_SPEEX ||
|
|
|
|
st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
|
2011-10-01 01:26:55 +02:00
|
|
|
av_freep(&oggstream->header[0]);
|
2007-11-10 19:27:03 +01:00
|
|
|
}
|
2012-02-23 01:31:40 +01:00
|
|
|
av_freep(&oggstream->header[1]);
|
2007-11-10 19:27:03 +01:00
|
|
|
av_freep(&st->priv_data);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-01 12:03:34 +01:00
|
|
|
#if CONFIG_OGG_MUXER
|
2014-08-23 21:39:14 +02:00
|
|
|
OGG_CLASS(ogg, Ogg)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_ogg_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "ogg",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Ogg"),
|
|
|
|
.mime_type = "application/ogg",
|
2013-12-01 12:03:34 +01:00
|
|
|
.extensions = "ogg,ogv"
|
2014-08-22 21:14:43 +02:00
|
|
|
#if !CONFIG_SPX_MUXER
|
2013-12-01 12:03:34 +01:00
|
|
|
",spx"
|
|
|
|
#endif
|
|
|
|
#if !CONFIG_OPUS_MUXER
|
|
|
|
",opus"
|
|
|
|
#endif
|
|
|
|
,
|
2011-07-16 22:18:12 +02:00
|
|
|
.priv_data_size = sizeof(OGGContext),
|
2014-02-08 17:18:57 +01:00
|
|
|
.audio_codec = CONFIG_LIBVORBIS_ENCODER ?
|
|
|
|
AV_CODEC_ID_VORBIS : AV_CODEC_ID_FLAC,
|
2012-08-05 11:11:04 +02:00
|
|
|
.video_codec = AV_CODEC_ID_THEORA,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = ogg_write_header,
|
|
|
|
.write_packet = ogg_write_packet,
|
|
|
|
.write_trailer = ogg_write_trailer,
|
2014-05-29 16:39:28 +02:00
|
|
|
.flags = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
|
2011-01-27 10:14:21 +01:00
|
|
|
.priv_class = &ogg_muxer_class,
|
2007-11-10 19:27:03 +01:00
|
|
|
};
|
2013-12-01 12:03:34 +01:00
|
|
|
#endif
|
|
|
|
|
2014-03-25 15:47:55 +01:00
|
|
|
#if CONFIG_OGA_MUXER
|
2014-08-23 21:39:14 +02:00
|
|
|
OGG_CLASS(oga, Ogg audio)
|
2014-03-25 15:47:55 +01:00
|
|
|
AVOutputFormat ff_oga_muxer = {
|
|
|
|
.name = "oga",
|
2014-08-17 20:55:37 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Ogg Audio"),
|
2014-03-25 15:47:55 +01:00
|
|
|
.mime_type = "audio/ogg",
|
|
|
|
.extensions = "oga",
|
|
|
|
.priv_data_size = sizeof(OGGContext),
|
2016-07-06 19:14:39 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_FLAC,
|
2014-03-25 15:47:55 +01:00
|
|
|
.write_header = ogg_write_header,
|
|
|
|
.write_packet = ogg_write_packet,
|
|
|
|
.write_trailer = ogg_write_trailer,
|
2014-08-17 20:55:37 +02:00
|
|
|
.flags = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
|
2014-03-25 15:47:55 +01:00
|
|
|
.priv_class = &oga_muxer_class,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2014-08-17 20:55:37 +02:00
|
|
|
#if CONFIG_SPX_MUXER
|
2014-08-23 21:39:14 +02:00
|
|
|
OGG_CLASS(spx, Ogg Speex)
|
2014-08-17 20:55:37 +02:00
|
|
|
AVOutputFormat ff_spx_muxer = {
|
|
|
|
.name = "spx",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Ogg Speex"),
|
2013-12-01 12:03:34 +01:00
|
|
|
.mime_type = "audio/ogg",
|
|
|
|
.extensions = "spx",
|
|
|
|
.priv_data_size = sizeof(OGGContext),
|
|
|
|
.audio_codec = AV_CODEC_ID_SPEEX,
|
|
|
|
.write_header = ogg_write_header,
|
|
|
|
.write_packet = ogg_write_packet,
|
|
|
|
.write_trailer = ogg_write_trailer,
|
2014-08-17 20:55:37 +02:00
|
|
|
.flags = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
|
2014-08-22 21:14:43 +02:00
|
|
|
.priv_class = &spx_muxer_class,
|
2013-12-01 12:03:34 +01:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_OPUS_MUXER
|
2014-08-23 21:39:14 +02:00
|
|
|
OGG_CLASS(opus, Ogg Opus)
|
2013-12-01 12:03:34 +01:00
|
|
|
AVOutputFormat ff_opus_muxer = {
|
|
|
|
.name = "opus",
|
2014-08-17 20:55:37 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Ogg Opus"),
|
2013-12-01 12:03:34 +01:00
|
|
|
.mime_type = "audio/ogg",
|
|
|
|
.extensions = "opus",
|
|
|
|
.priv_data_size = sizeof(OGGContext),
|
|
|
|
.audio_codec = AV_CODEC_ID_OPUS,
|
|
|
|
.write_header = ogg_write_header,
|
|
|
|
.write_packet = ogg_write_packet,
|
|
|
|
.write_trailer = ogg_write_trailer,
|
2014-08-17 20:55:37 +02:00
|
|
|
.flags = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
|
2013-12-01 12:03:34 +01:00
|
|
|
.priv_class = &opus_muxer_class,
|
|
|
|
};
|
|
|
|
#endif
|