1/* 2 * id Quake II CIN File Demuxer 3 * Copyright (c) 2003 The ffmpeg Project 4 * 5 * This file is part of Libav. 6 * 7 * Libav 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 * Libav 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 Libav; 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 * Probabalistically, 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 71#include "libavutil/intreadwrite.h" 72#include "avformat.h" 73#include "internal.h" 74 75#define HUFFMAN_TABLE_SIZE (64 * 1024) 76#define IDCIN_FPS 14 77 78typedef struct IdcinDemuxContext { 79 int video_stream_index; 80 int audio_stream_index; 81 int audio_chunk_size1; 82 int audio_chunk_size2; 83 84 /* demux state variables */ 85 int current_audio_chunk; 86 int next_chunk_is_video; 87 int audio_present; 88 89 int64_t pts; 90} IdcinDemuxContext; 91 92static int idcin_probe(AVProbeData *p) 93{ 94 unsigned int number; 95 96 /* 97 * This is what you could call a "probabilistic" file check: id CIN 98 * files don't have a definite file signature. In lieu of such a marker, 99 * perform sanity checks on the 5 32-bit header fields: 100 * width, height: greater than 0, less than or equal to 1024 101 * audio sample rate: greater than or equal to 8000, less than or 102 * equal to 48000, or 0 for no audio 103 * audio sample width (bytes/sample): 0 for no audio, or 1 or 2 104 * audio channels: 0 for no audio, or 1 or 2 105 */ 106 107 /* check we have enough data to do all checks, otherwise the 108 0-padding may cause a wrong recognition */ 109 if (p->buf_size < 20) 110 return 0; 111 112 /* check the video width */ 113 number = AV_RL32(&p->buf[0]); 114 if ((number == 0) || (number > 1024)) 115 return 0; 116 117 /* check the video height */ 118 number = AV_RL32(&p->buf[4]); 119 if ((number == 0) || (number > 1024)) 120 return 0; 121 122 /* check the audio sample rate */ 123 number = AV_RL32(&p->buf[8]); 124 if ((number != 0) && ((number < 8000) | (number > 48000))) 125 return 0; 126 127 /* check the audio bytes/sample */ 128 number = AV_RL32(&p->buf[12]); 129 if (number > 2) 130 return 0; 131 132 /* check the audio channels */ 133 number = AV_RL32(&p->buf[16]); 134 if (number > 2) 135 return 0; 136 137 /* return half certainly since this check is a bit sketchy */ 138 return AVPROBE_SCORE_MAX / 2; 139} 140 141static int idcin_read_header(AVFormatContext *s, 142 AVFormatParameters *ap) 143{ 144 AVIOContext *pb = s->pb; 145 IdcinDemuxContext *idcin = s->priv_data; 146 AVStream *st; 147 unsigned int width, height; 148 unsigned int sample_rate, bytes_per_sample, channels; 149 150 /* get the 5 header parameters */ 151 width = avio_rl32(pb); 152 height = avio_rl32(pb); 153 sample_rate = avio_rl32(pb); 154 bytes_per_sample = avio_rl32(pb); 155 channels = avio_rl32(pb); 156 157 st = avformat_new_stream(s, NULL); 158 if (!st) 159 return AVERROR(ENOMEM); 160 avpriv_set_pts_info(st, 33, 1, IDCIN_FPS); 161 idcin->video_stream_index = st->index; 162 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 163 st->codec->codec_id = CODEC_ID_IDCIN; 164 st->codec->codec_tag = 0; /* no fourcc */ 165 st->codec->width = width; 166 st->codec->height = height; 167 168 /* load up the Huffman tables into extradata */ 169 st->codec->extradata_size = HUFFMAN_TABLE_SIZE; 170 st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE); 171 if (avio_read(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) != 172 HUFFMAN_TABLE_SIZE) 173 return AVERROR(EIO); 174 175 /* if sample rate is 0, assume no audio */ 176 if (sample_rate) { 177 idcin->audio_present = 1; 178 st = avformat_new_stream(s, NULL); 179 if (!st) 180 return AVERROR(ENOMEM); 181 avpriv_set_pts_info(st, 33, 1, IDCIN_FPS); 182 idcin->audio_stream_index = st->index; 183 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; 184 st->codec->codec_tag = 1; 185 st->codec->channels = channels; 186 st->codec->sample_rate = sample_rate; 187 st->codec->bits_per_coded_sample = bytes_per_sample * 8; 188 st->codec->bit_rate = sample_rate * bytes_per_sample * 8 * channels; 189 st->codec->block_align = bytes_per_sample * channels; 190 if (bytes_per_sample == 1) 191 st->codec->codec_id = CODEC_ID_PCM_U8; 192 else 193 st->codec->codec_id = CODEC_ID_PCM_S16LE; 194 195 if (sample_rate % 14 != 0) { 196 idcin->audio_chunk_size1 = (sample_rate / 14) * 197 bytes_per_sample * channels; 198 idcin->audio_chunk_size2 = (sample_rate / 14 + 1) * 199 bytes_per_sample * channels; 200 } else { 201 idcin->audio_chunk_size1 = idcin->audio_chunk_size2 = 202 (sample_rate / 14) * bytes_per_sample * channels; 203 } 204 idcin->current_audio_chunk = 0; 205 } else 206 idcin->audio_present = 1; 207 208 idcin->next_chunk_is_video = 1; 209 idcin->pts = 0; 210 211 return 0; 212} 213 214static int idcin_read_packet(AVFormatContext *s, 215 AVPacket *pkt) 216{ 217 int ret; 218 unsigned int command; 219 unsigned int chunk_size; 220 IdcinDemuxContext *idcin = s->priv_data; 221 AVIOContext *pb = s->pb; 222 int i; 223 int palette_scale; 224 unsigned char r, g, b; 225 unsigned char palette_buffer[768]; 226 uint32_t palette[256]; 227 228 if (s->pb->eof_reached) 229 return AVERROR(EIO); 230 231 if (idcin->next_chunk_is_video) { 232 command = avio_rl32(pb); 233 if (command == 2) { 234 return AVERROR(EIO); 235 } else if (command == 1) { 236 /* trigger a palette change */ 237 if (avio_read(pb, palette_buffer, 768) != 768) 238 return AVERROR(EIO); 239 /* scale the palette as necessary */ 240 palette_scale = 2; 241 for (i = 0; i < 768; i++) 242 if (palette_buffer[i] > 63) { 243 palette_scale = 0; 244 break; 245 } 246 247 for (i = 0; i < 256; i++) { 248 r = palette_buffer[i * 3 ] << palette_scale; 249 g = palette_buffer[i * 3 + 1] << palette_scale; 250 b = palette_buffer[i * 3 + 2] << palette_scale; 251 palette[i] = (r << 16) | (g << 8) | (b); 252 } 253 } 254 255 chunk_size = avio_rl32(pb); 256 /* skip the number of decoded bytes (always equal to width * height) */ 257 avio_skip(pb, 4); 258 chunk_size -= 4; 259 ret= av_get_packet(pb, pkt, chunk_size); 260 if (ret < 0) 261 return ret; 262 if (command == 1) { 263 uint8_t *pal; 264 265 pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, 266 AVPALETTE_SIZE); 267 if (ret < 0) 268 return ret; 269 memcpy(pal, palette, AVPALETTE_SIZE); 270 } 271 pkt->stream_index = idcin->video_stream_index; 272 pkt->pts = idcin->pts; 273 } else { 274 /* send out the audio chunk */ 275 if (idcin->current_audio_chunk) 276 chunk_size = idcin->audio_chunk_size2; 277 else 278 chunk_size = idcin->audio_chunk_size1; 279 ret= av_get_packet(pb, pkt, chunk_size); 280 if (ret < 0) 281 return ret; 282 pkt->stream_index = idcin->audio_stream_index; 283 pkt->pts = idcin->pts; 284 285 idcin->current_audio_chunk ^= 1; 286 idcin->pts++; 287 } 288 289 if (idcin->audio_present) 290 idcin->next_chunk_is_video ^= 1; 291 292 return ret; 293} 294 295AVInputFormat ff_idcin_demuxer = { 296 .name = "idcin", 297 .long_name = NULL_IF_CONFIG_SMALL("id Cinematic format"), 298 .priv_data_size = sizeof(IdcinDemuxContext), 299 .read_probe = idcin_probe, 300 .read_header = idcin_read_header, 301 .read_packet = idcin_read_packet, 302}; 303