2006-03-21 17:27:47 +00:00
|
|
|
/*
|
2006-10-23 08:57:54 +00:00
|
|
|
* Smacker demuxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2006 Konstantin Shishkov
|
2006-03-21 17:27:47 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2006-03-21 17:27:47 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2006-03-21 17:27:47 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2006-03-21 17:27:47 +00: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 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-03-21 17:27:47 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Based on http://wiki.multimedia.cx/index.php?title=Smacker
|
|
|
|
*/
|
|
|
|
|
2014-03-10 14:35:59 +00:00
|
|
|
#include <inttypes.h>
|
|
|
|
|
2008-05-09 11:56:36 +00:00
|
|
|
#include "libavutil/bswap.h"
|
2012-04-07 22:36:49 +00:00
|
|
|
#include "libavutil/channel_layout.h"
|
2009-01-11 22:19:48 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2006-03-21 17:27:47 +00:00
|
|
|
#include "avformat.h"
|
2011-11-29 18:28:15 +00:00
|
|
|
#include "internal.h"
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
#define SMACKER_PAL 0x01
|
2007-08-23 06:59:19 +00:00
|
|
|
#define SMACKER_FLAG_RING_FRAME 0x01
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
enum SAudFlags {
|
2011-09-21 15:34:26 +00:00
|
|
|
SMK_AUD_PACKED = 0x80,
|
|
|
|
SMK_AUD_16BITS = 0x20,
|
|
|
|
SMK_AUD_STEREO = 0x10,
|
|
|
|
SMK_AUD_BINKAUD = 0x08,
|
|
|
|
SMK_AUD_USEDCT = 0x04
|
2006-03-21 17:27:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct SmackerContext {
|
|
|
|
/* Smacker file header */
|
|
|
|
uint32_t magic;
|
|
|
|
uint32_t width, height;
|
|
|
|
uint32_t frames;
|
|
|
|
int pts_inc;
|
|
|
|
uint32_t flags;
|
|
|
|
uint32_t audio[7];
|
|
|
|
uint32_t treesize;
|
|
|
|
uint32_t mmap_size, mclr_size, full_size, type_size;
|
2011-09-21 15:34:26 +00:00
|
|
|
uint8_t aflags[7];
|
2006-03-21 17:27:47 +00:00
|
|
|
uint32_t rates[7];
|
|
|
|
uint32_t pad;
|
|
|
|
/* frame info */
|
|
|
|
uint32_t *frm_size;
|
|
|
|
uint8_t *frm_flags;
|
|
|
|
/* internal variables */
|
|
|
|
int cur_frame;
|
|
|
|
int is_ver4;
|
|
|
|
int64_t cur_pts;
|
|
|
|
/* current frame for demuxing */
|
|
|
|
uint8_t pal[768];
|
|
|
|
int indexes[7];
|
|
|
|
int videoindex;
|
|
|
|
uint8_t *bufs[7];
|
|
|
|
int buf_sizes[7];
|
|
|
|
int stream_id[7];
|
|
|
|
int curstream;
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t nextpos;
|
2006-05-17 03:05:34 +00:00
|
|
|
int64_t aud_pts[7];
|
2006-03-21 17:27:47 +00:00
|
|
|
} SmackerContext;
|
|
|
|
|
|
|
|
typedef struct SmackerFrame {
|
|
|
|
int64_t pts;
|
|
|
|
int stream;
|
|
|
|
} SmackerFrame;
|
|
|
|
|
|
|
|
/* palette used in Smacker */
|
|
|
|
static const uint8_t smk_pal[64] = {
|
|
|
|
0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C,
|
|
|
|
0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C,
|
|
|
|
0x41, 0x45, 0x49, 0x4D, 0x51, 0x55, 0x59, 0x5D,
|
|
|
|
0x61, 0x65, 0x69, 0x6D, 0x71, 0x75, 0x79, 0x7D,
|
|
|
|
0x82, 0x86, 0x8A, 0x8E, 0x92, 0x96, 0x9A, 0x9E,
|
|
|
|
0xA2, 0xA6, 0xAA, 0xAE, 0xB2, 0xB6, 0xBA, 0xBE,
|
|
|
|
0xC3, 0xC7, 0xCB, 0xCF, 0xD3, 0xD7, 0xDB, 0xDF,
|
|
|
|
0xE3, 0xE7, 0xEB, 0xEF, 0xF3, 0xF7, 0xFB, 0xFF
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int smacker_probe(const AVProbeData *p)
|
2006-03-21 17:27:47 +00:00
|
|
|
{
|
2013-11-12 18:37:37 +00:00
|
|
|
if ( AV_RL32(p->buf) != MKTAG('S', 'M', 'K', '2')
|
|
|
|
&& AV_RL32(p->buf) != MKTAG('S', 'M', 'K', '4'))
|
2006-03-21 17:27:47 +00:00
|
|
|
return 0;
|
2013-11-12 18:37:37 +00:00
|
|
|
|
|
|
|
if (AV_RL32(p->buf+4) > 32768U || AV_RL32(p->buf+8) > 32768U)
|
|
|
|
return AVPROBE_SCORE_MAX/4;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX;
|
2006-03-21 17:27:47 +00:00
|
|
|
}
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int smacker_read_header(AVFormatContext *s)
|
2006-03-21 17:27:47 +00:00
|
|
|
{
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-04-08 20:24:16 +00:00
|
|
|
SmackerContext *smk = s->priv_data;
|
2006-03-21 17:27:47 +00:00
|
|
|
AVStream *st, *ast[7];
|
|
|
|
int i, ret;
|
|
|
|
int tbase;
|
|
|
|
|
|
|
|
/* read and check header */
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->magic = avio_rl32(pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != MKTAG('S', 'M', 'K', '4'))
|
2012-12-06 18:06:52 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->width = avio_rl32(pb);
|
|
|
|
smk->height = avio_rl32(pb);
|
|
|
|
smk->frames = avio_rl32(pb);
|
|
|
|
smk->pts_inc = (int32_t)avio_rl32(pb);
|
2015-12-05 12:06:16 +00:00
|
|
|
if (smk->pts_inc > INT_MAX / 100) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "pts_inc %d is too large\n", smk->pts_inc);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->flags = avio_rl32(pb);
|
2007-08-23 06:59:19 +00:00
|
|
|
if(smk->flags & SMACKER_FLAG_RING_FRAME)
|
|
|
|
smk->frames++;
|
2006-03-21 17:27:47 +00:00
|
|
|
for(i = 0; i < 7; i++)
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->audio[i] = avio_rl32(pb);
|
|
|
|
smk->treesize = avio_rl32(pb);
|
2006-05-13 11:37:56 +00:00
|
|
|
|
|
|
|
if(smk->treesize >= UINT_MAX/4){ // smk->treesize + 16 must not overflow (this check is probably redundant)
|
|
|
|
av_log(s, AV_LOG_ERROR, "treesize too large\n");
|
2012-12-06 18:06:52 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2006-05-13 11:37:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//FIXME remove extradata "rebuilding"
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->mmap_size = avio_rl32(pb);
|
|
|
|
smk->mclr_size = avio_rl32(pb);
|
|
|
|
smk->full_size = avio_rl32(pb);
|
|
|
|
smk->type_size = avio_rl32(pb);
|
2011-09-21 15:34:26 +00:00
|
|
|
for(i = 0; i < 7; i++) {
|
|
|
|
smk->rates[i] = avio_rl24(pb);
|
|
|
|
smk->aflags[i] = avio_r8(pb);
|
|
|
|
}
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->pad = avio_rl32(pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
/* setup data */
|
|
|
|
if(smk->frames > 0xFFFFFF) {
|
2014-03-10 14:35:59 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Too many frames: %"PRIu32"\n", smk->frames);
|
2012-12-06 18:06:52 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2006-03-21 17:27:47 +00:00
|
|
|
}
|
2013-09-16 18:20:08 +00:00
|
|
|
smk->frm_size = av_malloc_array(smk->frames, sizeof(*smk->frm_size));
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->frm_flags = av_malloc(smk->frames);
|
2013-09-16 18:20:08 +00:00
|
|
|
if (!smk->frm_size || !smk->frm_flags) {
|
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
smk->is_ver4 = (smk->magic != MKTAG('S', 'M', 'K', '2'));
|
|
|
|
|
|
|
|
/* read frame info */
|
|
|
|
for(i = 0; i < smk->frames; i++) {
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->frm_size[i] = avio_rl32(pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
}
|
|
|
|
for(i = 0; i < smk->frames; i++) {
|
2011-02-21 15:43:01 +00:00
|
|
|
smk->frm_flags[i] = avio_r8(pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* init video codec */
|
2011-06-18 09:43:24 +00:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2019-10-10 02:07:54 +00:00
|
|
|
if (!st) {
|
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
2012-12-06 18:06:52 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2019-10-10 02:07:54 +00:00
|
|
|
}
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->videoindex = st->index;
|
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 18:42:52 +00:00
|
|
|
st->codecpar->width = smk->width;
|
|
|
|
st->codecpar->height = smk->height;
|
|
|
|
st->codecpar->format = AV_PIX_FMT_PAL8;
|
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_SMACKVIDEO;
|
|
|
|
st->codecpar->codec_tag = smk->magic;
|
2006-03-21 17:27:47 +00:00
|
|
|
/* Smacker uses 100000 as internal timebase */
|
|
|
|
if(smk->pts_inc < 0)
|
|
|
|
smk->pts_inc = -smk->pts_inc;
|
|
|
|
else
|
|
|
|
smk->pts_inc *= 100;
|
|
|
|
tbase = 100000;
|
|
|
|
av_reduce(&tbase, &smk->pts_inc, tbase, smk->pts_inc, (1UL<<31)-1);
|
2011-11-29 18:28:15 +00:00
|
|
|
avpriv_set_pts_info(st, 33, smk->pts_inc, tbase);
|
2010-01-30 10:37:52 +00:00
|
|
|
st->duration = smk->frames;
|
2006-03-21 17:27:47 +00:00
|
|
|
/* handle possible audio streams */
|
|
|
|
for(i = 0; i < 7; i++) {
|
|
|
|
smk->indexes[i] = -1;
|
2011-09-21 15:34:26 +00:00
|
|
|
if (smk->rates[i]) {
|
2011-06-18 09:43:24 +00:00
|
|
|
ast[i] = avformat_new_stream(s, NULL);
|
2019-10-10 02:07:54 +00:00
|
|
|
if (!ast[i]) {
|
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
2013-09-11 10:23:03 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2019-10-10 02:07:54 +00:00
|
|
|
}
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->indexes[i] = ast[i]->index;
|
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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
2011-09-21 15:34:26 +00:00
|
|
|
if (smk->aflags[i] & SMK_AUD_BINKAUD) {
|
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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->codec_id = AV_CODEC_ID_BINKAUDIO_RDFT;
|
2011-09-21 15:34:26 +00:00
|
|
|
} else if (smk->aflags[i] & SMK_AUD_USEDCT) {
|
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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->codec_id = AV_CODEC_ID_BINKAUDIO_DCT;
|
2011-09-21 15:34:26 +00:00
|
|
|
} else if (smk->aflags[i] & SMK_AUD_PACKED){
|
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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->codec_id = AV_CODEC_ID_SMACKAUDIO;
|
|
|
|
ast[i]->codecpar->codec_tag = MKTAG('S', 'M', 'K', 'A');
|
2010-01-30 10:31:10 +00:00
|
|
|
} 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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
|
2010-01-30 10:31:10 +00:00
|
|
|
}
|
2012-04-07 22:36:49 +00:00
|
|
|
if (smk->aflags[i] & SMK_AUD_STEREO) {
|
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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->channels = 2;
|
|
|
|
ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
|
2012-04-07 22:36:49 +00:00
|
|
|
} 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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->channels = 1;
|
|
|
|
ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
|
2012-04-07 22:36:49 +00: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 18:42:52 +00:00
|
|
|
ast[i]->codecpar->sample_rate = smk->rates[i];
|
|
|
|
ast[i]->codecpar->bits_per_coded_sample = (smk->aflags[i] & SMK_AUD_16BITS) ? 16 : 8;
|
|
|
|
if(ast[i]->codecpar->bits_per_coded_sample == 16 && ast[i]->codecpar->codec_id == AV_CODEC_ID_PCM_U8)
|
|
|
|
ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
|
|
|
|
avpriv_set_pts_info(ast[i], 64, 1, ast[i]->codecpar->sample_rate
|
|
|
|
* ast[i]->codecpar->channels * ast[i]->codecpar->bits_per_coded_sample / 8);
|
2006-03-21 17:27:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* load trees to extradata, they will be unpacked by decoder */
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = ff_alloc_extradata(st->codecpar, smk->treesize + 16)) < 0) {
|
2014-03-10 14:35:59 +00:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Cannot allocate %"PRIu32" bytes of extradata\n",
|
|
|
|
smk->treesize + 16);
|
2013-09-12 13:27:17 +00:00
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
2019-12-10 21:59:53 +00:00
|
|
|
return ret;
|
2006-03-21 17:27:47 +00: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 18:42:52 +00:00
|
|
|
ret = avio_read(pb, st->codecpar->extradata + 16, st->codecpar->extradata_size - 16);
|
|
|
|
if(ret != st->codecpar->extradata_size - 16){
|
2013-09-12 13:27:17 +00:00
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2006-03-21 17:27:47 +00: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 18:42:52 +00:00
|
|
|
((int32_t*)st->codecpar->extradata)[0] = av_le2ne32(smk->mmap_size);
|
|
|
|
((int32_t*)st->codecpar->extradata)[1] = av_le2ne32(smk->mclr_size);
|
|
|
|
((int32_t*)st->codecpar->extradata)[2] = av_le2ne32(smk->full_size);
|
|
|
|
((int32_t*)st->codecpar->extradata)[3] = av_le2ne32(smk->type_size);
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
smk->curstream = -1;
|
2011-03-03 19:11:45 +00:00
|
|
|
smk->nextpos = avio_tell(pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
2007-04-08 20:24:16 +00:00
|
|
|
SmackerContext *smk = s->priv_data;
|
2006-03-21 17:27:47 +00:00
|
|
|
int flags;
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
int frame_size = 0;
|
|
|
|
int palchange = 0;
|
|
|
|
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(s->pb) || smk->cur_frame >= smk->frames)
|
2010-06-24 06:55:53 +00:00
|
|
|
return AVERROR_EOF;
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
/* if we demuxed all streams, pass another frame */
|
|
|
|
if(smk->curstream < 0) {
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(s->pb, smk->nextpos, 0);
|
2006-03-21 17:27:47 +00:00
|
|
|
frame_size = smk->frm_size[smk->cur_frame] & (~3);
|
|
|
|
flags = smk->frm_flags[smk->cur_frame];
|
|
|
|
/* handle palette change event */
|
|
|
|
if(flags & SMACKER_PAL){
|
|
|
|
int size, sz, t, off, j, pos;
|
|
|
|
uint8_t *pal = smk->pal;
|
|
|
|
uint8_t oldpal[768];
|
|
|
|
|
|
|
|
memcpy(oldpal, pal, 768);
|
2011-02-21 15:43:01 +00:00
|
|
|
size = avio_r8(s->pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
size = size * 4 - 1;
|
2011-12-16 01:57:22 +00:00
|
|
|
if(size + 1 > frame_size)
|
|
|
|
return AVERROR_INVALIDDATA;
|
2006-03-21 17:27:47 +00:00
|
|
|
frame_size -= size;
|
|
|
|
frame_size--;
|
|
|
|
sz = 0;
|
2011-03-03 19:11:45 +00:00
|
|
|
pos = avio_tell(s->pb) + size;
|
2006-03-21 17:27:47 +00:00
|
|
|
while(sz < 256){
|
2011-02-21 15:43:01 +00:00
|
|
|
t = avio_r8(s->pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
if(t & 0x80){ /* skip palette entries */
|
|
|
|
sz += (t & 0x7F) + 1;
|
|
|
|
pal += ((t & 0x7F) + 1) * 3;
|
|
|
|
} else if(t & 0x40){ /* copy with offset */
|
2012-03-07 01:24:20 +00:00
|
|
|
off = avio_r8(s->pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
j = (t & 0x3F) + 1;
|
2013-05-27 04:26:28 +00:00
|
|
|
if (off + j > 0x100) {
|
2012-03-07 01:24:20 +00:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Invalid palette update, offset=%d length=%d extends beyond palette size\n",
|
|
|
|
off, j);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
off *= 3;
|
2006-03-21 17:27:47 +00:00
|
|
|
while(j-- && sz < 256) {
|
|
|
|
*pal++ = oldpal[off + 0];
|
|
|
|
*pal++ = oldpal[off + 1];
|
|
|
|
*pal++ = oldpal[off + 2];
|
|
|
|
sz++;
|
|
|
|
off += 3;
|
|
|
|
}
|
|
|
|
} else { /* new entries */
|
|
|
|
*pal++ = smk_pal[t];
|
2011-02-21 15:43:01 +00:00
|
|
|
*pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
|
|
|
|
*pal++ = smk_pal[avio_r8(s->pb) & 0x3F];
|
2006-03-21 17:27:47 +00:00
|
|
|
sz++;
|
|
|
|
}
|
|
|
|
}
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(s->pb, pos, 0);
|
2006-03-21 17:27:47 +00:00
|
|
|
palchange |= 1;
|
|
|
|
}
|
|
|
|
flags >>= 1;
|
|
|
|
smk->curstream = -1;
|
|
|
|
/* if audio chunks are present, put them to stack and retrieve later */
|
|
|
|
for(i = 0; i < 7; i++) {
|
|
|
|
if(flags & 1) {
|
2013-06-12 12:30:51 +00:00
|
|
|
uint32_t size;
|
2013-09-18 16:12:36 +00:00
|
|
|
int err;
|
2011-09-12 07:40:42 +00:00
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
size = avio_rl32(s->pb) - 4;
|
2015-02-01 18:36:13 +00:00
|
|
|
if (!size || size + 4LL > frame_size) {
|
2013-06-12 12:30:51 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid audio part size\n");
|
2011-12-16 01:57:22 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2013-06-12 12:30:51 +00:00
|
|
|
}
|
2006-03-21 17:27:47 +00:00
|
|
|
frame_size -= size;
|
|
|
|
frame_size -= 4;
|
|
|
|
smk->curstream++;
|
2013-09-26 13:37:02 +00:00
|
|
|
if ((err = av_reallocp(&smk->bufs[smk->curstream], size)) < 0) {
|
|
|
|
smk->buf_sizes[smk->curstream] = 0;
|
2013-09-18 16:12:36 +00:00
|
|
|
return err;
|
2013-09-26 13:37:02 +00:00
|
|
|
}
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->buf_sizes[smk->curstream] = size;
|
2011-02-21 15:43:01 +00:00
|
|
|
ret = avio_read(s->pb, smk->bufs[smk->curstream], size);
|
2006-03-21 17:27:47 +00:00
|
|
|
if(ret != size)
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->stream_id[smk->curstream] = smk->indexes[i];
|
|
|
|
}
|
|
|
|
flags >>= 1;
|
|
|
|
}
|
2013-09-11 12:25:13 +00:00
|
|
|
if (frame_size < 0 || frame_size >= INT_MAX/2)
|
2011-09-11 16:51:52 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = av_new_packet(pkt, frame_size + 769)) < 0)
|
|
|
|
return ret;
|
2006-03-21 17:27:47 +00:00
|
|
|
if(smk->frm_size[smk->cur_frame] & 1)
|
|
|
|
palchange |= 2;
|
|
|
|
pkt->data[0] = palchange;
|
|
|
|
memcpy(pkt->data + 1, smk->pal, 768);
|
2011-02-21 15:43:01 +00:00
|
|
|
ret = avio_read(s->pb, pkt->data + 769, frame_size);
|
2006-03-21 17:27:47 +00:00
|
|
|
if(ret != frame_size)
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2006-03-21 17:27:47 +00:00
|
|
|
pkt->stream_index = smk->videoindex;
|
2013-05-27 03:45:29 +00:00
|
|
|
pkt->pts = smk->cur_frame;
|
2006-03-21 17:27:47 +00:00
|
|
|
pkt->size = ret + 769;
|
|
|
|
smk->cur_frame++;
|
2011-03-03 19:11:45 +00:00
|
|
|
smk->nextpos = avio_tell(s->pb);
|
2006-03-21 17:27:47 +00:00
|
|
|
} else {
|
2013-09-19 12:20:21 +00:00
|
|
|
if (smk->stream_id[smk->curstream] < 0 || !smk->bufs[smk->curstream])
|
2013-09-11 12:20:01 +00:00
|
|
|
return AVERROR_INVALIDDATA;
|
2019-12-10 21:59:53 +00:00
|
|
|
if ((ret = av_new_packet(pkt, smk->buf_sizes[smk->curstream])) < 0)
|
|
|
|
return ret;
|
2006-03-21 17:27:47 +00:00
|
|
|
memcpy(pkt->data, smk->bufs[smk->curstream], smk->buf_sizes[smk->curstream]);
|
|
|
|
pkt->size = smk->buf_sizes[smk->curstream];
|
|
|
|
pkt->stream_index = smk->stream_id[smk->curstream];
|
2006-05-17 03:05:34 +00:00
|
|
|
pkt->pts = smk->aud_pts[smk->curstream];
|
2007-01-19 22:12:59 +00:00
|
|
|
smk->aud_pts[smk->curstream] += AV_RL32(pkt->data);
|
2006-03-21 17:27:47 +00:00
|
|
|
smk->curstream--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int smacker_read_close(AVFormatContext *s)
|
|
|
|
{
|
2007-04-08 20:24:16 +00:00
|
|
|
SmackerContext *smk = s->priv_data;
|
2006-03-21 17:27:47 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 7; i++)
|
2013-09-12 13:27:17 +00:00
|
|
|
av_freep(&smk->bufs[i]);
|
|
|
|
av_freep(&smk->frm_size);
|
|
|
|
av_freep(&smk->frm_flags);
|
2006-03-21 17:27:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVInputFormat ff_smacker_demuxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "smk",
|
2012-07-29 02:22:09 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Smacker"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.priv_data_size = sizeof(SmackerContext),
|
|
|
|
.read_probe = smacker_probe,
|
|
|
|
.read_header = smacker_read_header,
|
|
|
|
.read_packet = smacker_read_packet,
|
|
|
|
.read_close = smacker_read_close,
|
2006-03-21 17:27:47 +00:00
|
|
|
};
|