2006-07-03 19:32:57 +03:00
|
|
|
/*
|
|
|
|
* GXF demuxer.
|
2009-01-19 17:46:40 +02:00
|
|
|
* Copyright (c) 2006 Reimar Doeffinger
|
2006-07-03 19:32:57 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2006-07-03 19:32:57 +03:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 18:30:46 +03:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2006-07-03 19:32:57 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2006-07-03 19:32:57 +03:00
|
|
|
* 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
|
2006-10-07 18:30:46 +03:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-07-03 19:32:57 +03:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
2008-05-09 14:56:36 +03:00
|
|
|
|
2014-03-10 17:35:59 +03:00
|
|
|
#include <inttypes.h>
|
|
|
|
|
2012-04-07 21:00:04 +03:00
|
|
|
#include "libavutil/channel_layout.h"
|
2008-05-09 14:56:36 +03:00
|
|
|
#include "libavutil/common.h"
|
2006-07-03 19:32:57 +03:00
|
|
|
#include "avformat.h"
|
2010-12-26 03:24:51 +02:00
|
|
|
#include "internal.h"
|
2007-07-26 16:01:09 +03:00
|
|
|
#include "gxf.h"
|
2012-10-07 12:42:54 +03:00
|
|
|
#include "libavcodec/mpeg12data.h"
|
2006-08-01 13:19:25 +03:00
|
|
|
|
2008-12-11 12:42:06 +02:00
|
|
|
struct gxf_stream_info {
|
2006-08-01 13:19:25 +03:00
|
|
|
int64_t first_field;
|
|
|
|
int64_t last_field;
|
|
|
|
AVRational frames_per_second;
|
|
|
|
int32_t fields_per_frame;
|
2011-10-31 21:54:31 +03:00
|
|
|
int64_t track_aux_data;
|
2008-12-11 12:42:06 +02:00
|
|
|
};
|
2006-08-01 13:19:25 +03:00
|
|
|
|
2011-10-31 21:54:31 +03:00
|
|
|
/**
|
|
|
|
* @brief parse gxf timecode and add it to metadata
|
|
|
|
*/
|
|
|
|
static int add_timecode_metadata(AVDictionary **pm, const char *key, uint32_t timecode, int fields_per_frame)
|
|
|
|
{
|
|
|
|
char tmp[128];
|
|
|
|
int field = timecode & 0xff;
|
|
|
|
int frame = fields_per_frame ? field / fields_per_frame : field;
|
|
|
|
int second = (timecode >> 8) & 0xff;
|
|
|
|
int minute = (timecode >> 16) & 0xff;
|
|
|
|
int hour = (timecode >> 24) & 0x1f;
|
|
|
|
int drop = (timecode >> 29) & 1;
|
|
|
|
// bit 30: color_frame, unused
|
|
|
|
// ignore invalid time code
|
|
|
|
if (timecode >> 31)
|
|
|
|
return 0;
|
|
|
|
snprintf(tmp, sizeof(tmp), "%02d:%02d:%02d%c%02d",
|
|
|
|
hour, minute, second, drop ? ';' : ':', frame);
|
|
|
|
return av_dict_set(pm, key, tmp, 0);
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:32:57 +03:00
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief parses a packet header, extracting type and length
|
|
|
|
* @param pb AVIOContext to read header from
|
|
|
|
* @param type detected packet type is stored here
|
|
|
|
* @param length detected packet length, excluding header is stored here
|
|
|
|
* @return 0 if header not found or contains invalid data, 1 otherwise
|
2006-07-03 19:32:57 +03:00
|
|
|
*/
|
2011-02-20 12:04:12 +02:00
|
|
|
static int parse_packet_header(AVIOContext *pb, GXFPktType *type, int *length) {
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_rb32(pb))
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_r8(pb) != 1)
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
2011-02-21 17:43:01 +02:00
|
|
|
*type = avio_r8(pb);
|
|
|
|
*length = avio_rb32(pb);
|
2006-07-03 19:32:57 +03:00
|
|
|
if ((*length >> 24) || *length < 16)
|
|
|
|
return 0;
|
|
|
|
*length -= 16;
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_rb32(pb))
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_r8(pb) != 0xe1)
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_r8(pb) != 0xe2)
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief check if file starts with a PKT_MAP header
|
2006-07-03 19:32:57 +03:00
|
|
|
*/
|
2019-03-21 02:18:37 +02:00
|
|
|
static int gxf_probe(const AVProbeData *p) {
|
2006-07-03 19:32:57 +03:00
|
|
|
static const uint8_t startcode[] = {0, 0, 0, 0, 1, 0xbc}; // start with map packet
|
|
|
|
static const uint8_t endcode[] = {0, 0, 0, 0, 0xe1, 0xe2};
|
|
|
|
if (!memcmp(p->buf, startcode, sizeof(startcode)) &&
|
|
|
|
!memcmp(&p->buf[16 - sizeof(endcode)], endcode, sizeof(endcode)))
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief gets the stream index for the track with the specified id, creates new
|
2006-07-03 19:32:57 +03:00
|
|
|
* stream if not found
|
2011-06-23 23:41:54 +03:00
|
|
|
* @param id id of stream to find / add
|
|
|
|
* @param format stream format identifier
|
2006-07-03 19:32:57 +03:00
|
|
|
*/
|
|
|
|
static int get_sindex(AVFormatContext *s, int id, int format) {
|
|
|
|
int i;
|
|
|
|
AVStream *st = NULL;
|
2010-12-26 03:24:51 +02:00
|
|
|
i = ff_find_stream_index(s, id);
|
|
|
|
if (i >= 0)
|
|
|
|
return i;
|
2011-06-18 12:43:24 +03:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2008-05-29 18:22:45 +03:00
|
|
|
if (!st)
|
|
|
|
return AVERROR(ENOMEM);
|
2011-06-18 12:43:24 +03:00
|
|
|
st->id = id;
|
2006-07-03 19:32:57 +03:00
|
|
|
switch (format) {
|
|
|
|
case 3:
|
|
|
|
case 4:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 13:
|
|
|
|
case 14:
|
2013-06-17 23:22:46 +03:00
|
|
|
case 15:
|
2006-07-03 19:32:57 +03:00
|
|
|
case 16:
|
2013-06-17 23:22:46 +03:00
|
|
|
case 25:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 11:
|
|
|
|
case 12:
|
|
|
|
case 20:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;
|
2007-04-15 16:51:57 +03:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 22:
|
|
|
|
case 23:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_MPEG1VIDEO;
|
2007-04-15 16:51:57 +03:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 9:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
|
|
|
|
st->codecpar->channels = 1;
|
|
|
|
st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
|
|
|
|
st->codecpar->sample_rate = 48000;
|
|
|
|
st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
|
|
|
|
st->codecpar->block_align = 3 * 1;
|
|
|
|
st->codecpar->bits_per_coded_sample = 24;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 10:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
|
|
|
|
st->codecpar->channels = 1;
|
|
|
|
st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
|
|
|
|
st->codecpar->sample_rate = 48000;
|
|
|
|
st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
|
|
|
|
st->codecpar->block_align = 2 * 1;
|
|
|
|
st->codecpar->bits_per_coded_sample = 16;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
case 17:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_AC3;
|
|
|
|
st->codecpar->channels = 2;
|
|
|
|
st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
|
|
|
|
st->codecpar->sample_rate = 48000;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
2013-06-13 06:21:35 +03:00
|
|
|
case 26: /* AVCi50 / AVCi100 (AVC Intra) */
|
2013-06-18 03:09:34 +03:00
|
|
|
case 29: /* AVCHD */
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_H264;
|
2013-06-13 06:21:35 +03:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS;
|
|
|
|
break;
|
2006-11-22 20:47:05 +02:00
|
|
|
// timecode tracks:
|
|
|
|
case 7:
|
|
|
|
case 8:
|
|
|
|
case 24:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_NONE;
|
2006-11-22 20:47:05 +02:00
|
|
|
break;
|
2013-06-29 05:11:53 +03:00
|
|
|
case 30:
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_DNXHD;
|
2013-06-29 05:11:53 +03:00
|
|
|
break;
|
2006-07-03 19:32:57 +03:00
|
|
|
default:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_NONE;
|
2006-07-03 19:32:57 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return s->nb_streams - 1;
|
|
|
|
}
|
|
|
|
|
2006-08-01 13:19:25 +03:00
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief filters out interesting tags from material information.
|
|
|
|
* @param len length of tag section, will be adjusted to contain remaining bytes
|
|
|
|
* @param si struct to store collected information into
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
2011-02-20 12:04:12 +02:00
|
|
|
static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
|
2006-08-01 13:19:25 +03:00
|
|
|
si->first_field = AV_NOPTS_VALUE;
|
|
|
|
si->last_field = AV_NOPTS_VALUE;
|
|
|
|
while (*len >= 2) {
|
2011-02-21 17:43:01 +02:00
|
|
|
GXFMatTag tag = avio_r8(pb);
|
|
|
|
int tlen = avio_r8(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
*len -= 2;
|
|
|
|
if (tlen > *len)
|
|
|
|
return;
|
|
|
|
*len -= tlen;
|
|
|
|
if (tlen == 4) {
|
2011-02-21 17:43:01 +02:00
|
|
|
uint32_t value = avio_rb32(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
if (tag == MAT_FIRST_FIELD)
|
|
|
|
si->first_field = value;
|
|
|
|
else if (tag == MAT_LAST_FIELD)
|
|
|
|
si->last_field = value;
|
|
|
|
} else
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, tlen);
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-18 10:23:12 +03:00
|
|
|
static const AVRational frame_rate_tab[] = {
|
|
|
|
{ 60, 1},
|
|
|
|
{60000, 1001},
|
|
|
|
{ 50, 1},
|
|
|
|
{ 30, 1},
|
|
|
|
{30000, 1001},
|
|
|
|
{ 25, 1},
|
|
|
|
{ 24, 1},
|
|
|
|
{24000, 1001},
|
|
|
|
{ 0, 0},
|
|
|
|
};
|
|
|
|
|
2006-08-01 13:19:25 +03:00
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief convert fps tag value to AVRational fps
|
|
|
|
* @param fps fps value from tag
|
|
|
|
* @return fps as AVRational, or 0 / 0 if unknown
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
|
|
|
static AVRational fps_tag2avr(int32_t fps) {
|
|
|
|
if (fps < 1 || fps > 9) fps = 9;
|
2012-10-18 10:23:12 +03:00
|
|
|
return frame_rate_tab[fps - 1];
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief convert UMF attributes flags to AVRational fps
|
|
|
|
* @param flags UMF flags to convert
|
|
|
|
* @return fps as AVRational, or 0 / 0 if unknown
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
|
|
|
static AVRational fps_umf2avr(uint32_t flags) {
|
|
|
|
static const AVRational map[] = {{50, 1}, {60000, 1001}, {24, 1},
|
|
|
|
{25, 1}, {30000, 1001}};
|
|
|
|
int idx = av_log2((flags & 0x7c0) >> 6);
|
|
|
|
return map[idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief filters out interesting tags from track information.
|
|
|
|
* @param len length of tag section, will be adjusted to contain remaining bytes
|
|
|
|
* @param si struct to store collected information into
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
2011-02-20 12:04:12 +02:00
|
|
|
static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si) {
|
2006-08-01 13:19:25 +03:00
|
|
|
si->frames_per_second = (AVRational){0, 0};
|
|
|
|
si->fields_per_frame = 0;
|
2011-10-31 21:54:31 +03:00
|
|
|
si->track_aux_data = 0x80000000;
|
2006-08-01 13:19:25 +03:00
|
|
|
while (*len >= 2) {
|
2011-02-21 17:43:01 +02:00
|
|
|
GXFTrackTag tag = avio_r8(pb);
|
|
|
|
int tlen = avio_r8(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
*len -= 2;
|
|
|
|
if (tlen > *len)
|
|
|
|
return;
|
|
|
|
*len -= tlen;
|
|
|
|
if (tlen == 4) {
|
2011-02-21 17:43:01 +02:00
|
|
|
uint32_t value = avio_rb32(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
if (tag == TRACK_FPS)
|
|
|
|
si->frames_per_second = fps_tag2avr(value);
|
|
|
|
else if (tag == TRACK_FPF && (value == 1 || value == 2))
|
|
|
|
si->fields_per_frame = value;
|
2011-10-31 21:54:31 +03:00
|
|
|
} else if (tlen == 8 && tag == TRACK_AUX)
|
|
|
|
si->track_aux_data = avio_rl64(pb);
|
|
|
|
else
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, tlen);
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief read index from FLT packet into stream 0 av_index
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
|
|
|
static void gxf_read_index(AVFormatContext *s, int pkt_len) {
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2012-11-11 22:57:45 +03:00
|
|
|
AVStream *st;
|
2020-10-26 22:08:55 +02:00
|
|
|
uint32_t fields_per_map, map_cnt;
|
2006-08-01 13:19:25 +03:00
|
|
|
int i;
|
2020-10-26 22:08:55 +02:00
|
|
|
if (pkt_len < 8)
|
|
|
|
return;
|
|
|
|
fields_per_map = avio_rl32(pb);
|
|
|
|
map_cnt = avio_rl32(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
pkt_len -= 8;
|
2012-11-11 22:57:45 +03:00
|
|
|
if ((s->flags & AVFMT_FLAG_IGNIDX) || !s->streams) {
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, pkt_len);
|
2010-06-06 13:51:06 +03:00
|
|
|
return;
|
|
|
|
}
|
2012-11-11 22:57:45 +03:00
|
|
|
st = s->streams[0];
|
2006-08-01 13:19:25 +03:00
|
|
|
if (map_cnt > 1000) {
|
2014-03-10 17:35:59 +03:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"too many index entries %"PRIu32" (%"PRIx32")\n",
|
|
|
|
map_cnt, map_cnt);
|
2006-08-01 13:19:25 +03:00
|
|
|
map_cnt = 1000;
|
|
|
|
}
|
|
|
|
if (pkt_len < 4 * map_cnt) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "invalid index length\n");
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, pkt_len);
|
2006-08-01 13:19:25 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
pkt_len -= 4 * map_cnt;
|
|
|
|
av_add_index_entry(st, 0, 0, 0, 0, 0);
|
|
|
|
for (i = 0; i < map_cnt; i++)
|
2011-02-21 17:43:01 +02:00
|
|
|
av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024,
|
2006-08-01 13:19:25 +03:00
|
|
|
i * (uint64_t)fields_per_map + 1, 0, 0, 0);
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, pkt_len);
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
|
2012-01-12 15:20:36 +03:00
|
|
|
static int gxf_header(AVFormatContext *s) {
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2008-12-13 23:58:17 +02:00
|
|
|
GXFPktType pkt_type;
|
2006-07-03 19:32:57 +03:00
|
|
|
int map_len;
|
|
|
|
int len;
|
2006-08-01 13:19:25 +03:00
|
|
|
AVRational main_timebase = {0, 0};
|
2011-06-23 16:59:33 +03:00
|
|
|
struct gxf_stream_info *si = s->priv_data;
|
2006-08-01 13:19:25 +03:00
|
|
|
int i;
|
2006-07-03 19:32:57 +03:00
|
|
|
if (!parse_packet_header(pb, &pkt_type, &map_len) || pkt_type != PKT_MAP) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "map packet not found\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
map_len -= 2;
|
2011-02-21 17:43:01 +02:00
|
|
|
if (avio_r8(pb) != 0x0e0 || avio_r8(pb) != 0xff) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "unknown version or invalid map preamble\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
map_len -= 2;
|
2011-02-21 17:43:01 +02:00
|
|
|
len = avio_rb16(pb); // length of material data section
|
2006-07-03 19:32:57 +03:00
|
|
|
if (len > map_len) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "material data longer than map data\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
map_len -= len;
|
2011-06-23 16:59:33 +03:00
|
|
|
gxf_material_tags(pb, &len, si);
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, len);
|
2006-07-03 19:32:57 +03:00
|
|
|
map_len -= 2;
|
2011-02-21 17:43:01 +02:00
|
|
|
len = avio_rb16(pb); // length of track description
|
2006-07-03 19:32:57 +03:00
|
|
|
if (len > map_len) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "track description longer than map data\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
map_len -= len;
|
|
|
|
while (len > 0) {
|
|
|
|
int track_type, track_id, track_len;
|
2006-08-01 13:19:25 +03:00
|
|
|
AVStream *st;
|
|
|
|
int idx;
|
2006-07-03 19:32:57 +03:00
|
|
|
len -= 4;
|
2011-02-21 17:43:01 +02:00
|
|
|
track_type = avio_r8(pb);
|
|
|
|
track_id = avio_r8(pb);
|
|
|
|
track_len = avio_rb16(pb);
|
2006-07-03 19:32:57 +03:00
|
|
|
len -= track_len;
|
|
|
|
if (!(track_type & 0x80)) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type);
|
2006-07-03 19:32:57 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
track_type &= 0x7f;
|
|
|
|
if ((track_id & 0xc0) != 0xc0) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "invalid track id %x\n", track_id);
|
2006-07-03 19:32:57 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
track_id &= 0x3f;
|
2011-10-31 21:54:31 +03:00
|
|
|
gxf_track_tags(pb, &track_len, si);
|
|
|
|
// check for timecode tracks
|
|
|
|
if (track_type == 7 || track_type == 8 || track_type == 24) {
|
2011-12-15 18:34:09 +03:00
|
|
|
add_timecode_metadata(&s->metadata, "timecode",
|
2011-10-31 21:54:31 +03:00
|
|
|
si->track_aux_data & 0xffffffff,
|
|
|
|
si->fields_per_frame);
|
|
|
|
|
|
|
|
}
|
|
|
|
avio_skip(pb, track_len);
|
|
|
|
|
2006-08-01 13:19:25 +03:00
|
|
|
idx = get_sindex(s, track_id, track_type);
|
|
|
|
if (idx < 0) continue;
|
|
|
|
st = s->streams[idx];
|
|
|
|
if (!main_timebase.num || !main_timebase.den) {
|
2011-06-23 16:59:33 +03:00
|
|
|
main_timebase.num = si->frames_per_second.den;
|
|
|
|
main_timebase.den = si->frames_per_second.num * 2;
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
2011-06-23 16:59:33 +03:00
|
|
|
st->start_time = si->first_field;
|
|
|
|
if (si->first_field != AV_NOPTS_VALUE && si->last_field != AV_NOPTS_VALUE)
|
|
|
|
st->duration = si->last_field - si->first_field;
|
2006-07-03 19:32:57 +03:00
|
|
|
}
|
|
|
|
if (len < 0)
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "invalid track description length specified\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
if (map_len)
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, map_len);
|
2006-08-01 13:19:25 +03:00
|
|
|
if (!parse_packet_header(pb, &pkt_type, &len)) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "sync lost in header\n");
|
2006-08-01 13:19:25 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (pkt_type == PKT_FLT) {
|
|
|
|
gxf_read_index(s, len);
|
|
|
|
if (!parse_packet_header(pb, &pkt_type, &len)) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "sync lost in header\n");
|
2006-08-01 13:19:25 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pkt_type == PKT_UMF) {
|
2007-02-08 00:51:42 +02:00
|
|
|
if (len >= 0x39) {
|
2006-08-01 13:19:25 +03:00
|
|
|
AVRational fps;
|
2007-02-08 00:51:42 +02:00
|
|
|
len -= 0x39;
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 5); // preamble
|
|
|
|
avio_skip(pb, 0x30); // payload description
|
2011-02-21 17:43:01 +02:00
|
|
|
fps = fps_umf2avr(avio_rl32(pb));
|
2006-08-01 13:19:25 +03:00
|
|
|
if (!main_timebase.num || !main_timebase.den) {
|
2011-08-03 21:05:59 +03:00
|
|
|
av_log(s, AV_LOG_WARNING, "No FPS track tag, using UMF fps tag."
|
|
|
|
" This might give wrong results.\n");
|
2006-08-01 13:19:25 +03:00
|
|
|
// this may not always be correct, but simply the best we can get
|
|
|
|
main_timebase.num = fps.den;
|
2010-03-07 00:20:33 +02:00
|
|
|
main_timebase.den = fps.num * 2;
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
2011-10-31 21:54:31 +03:00
|
|
|
|
|
|
|
if (len >= 0x18) {
|
|
|
|
len -= 0x18;
|
|
|
|
avio_skip(pb, 0x10);
|
2011-12-15 18:34:09 +03:00
|
|
|
add_timecode_metadata(&s->metadata, "timecode_at_mark_in",
|
2011-10-31 21:54:31 +03:00
|
|
|
avio_rl32(pb), si->fields_per_frame);
|
2011-12-15 18:34:09 +03:00
|
|
|
add_timecode_metadata(&s->metadata, "timecode_at_mark_out",
|
2011-10-31 21:54:31 +03:00
|
|
|
avio_rl32(pb), si->fields_per_frame);
|
|
|
|
}
|
2006-08-01 13:19:25 +03:00
|
|
|
} else
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_INFO, "UMF packet too short\n");
|
2006-08-01 13:19:25 +03:00
|
|
|
} else
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_INFO, "UMF packet missing\n");
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, len);
|
2010-03-07 00:25:53 +02:00
|
|
|
// set a fallback value, 60000/1001 is specified for audio-only files
|
|
|
|
// so use that regardless of why we do not know the video frame rate.
|
2007-02-08 22:54:12 +02:00
|
|
|
if (!main_timebase.num || !main_timebase.den)
|
2010-03-07 00:25:53 +02:00
|
|
|
main_timebase = (AVRational){1001, 60000};
|
2006-08-01 13:19:25 +03:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
AVStream *st = s->streams[i];
|
2011-11-29 21:28:15 +03:00
|
|
|
avpriv_set_pts_info(st, 32, main_timebase.num, main_timebase.den);
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
2006-07-03 19:32:57 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-01 13:19:25 +03:00
|
|
|
#define READ_ONE() \
|
|
|
|
{ \
|
2014-08-07 23:12:41 +03:00
|
|
|
if (!max_interval-- || avio_feof(pb)) \
|
2006-08-01 13:19:25 +03:00
|
|
|
goto out; \
|
2011-02-21 17:43:01 +02:00
|
|
|
tmp = tmp << 8 | avio_r8(pb); \
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-06-23 23:41:54 +03:00
|
|
|
* @brief resync the stream on the next media packet with specified properties
|
|
|
|
* @param max_interval how many bytes to search for matching packet at most
|
|
|
|
* @param track track id the media packet must belong to, -1 for any
|
|
|
|
* @param timestamp minimum timestamp (== field number) the packet must have, -1 for any
|
|
|
|
* @return timestamp of packet found
|
2006-08-01 13:19:25 +03:00
|
|
|
*/
|
|
|
|
static int64_t gxf_resync_media(AVFormatContext *s, uint64_t max_interval, int track, int timestamp) {
|
|
|
|
uint32_t tmp;
|
|
|
|
uint64_t last_pos;
|
|
|
|
uint64_t last_found_pos = 0;
|
|
|
|
int cur_track;
|
|
|
|
int64_t cur_timestamp = AV_NOPTS_VALUE;
|
|
|
|
int len;
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2008-12-13 23:58:17 +02:00
|
|
|
GXFPktType type;
|
2011-02-21 17:43:01 +02:00
|
|
|
tmp = avio_rb32(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
start:
|
|
|
|
while (tmp)
|
|
|
|
READ_ONE();
|
|
|
|
READ_ONE();
|
|
|
|
if (tmp != 1)
|
|
|
|
goto start;
|
2011-03-03 21:11:45 +02:00
|
|
|
last_pos = avio_tell(pb);
|
2011-02-28 15:57:54 +02:00
|
|
|
if (avio_seek(pb, -5, SEEK_CUR) < 0)
|
2010-07-11 02:42:08 +03:00
|
|
|
goto out;
|
2006-08-01 13:19:25 +03:00
|
|
|
if (!parse_packet_header(pb, &type, &len) || type != PKT_MEDIA) {
|
2011-02-28 15:57:54 +02:00
|
|
|
if (avio_seek(pb, last_pos, SEEK_SET) < 0)
|
2010-07-11 02:42:08 +03:00
|
|
|
goto out;
|
2006-08-01 13:19:25 +03:00
|
|
|
goto start;
|
|
|
|
}
|
2011-02-21 17:43:01 +02:00
|
|
|
avio_r8(pb);
|
|
|
|
cur_track = avio_r8(pb);
|
|
|
|
cur_timestamp = avio_rb32(pb);
|
2011-03-03 21:11:45 +02:00
|
|
|
last_found_pos = avio_tell(pb) - 16 - 6;
|
2006-08-01 13:19:25 +03:00
|
|
|
if ((track >= 0 && track != cur_track) || (timestamp >= 0 && timestamp > cur_timestamp)) {
|
2011-02-28 15:57:54 +02:00
|
|
|
if (avio_seek(pb, last_pos, SEEK_SET) >= 0)
|
2010-07-11 02:42:08 +03:00
|
|
|
goto start;
|
2006-08-01 13:19:25 +03:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (last_found_pos)
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(pb, last_found_pos, SEEK_SET);
|
2006-08-01 13:19:25 +03:00
|
|
|
return cur_timestamp;
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:32:57 +03:00
|
|
|
static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2008-12-13 23:58:17 +02:00
|
|
|
GXFPktType pkt_type;
|
2006-07-03 19:32:57 +03:00
|
|
|
int pkt_len;
|
2011-06-23 16:59:33 +03:00
|
|
|
struct gxf_stream_info *si = s->priv_data;
|
|
|
|
|
2011-03-07 22:50:25 +02:00
|
|
|
while (!pb->eof_reached) {
|
2008-09-25 02:31:04 +03:00
|
|
|
AVStream *st;
|
2006-07-03 19:32:57 +03:00
|
|
|
int track_type, track_id, ret;
|
2008-09-25 02:31:04 +03:00
|
|
|
int field_nr, field_info, skip = 0;
|
2008-05-29 18:22:45 +03:00
|
|
|
int stream_index;
|
2006-07-03 19:32:57 +03:00
|
|
|
if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
|
2014-08-07 23:12:41 +03:00
|
|
|
if (!avio_feof(pb))
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "sync lost\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2006-08-01 13:19:25 +03:00
|
|
|
if (pkt_type == PKT_FLT) {
|
|
|
|
gxf_read_index(s, pkt_len);
|
|
|
|
continue;
|
|
|
|
}
|
2006-07-03 19:32:57 +03:00
|
|
|
if (pkt_type != PKT_MEDIA) {
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, pkt_len);
|
2006-07-03 19:32:57 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (pkt_len < 16) {
|
2008-09-25 02:40:55 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "invalid media packet length\n");
|
2006-07-03 19:32:57 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
pkt_len -= 16;
|
2011-02-21 17:43:01 +02:00
|
|
|
track_type = avio_r8(pb);
|
|
|
|
track_id = avio_r8(pb);
|
2008-05-29 18:22:45 +03:00
|
|
|
stream_index = get_sindex(s, track_id, track_type);
|
|
|
|
if (stream_index < 0)
|
|
|
|
return stream_index;
|
2008-09-25 02:31:04 +03:00
|
|
|
st = s->streams[stream_index];
|
2011-02-21 17:43:01 +02:00
|
|
|
field_nr = avio_rb32(pb);
|
|
|
|
field_info = avio_rb32(pb);
|
|
|
|
avio_rb32(pb); // "timeline" field number
|
|
|
|
avio_r8(pb); // flags
|
|
|
|
avio_r8(pb); // reserved
|
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 21:42:52 +03:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||
|
|
|
|
st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
|
2008-09-25 02:31:04 +03:00
|
|
|
int first = field_info >> 16;
|
|
|
|
int last = field_info & 0xffff; // last is exclusive
|
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 21:42:52 +03:00
|
|
|
int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;
|
2008-09-25 02:31:04 +03:00
|
|
|
if (first <= last && last*bps <= pkt_len) {
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, first*bps);
|
2008-09-25 02:31:04 +03:00
|
|
|
skip = pkt_len - last*bps;
|
|
|
|
pkt_len = (last-first)*bps;
|
|
|
|
} else
|
|
|
|
av_log(s, AV_LOG_ERROR, "invalid first and last sample values\n");
|
|
|
|
}
|
2006-07-03 19:32:57 +03:00
|
|
|
ret = av_get_packet(pb, pkt, pkt_len);
|
2008-09-25 02:31:04 +03:00
|
|
|
if (skip)
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, skip);
|
2008-05-29 18:22:45 +03:00
|
|
|
pkt->stream_index = stream_index;
|
2006-08-08 21:02:09 +03:00
|
|
|
pkt->dts = field_nr;
|
2011-06-23 16:59:33 +03:00
|
|
|
|
|
|
|
//set duration manually for DV or else lavf misdetects the frame rate
|
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 21:42:52 +03:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
|
2011-06-23 16:59:33 +03:00
|
|
|
pkt->duration = si->fields_per_frame;
|
|
|
|
|
2006-07-03 19:32:57 +03:00
|
|
|
return ret;
|
|
|
|
}
|
2012-03-17 12:59:11 +03:00
|
|
|
return AVERROR_EOF;
|
2006-07-03 19:32:57 +03:00
|
|
|
}
|
|
|
|
|
2006-08-01 13:19:25 +03:00
|
|
|
static int gxf_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
|
2015-02-20 21:14:56 +02:00
|
|
|
int64_t res = 0;
|
2006-08-01 13:19:25 +03:00
|
|
|
uint64_t pos;
|
|
|
|
uint64_t maxlen = 100 * 1024 * 1024;
|
|
|
|
AVStream *st = s->streams[0];
|
|
|
|
int64_t start_time = s->streams[stream_index]->start_time;
|
|
|
|
int64_t found;
|
|
|
|
int idx;
|
|
|
|
if (timestamp < start_time) timestamp = start_time;
|
|
|
|
idx = av_index_search_timestamp(st, timestamp - start_time,
|
|
|
|
AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
|
|
|
|
if (idx < 0)
|
|
|
|
return -1;
|
2020-10-09 09:22:36 +02:00
|
|
|
pos = st->internal->index_entries[idx].pos;
|
|
|
|
if (idx < st->internal->nb_index_entries - 2)
|
|
|
|
maxlen = st->internal->index_entries[idx + 2].pos - pos;
|
2006-08-01 13:19:25 +03:00
|
|
|
maxlen = FFMAX(maxlen, 200 * 1024);
|
2011-02-28 15:57:54 +02:00
|
|
|
res = avio_seek(s->pb, pos, SEEK_SET);
|
2010-07-11 02:42:08 +03:00
|
|
|
if (res < 0)
|
|
|
|
return res;
|
2006-08-01 13:19:25 +03:00
|
|
|
found = gxf_resync_media(s, maxlen, -1, timestamp);
|
2006-10-12 02:17:58 +03:00
|
|
|
if (FFABS(found - timestamp) > 4)
|
2006-08-01 13:19:25 +03:00
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
|
|
|
|
int64_t *pos, int64_t pos_limit) {
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2006-08-01 13:19:25 +03:00
|
|
|
int64_t res;
|
2011-02-28 15:57:54 +02:00
|
|
|
if (avio_seek(pb, *pos, SEEK_SET) < 0)
|
2010-07-11 02:42:08 +03:00
|
|
|
return AV_NOPTS_VALUE;
|
2006-08-01 13:19:25 +03:00
|
|
|
res = gxf_resync_media(s, pos_limit - *pos, -1, -1);
|
2011-03-03 21:11:45 +02:00
|
|
|
*pos = avio_tell(pb);
|
2006-08-01 13:19:25 +03:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-01-26 00:03:28 +02:00
|
|
|
AVInputFormat ff_gxf_demuxer = {
|
2011-07-16 23:18:12 +03:00
|
|
|
.name = "gxf",
|
2012-07-24 04:23:48 +03:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
|
2011-07-16 23:18:12 +03:00
|
|
|
.priv_data_size = sizeof(struct gxf_stream_info),
|
|
|
|
.read_probe = gxf_probe,
|
|
|
|
.read_header = gxf_header,
|
|
|
|
.read_packet = gxf_packet,
|
|
|
|
.read_seek = gxf_seek,
|
|
|
|
.read_timestamp = gxf_read_timestamp,
|
2006-07-03 19:32:57 +03:00
|
|
|
};
|