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 "demux.h"
38 #include "internal.h"
39 
40 #define FLIC_FILE_MAGIC_1 0xAF11
41 #define FLIC_FILE_MAGIC_2 0xAF12
42 #define FLIC_FILE_MAGIC_3 0xAF44 /* Flic Type for Extended FLX Format which
43  originated in Dave's Targa Animator (DTA) */
44 #define FLIC_CHUNK_MAGIC_1 0xF1FA
45 #define FLIC_CHUNK_MAGIC_2 0xF5FA
46 #define FLIC_MC_SPEED 5 /* speed for Magic Carpet game FLIs */
47 #define FLIC_DEFAULT_SPEED 5 /* for FLIs that have 0 speed */
48 #define FLIC_TFTD_CHUNK_AUDIO 0xAAAA /* Audio chunk. Used in Terror from the Deep.
49  Has 10 B extra header not accounted for in the chunk header */
50 #define FLIC_TFTD_SAMPLE_RATE 22050
51 
52 #define FLIC_HEADER_SIZE 128
53 #define FLIC_PREAMBLE_SIZE 6
54 
55 typedef struct FlicDemuxContext {
58  int frame_number;
60 
61 static int flic_probe(const AVProbeData *p)
62 {
63  int magic_number;
64 
65  if(p->buf_size < FLIC_HEADER_SIZE)
66  return 0;
67 
68  magic_number = AV_RL16(&p->buf[4]);
69  if ((magic_number != FLIC_FILE_MAGIC_1) &&
70  (magic_number != FLIC_FILE_MAGIC_2) &&
71  (magic_number != FLIC_FILE_MAGIC_3))
72  return 0;
73 
74  if(AV_RL16(&p->buf[0x10]) != FLIC_CHUNK_MAGIC_1){
75  if(AV_RL32(&p->buf[0x10]) > 2000)
76  return 0;
77  }
78 
79  if( AV_RL16(&p->buf[0x08]) > 4096
80  || AV_RL16(&p->buf[0x0A]) > 4096)
81  return 0;
82 
83 
84  return AVPROBE_SCORE_MAX - 1;
85 }
86 
88 {
89  FlicDemuxContext *flic = s->priv_data;
90  AVIOContext *pb = s->pb;
91  unsigned char header[FLIC_HEADER_SIZE];
92  AVStream *st, *ast;
93  int speed, ret;
94  int magic_number;
95  unsigned char preamble[FLIC_PREAMBLE_SIZE];
96 
97  flic->frame_number = 0;
98 
99  /* load the whole header and pull out the width and height */
101  return AVERROR(EIO);
102 
103  magic_number = AV_RL16(&header[4]);
104  speed = AV_RL32(&header[0x10]);
105  if (speed == 0)
106  speed = FLIC_DEFAULT_SPEED;
107 
108  /* initialize the decoder streams */
109  st = avformat_new_stream(s, NULL);
110  if (!st)
111  return AVERROR(ENOMEM);
112  flic->video_stream_index = st->index;
115  st->codecpar->codec_tag = 0; /* no fourcc */
116  st->codecpar->width = AV_RL16(&header[0x08]);
117  st->codecpar->height = AV_RL16(&header[0x0A]);
118 
119  if (!st->codecpar->width || !st->codecpar->height) {
120  /* Ugly hack needed for the following sample: */
121  /* http://samples.mplayerhq.hu/fli-flc/fli-bugs/specular.flc */
123  "File with no specified width/height. Trying 640x480.\n");
124  st->codecpar->width = 640;
125  st->codecpar->height = 480;
126  }
127 
128  /* send over the whole 128-byte FLIC header */
130  return ret;
131  memcpy(st->codecpar->extradata, header, FLIC_HEADER_SIZE);
132 
133  /* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
134  if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {
135  av_log(s, AV_LOG_ERROR, "Failed to peek at preamble\n");
136  return AVERROR(EIO);
137  }
138 
139  avio_seek(pb, -FLIC_PREAMBLE_SIZE, SEEK_CUR);
140 
141  /* Time to figure out the framerate:
142  * If the first preamble's magic number is 0xAAAA then this file is from
143  * X-COM: Terror from the Deep. If on the other hand there is a FLIC chunk
144  * magic number at offset 0x10 assume this file is from Magic Carpet instead.
145  * If neither of the above is true then this is a normal FLIC file.
146  */
147  if (AV_RL16(&preamble[4]) == FLIC_TFTD_CHUNK_AUDIO) {
148  /* TFTD videos have an extra 22050 Hz 8-bit mono audio stream */
149  ast = avformat_new_stream(s, NULL);
150  if (!ast)
151  return AVERROR(ENOMEM);
152 
153  flic->audio_stream_index = ast->index;
154 
155  /* all audio frames are the same size, so use the size of the first chunk for block_align */
156  ast->codecpar->block_align = AV_RL32(&preamble[0]);
159  ast->codecpar->codec_tag = 0;
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  .p.name = "flic",
291  .p.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:215
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
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
FLIC_TFTD_SAMPLE_RATE
#define FLIC_TFTD_SAMPLE_RATE
Definition: flic.c:48
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
int64_t
long long int64_t
Definition: coverity.c:34
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_CODEC_ID_FLIC
@ AV_CODEC_ID_FLIC
Definition: codec_id.h:102
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
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
flic_probe
static int flic_probe(const AVProbeData *p)
Definition: flic.c:59
FLIC_TFTD_CHUNK_AUDIO
#define FLIC_TFTD_CHUNK_AUDIO
Definition: flic.c:47
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
FlicDemuxContext::frame_number
int frame_number
Definition: flic.c:56
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:867
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:358
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
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:122
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
FLIC_HEADER_SIZE
#define FLIC_HEADER_SIZE
Definition: flic.c:50
pts
static int64_t pts
Definition: transcode_aac.c:644
FLIC_MC_SPEED
#define FLIC_MC_SPEED
Definition: flic.c:45
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:209
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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: packet.c:98
FLIC_CHUNK_MAGIC_2
#define FLIC_CHUNK_MAGIC_2
Definition: flic.c:44
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
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
FLIC_FILE_MAGIC_1
#define FLIC_FILE_MAGIC_1
Definition: flic.c:40
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:604
FLIC_CHUNK_MAGIC_1
#define FLIC_CHUNK_MAGIC_1
Definition: flic.c:43
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:53
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2498
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
NULL
#define NULL
Definition: coverity.c:32
FlicDemuxContext::video_stream_index
int video_stream_index
Definition: flic.c:54
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
FLIC_DEFAULT_SPEED
#define FLIC_DEFAULT_SPEED
Definition: flic.c:46
flic_read_packet
static int flic_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flic.c:193
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
index
int index
Definition: gxfenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
FlicDemuxContext::audio_stream_index
int audio_stream_index
Definition: flic.c:55
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
FLIC_PREAMBLE_SIZE
#define FLIC_PREAMBLE_SIZE
Definition: flic.c:51
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
FFStream
Definition: internal.h:132
size
int size
Definition: twinvq_data.h:10344
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
header
static const uint8_t header[24]
Definition: sdr2.c:68
FLIC_FILE_MAGIC_3
#define FLIC_FILE_MAGIC_3
Definition: flic.c:42
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
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
flic_read_seek
static int flic_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
Definition: flic.c:261
demux.h
FLIC_FILE_MAGIC_2
#define FLIC_FILE_MAGIC_2
Definition: flic.c:41
ret
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
pos
unsigned int pos
Definition: spdifenc.c:414
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:754
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:612
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
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
ff_flic_demuxer
const FFInputFormat ff_flic_demuxer
Definition: flic.c:287
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:188
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:339
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:386
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
FFInputFormat
Definition: demux.h:42
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:85
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:245
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:227
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346