1 /*
2 * id Quake II CIN 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 * id Quake II CIN file demuxer by Mike Melanson (melanson@pcisys.net)
25 * For more information about the id CIN format, visit:
26 * http://www.csse.monash.edu.au/~timf/
27 *
28 * CIN is a somewhat quirky and ill-defined format. Here are some notes
29 * for anyone trying to understand the technical details of this format:
30 *
31 * The format has no definite file signature. This is problematic for a
32 * general-purpose media player that wants to automatically detect file
33 * types. However, a CIN file does start with 5 32-bit numbers that
34 * specify audio and video parameters. This demuxer gets around the lack
35 * of file signature by performing sanity checks on those parameters.
36 * Probabilistically, this is a reasonable solution since the number of
37 * valid combinations of the 5 parameters is a very small subset of the
38 * total 160-bit number space.
39 *
40 * Refer to the function idcin_probe() for the precise A/V parameters
41 * that this demuxer allows.
42 *
43 * Next, each audio and video frame has a duration of 1/14 sec. If the
44 * audio sample rate is a multiple of the common frequency 22050 Hz it will
45 * divide evenly by 14. However, if the sample rate is 11025 Hz:
46 * 11025 (samples/sec) / 14 (frames/sec) = 787.5 (samples/frame)
47 * The way the CIN stores audio in this case is by storing 787 sample
48 * frames in the first audio frame and 788 sample frames in the second
49 * audio frame. Therefore, the total number of bytes in an audio frame
50 * is given as:
51 * audio frame #0: 787 * (bytes/sample) * (# channels) bytes in frame
52 * audio frame #1: 788 * (bytes/sample) * (# channels) bytes in frame
53 * audio frame #2: 787 * (bytes/sample) * (# channels) bytes in frame
54 * audio frame #3: 788 * (bytes/sample) * (# channels) bytes in frame
55 *
56 * Finally, not all id CIN creation tools agree on the resolution of the
57 * color palette, apparently. Some creation tools specify red, green, and
58 * blue palette components in terms of 6-bit VGA color DAC values which
59 * range from 0..63. Other tools specify the RGB components as full 8-bit
60 * values that range from 0..255. Since there are no markers in the file to
61 * differentiate between the two variants, this demuxer uses the following
62 * heuristic:
63 * - load the 768 palette bytes from disk
64 * - assume that they will need to be shifted left by 2 bits to
65 * transform them from 6-bit values to 8-bit values
66 * - scan through all 768 palette bytes
67 * - if any bytes exceed 63, do not shift the bytes at all before
68 * transmitting them to the video decoder
69 */
70
77
78 #define HUFFMAN_TABLE_SIZE (64 * 1024)
80
87
88 /* demux state variables */
94
96 {
97 unsigned int number, sample_rate;
100
101 /*
102 * This is what you could call a "probabilistic" file check: id CIN
103 * files don't have a definite file signature. In lieu of such a marker,
104 * perform sanity checks on the 5 32-bit header fields:
105 * width, height: greater than 0, less than or equal to 1024
106 * audio sample rate: greater than or equal to 8000, less than or
107 * equal to 48000, or 0 for no audio
108 * audio sample width (bytes/sample): 0 for no audio, or 1 or 2
109 * audio channels: 0 for no audio, or 1 or 2
110 */
111
112 /* check we have enough data to do all checks, otherwise the
113 0-padding may cause a wrong recognition */
115 return 0;
116
117 /* check the video width */
119 if ((
w == 0) || (
w > 1024))
120 return 0;
121
122 /* check the video height */
124 if ((
h == 0) || (
h > 1024))
125 return 0;
126
127 /* check the audio sample rate */
129 if (sample_rate && (sample_rate < 8000 || sample_rate > 48000))
130 return 0;
131
132 /* check the audio bytes/sample */
134 if (number > 2 || sample_rate && !number)
135 return 0;
136
137 /* check the audio channels */
139 if (number > 2 || sample_rate && !number)
140 return 0;
141
145
147 return 1;
148
149 /* return half certainty since this check is a bit sketchy */
151 }
152
154 {
159 unsigned int sample_rate, bytes_per_sample,
channels;
161
162 /* get the 5 header parameters */
168
169 if (
s->pb->eof_reached) {
172 }
173
176 if (sample_rate > 0) {
177 if (sample_rate < 14 || sample_rate > INT_MAX) {
180 }
181 if (bytes_per_sample < 1 || bytes_per_sample > 2) {
183 bytes_per_sample);
185 }
189 }
191 } else {
192 /* if sample rate is 0, assume no audio */
194 }
195
197 if (!st)
207
208 /* load up the Huffman tables into extradata */
211
215 if (!st)
227 if (bytes_per_sample == 1)
229 else
231
232 if (sample_rate % 14 != 0) {
237 } else {
239 (sample_rate / 14) * bytes_per_sample *
channels;
240 }
242 }
243
246
247 return 0;
248 }
249
252 {
255 unsigned int chunk_size;
259 int palette_scale;
260 unsigned char r,
g,
b;
261 unsigned char palette_buffer[768];
262 uint32_t palette[256];
263
266
272 /* trigger a palette change */
276 }
else if (
ret != 768) {
279 }
280 /* scale the palette as necessary */
281 palette_scale = 2;
282 for (
i = 0;
i < 768;
i++)
283 if (palette_buffer[
i] > 63) {
284 palette_scale = 0;
285 break;
286 }
287
288 for (
i = 0;
i < 256;
i++) {
289 r = palette_buffer[
i * 3 ] << palette_scale;
290 g = palette_buffer[
i * 3 + 1] << palette_scale;
291 b = palette_buffer[
i * 3 + 2] << palette_scale;
292 palette[
i] = (0xFF
U << 24) | (
r << 16) | (
g << 8) | (
b);
293 if (palette_scale == 2)
294 palette[
i] |= palette[
i] >> 6 & 0x30303;
295 }
296 }
297
298 if (
s->pb->eof_reached) {
301 }
303 if (chunk_size < 4 || chunk_size > INT_MAX - 4) {
306 }
307 /* skip the number of decoded bytes (always equal to width * height) */
309 chunk_size -= 4;
313 else if (
ret != chunk_size) {
316 }
318 uint8_t *pal;
319
322 if (!pal) {
324 }
327 }
330 } else {
331 /* send out the audio chunk */
334 else
341
343 }
344
347
348 return 0;
349 }
350
353 {
355
363 return 0;
364 }
365 return -1;
366 }
367
377 };