psxstr.c 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303
  1. /*
  2. * Sony Playstation (PSX) STR 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. * @file
  23. * PSX STR file demuxer
  24. * by Mike Melanson (melanson@pcisys.net)
  25. * This module handles streams that have been ripped from Sony Playstation
  26. * CD games. This demuxer can handle either raw STR files (which are just
  27. * concatenations of raw compact disc sectors) or STR files with 0x2C-byte
  28. * RIFF headers, followed by CD sectors.
  29. */
  30. #include "libavutil/intreadwrite.h"
  31. #include "avformat.h"
  32. #include "internal.h"
  33. #define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
  34. #define CDXA_TAG MKTAG('C', 'D', 'X', 'A')
  35. #define RAW_CD_SECTOR_SIZE 2352
  36. #define RAW_CD_SECTOR_DATA_SIZE 2304
  37. #define VIDEO_DATA_CHUNK_SIZE 0x7E0
  38. #define VIDEO_DATA_HEADER_SIZE 0x38
  39. #define RIFF_HEADER_SIZE 0x2C
  40. #define CDXA_TYPE_MASK 0x0E
  41. #define CDXA_TYPE_DATA 0x08
  42. #define CDXA_TYPE_AUDIO 0x04
  43. #define CDXA_TYPE_VIDEO 0x02
  44. #define STR_MAGIC (0x80010160)
  45. typedef struct StrChannel {
  46. /* video parameters */
  47. int video_stream_index;
  48. AVPacket tmp_pkt;
  49. /* audio parameters */
  50. int audio_stream_index;
  51. } StrChannel;
  52. typedef struct StrDemuxContext {
  53. /* a STR file can contain up to 32 channels of data */
  54. StrChannel channels[32];
  55. } StrDemuxContext;
  56. static const char sync_header[12] = {0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};
  57. static int str_probe(AVProbeData *p)
  58. {
  59. uint8_t *sector= p->buf;
  60. uint8_t *end= sector + p->buf_size;
  61. int aud=0, vid=0;
  62. if (p->buf_size < RAW_CD_SECTOR_SIZE)
  63. return 0;
  64. if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
  65. (AV_RL32(&p->buf[8]) == CDXA_TAG)) {
  66. /* RIFF header seen; skip 0x2C bytes */
  67. sector += RIFF_HEADER_SIZE;
  68. }
  69. while (end - sector >= RAW_CD_SECTOR_SIZE) {
  70. /* look for CD sync header (00, 0xFF x 10, 00) */
  71. if (memcmp(sector,sync_header,sizeof(sync_header)))
  72. return 0;
  73. if (sector[0x11] >= 32)
  74. return 0;
  75. switch (sector[0x12] & CDXA_TYPE_MASK) {
  76. case CDXA_TYPE_DATA:
  77. case CDXA_TYPE_VIDEO: {
  78. int current_sector = AV_RL16(&sector[0x1C]);
  79. int sector_count = AV_RL16(&sector[0x1E]);
  80. int frame_size = AV_RL32(&sector[0x24]);
  81. if(!( frame_size>=0
  82. && current_sector < sector_count
  83. && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
  84. return 0;
  85. }
  86. /*st->codec->width = AV_RL16(&sector[0x28]);
  87. st->codec->height = AV_RL16(&sector[0x2A]);*/
  88. // if (current_sector == sector_count-1) {
  89. vid++;
  90. // }
  91. }
  92. break;
  93. case CDXA_TYPE_AUDIO:
  94. if(sector[0x13]&0x2A)
  95. return 0;
  96. aud++;
  97. break;
  98. default:
  99. if(sector[0x12] & CDXA_TYPE_MASK)
  100. return 0;
  101. }
  102. sector += RAW_CD_SECTOR_SIZE;
  103. }
  104. /* MPEG files (like those ripped from VCDs) can also look like this;
  105. * only return half certainty */
  106. if(vid+aud > 3) return 50;
  107. else if(vid+aud) return 1;
  108. else return 0;
  109. }
  110. static int str_read_header(AVFormatContext *s,
  111. AVFormatParameters *ap)
  112. {
  113. AVIOContext *pb = s->pb;
  114. StrDemuxContext *str = s->priv_data;
  115. unsigned char sector[RAW_CD_SECTOR_SIZE];
  116. int start;
  117. int i;
  118. /* skip over any RIFF header */
  119. if (avio_read(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
  120. return AVERROR(EIO);
  121. if (AV_RL32(&sector[0]) == RIFF_TAG)
  122. start = RIFF_HEADER_SIZE;
  123. else
  124. start = 0;
  125. avio_seek(pb, start, SEEK_SET);
  126. for(i=0; i<32; i++){
  127. str->channels[i].video_stream_index=
  128. str->channels[i].audio_stream_index= -1;
  129. }
  130. s->ctx_flags |= AVFMTCTX_NOHEADER;
  131. return 0;
  132. }
  133. static int str_read_packet(AVFormatContext *s,
  134. AVPacket *ret_pkt)
  135. {
  136. AVIOContext *pb = s->pb;
  137. StrDemuxContext *str = s->priv_data;
  138. unsigned char sector[RAW_CD_SECTOR_SIZE];
  139. int channel;
  140. AVPacket *pkt;
  141. AVStream *st;
  142. while (1) {
  143. if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
  144. return AVERROR(EIO);
  145. channel = sector[0x11];
  146. if (channel >= 32)
  147. return AVERROR_INVALIDDATA;
  148. switch (sector[0x12] & CDXA_TYPE_MASK) {
  149. case CDXA_TYPE_DATA:
  150. case CDXA_TYPE_VIDEO:
  151. {
  152. int current_sector = AV_RL16(&sector[0x1C]);
  153. int sector_count = AV_RL16(&sector[0x1E]);
  154. int frame_size = AV_RL32(&sector[0x24]);
  155. if(!( frame_size>=0
  156. && current_sector < sector_count
  157. && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
  158. av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
  159. break;
  160. }
  161. if(str->channels[channel].video_stream_index < 0){
  162. /* allocate a new AVStream */
  163. st = avformat_new_stream(s, NULL);
  164. if (!st)
  165. return AVERROR(ENOMEM);
  166. avpriv_set_pts_info(st, 64, 1, 15);
  167. str->channels[channel].video_stream_index = st->index;
  168. st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  169. st->codec->codec_id = CODEC_ID_MDEC;
  170. st->codec->codec_tag = 0; /* no fourcc */
  171. st->codec->width = AV_RL16(&sector[0x28]);
  172. st->codec->height = AV_RL16(&sector[0x2A]);
  173. }
  174. /* if this is the first sector of the frame, allocate a pkt */
  175. pkt = &str->channels[channel].tmp_pkt;
  176. if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
  177. if(pkt->data)
  178. av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
  179. av_free_packet(pkt);
  180. if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
  181. return AVERROR(EIO);
  182. pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
  183. pkt->stream_index =
  184. str->channels[channel].video_stream_index;
  185. }
  186. memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
  187. sector + VIDEO_DATA_HEADER_SIZE,
  188. VIDEO_DATA_CHUNK_SIZE);
  189. if (current_sector == sector_count-1) {
  190. pkt->size= frame_size;
  191. *ret_pkt = *pkt;
  192. pkt->data= NULL;
  193. pkt->size= -1;
  194. return 0;
  195. }
  196. }
  197. break;
  198. case CDXA_TYPE_AUDIO:
  199. if(str->channels[channel].audio_stream_index < 0){
  200. int fmt = sector[0x13];
  201. /* allocate a new AVStream */
  202. st = avformat_new_stream(s, NULL);
  203. if (!st)
  204. return AVERROR(ENOMEM);
  205. str->channels[channel].audio_stream_index = st->index;
  206. st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  207. st->codec->codec_id = CODEC_ID_ADPCM_XA;
  208. st->codec->codec_tag = 0; /* no fourcc */
  209. st->codec->channels = (fmt&1)?2:1;
  210. st->codec->sample_rate = (fmt&4)?18900:37800;
  211. // st->codec->bit_rate = 0; //FIXME;
  212. st->codec->block_align = 128;
  213. avpriv_set_pts_info(st, 64, 128, st->codec->sample_rate);
  214. }
  215. pkt = ret_pkt;
  216. if (av_new_packet(pkt, 2304))
  217. return AVERROR(EIO);
  218. memcpy(pkt->data,sector+24,2304);
  219. pkt->stream_index =
  220. str->channels[channel].audio_stream_index;
  221. return 0;
  222. default:
  223. av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
  224. /* drop the sector and move on */
  225. break;
  226. }
  227. if (url_feof(pb))
  228. return AVERROR(EIO);
  229. }
  230. }
  231. static int str_read_close(AVFormatContext *s)
  232. {
  233. StrDemuxContext *str = s->priv_data;
  234. int i;
  235. for(i=0; i<32; i++){
  236. if(str->channels[i].tmp_pkt.data)
  237. av_free_packet(&str->channels[i].tmp_pkt);
  238. }
  239. return 0;
  240. }
  241. AVInputFormat ff_str_demuxer = {
  242. .name = "psxstr",
  243. .long_name = NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
  244. .priv_data_size = sizeof(StrDemuxContext),
  245. .read_probe = str_probe,
  246. .read_header = str_read_header,
  247. .read_packet = str_read_packet,
  248. .read_close = str_read_close,
  249. };