FFmpeg: libavformat/wc3movie.c Source File

FFmpeg

[フレーム]

libavformat

wc3movie.c

Go to the documentation of this file.

1 /*

2 * Wing Commander III Movie (.mve) File Demuxer

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Wing Commander III Movie file demuxer

25 * by Mike Melanson (melanson@pcisys.net)

26 * for more information on the WC3 .mve file format, visit:

27 * http://www.pcisys.net/~melanson/codecs/

28 */

30 #include "libavutil/avstring.h"

31 #include "libavutil/channel_layout.h"

32 #include "libavutil/intreadwrite.h"

33 #include "libavutil/dict.h"

34 #include "libavutil/mem.h"

35 #include "avformat.h"

36 #include "demux.h"

37 #include "internal.h"

39 #define FORM_TAG MKTAG('F', 'O', 'R', 'M')

40 #define MOVE_TAG MKTAG('M', 'O', 'V', 'E')

41 #define PC__TAG MKTAG('_', 'P', 'C', '_')

42 #define SOND_TAG MKTAG('S', 'O', 'N', 'D')

43 #define BNAM_TAG MKTAG('B', 'N', 'A', 'M')

44 #define SIZE_TAG MKTAG('S', 'I', 'Z', 'E')

45 #define PALT_TAG MKTAG('P', 'A', 'L', 'T')

46 #define INDX_TAG MKTAG('I', 'N', 'D', 'X')

47 #define BRCH_TAG MKTAG('B', 'R', 'C', 'H')

48 #define SHOT_TAG MKTAG('S', 'H', 'O', 'T')

49 #define VGA__TAG MKTAG('V', 'G', 'A', ' ')

50 #define TEXT_TAG MKTAG('T', 'E', 'X', 'T')

51 #define AUDI_TAG MKTAG('A', 'U', 'D', 'I')

53 /* video resolution unless otherwise specified */

54 #define WC3_DEFAULT_WIDTH 320

55 #define WC3_DEFAULT_HEIGHT 165

57 /* always use the same PCM audio parameters */

58 #define WC3_SAMPLE_RATE 22050

59 #define WC3_AUDIO_BITS 16

61 /* nice, constant framerate */

62 #define WC3_FRAME_FPS 15

64 #define PALETTE_SIZE (256 * 3)

66 typedef struct Wc3DemuxContext {

67 int width;

68 int height;

69 int64_t pts;

70 int video_stream_index;

71 int audio_stream_index;

73 AVPacket *vpkt;

75 } Wc3DemuxContext;

77 static int wc3_read_close(AVFormatContext *s)

78 {

79 Wc3DemuxContext *wc3 = s->priv_data;

81 av_packet_free(&wc3->vpkt);

83 return 0;

84 }

86 static int wc3_probe(const AVProbeData *p)

87 {

88 if (p->buf_size < 12)

89 return 0;

91 if ((AV_RL32(&p->buf[0]) != FORM_TAG) ||

92 (AV_RL32(&p->buf[8]) != MOVE_TAG))

93 return 0;

95 return AVPROBE_SCORE_MAX;

96 }

98 static int wc3_read_header(AVFormatContext *s)

