2004-10-16 22:33:57 +03:00
|
|
|
/* Electronic Arts Multimedia File Demuxer
|
2016-04-27 19:45:23 +02:00
|
|
|
* Copyright (c) 2004 The FFmpeg project
|
2008-07-08 16:24:13 +03:00
|
|
|
* Copyright (c) 2006-2008 Peter Ross
|
2004-10-16 22:33: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
|
2004-10-16 22:33: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.
|
2004-10-16 22:33:57 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2004-10-16 22:33: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-01-13 00:43:26 +02:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2004-10-16 22:33:57 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2010-04-20 17:45:34 +03:00
|
|
|
* @file
|
2004-10-16 22:33:57 +03:00
|
|
|
* Electronic Arts Multimedia file demuxer (WVE/UV2/etc.)
|
|
|
|
* by Robin Kay (komadori at gekkou.co.uk)
|
|
|
|
*/
|
|
|
|
|
2014-03-10 17:35:59 +03:00
|
|
|
#include <inttypes.h>
|
|
|
|
|
2009-01-12 00:19:48 +02:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2004-10-16 22:33:57 +03:00
|
|
|
#include "avformat.h"
|
2011-11-29 21:28:15 +03:00
|
|
|
#include "internal.h"
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
#define SCHl_TAG MKTAG('S', 'C', 'H', 'l')
|
2013-08-14 17:45:06 +03:00
|
|
|
#define SEAD_TAG MKTAG('S', 'E', 'A', 'D') /* Sxxx header */
|
|
|
|
#define SNDC_TAG MKTAG('S', 'N', 'D', 'C') /* Sxxx data */
|
|
|
|
#define SEND_TAG MKTAG('S', 'E', 'N', 'D') /* Sxxx end */
|
|
|
|
#define SHEN_TAG MKTAG('S', 'H', 'E', 'N') /* SxEN header */
|
|
|
|
#define SDEN_TAG MKTAG('S', 'D', 'E', 'N') /* SxEN data */
|
|
|
|
#define SEEN_TAG MKTAG('S', 'E', 'E', 'N') /* SxEN end */
|
|
|
|
#define ISNh_TAG MKTAG('1', 'S', 'N', 'h') /* 1SNx header */
|
2007-10-25 23:38:49 +03:00
|
|
|
#define EACS_TAG MKTAG('E', 'A', 'C', 'S')
|
2013-08-14 17:45:06 +03:00
|
|
|
#define ISNd_TAG MKTAG('1', 'S', 'N', 'd') /* 1SNx data */
|
|
|
|
#define ISNe_TAG MKTAG('1', 'S', 'N', 'e') /* 1SNx end */
|
2004-10-16 22:33:57 +03:00
|
|
|
#define PT00_TAG MKTAG('P', 'T', 0x0, 0x0)
|
2007-10-16 01:51:52 +03:00
|
|
|
#define GSTR_TAG MKTAG('G', 'S', 'T', 'R')
|
2004-10-16 22:33:57 +03:00
|
|
|
#define SCDl_TAG MKTAG('S', 'C', 'D', 'l')
|
|
|
|
#define SCEl_TAG MKTAG('S', 'C', 'E', 'l')
|
2013-08-14 17:53:08 +03:00
|
|
|
#define kVGT_TAG MKTAG('k', 'V', 'G', 'T') /* TGV I-frame */
|
|
|
|
#define fVGT_TAG MKTAG('f', 'V', 'G', 'T') /* TGV P-frame */
|
2013-08-14 17:45:06 +03:00
|
|
|
#define mTCD_TAG MKTAG('m', 'T', 'C', 'D') /* MDEC */
|
2013-08-14 17:53:08 +03:00
|
|
|
#define MADk_TAG MKTAG('M', 'A', 'D', 'k') /* MAD I-frame */
|
|
|
|
#define MADm_TAG MKTAG('M', 'A', 'D', 'm') /* MAD P-frame */
|
2013-08-14 17:45:06 +03:00
|
|
|
#define MADe_TAG MKTAG('M', 'A', 'D', 'e') /* MAD lqp-frame */
|
2013-08-14 17:53:08 +03:00
|
|
|
#define MPCh_TAG MKTAG('M', 'P', 'C', 'h') /* MPEG-2 */
|
|
|
|
#define TGQs_TAG MKTAG('T', 'G', 'Q', 's') /* TGQ I-frame (appears in .TGQ files) */
|
|
|
|
#define pQGT_TAG MKTAG('p', 'Q', 'G', 'T') /* TGQ I-frame (appears in .UV files) */
|
|
|
|
#define pIQT_TAG MKTAG('p', 'I', 'Q', 'T') /* TQI/UV2 I-frame (.UV2/.WVE) */
|
2007-10-16 01:51:52 +03:00
|
|
|
#define MVhd_TAG MKTAG('M', 'V', 'h', 'd')
|
|
|
|
#define MV0K_TAG MKTAG('M', 'V', '0', 'K')
|
|
|
|
#define MV0F_TAG MKTAG('M', 'V', '0', 'F')
|
2015-06-25 07:05:07 +02:00
|
|
|
#define AVhd_TAG MKTAG('A', 'V', 'h', 'd')
|
|
|
|
#define AV0K_TAG MKTAG('A', 'V', '0', 'K')
|
|
|
|
#define AV0F_TAG MKTAG('A', 'V', '0', 'F')
|
2013-08-14 17:45:06 +03:00
|
|
|
#define MVIh_TAG MKTAG('M', 'V', 'I', 'h') /* CMV header */
|
2013-08-14 17:53:08 +03:00
|
|
|
#define MVIf_TAG MKTAG('M', 'V', 'I', 'f') /* CMV I-frame */
|
2015-06-22 20:58:41 +02:00
|
|
|
#define AVP6_TAG MKTAG('A', 'V', 'P', '6')
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
typedef struct VideoProperties {
|
|
|
|
enum AVCodecID codec;
|
2007-10-16 01:51:52 +03:00
|
|
|
AVRational time_base;
|
2008-08-10 04:58:46 +03:00
|
|
|
int width, height;
|
2012-03-22 02:17:05 +03:00
|
|
|
int nb_frames;
|
2015-06-25 07:04:58 +02:00
|
|
|
int stream_index;
|
|
|
|
} VideoProperties;
|
|
|
|
|
|
|
|
typedef struct EaDemuxContext {
|
|
|
|
int big_endian;
|
|
|
|
|
2015-06-25 07:05:07 +02:00
|
|
|
VideoProperties video, alpha;
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2012-08-05 12:11:04 +03:00
|
|
|
enum AVCodecID audio_codec;
|
2004-10-16 22:33:57 +03:00
|
|
|
int audio_stream_index;
|
|
|
|
|
2007-10-19 02:36:12 +03:00
|
|
|
int bytes;
|
2007-10-19 02:13:46 +03:00
|
|
|
int sample_rate;
|
2004-10-16 22:33:57 +03:00
|
|
|
int num_channels;
|
|
|
|
int num_samples;
|
2015-10-21 22:59:08 +02:00
|
|
|
|
|
|
|
int platform;
|
2004-10-16 22:33:57 +03:00
|
|
|
} EaDemuxContext;
|
|
|
|
|
2013-08-14 18:06:41 +03:00
|
|
|
static uint32_t read_arbitrary(AVIOContext *pb)
|
2013-08-14 17:45:06 +03:00
|
|
|
{
|
2004-10-16 22:33:57 +03:00
|
|
|
uint8_t size, byte;
|
|
|
|
int i;
|
|
|
|
uint32_t word;
|
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
size = avio_r8(pb);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
word = 0;
|
|
|
|
for (i = 0; i < size; i++) {
|
2013-08-14 17:45:06 +03:00
|
|
|
byte = avio_r8(pb);
|
2004-10-16 22:33:57 +03:00
|
|
|
word <<= 8;
|
2013-08-14 17:45:06 +03:00
|
|
|
word |= byte;
|
2004-10-16 22:33:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return word;
|
|
|
|
}
|
|
|
|
|
2007-10-19 00:55:51 +03:00
|
|
|
static int process_audio_header_elements(AVFormatContext *s)
|
|
|
|
{
|
2007-04-08 23:24:16 +03:00
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2013-08-14 18:06:41 +03:00
|
|
|
int in_header = 1;
|
2007-11-25 18:32:47 +02:00
|
|
|
int compression_type = -1, revision = -1, revision2 = -1;
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
ea->bytes = 2;
|
|
|
|
ea->sample_rate = -1;
|
2007-10-19 00:56:44 +03:00
|
|
|
ea->num_channels = 1;
|
|
|
|
|
2014-08-07 23:12:41 +03:00
|
|
|
while (!avio_feof(pb) && in_header) {
|
2013-08-14 18:06:41 +03:00
|
|
|
int in_subheader;
|
2004-10-16 22:33:57 +03:00
|
|
|
uint8_t byte;
|
2011-02-21 17:43:01 +02:00
|
|
|
byte = avio_r8(pb);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
switch (byte) {
|
|
|
|
case 0xFD:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG, "entered audio subheader\n");
|
2013-08-14 18:06:41 +03:00
|
|
|
in_subheader = 1;
|
2014-08-07 23:12:41 +03:00
|
|
|
while (!avio_feof(pb) && in_subheader) {
|
2004-10-16 22:33:57 +03:00
|
|
|
uint8_t subbyte;
|
2011-02-21 17:43:01 +02:00
|
|
|
subbyte = avio_r8(pb);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
switch (subbyte) {
|
2007-10-19 02:13:46 +03:00
|
|
|
case 0x80:
|
2013-08-14 18:06:41 +03:00
|
|
|
revision = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"revision (element 0x80) set to 0x%08x\n", revision);
|
2007-10-19 02:13:46 +03:00
|
|
|
break;
|
2004-10-16 22:33:57 +03:00
|
|
|
case 0x82:
|
2013-08-14 18:06:41 +03:00
|
|
|
ea->num_channels = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"num_channels (element 0x82) set to 0x%08x\n",
|
|
|
|
ea->num_channels);
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
case 0x83:
|
2013-08-14 18:06:41 +03:00
|
|
|
compression_type = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"compression_type (element 0x83) set to 0x%08x\n",
|
|
|
|
compression_type);
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
2007-10-19 02:13:46 +03:00
|
|
|
case 0x84:
|
2013-08-14 18:06:41 +03:00
|
|
|
ea->sample_rate = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"sample_rate (element 0x84) set to %i\n",
|
|
|
|
ea->sample_rate);
|
2007-10-19 02:13:46 +03:00
|
|
|
break;
|
2004-10-16 22:33:57 +03:00
|
|
|
case 0x85:
|
2013-08-14 18:06:41 +03:00
|
|
|
ea->num_samples = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"num_samples (element 0x85) set to 0x%08x\n",
|
|
|
|
ea->num_samples);
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
case 0x8A:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
2014-03-10 17:35:59 +03:00
|
|
|
"element 0x%02x set to 0x%08"PRIx32"\n",
|
2013-08-14 18:06:41 +03:00
|
|
|
subbyte, read_arbitrary(pb));
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG, "exited audio subheader\n");
|
2013-08-14 18:06:41 +03:00
|
|
|
in_subheader = 0;
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
2007-11-25 18:32:47 +02:00
|
|
|
case 0xA0:
|
2013-08-14 18:06:41 +03:00
|
|
|
revision2 = read_arbitrary(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"revision2 (element 0xA0) set to 0x%08x\n",
|
|
|
|
revision2);
|
2007-11-25 18:32:47 +02:00
|
|
|
break;
|
2007-10-16 01:51:52 +03:00
|
|
|
case 0xFF:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
|
|
|
"end of header block reached (within audio subheader)\n");
|
2013-08-14 18:06:41 +03:00
|
|
|
in_subheader = 0;
|
|
|
|
in_header = 0;
|
2007-10-16 01:51:52 +03:00
|
|
|
break;
|
2004-10-16 22:33:57 +03:00
|
|
|
default:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
2014-03-10 17:35:59 +03:00
|
|
|
"element 0x%02x set to 0x%08"PRIx32"\n",
|
2013-08-14 18:06:41 +03:00
|
|
|
subbyte, read_arbitrary(pb));
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0xFF:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG, "end of header block reached\n");
|
2013-08-14 18:06:41 +03:00
|
|
|
in_header = 0;
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
default:
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG,
|
2014-03-10 17:35:59 +03:00
|
|
|
"header element 0x%02x set to 0x%08"PRIx32"\n",
|
2013-08-14 18:06:41 +03:00
|
|
|
byte, read_arbitrary(pb));
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-19 01:53:37 +03:00
|
|
|
switch (compression_type) {
|
2013-08-14 17:45:06 +03:00
|
|
|
case 0:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
|
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_EA;
|
|
|
|
break;
|
2007-10-24 23:49:42 +03:00
|
|
|
case -1:
|
|
|
|
switch (revision) {
|
2013-08-14 17:45:06 +03:00
|
|
|
case 1:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3;
|
|
|
|
break;
|
|
|
|
case -1:
|
|
|
|
break;
|
2007-10-24 23:49:42 +03:00
|
|
|
default:
|
2013-03-15 20:13:52 +03:00
|
|
|
avpriv_request_sample(s, "stream type; revision=%i", revision);
|
2007-10-24 23:49:42 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2007-11-25 18:32:47 +02:00
|
|
|
switch (revision2) {
|
2013-08-14 17:45:06 +03:00
|
|
|
case 8:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR;
|
|
|
|
break;
|
2012-11-10 02:27:36 +03:00
|
|
|
case 10:
|
|
|
|
switch (revision) {
|
|
|
|
case -1:
|
|
|
|
case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;
|
|
|
|
case 3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
|
|
|
|
default:
|
2013-03-15 20:13:52 +03:00
|
|
|
avpriv_request_sample(s, "stream type; revision=%i, revision2=%i", revision, revision2);
|
2012-11-10 02:27:36 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2015-10-22 04:46:25 +02:00
|
|
|
case 15:
|
2013-08-14 17:45:06 +03:00
|
|
|
case 16:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_MP3;
|
|
|
|
break;
|
|
|
|
case -1:
|
|
|
|
break;
|
2007-11-25 18:32:47 +02:00
|
|
|
default:
|
2012-08-05 12:11:04 +03:00
|
|
|
ea->audio_codec = AV_CODEC_ID_NONE;
|
2013-03-15 20:13:52 +03:00
|
|
|
avpriv_request_sample(s, "stream type; revision2=%i", revision2);
|
2007-11-25 18:32:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-24 23:49:42 +03:00
|
|
|
break;
|
2007-10-19 01:53:37 +03:00
|
|
|
default:
|
2013-08-16 13:01:22 +03:00
|
|
|
avpriv_request_sample(s,
|
|
|
|
"stream type; compression_type=%i",
|
|
|
|
compression_type);
|
2007-10-19 01:53:37 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-19 01:23:30 +03:00
|
|
|
|
2015-10-21 22:59:08 +02:00
|
|
|
if (ea->audio_codec == AV_CODEC_ID_NONE && ea->platform == 0x01)
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_PSX;
|
2007-10-19 02:13:46 +03:00
|
|
|
if (ea->sample_rate == -1)
|
2013-08-14 17:45:06 +03:00
|
|
|
ea->sample_rate = revision == 3 ? 48000 : 22050;
|
2007-10-19 02:13:46 +03:00
|
|
|
|
2007-10-19 00:55:51 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-08-14 19:04:36 +03:00
|
|
|
static void process_audio_header_eacs(AVFormatContext *s)
|
2007-10-25 23:38:49 +03:00
|
|
|
{
|
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-10-25 23:38:49 +03:00
|
|
|
int compression_type;
|
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
ea->sample_rate = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
|
|
|
|
ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */
|
|
|
|
ea->num_channels = avio_r8(pb);
|
|
|
|
compression_type = avio_r8(pb);
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 13);
|
2007-10-25 23:38:49 +03:00
|
|
|
|
|
|
|
switch (compression_type) {
|
|
|
|
case 0:
|
|
|
|
switch (ea->bytes) {
|
2013-08-14 17:45:06 +03:00
|
|
|
case 1:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_PCM_S8;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
|
|
|
|
break;
|
2007-10-25 23:38:49 +03:00
|
|
|
}
|
|
|
|
break;
|
2013-08-14 17:45:06 +03:00
|
|
|
case 1:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_PCM_MULAW;
|
|
|
|
ea->bytes = 1;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS;
|
|
|
|
break;
|
2007-10-25 23:38:49 +03:00
|
|
|
default:
|
2013-08-16 13:01:22 +03:00
|
|
|
avpriv_request_sample(s,
|
|
|
|
"stream type; audio compression_type=%i",
|
|
|
|
compression_type);
|
2007-10-25 23:38:49 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-14 19:04:36 +03:00
|
|
|
static void process_audio_header_sead(AVFormatContext *s)
|
2007-10-31 01:12:18 +02:00
|
|
|
{
|
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-10-31 01:12:18 +02:00
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
ea->sample_rate = avio_rl32(pb);
|
|
|
|
ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */
|
|
|
|
ea->num_channels = avio_rl32(pb);
|
2012-08-05 12:11:04 +03:00
|
|
|
ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
|
2007-10-31 01:12:18 +02:00
|
|
|
}
|
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)
|
2008-08-10 04:58:46 +03:00
|
|
|
{
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 4);
|
2015-06-25 07:04:58 +02:00
|
|
|
video->width = avio_rl16(pb);
|
|
|
|
video->height = avio_rl16(pb);
|
|
|
|
video->time_base = (AVRational) { 1, 15 };
|
|
|
|
video->codec = AV_CODEC_ID_MDEC;
|
2008-08-10 04:58:46 +03:00
|
|
|
}
|
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
|
2007-10-19 01:01:30 +03:00
|
|
|
{
|
2015-06-25 07:04:58 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-10-19 01:01:30 +03:00
|
|
|
|
2012-03-22 02:17:05 +03:00
|
|
|
avio_skip(pb, 8);
|
2015-06-25 07:04:58 +02:00
|
|
|
video->nb_frames = avio_rl32(pb);
|
2012-03-22 02:17:05 +03:00
|
|
|
avio_skip(pb, 4);
|
2015-06-25 07:04:58 +02:00
|
|
|
video->time_base.den = avio_rl32(pb);
|
|
|
|
video->time_base.num = avio_rl32(pb);
|
|
|
|
if (video->time_base.den <= 0 || video->time_base.num <= 0) {
|
2013-03-28 03:08:24 +03:00
|
|
|
av_log(s, AV_LOG_ERROR, "Timebase is invalid\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2015-06-25 07:04:58 +02:00
|
|
|
video->codec = AV_CODEC_ID_VP6;
|
2007-10-19 01:01:30 +03:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)
|
2012-03-01 15:16:49 +03:00
|
|
|
{
|
|
|
|
int fps;
|
|
|
|
|
|
|
|
avio_skip(s->pb, 10);
|
|
|
|
fps = avio_rl16(s->pb);
|
|
|
|
if (fps)
|
2015-06-25 07:04:58 +02:00
|
|
|
video->time_base = (AVRational) { 1, fps };
|
|
|
|
video->codec = AV_CODEC_ID_CMV;
|
2012-03-01 15:16:49 +03:00
|
|
|
}
|
|
|
|
|
2013-08-14 17:53:08 +03:00
|
|
|
/* Process EA file header.
|
|
|
|
* Return 1 if the EA file is valid and successfully opened, 0 otherwise. */
|
2013-08-14 17:45:06 +03:00
|
|
|
static int process_ea_header(AVFormatContext *s)
|
|
|
|
{
|
2007-10-19 00:55:51 +03:00
|
|
|
uint32_t blockid, size = 0;
|
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-10-19 01:26:23 +03:00
|
|
|
int i;
|
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
for (i = 0; i < 5 && (!ea->audio_codec || !ea->video.codec); i++) {
|
2013-12-21 15:48:15 +03:00
|
|
|
uint64_t startpos = avio_tell(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
int err = 0;
|
2007-10-19 00:55:51 +03:00
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
blockid = avio_rl32(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
size = avio_rl32(pb);
|
2007-10-19 01:39:27 +03:00
|
|
|
if (i == 0)
|
2013-12-21 16:09:45 +03:00
|
|
|
ea->big_endian = size > av_bswap32(size);
|
2007-10-19 01:39:27 +03:00
|
|
|
if (ea->big_endian)
|
2010-07-11 01:12:30 +03:00
|
|
|
size = av_bswap32(size);
|
2007-10-19 01:26:23 +03:00
|
|
|
|
2013-11-11 21:51:12 +03:00
|
|
|
if (size < 8) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "chunk size too small\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2007-10-19 01:26:23 +03:00
|
|
|
switch (blockid) {
|
2013-08-14 17:45:06 +03:00
|
|
|
case ISNh_TAG:
|
|
|
|
if (avio_rl32(pb) != EACS_TAG) {
|
2013-08-16 13:01:22 +03:00
|
|
|
avpriv_request_sample(s, "unknown 1SNh headerid");
|
2013-08-14 17:45:06 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2013-08-14 19:04:36 +03:00
|
|
|
process_audio_header_eacs(s);
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2007-10-25 23:38:49 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case SCHl_TAG:
|
|
|
|
case SHEN_TAG:
|
|
|
|
blockid = avio_rl32(pb);
|
|
|
|
if (blockid == GSTR_TAG) {
|
|
|
|
avio_skip(pb, 4);
|
2015-10-21 22:59:08 +02:00
|
|
|
} else if ((blockid & 0xFF) != (PT00_TAG & 0xFF)) {
|
|
|
|
blockid = avio_rl32(pb);
|
2013-08-14 17:45:06 +03:00
|
|
|
}
|
2015-10-21 22:59:08 +02:00
|
|
|
ea->platform = (blockid >> 16) & 0xFF;
|
2013-08-14 17:45:06 +03:00
|
|
|
err = process_audio_header_elements(s);
|
|
|
|
break;
|
2007-10-19 01:26:23 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case SEAD_TAG:
|
2013-08-14 19:04:36 +03:00
|
|
|
process_audio_header_sead(s);
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2007-10-31 01:12:18 +02:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case MVIh_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
process_video_header_cmv(s, &ea->video);
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2008-07-08 16:24:13 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case kVGT_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.codec = AV_CODEC_ID_TGV;
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2008-08-06 11:34:35 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case mTCD_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
process_video_header_mdec(s, &ea->video);
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2008-08-10 04:58:46 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case MPCh_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.codec = AV_CODEC_ID_MPEG2VIDEO;
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2008-08-12 11:32:59 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case pQGT_TAG:
|
|
|
|
case TGQs_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.codec = AV_CODEC_ID_TGQ;
|
|
|
|
ea->video.time_base = (AVRational) { 1, 15 };
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2008-11-08 02:39:31 +02:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case pIQT_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.codec = AV_CODEC_ID_TQI;
|
|
|
|
ea->video.time_base = (AVRational) { 1, 15 };
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2009-02-05 10:59:38 +02:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case MADk_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.codec = AV_CODEC_ID_MAD;
|
2014-08-20 08:52:44 +03:00
|
|
|
avio_skip(pb, 6);
|
2015-06-25 07:04:58 +02:00
|
|
|
ea->video.time_base = (AVRational) { avio_rl16(pb), 1000 };
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2009-06-13 05:20:54 +03:00
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
case MVhd_TAG:
|
2015-06-25 07:04:58 +02:00
|
|
|
err = process_video_header_vp6(s, &ea->video);
|
2013-08-14 17:45:06 +03:00
|
|
|
break;
|
2015-06-25 07:05:07 +02:00
|
|
|
|
|
|
|
case AVhd_TAG:
|
|
|
|
err = process_video_header_vp6(s, &ea->alpha);
|
|
|
|
break;
|
2007-10-19 01:26:23 +03:00
|
|
|
}
|
|
|
|
|
2007-10-19 01:32:26 +03:00
|
|
|
if (err < 0) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "error parsing header: %i\n", err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(pb, startpos + size, SEEK_SET);
|
2007-10-19 01:26:23 +03:00
|
|
|
}
|
2007-10-19 00:55:51 +03:00
|
|
|
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(pb, 0, SEEK_SET);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-03-21 02:18:37 +02:00
|
|
|
static int ea_probe(const AVProbeData *p)
|
2004-10-16 22:33:57 +03:00
|
|
|
{
|
2013-11-11 21:53:22 +03:00
|
|
|
unsigned big_endian, size;
|
|
|
|
|
2007-10-23 00:06:04 +03:00
|
|
|
switch (AV_RL32(&p->buf[0])) {
|
2007-10-26 00:17:39 +03:00
|
|
|
case ISNh_TAG:
|
2007-10-23 00:06:04 +03:00
|
|
|
case SCHl_TAG:
|
2007-10-31 01:12:18 +02:00
|
|
|
case SEAD_TAG:
|
2008-08-12 15:36:00 +03:00
|
|
|
case SHEN_TAG:
|
2007-11-08 01:01:32 +02:00
|
|
|
case kVGT_TAG:
|
|
|
|
case MADk_TAG:
|
|
|
|
case MPCh_TAG:
|
2007-10-23 00:06:04 +03:00
|
|
|
case MVhd_TAG:
|
2007-11-08 01:01:32 +02:00
|
|
|
case MVIh_TAG:
|
2015-06-22 20:58:41 +02:00
|
|
|
case AVP6_TAG:
|
2009-09-17 21:07:27 +03:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
2007-10-23 00:06:04 +03:00
|
|
|
}
|
2013-11-11 21:53:22 +03:00
|
|
|
size = AV_RL32(&p->buf[4]);
|
|
|
|
big_endian = size > 0x000FFFFF;
|
|
|
|
if (big_endian)
|
|
|
|
size = av_bswap32(size);
|
|
|
|
if (size > 0xfffff || size < 8)
|
2009-09-17 21:07:27 +03:00
|
|
|
return 0;
|
2013-08-14 17:45:06 +03:00
|
|
|
|
2009-09-17 21:07:27 +03:00
|
|
|
return AVPROBE_SCORE_MAX;
|
2004-10-16 22:33:57 +03:00
|
|
|
}
|
|
|
|
|
2015-06-25 07:04:58 +02:00
|
|
|
static int init_video_stream(AVFormatContext *s, VideoProperties *video)
|
|
|
|
{
|
|
|
|
AVStream *st;
|
|
|
|
|
|
|
|
if (!video->codec)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* initialize the video decoder stream */
|
|
|
|
st = avformat_new_stream(s, NULL);
|
|
|
|
if (!st)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
video->stream_index = st->index;
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = video->codec;
|
2015-06-25 07:04:58 +02:00
|
|
|
// parsing is necessary to make FFmpeg generate correct timestamps
|
2016-04-10 21:58:15 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)
|
2015-06-25 07:04:58 +02:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_HEADERS;
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->codec_tag = 0; /* no fourcc */
|
|
|
|
st->codecpar->width = video->width;
|
|
|
|
st->codecpar->height = video->height;
|
2015-06-25 07:04:58 +02:00
|
|
|
st->duration = st->nb_frames = video->nb_frames;
|
|
|
|
if (video->time_base.num)
|
|
|
|
avpriv_set_pts_info(st, 64, video->time_base.num, video->time_base.den);
|
|
|
|
st->r_frame_rate =
|
|
|
|
st->avg_frame_rate = av_inv_q(video->time_base);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-12 15:20:36 +03:00
|
|
|
static int ea_read_header(AVFormatContext *s)
|
2004-10-16 22:33:57 +03:00
|
|
|
{
|
2007-04-08 23:24:16 +03:00
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2004-10-16 22:33:57 +03:00
|
|
|
AVStream *st;
|
|
|
|
|
2012-01-04 06:02:22 +03:00
|
|
|
if (process_ea_header(s)<=0)
|
2007-07-19 18:23:32 +03:00
|
|
|
return AVERROR(EIO);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2015-06-25 07:05:07 +02:00
|
|
|
if (init_video_stream(s, &ea->video) || init_video_stream(s, &ea->alpha))
|
2015-06-25 07:04:58 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2007-10-19 02:42:54 +03:00
|
|
|
if (ea->audio_codec) {
|
2013-09-28 23:38:40 +03:00
|
|
|
if (ea->num_channels <= 0 || ea->num_channels > 2) {
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_WARNING,
|
|
|
|
"Unsupported number of channels: %d\n", ea->num_channels);
|
2020-09-07 00:09:33 +02:00
|
|
|
goto no_audio;
|
2011-01-10 14:51:45 +02:00
|
|
|
}
|
|
|
|
if (ea->sample_rate <= 0) {
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Unsupported sample rate: %d\n", ea->sample_rate);
|
2020-09-07 00:09:33 +02:00
|
|
|
goto no_audio;
|
2011-01-10 14:51:45 +02:00
|
|
|
}
|
2016-12-15 03:14:37 +02:00
|
|
|
if (ea->bytes <= 0 || ea->bytes > 2) {
|
2013-08-14 17:45:06 +03:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Invalid number of bytes per sample: %d\n", ea->bytes);
|
2020-09-07 00:09:33 +02:00
|
|
|
goto no_audio;
|
2012-01-06 00:12:35 +03:00
|
|
|
}
|
2011-01-10 14:51:45 +02:00
|
|
|
|
2007-10-19 02:44:05 +03:00
|
|
|
/* initialize the audio decoder stream */
|
2011-06-18 12:43:24 +03:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2007-10-19 02:44:05 +03:00
|
|
|
if (!st)
|
|
|
|
return AVERROR(ENOMEM);
|
2011-11-29 21:28:15 +03:00
|
|
|
avpriv_set_pts_info(st, 33, 1, ea->sample_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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = ea->audio_codec;
|
|
|
|
st->codecpar->codec_tag = 0; /* no tag */
|
|
|
|
st->codecpar->channels = ea->num_channels;
|
|
|
|
st->codecpar->sample_rate = ea->sample_rate;
|
|
|
|
st->codecpar->bits_per_coded_sample = ea->bytes * 8;
|
2016-12-13 01:38:25 +02:00
|
|
|
st->codecpar->bit_rate = (int64_t)st->codecpar->channels *
|
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->sample_rate *
|
|
|
|
st->codecpar->bits_per_coded_sample / 4;
|
|
|
|
st->codecpar->block_align = st->codecpar->channels *
|
|
|
|
st->codecpar->bits_per_coded_sample;
|
2013-08-14 17:45:06 +03:00
|
|
|
ea->audio_stream_index = st->index;
|
|
|
|
st->start_time = 0;
|
2020-09-08 00:06:53 +02:00
|
|
|
return 0;
|
2007-10-19 02:42:54 +03:00
|
|
|
}
|
2020-09-07 00:09:33 +02:00
|
|
|
no_audio:
|
|
|
|
ea->audio_codec = AV_CODEC_ID_NONE;
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2020-09-07 00:09:33 +02:00
|
|
|
if (!ea->video.codec)
|
|
|
|
return AVERROR_INVALIDDATA;
|
2020-09-08 00:06:53 +02:00
|
|
|
return 0;
|
2004-10-16 22:33:57 +03:00
|
|
|
}
|
|
|
|
|
2013-08-14 17:45:06 +03:00
|
|
|
static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
|
2004-10-16 22:33:57 +03:00
|
|
|
{
|
|
|
|
EaDemuxContext *ea = s->priv_data;
|
2013-08-14 17:45:06 +03:00
|
|
|
AVIOContext *pb = s->pb;
|
2012-01-22 15:17:53 +03:00
|
|
|
int partial_packet = 0;
|
2019-09-30 23:42:41 +02:00
|
|
|
int hit_end = 0;
|
2004-10-16 22:33:57 +03:00
|
|
|
unsigned int chunk_type, chunk_size;
|
2013-08-14 17:45:06 +03:00
|
|
|
int ret = 0, packet_read = 0, key = 0;
|
2009-02-11 17:01:52 +02:00
|
|
|
int av_uninit(num_samples);
|
2004-10-16 22:33:57 +03:00
|
|
|
|
2019-09-30 23:42:41 +02:00
|
|
|
while ((!packet_read && !hit_end) || partial_packet) {
|
2011-02-21 17:43:01 +02:00
|
|
|
chunk_type = avio_rl32(pb);
|
2012-05-05 02:06:26 +03:00
|
|
|
chunk_size = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
|
2014-08-20 08:40:53 +03:00
|
|
|
if (chunk_size < 8)
|
2012-05-05 02:06:26 +03:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
chunk_size -= 8;
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
switch (chunk_type) {
|
|
|
|
/* audio data */
|
2007-10-26 00:10:18 +03:00
|
|
|
case ISNh_TAG:
|
2013-08-14 17:45:06 +03:00
|
|
|
/* header chunk also contains data; skip over the header portion */
|
2012-05-05 02:06:26 +03:00
|
|
|
if (chunk_size < 32)
|
|
|
|
return AVERROR_INVALIDDATA;
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 32);
|
2007-10-25 23:38:49 +03:00
|
|
|
chunk_size -= 32;
|
2007-10-26 00:10:18 +03:00
|
|
|
case ISNd_TAG:
|
2004-10-16 22:33:57 +03:00
|
|
|
case SCDl_TAG:
|
2007-10-31 01:12:18 +02:00
|
|
|
case SNDC_TAG:
|
2008-08-12 15:36:00 +03:00
|
|
|
case SDEN_TAG:
|
2007-10-19 02:50:52 +03:00
|
|
|
if (!ea->audio_codec) {
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, chunk_size);
|
2007-10-19 02:50:52 +03:00
|
|
|
break;
|
2012-08-05 12:11:04 +03:00
|
|
|
} else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR ||
|
|
|
|
ea->audio_codec == AV_CODEC_ID_MP3) {
|
2011-02-21 17:43:01 +02:00
|
|
|
num_samples = avio_rl32(pb);
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 8);
|
2007-11-25 18:32:47 +02:00
|
|
|
chunk_size -= 12;
|
2015-10-21 22:59:08 +02:00
|
|
|
} else if (ea->audio_codec == AV_CODEC_ID_ADPCM_PSX) {
|
|
|
|
avio_skip(pb, 8);
|
|
|
|
chunk_size -= 8;
|
2007-10-19 02:50:52 +03:00
|
|
|
}
|
2014-08-22 20:01:26 +03:00
|
|
|
|
2012-01-22 15:17:53 +03:00
|
|
|
if (partial_packet) {
|
2013-03-15 20:13:52 +03:00
|
|
|
avpriv_request_sample(s, "video header followed by audio packet");
|
2015-10-27 15:35:30 +02:00
|
|
|
av_packet_unref(pkt);
|
2012-01-22 15:17:53 +03:00
|
|
|
partial_packet = 0;
|
|
|
|
}
|
2014-08-22 20:01:26 +03:00
|
|
|
|
2014-08-20 08:40:53 +03:00
|
|
|
if (!chunk_size)
|
|
|
|
continue;
|
|
|
|
|
2005-05-26 23:17:12 +03:00
|
|
|
ret = av_get_packet(pb, pkt, chunk_size);
|
2009-04-11 13:38:56 +03:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2009-04-11 13:41:06 +03:00
|
|
|
pkt->stream_index = ea->audio_stream_index;
|
|
|
|
|
|
|
|
switch (ea->audio_codec) {
|
2012-08-05 12:11:04 +03:00
|
|
|
case AV_CODEC_ID_ADPCM_EA:
|
|
|
|
case AV_CODEC_ID_ADPCM_EA_R1:
|
|
|
|
case AV_CODEC_ID_ADPCM_EA_R2:
|
|
|
|
case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
|
|
|
|
case AV_CODEC_ID_ADPCM_EA_R3:
|
2013-09-20 12:26:45 +03:00
|
|
|
if (pkt->size < 4) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Packet is too short\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3)
|
2012-11-17 21:56:26 +03:00
|
|
|
pkt->duration = AV_RB32(pkt->data);
|
2013-09-20 12:26:45 +03:00
|
|
|
else
|
|
|
|
pkt->duration = AV_RL32(pkt->data);
|
2012-01-11 18:22:47 +03:00
|
|
|
break;
|
2012-08-05 12:11:04 +03:00
|
|
|
case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
|
2012-01-11 18:22:47 +03:00
|
|
|
pkt->duration = ret * 2 / ea->num_channels;
|
2009-04-11 13:41:06 +03:00
|
|
|
break;
|
2012-08-05 12:11:04 +03:00
|
|
|
case AV_CODEC_ID_PCM_S16LE_PLANAR:
|
|
|
|
case AV_CODEC_ID_MP3:
|
2012-01-11 18:22:47 +03:00
|
|
|
pkt->duration = num_samples;
|
2009-04-11 13:41:06 +03:00
|
|
|
break;
|
2015-10-21 22:59:08 +02:00
|
|
|
case AV_CODEC_ID_ADPCM_PSX:
|
|
|
|
pkt->duration = chunk_size / (16 * ea->num_channels) * 28;
|
|
|
|
break;
|
2009-04-11 13:41:06 +03:00
|
|
|
default:
|
2012-01-11 18:22:47 +03:00
|
|
|
pkt->duration = chunk_size / (ea->bytes * ea->num_channels);
|
2009-04-11 13:41:06 +03:00
|
|
|
}
|
2004-10-16 22:33:57 +03:00
|
|
|
|
|
|
|
packet_read = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* ending tag */
|
2007-10-25 00:44:20 +03:00
|
|
|
case 0:
|
2007-10-26 00:10:18 +03:00
|
|
|
case ISNe_TAG:
|
2004-10-16 22:33:57 +03:00
|
|
|
case SCEl_TAG:
|
2007-10-31 01:12:18 +02:00
|
|
|
case SEND_TAG:
|
2008-08-12 15:36:00 +03:00
|
|
|
case SEEN_TAG:
|
2015-10-22 10:35:09 +02:00
|
|
|
while (!avio_feof(pb)) {
|
|
|
|
int tag = avio_rl32(pb);
|
|
|
|
|
|
|
|
if (tag == ISNh_TAG ||
|
|
|
|
tag == SCHl_TAG ||
|
|
|
|
tag == SEAD_TAG ||
|
|
|
|
tag == SHEN_TAG) {
|
|
|
|
avio_skip(pb, -4);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (avio_feof(pb))
|
|
|
|
ret = AVERROR_EOF;
|
2019-09-30 23:42:41 +02:00
|
|
|
hit_end = 1;
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
|
2008-07-08 16:24:13 +03:00
|
|
|
case MVIh_TAG:
|
2008-08-06 11:34:35 +03:00
|
|
|
case kVGT_TAG:
|
2008-11-08 02:39:31 +02:00
|
|
|
case pQGT_TAG:
|
|
|
|
case TGQs_TAG:
|
2009-06-13 05:20:54 +03:00
|
|
|
case MADk_TAG:
|
2010-03-31 15:29:58 +03:00
|
|
|
key = AV_PKT_FLAG_KEY;
|
2008-07-08 16:24:13 +03:00
|
|
|
case MVIf_TAG:
|
2008-08-06 11:34:35 +03:00
|
|
|
case fVGT_TAG:
|
2009-06-13 05:20:54 +03:00
|
|
|
case MADm_TAG:
|
|
|
|
case MADe_TAG:
|
2013-08-14 17:45:06 +03:00
|
|
|
avio_seek(pb, -8, SEEK_CUR); // include chunk preamble
|
2008-07-08 16:24:13 +03:00
|
|
|
chunk_size += 8;
|
|
|
|
goto get_video_packet;
|
|
|
|
|
2008-08-10 04:58:46 +03:00
|
|
|
case mTCD_TAG:
|
2014-08-20 08:40:53 +03:00
|
|
|
if (chunk_size < 8)
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
2013-08-14 17:53:08 +03:00
|
|
|
avio_skip(pb, 8); // skip ea DCT header
|
2008-08-10 04:58:46 +03:00
|
|
|
chunk_size -= 8;
|
|
|
|
goto get_video_packet;
|
|
|
|
|
2007-10-16 01:51:52 +03:00
|
|
|
case MV0K_TAG:
|
2015-06-25 07:05:07 +02:00
|
|
|
case AV0K_TAG:
|
2008-08-12 11:32:59 +03:00
|
|
|
case MPCh_TAG:
|
2009-02-05 10:59:38 +02:00
|
|
|
case pIQT_TAG:
|
2010-03-31 15:29:58 +03:00
|
|
|
key = AV_PKT_FLAG_KEY;
|
2007-10-16 01:51:52 +03:00
|
|
|
case MV0F_TAG:
|
2015-06-25 07:05:07 +02:00
|
|
|
case AV0F_TAG:
|
2008-07-08 16:24:13 +03:00
|
|
|
get_video_packet:
|
2014-08-20 08:40:53 +03:00
|
|
|
if (!chunk_size)
|
|
|
|
continue;
|
|
|
|
|
2012-01-22 15:17:53 +03:00
|
|
|
if (partial_packet) {
|
|
|
|
ret = av_append_packet(pb, pkt, chunk_size);
|
|
|
|
} else
|
|
|
|
ret = av_get_packet(pb, pkt, chunk_size);
|
|
|
|
if (ret < 0) {
|
|
|
|
packet_read = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
partial_packet = chunk_type == MVIh_TAG;
|
2015-06-25 07:05:07 +02:00
|
|
|
if (chunk_type == AV0K_TAG || chunk_type == AV0F_TAG)
|
|
|
|
pkt->stream_index = ea->alpha.stream_index;
|
|
|
|
else
|
|
|
|
pkt->stream_index = ea->video.stream_index;
|
2013-08-14 17:45:06 +03:00
|
|
|
pkt->flags |= key;
|
|
|
|
packet_read = 1;
|
2007-10-16 01:51:52 +03:00
|
|
|
break;
|
|
|
|
|
2004-10-16 22:33:57 +03:00
|
|
|
default:
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, chunk_size);
|
2004-10-16 22:33:57 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-30 23:42:41 +02:00
|
|
|
if (ret >= 0 && hit_end && !packet_read)
|
|
|
|
return AVERROR(EAGAIN);
|
|
|
|
|
2004-10-16 22:33:57 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-01-26 00:03:28 +02:00
|
|
|
AVInputFormat ff_ea_demuxer = {
|
2011-07-16 23:18:12 +03:00
|
|
|
.name = "ea",
|
2012-07-25 00:51:41 +03:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),
|
2011-07-16 23:18:12 +03:00
|
|
|
.priv_data_size = sizeof(EaDemuxContext),
|
|
|
|
.read_probe = ea_probe,
|
|
|
|
.read_header = ea_read_header,
|
|
|
|
.read_packet = ea_read_packet,
|
2004-10-16 22:33:57 +03:00
|
|
|
};
|