FFmpeg
flic.c
Go to the documentation of this file.
1 /*
2  * FLI/FLC Animation File Demuxer
3  * Copyright (c) 2003 The FFmpeg project
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  */
21 
22 /**
23  * @file
24  * FLI/FLC file demuxer
25  * by Mike Melanson (melanson@pcisys.net)
26  * for more information on the .fli/.flc file format and all of its many
27  * variations, visit:
28  * http://www.compuphase.com/flic.htm
29  *
30  * This demuxer handles standard 0xAF11- and 0xAF12-type FLIs. It also handles
31  * special FLIs from the PC games "Magic Carpet" and "X-COM: Terror from the Deep".
32  */
33 
35 #include "libavutil/intreadwrite.h"
36 #include "avformat.h"
37 #include "internal.h"
38 
39 #define FLIC_FILE_MAGIC_1 0xAF11
40 #define FLIC_FILE_MAGIC_2 0xAF12
41 #define FLIC_FILE_MAGIC_3 0xAF44 /* Flic Type for Extended FLX Format which
42  originated in Dave's Targa Animator (DTA) */
43 #define FLIC_CHUNK_MAGIC_1 0xF1FA
44 #define FLIC_CHUNK_MAGIC_2 0xF5FA
45 #define FLIC_MC_SPEED 5 /* speed for Magic Carpet game FLIs */
46 #define FLIC_DEFAULT_SPEED 5 /* for FLIs that have 0 speed */
47 #define FLIC_TFTD_CHUNK_AUDIO 0xAAAA /* Audio chunk. Used in Terror from the Deep.
48  Has 10 B extra header not accounted for in the chunk header */
49 #define FLIC_TFTD_SAMPLE_RATE 22050
50 
51 #define FLIC_HEADER_SIZE 128
52 #define FLIC_PREAMBLE_SIZE 6
53 
54 typedef struct FlicDemuxContext {
57  int frame_number;
59 
60 static int flic_probe(const AVProbeData *p)
61 {
62  int magic_number;
63 
64  if(p->buf_size < FLIC_HEADER_SIZE)
65  return 0;
66 
67  magic_number = AV_RL16(&p->buf[4]);
68  if ((magic_number != FLIC_FILE_MAGIC_1) &&
69  (magic_number != FLIC_FILE_MAGIC_2) &&
70  (magic_number != FLIC_FILE_MAGIC_3))
71  return 0;
72 
73  if(AV_RL16(&p->buf[0x10]) != FLIC_CHUNK_MAGIC_1){
74  if(AV_RL32(&p->buf[0x10]) > 2000)
75  return 0;
76  }
77 
78  if( AV_RL16(&p->buf[0x08]) > 4096
79  || AV_RL16(&p->buf[0x0A]) > 4096)
80  return 0;
81 
82 
83  return AVPROBE_SCORE_MAX - 1;
84 }
85 
87 {
88  FlicDemuxContext *flic = s->priv_data;
89  AVIOContext *pb = s->pb;
90  unsigned char header[FLIC_HEADER_SIZE];
91  AVStream *st, *ast;
92  int speed, ret;
93  int magic_number;
94  unsigned char preamble[FLIC_PREAMBLE_SIZE];
95 
96  flic->frame_number = 0;
97 
98  /* load the whole header and pull out the width and height */
100  return AVERROR(EIO);
101 
102  magic_number = AV_RL16(&header[4]);
103  speed = AV_RL32(&header[0x10]);
104  if (speed == 0)
105  speed = FLIC_DEFAULT_SPEED;
106 
107  /* initialize the decoder streams */
108  st = avformat_new_stream(s, NULL);
109  if (!st)
110  return AVERROR(ENOMEM);
111  flic->video_stream_index = st->index;
114  st->codecpar->codec_tag = 0; /* no fourcc */
115  st->codecpar->width = AV_RL16(&header[0x08]);
116  st->codecpar->height = AV_RL16(&header[0x0A]);
117 
118  if (!st->codecpar->width || !st->codecpar->height) {
119  /* Ugly hack needed for the following sample: */
120  /* http://samples.mplayerhq.hu/fli-flc/fli-bugs/specular.flc */
122  "File with no specified width/height. Trying 640x480.\n");
123  st->codecpar->width = 640;
124  st->codecpar->height = 480;
125  }
126 
127  /* send over the whole 128-byte FLIC header */
129  return ret;
130  memcpy(st->codecpar->extradata, header, FLIC_HEADER_SIZE);
131 
132  /* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
133  if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {
134  av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n");
135  return AVERROR(EIO);
136  }
137 
138  avio_seek(pb, -FLIC_PREAMBLE_SIZE, SEEK_CUR);
139 
140  /* Time to figure out the framerate:
141  * If the first preamble's magic number is 0xAAAA then this file is from
142  * X-COM: Terror from the Deep. If on the other hand there is a FLIC chunk
143  * magic number at offset 0x10 assume this file is from Magic Carpet instead.
144  * If neither of the above is true then this is a normal FLIC file.
145  */
146  if (AV_RL16(&preamble[4]) == FLIC_TFTD_CHUNK_AUDIO) {
147  /* TFTD videos have an extra 22050 Hz 8-bit mono audio stream */
148  ast = avformat_new_stream(s, NULL);
149  if (!ast)
150  return AVERROR(ENOMEM);
151 
152  flic->audio_stream_index = ast->index;
153 
154  /* all audio frames are the same size, so use the size of the first chunk for block_align */
155  ast->codecpar->block_align = AV_RL32(&preamble[0]);
158  ast->codecpar->codec_tag = 0;
160  ast->codecpar->channels = 1;
161  ast->codecpar->bit_rate = st->codecpar->sample_rate * 8;
164  ast->codecpar->extradata_size = 0;
165 
166  /* Since the header information is incorrect we have to figure out the
167  * framerate using block_align and the fact that the audio is 22050 Hz.
168  * We usually have two cases: 2205 -> 10 fps and 1470 -> 15 fps */
171  } else if (AV_RL16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) {
172  avpriv_set_pts_info(st, 64, FLIC_MC_SPEED, 70);
173 
174  /* rewind the stream since the first chunk is at offset 12 */
175  avio_seek(pb, 12, SEEK_SET);
176 
177  /* send over abbreviated FLIC header chunk */
178  if ((ret = ff_alloc_extradata(st->codecpar, 12)) < 0)
179  return ret;
180  memcpy(st->codecpar->extradata, header, 12);
181 
182  } else if (magic_number == FLIC_FILE_MAGIC_1) {
183  avpriv_set_pts_info(st, 64, speed, 70);
184  } else if ((magic_number == FLIC_FILE_MAGIC_2) ||
185  (magic_number == FLIC_FILE_MAGIC_3)) {
186  avpriv_set_pts_info(st, 64, speed, 1000);
187  } else {
188  av_log(s, AV_LOG_ERROR, "Invalid or unsupported magic chunk in file\n");
189  return AVERROR_INVALIDDATA;
190  }
191 
192  return 0;
193 }
194 
196  AVPacket *pkt)
197 {
198  FlicDemuxContext *flic = s->priv_data;
199  AVIOContext *pb = s->pb;
200  int packet_read = 0;
201  unsigned int size;
202  int magic;
203  int ret = 0;
204  unsigned char preamble[FLIC_PREAMBLE_SIZE];
205  int64_t pos = avio_tell(pb);
206 
207  while (!packet_read && !avio_feof(pb)) {
208 
209  if ((ret = avio_read(pb, preamble, FLIC_PREAMBLE_SIZE)) !=
211  ret = AVERROR(EIO);
212  break;
213  }
214 
215  size = AV_RL32(&preamble[0]);
216  magic = AV_RL16(&preamble[4]);
217 
218  if (((magic == FLIC_CHUNK_MAGIC_1) || (magic == FLIC_CHUNK_MAGIC_2)) && size > FLIC_PREAMBLE_SIZE) {
219  if ((ret = av_new_packet(pkt, size)) < 0)
220  return ret;
221 
223  pkt->pos = pos;
224  memcpy(pkt->data, preamble, FLIC_PREAMBLE_SIZE);
227  if (ret != size - FLIC_PREAMBLE_SIZE) {
228  ret = AVERROR(EIO);
229  }
230  pkt->flags = flic->frame_number == 0 ? AV_PKT_FLAG_KEY : 0;
231  pkt->pts = flic->frame_number;
232  if (flic->frame_number == 0)
234  packet_read = 1;
235  flic->frame_number++;
236  } else if (magic == FLIC_TFTD_CHUNK_AUDIO) {
237  if ((ret = av_new_packet(pkt, size)) < 0)
238  return ret;
239 
240  /* skip useless 10B sub-header (yes, it's not accounted for in the chunk header) */
241  avio_skip(pb, 10);
242 
244  pkt->pos = pos;
246  ret = avio_read(pb, pkt->data, size);
247 
248  if (ret != size) {
249  ret = AVERROR(EIO);
250  break;
251  }
252 
253  packet_read = 1;
254  } else {
255  /* not interested in this chunk */
256  avio_skip(pb, size - 6);
257  }
258  }
259 
260  return avio_feof(pb) ? AVERROR_EOF : ret;
261 }
262 
263 static int flic_read_seek(AVFormatContext *s, int stream_index,
264  int64_t pts, int flags)
265 {
266  FlicDemuxContext *flic = s->priv_data;
267  AVStream *st = s->streams[stream_index];
268  FFStream *const sti = ffstream(st);
269  int64_t pos, ts;
270  int index;
271 
272  if (!sti->index_entries || stream_index != flic->video_stream_index)
273  return -1;
274 
276 
277  if (index < 0)
279  if (index < 0)
280  return -1;
281 
282  pos = sti->index_entries[index].pos;
283  ts = sti->index_entries[index].timestamp;
284  flic->frame_number = ts;
285  avio_seek(s->pb, pos, SEEK_SET);
286  return 0;
287 }
288 
290  .name = "flic",
291  .long_name = NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation"),
292  .priv_data_size = sizeof(FlicDemuxContext),
297 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:768
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
FLIC_TFTD_SAMPLE_RATE
#define FLIC_TFTD_SAMPLE_RATE
Definition: flic.c:47
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
index
fg index
Definition: ffmpeg_filter.c:167
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV_CODEC_ID_FLIC
@ AV_CODEC_ID_FLIC
Definition: codec_id.h:100
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:450
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
flic_probe
static int flic_probe(const AVProbeData *p)
Definition: flic.c:58
FLIC_TFTD_CHUNK_AUDIO
#define FLIC_TFTD_CHUNK_AUDIO
Definition: flic.c:46
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:809
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:459
FlicDemuxContext::frame_number
int frame_number
Definition: flic.c:55
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:432
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:149
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:117
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
FLIC_HEADER_SIZE
#define FLIC_HEADER_SIZE
Definition: flic.c:49
pts
static int64_t pts
Definition: transcode_aac.c:653
FLIC_MC_SPEED
#define FLIC_MC_SPEED
Definition: flic.c:44
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:650
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
FLIC_CHUNK_MAGIC_2
#define FLIC_CHUNK_MAGIC_2
Definition: flic.c:43
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:655
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:449
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
FLIC_FILE_MAGIC_1
#define FLIC_FILE_MAGIC_1
Definition: flic.c:39
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:803
FLIC_CHUNK_MAGIC_1
#define FLIC_CHUNK_MAGIC_1
Definition: flic.c:42
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
FlicDemuxContext
Definition: flic.c:52
ff_flic_demuxer
const AVInputFormat ff_flic_demuxer
Definition: flic.c:287
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2275
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
FlicDemuxContext::video_stream_index
int video_stream_index
Definition: flic.c:53
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:447
FLIC_DEFAULT_SPEED
#define FLIC_DEFAULT_SPEED
Definition: flic.c:45
flic_read_packet
static int flic_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flic.c:193
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
FlicDemuxContext::audio_stream_index
int audio_stream_index
Definition: flic.c:54
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
FLIC_PREAMBLE_SIZE
#define FLIC_PREAMBLE_SIZE
Definition: flic.c:50
AVPacket::size
int size
Definition: packet.h:374
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:117
FFStream
Definition: internal.h:194
size
int size
Definition: twinvq_data.h:10344
header
static const uint8_t header[24]
Definition: sdr2.c:67
FLIC_FILE_MAGIC_3
#define FLIC_FILE_MAGIC_3
Definition: flic.c:41
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecParameters::height
int height
Definition: codec_par.h:127
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
flic_read_seek
static int flic_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
Definition: flic.c:261
FLIC_FILE_MAGIC_2
#define FLIC_FILE_MAGIC_2
Definition: flic.c:40
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:935
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.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:943
channel_layout.h
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:802
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: utils.c:1196
AVPacket::stream_index
int stream_index
Definition: packet.h:375
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:277
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:319
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:393
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
flic_read_header
static int flic_read_header(AVFormatContext *s)
Definition: flic.c:84
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:237
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:451
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375