99 {

100 Wc3DemuxContext *wc3 = s->priv_data;

101 AVIOContext *pb = s->pb;

102 unsigned int fourcc_tag;

103 unsigned int size;

104 AVStream *st;

105 int ret = 0;

106 char *buffer;

107

108 /* default context members */

109 wc3->width = WC3_DEFAULT_WIDTH;

110 wc3->height = WC3_DEFAULT_HEIGHT;

111 wc3->pts = 0;

112 wc3->video_stream_index = wc3->audio_stream_index = 0;

113 wc3->vpkt = av_packet_alloc();

114 if (!wc3->vpkt)

115 return AVERROR(ENOMEM);

116

117 /* skip the first 3 32-bit numbers */

118 avio_skip(pb, 12);

119

120 /* traverse through the chunks and load the header information before

121 * the first BRCH tag */

122 fourcc_tag = avio_rl32(pb);

123 size = (avio_rb32(pb) + 1) & (~1);

124

125 do {

126 switch (fourcc_tag) {

127

128 case SOND_TAG:

129 case INDX_TAG:

130 /* SOND unknown, INDX unnecessary; ignore both */

131 avio_skip(pb, size);

132 break;

133

134 case PC__TAG:

135 /* number of palettes, unneeded */

136 avio_skip(pb, 12);

137 break;

138

139 case BNAM_TAG:

140 /* load up the name */

141 buffer = av_malloc(size+1);

142 if (!buffer)

143 return AVERROR(ENOMEM);

144 if ((ret = avio_read(pb, buffer, size)) != size) {

145 av_freep(&buffer);

146 return AVERROR(EIO);

147 }

148 buffer[size] = 0;

149 av_dict_set(&s->metadata, "title", buffer,

150 AV_DICT_DONT_STRDUP_VAL);

151 break;

152

153 case SIZE_TAG:

154 /* video resolution override */

155 wc3->width = avio_rl32(pb);

156 wc3->height = avio_rl32(pb);

157 break;

158

159 case PALT_TAG:

160 /* one of several palettes */

161 avio_seek(pb, -8, SEEK_CUR);

162 av_append_packet(pb, wc3->vpkt, 8 + PALETTE_SIZE);

163 break;

164

165 default:

166 av_log(s, AV_LOG_ERROR, "unrecognized WC3 chunk: %s\n",

167 av_fourcc2str(fourcc_tag));

168 return AVERROR_INVALIDDATA;

169 }

170

171 fourcc_tag = avio_rl32(pb);

172 /* chunk sizes are 16-bit aligned */

173 size = (avio_rb32(pb) + 1) & (~1);

174 if (avio_feof(pb))

175 return AVERROR(EIO);

176

177 } while (fourcc_tag != BRCH_TAG);

178

179 /* initialize the decoder streams */

180 st = avformat_new_stream(s, NULL);

181 if (!st)

182 return AVERROR(ENOMEM);

183 avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);

184 wc3->video_stream_index = st->index;

185 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

186 st->codecpar->codec_id = AV_CODEC_ID_XAN_WC3;

187 st->codecpar->codec_tag = 0; /* no fourcc */

188 st->codecpar->width = wc3->width;

189 st->codecpar->height = wc3->height;

190

191 st = avformat_new_stream(s, NULL);

192 if (!st)

193 return AVERROR(ENOMEM);

194 avpriv_set_pts_info(st, 33, 1, WC3_FRAME_FPS);

195 wc3->audio_stream_index = st->index;

196 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

197 st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;

198 st->codecpar->codec_tag = 1;

199 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

200 st->codecpar->bits_per_coded_sample = WC3_AUDIO_BITS;

201 st->codecpar->sample_rate = WC3_SAMPLE_RATE;

202 st->codecpar->bit_rate = st->codecpar->ch_layout.nb_channels * st->codecpar->sample_rate *

203 st->codecpar->bits_per_coded_sample;

204 st->codecpar->block_align = WC3_AUDIO_BITS * st->codecpar->ch_layout.nb_channels;

205

206 return 0;

207 }

208

209 static int wc3_read_packet(AVFormatContext *s,

210 AVPacket *pkt)

