You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

330 lines
11KB

  1. /*
  2. * Sega FILM Format (CPK) 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. * @file
  23. * Sega FILM (.cpk) file demuxer
  24. * by Mike Melanson (melanson@pcisys.net)
  25. * For more information regarding the Sega FILM file format, visit:
  26. * http://www.pcisys.net/~melanson/codecs/
  27. */
  28. #include "libavutil/intreadwrite.h"
  29. #include "avformat.h"
  30. #define FILM_TAG MKBETAG('F', 'I', 'L', 'M')
  31. #define FDSC_TAG MKBETAG('F', 'D', 'S', 'C')
  32. #define STAB_TAG MKBETAG('S', 'T', 'A', 'B')
  33. #define CVID_TAG MKBETAG('c', 'v', 'i', 'd')
  34. #define RAW_TAG MKBETAG('r', 'a', 'w', ' ')
  35. typedef struct {
  36. int stream;
  37. int64_t sample_offset;
  38. unsigned int sample_size;
  39. int64_t pts;
  40. int keyframe;
  41. } film_sample;
  42. typedef struct FilmDemuxContext {
  43. int video_stream_index;
  44. int audio_stream_index;
  45. enum CodecID audio_type;
  46. unsigned int audio_samplerate;
  47. unsigned int audio_bits;
  48. unsigned int audio_channels;
  49. enum CodecID video_type;
  50. unsigned int sample_count;
  51. film_sample *sample_table;
  52. unsigned int current_sample;
  53. unsigned int base_clock;
  54. unsigned int version;
  55. /* buffer used for interleaving stereo PCM data */
  56. unsigned char *stereo_buffer;
  57. int stereo_buffer_size;
  58. } FilmDemuxContext;
  59. static int film_probe(AVProbeData *p)
  60. {
  61. if (AV_RB32(&p->buf[0]) != FILM_TAG)
  62. return 0;
  63. return AVPROBE_SCORE_MAX;
  64. }
  65. static int film_read_header(AVFormatContext *s,
  66. AVFormatParameters *ap)
  67. {
  68. FilmDemuxContext *film = s->priv_data;
  69. AVIOContext *pb = s->pb;
  70. AVStream *st;
  71. unsigned char scratch[256];
  72. int i;
  73. unsigned int data_offset;
  74. unsigned int audio_frame_counter;
  75. film->sample_table = NULL;
  76. film->stereo_buffer = NULL;
  77. film->stereo_buffer_size = 0;
  78. /* load the main FILM header */
  79. if (avio_read(pb, scratch, 16) != 16)
  80. return AVERROR(EIO);
  81. data_offset = AV_RB32(&scratch[4]);
  82. film->version = AV_RB32(&scratch[8]);
  83. /* load the FDSC chunk */
  84. if (film->version == 0) {
  85. /* special case for Lemmings .film files; 20-byte header */
  86. if (avio_read(pb, scratch, 20) != 20)
  87. return AVERROR(EIO);
  88. /* make some assumptions about the audio parameters */
  89. film->audio_type = CODEC_ID_PCM_S8;
  90. film->audio_samplerate = 22050;
  91. film->audio_channels = 1;
  92. film->audio_bits = 8;
  93. } else {
  94. /* normal Saturn .cpk files; 32-byte header */
  95. if (avio_read(pb, scratch, 32) != 32)
  96. return AVERROR(EIO);
  97. film->audio_samplerate = AV_RB16(&scratch[24]);
  98. film->audio_channels = scratch[21];
  99. film->audio_bits = scratch[22];
  100. if (scratch[23] == 2)
  101. film->audio_type = CODEC_ID_ADPCM_ADX;
  102. else if (film->audio_channels > 0) {
  103. if (film->audio_bits == 8)
  104. film->audio_type = CODEC_ID_PCM_S8;
  105. else if (film->audio_bits == 16)
  106. film->audio_type = CODEC_ID_PCM_S16BE;
  107. else
  108. film->audio_type = CODEC_ID_NONE;
  109. } else
  110. film->audio_type = CODEC_ID_NONE;
  111. }
  112. if (AV_RB32(&scratch[0]) != FDSC_TAG)
  113. return AVERROR_INVALIDDATA;
  114. if (AV_RB32(&scratch[8]) == CVID_TAG) {
  115. film->video_type = CODEC_ID_CINEPAK;
  116. } else if (AV_RB32(&scratch[8]) == RAW_TAG) {
  117. film->video_type = CODEC_ID_RAWVIDEO;
  118. } else {
  119. film->video_type = CODEC_ID_NONE;
  120. }
  121. /* initialize the decoder streams */
  122. if (film->video_type) {
  123. st = avformat_new_stream(s, NULL);
  124. if (!st)
  125. return AVERROR(ENOMEM);
  126. film->video_stream_index = st->index;
  127. st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  128. st->codec->codec_id = film->video_type;
  129. st->codec->codec_tag = 0; /* no fourcc */
  130. st->codec->width = AV_RB32(&scratch[16]);
  131. st->codec->height = AV_RB32(&scratch[12]);
  132. if (film->video_type == CODEC_ID_RAWVIDEO) {
  133. if (scratch[20] == 24) {
  134. st->codec->pix_fmt = PIX_FMT_RGB24;
  135. } else {
  136. av_log(s, AV_LOG_ERROR, "raw video is using unhandled %dbpp\n", scratch[20]);
  137. return -1;
  138. }
  139. }
  140. }
  141. if (film->audio_type) {
  142. st = avformat_new_stream(s, NULL);
  143. if (!st)
  144. return AVERROR(ENOMEM);
  145. film->audio_stream_index = st->index;
  146. st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  147. st->codec->codec_id = film->audio_type;
  148. st->codec->codec_tag = 1;
  149. st->codec->channels = film->audio_channels;
  150. st->codec->sample_rate = film->audio_samplerate;
  151. if (film->audio_type == CODEC_ID_ADPCM_ADX) {
  152. st->codec->bits_per_coded_sample = 18 * 8 / 32;
  153. st->codec->block_align = st->codec->channels * 18;
  154. } else {
  155. st->codec->bits_per_coded_sample = film->audio_bits;
  156. st->codec->block_align = st->codec->channels *
  157. st->codec->bits_per_coded_sample / 8;
  158. }
  159. st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
  160. st->codec->bits_per_coded_sample;
  161. }
  162. /* load the sample table */
  163. if (avio_read(pb, scratch, 16) != 16)
  164. return AVERROR(EIO);
  165. if (AV_RB32(&scratch[0]) != STAB_TAG)
  166. return AVERROR_INVALIDDATA;
  167. film->base_clock = AV_RB32(&scratch[8]);
  168. film->sample_count = AV_RB32(&scratch[12]);
  169. if(film->sample_count >= UINT_MAX / sizeof(film_sample))
  170. return -1;
  171. film->sample_table = av_malloc(film->sample_count * sizeof(film_sample));
  172. if (!film->sample_table)
  173. return AVERROR(ENOMEM);
  174. for(i=0; i<s->nb_streams; i++)
  175. av_set_pts_info(s->streams[i], 33, 1, film->base_clock);
  176. audio_frame_counter = 0;
  177. for (i = 0; i < film->sample_count; i++) {
  178. /* load the next sample record and transfer it to an internal struct */
  179. if (avio_read(pb, scratch, 16) != 16) {
  180. av_free(film->sample_table);
  181. return AVERROR(EIO);
  182. }
  183. film->sample_table[i].sample_offset =
  184. data_offset + AV_RB32(&scratch[0]);
  185. film->sample_table[i].sample_size = AV_RB32(&scratch[4]);
  186. if (AV_RB32(&scratch[8]) == 0xFFFFFFFF) {
  187. film->sample_table[i].stream = film->audio_stream_index;
  188. film->sample_table[i].pts = audio_frame_counter;
  189. film->sample_table[i].pts *= film->base_clock;
  190. film->sample_table[i].pts /= film->audio_samplerate;
  191. if (film->audio_type == CODEC_ID_ADPCM_ADX)
  192. audio_frame_counter += (film->sample_table[i].sample_size * 32 /
  193. (18 * film->audio_channels));
  194. else if (film->audio_type != CODEC_ID_NONE)
  195. audio_frame_counter += (film->sample_table[i].sample_size /
  196. (film->audio_channels * film->audio_bits / 8));
  197. } else {
  198. film->sample_table[i].stream = film->video_stream_index;
  199. film->sample_table[i].pts = AV_RB32(&scratch[8]) & 0x7FFFFFFF;
  200. film->sample_table[i].keyframe = (scratch[8] & 0x80) ? 0 : 1;
  201. }
  202. }
  203. film->current_sample = 0;
  204. return 0;
  205. }
  206. static int film_read_packet(AVFormatContext *s,
  207. AVPacket *pkt)
  208. {
  209. FilmDemuxContext *film = s->priv_data;
  210. AVIOContext *pb = s->pb;
  211. film_sample *sample;
  212. int ret = 0;
  213. int i;
  214. int left, right;
  215. if (film->current_sample >= film->sample_count)
  216. return AVERROR(EIO);
  217. sample = &film->sample_table[film->current_sample];
  218. /* position the stream (will probably be there anyway) */
  219. avio_seek(pb, sample->sample_offset, SEEK_SET);
  220. /* do a special song and dance when loading FILM Cinepak chunks */
  221. if ((sample->stream == film->video_stream_index) &&
  222. (film->video_type == CODEC_ID_CINEPAK)) {
  223. pkt->pos= avio_tell(pb);
  224. if (av_new_packet(pkt, sample->sample_size))
  225. return AVERROR(ENOMEM);
  226. avio_read(pb, pkt->data, sample->sample_size);
  227. } else if ((sample->stream == film->audio_stream_index) &&
  228. (film->audio_channels == 2) &&
  229. (film->audio_type != CODEC_ID_ADPCM_ADX)) {
  230. /* stereo PCM needs to be interleaved */
  231. if (av_new_packet(pkt, sample->sample_size))
  232. return AVERROR(ENOMEM);
  233. /* make sure the interleave buffer is large enough */
  234. if (sample->sample_size > film->stereo_buffer_size) {
  235. av_free(film->stereo_buffer);
  236. film->stereo_buffer_size = sample->sample_size;
  237. film->stereo_buffer = av_malloc(film->stereo_buffer_size);
  238. if (!film->stereo_buffer) {
  239. film->stereo_buffer_size = 0;
  240. return AVERROR(ENOMEM);
  241. }
  242. }
  243. pkt->pos= avio_tell(pb);
  244. ret = avio_read(pb, film->stereo_buffer, sample->sample_size);
  245. if (ret != sample->sample_size)
  246. ret = AVERROR(EIO);
  247. left = 0;
  248. right = sample->sample_size / 2;
  249. for (i = 0; i < sample->sample_size; ) {
  250. if (film->audio_bits == 8) {
  251. pkt->data[i++] = film->stereo_buffer[left++];
  252. pkt->data[i++] = film->stereo_buffer[right++];
  253. } else {
  254. pkt->data[i++] = film->stereo_buffer[left++];
  255. pkt->data[i++] = film->stereo_buffer[left++];
  256. pkt->data[i++] = film->stereo_buffer[right++];
  257. pkt->data[i++] = film->stereo_buffer[right++];
  258. }
  259. }
  260. } else {
  261. ret= av_get_packet(pb, pkt, sample->sample_size);
  262. if (ret != sample->sample_size)
  263. ret = AVERROR(EIO);
  264. }
  265. pkt->stream_index = sample->stream;
  266. pkt->pts = sample->pts;
  267. film->current_sample++;
  268. return ret;
  269. }
  270. static int film_read_close(AVFormatContext *s)
  271. {
  272. FilmDemuxContext *film = s->priv_data;
  273. av_free(film->sample_table);
  274. av_free(film->stereo_buffer);
  275. return 0;
  276. }
  277. AVInputFormat ff_segafilm_demuxer = {
  278. .name = "film_cpk",
  279. .long_name = NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
  280. .priv_data_size = sizeof(FilmDemuxContext),
  281. .read_probe = film_probe,
  282. .read_header = film_read_header,
  283. .read_packet = film_read_packet,
  284. .read_close = film_read_close,
  285. };