211 {

212 Wc3DemuxContext *wc3 = s->priv_data;

213 AVIOContext *pb = s->pb;

214 unsigned int fourcc_tag;

215 unsigned int size;

216 int packet_read = 0;

217 int ret = 0;

218 unsigned char text[1024];

219

220 while (!packet_read) {

221

222 fourcc_tag = avio_rl32(pb);

223 /* chunk sizes are 16-bit aligned */

224 size = (avio_rb32(pb) + 1) & (~1);

225 if (avio_feof(pb))

226 return AVERROR(EIO);

227

228 switch (fourcc_tag) {

229

230 case BRCH_TAG:

231 /* no-op */

232 break;

233

234 case SHOT_TAG:

235 /* load up new palette */

236 avio_seek(pb, -8, SEEK_CUR);

237 av_append_packet(pb, wc3->vpkt, 8 + 4);

238 break;

239

240 case VGA__TAG:

241 /* send out video chunk */

242 avio_seek(pb, -8, SEEK_CUR);

243 ret= av_append_packet(pb, wc3->vpkt, 8 + size);

244 // ignore error if we have some data

245 if (wc3->vpkt->size > 0)

246 ret = 0;

247 av_packet_move_ref(pkt, wc3->vpkt);

248 pkt->stream_index = wc3->video_stream_index;

249 pkt->pts = wc3->pts;

250 packet_read = 1;

251 break;

252

253 case TEXT_TAG:

254 /* subtitle chunk */

255 if ((unsigned)size > sizeof(text) || (ret = avio_read(pb, text, size)) != size)

256 ret = AVERROR(EIO);

257 else {

258 int i = 0;

259 av_log (s, AV_LOG_DEBUG, "Subtitle time!\n");

260 if (i >= size || av_strnlen(&text[i + 1], size - i - 1) >= size - i - 1)

261 return AVERROR_INVALIDDATA;

262 av_log (s, AV_LOG_DEBUG, " inglish: %s\n", &text[i + 1]);

263 i += text[i] + 1;

264 if (i >= size || av_strnlen(&text[i + 1], size - i - 1) >= size - i - 1)

265 return AVERROR_INVALIDDATA;

266 av_log (s, AV_LOG_DEBUG, " doytsch: %s\n", &text[i + 1]);

267 i += text[i] + 1;

268 if (i >= size || av_strnlen(&text[i + 1], size - i - 1) >= size - i - 1)

269 return AVERROR_INVALIDDATA;

270 av_log (s, AV_LOG_DEBUG, " fronsay: %s\n", &text[i + 1]);

271 }

272 break;

273

274 case AUDI_TAG:

275 /* send out audio chunk */

276 ret= av_get_packet(pb, pkt, size);

277 pkt->stream_index = wc3->audio_stream_index;

278 pkt->pts = wc3->pts;

279

280 /* time to advance pts */

281 wc3->pts++;

282

283 packet_read = 1;

284 break;

285

286 default:

287 av_log(s, AV_LOG_ERROR, "unrecognized WC3 chunk: %s\n",

288 av_fourcc2str(fourcc_tag));

289 ret = AVERROR_INVALIDDATA;

290 packet_read = 1;

291 break;

292 }

293 }

294

295 return ret;

296 }

297

298 const FFInputFormat ff_wc3_demuxer = {

299 .p.name = "wc3movie",

300 .p.long_name = NULL_IF_CONFIG_SMALL("Wing Commander III movie"),

301 .priv_data_size = sizeof(Wc3DemuxContext),

302 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

303 .read_probe = wc3_probe,

304 .read_header = wc3_read_header,

305 .read_packet = wc3_read_packet,

306 .read_close = wc3_read_close,

307 };

Wc3DemuxContext::audio_stream_index

int audio_stream_index

Definition: wc3movie.c:71

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:328

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

int64_t

long long int64_t

Definition: coverity.c:34

ff_wc3_demuxer

const FFInputFormat ff_wc3_demuxer

Definition: wc3movie.c:298

AVCodecParameters::codec_tag

uint32_t codec_tag

Additional information about the codec (corresponds to the AVI FOURCC).

Definition: codec_par.h:59

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:454

FORM_TAG

#define FORM_TAG

Definition: wc3movie.c:39

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

av_packet_free

void av_packet_free(AVPacket **pkt)

Free the packet, if the packet is reference counted, it will be unreferenced first.

Definition: packet.c:74

PC__TAG

#define PC__TAG

Definition: wc3movie.c:41

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

Wc3DemuxContext::pts

int64_t pts

Definition: wc3movie.c:69

Wc3DemuxContext

Definition: wc3movie.c:66

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:463

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:860

WC3_SAMPLE_RATE

#define WC3_SAMPLE_RATE

Definition: wc3movie.c:58

AUDI_TAG

#define AUDI_TAG

Definition: wc3movie.c:51

wc3_read_header

static int wc3_read_header(AVFormatContext *s)

Definition: wc3movie.c:98

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

AV_DICT_DONT_STRDUP_VAL

#define AV_DICT_DONT_STRDUP_VAL

Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...

Definition: dict.h:79

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:761

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:42

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

TEXT_TAG

#define TEXT_TAG

Definition: wc3movie.c:50

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:453

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:134

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

FF_INFMT_FLAG_INIT_CLEANUP

#define FF_INFMT_FLAG_INIT_CLEANUP

For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...

Definition: demux.h:35

AVFormatContext

Format I/O context.

Definition: avformat.h:1287

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:771

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:535

SOND_TAG

#define SOND_TAG

Definition: wc3movie.c:42

NULL

#define NULL

Definition: coverity.c:32

av_strnlen

size_t static size_t av_strnlen(const char *s, size_t len)

Get the count of continuous non zero chars starting from the beginning.

Definition: avstring.h:141

VGA__TAG

#define VGA__TAG

Definition: wc3movie.c:49

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

MOVE_TAG

#define MOVE_TAG

Definition: wc3movie.c:40

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

av_packet_move_ref

void av_packet_move_ref(AVPacket *dst, AVPacket *src)

Move every field in src to dst and reset src.

Definition: packet.c:486

WC3_DEFAULT_HEIGHT

#define WC3_DEFAULT_HEIGHT

Definition: wc3movie.c:55

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

BRCH_TAG

#define BRCH_TAG

Definition: wc3movie.c:47

SHOT_TAG

#define SHOT_TAG

Definition: wc3movie.c:48

BNAM_TAG

#define BNAM_TAG

Definition: wc3movie.c:43

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:730

Wc3DemuxContext::vpkt

AVPacket * vpkt

Definition: wc3movie.c:73

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

AVPacket::size

int size

Definition: packet.h:540

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:311

size

int size

Definition: twinvq_data.h:10344

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:41

av_packet_alloc

AVPacket * av_packet_alloc(void)

Allocate an AVPacket and set its fields to default values.

Definition: packet.c:63

WC3_AUDIO_BITS

#define WC3_AUDIO_BITS

Definition: wc3movie.c:59

AV_CODEC_ID_XAN_WC3

@ AV_CODEC_ID_XAN_WC3

Definition: codec_id.h:92

wc3_probe

static int wc3_probe(const AVProbeData *p)

Definition: wc3movie.c:86

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:532

AVCodecParameters::height

int height

Definition: codec_par.h:135

AVCodecParameters::block_align

int block_align

Audio only.

Definition: codec_par.h:191

wc3_read_packet

static int wc3_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: wc3movie.c:209

demux.h

wc3_read_close

static int wc3_read_close(AVFormatContext *s)

Definition: wc3movie.c:77

Wc3DemuxContext::width

int width

Definition: wc3movie.c:67

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:91

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:748

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:231

av_append_packet

int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)

Read data and append it to the current content of the AVPacket.

Definition: utils.c:107

avformat.h

dict.h

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:754

channel_layout.h

PALETTE_SIZE

#define PALETTE_SIZE

Definition: wc3movie.c:64

SIZE_TAG

#define SIZE_TAG

Definition: wc3movie.c:44

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:612

AVPacket::stream_index

int stream_index

Definition: packet.h:541

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:318