psxstr.c 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  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 libavformat/psxstr.c
  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. #define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
  33. #define CDXA_TAG MKTAG('C', 'D', 'X', 'A')
  34. #define RAW_CD_SECTOR_SIZE 2352
  35. #define RAW_CD_SECTOR_DATA_SIZE 2304
  36. #define VIDEO_DATA_CHUNK_SIZE 0x7E0
  37. #define VIDEO_DATA_HEADER_SIZE 0x38
  38. #define RIFF_HEADER_SIZE 0x2C
  39. #define CDXA_TYPE_MASK 0x0E
  40. #define CDXA_TYPE_DATA 0x08
  41. #define CDXA_TYPE_AUDIO 0x04
  42. #define CDXA_TYPE_VIDEO 0x02
  43. #define STR_MAGIC (0x80010160)
  44. typedef struct StrChannel {
  45. /* video parameters */
  46. int video_stream_index;
  47. AVPacket tmp_pkt;
  48. /* audio parameters */
  49. int audio_stream_index;
  50. } StrChannel;
  51. typedef struct StrDemuxContext {
  52. /* a STR file can contain up to 32 channels of data */
  53. StrChannel channels[32];
  54. } StrDemuxContext;
  55. static const char sync_header[12] = {0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};
  56. static int str_probe(AVProbeData *p)
  57. {
  58. uint8_t *sector= p->buf;
  59. if (p->buf_size < RAW_CD_SECTOR_SIZE)
  60. return 0;
  61. if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
  62. (AV_RL32(&p->buf[8]) == CDXA_TAG)) {
  63. /* RIFF header seen; skip 0x2C bytes */
  64. sector += RIFF_HEADER_SIZE;
  65. }
  66. /* look for CD sync header (00, 0xFF x 10, 00) */
  67. if (memcmp(sector,sync_header,sizeof(sync_header)))
  68. return 0;
  69. if(sector[0x11] >= 32)
  70. return 0;
  71. if( (sector[0x12] & CDXA_TYPE_MASK) != CDXA_TYPE_VIDEO
  72. && (sector[0x12] & CDXA_TYPE_MASK) != CDXA_TYPE_AUDIO
  73. && (sector[0x12] & CDXA_TYPE_MASK) != CDXA_TYPE_DATA)
  74. return 0;
  75. /* MPEG files (like those ripped from VCDs) can also look like this;
  76. * only return half certainty */
  77. return 50;
  78. }
  79. static int str_read_header(AVFormatContext *s,
  80. AVFormatParameters *ap)
  81. {
  82. ByteIOContext *pb = s->pb;
  83. StrDemuxContext *str = s->priv_data;
  84. unsigned char sector[RAW_CD_SECTOR_SIZE];
  85. int start;
  86. int i;
  87. /* skip over any RIFF header */
  88. if (get_buffer(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
  89. return AVERROR(EIO);
  90. if (AV_RL32(&sector[0]) == RIFF_TAG)
  91. start = RIFF_HEADER_SIZE;
  92. else
  93. start = 0;
  94. url_fseek(pb, start, SEEK_SET);
  95. for(i=0; i<32; i++){
  96. str->channels[i].video_stream_index=
  97. str->channels[i].audio_stream_index= -1;
  98. }
  99. s->ctx_flags |= AVFMTCTX_NOHEADER;
  100. return 0;
  101. }
  102. static int str_read_packet(AVFormatContext *s,
  103. AVPacket *ret_pkt)
  104. {
  105. ByteIOContext *pb = s->pb;
  106. StrDemuxContext *str = s->priv_data;
  107. unsigned char sector[RAW_CD_SECTOR_SIZE];
  108. int channel;
  109. AVPacket *pkt;
  110. AVStream *st;
  111. while (1) {
  112. if (get_buffer(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
  113. return AVERROR(EIO);
  114. channel = sector[0x11];
  115. if (channel >= 32)
  116. return AVERROR_INVALIDDATA;
  117. switch (sector[0x12] & CDXA_TYPE_MASK) {
  118. case CDXA_TYPE_DATA:
  119. case CDXA_TYPE_VIDEO:
  120. {
  121. int current_sector = AV_RL16(&sector[0x1C]);
  122. int sector_count = AV_RL16(&sector[0x1E]);
  123. int frame_size = AV_RL32(&sector[0x24]);
  124. if(!( frame_size>=0
  125. && current_sector < sector_count
  126. && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
  127. av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
  128. break;
  129. }
  130. if(str->channels[channel].video_stream_index < 0){
  131. /* allocate a new AVStream */
  132. st = av_new_stream(s, 0);
  133. if (!st)
  134. return AVERROR(ENOMEM);
  135. av_set_pts_info(st, 64, 1, 15);
  136. str->channels[channel].video_stream_index = st->index;
  137. st->codec->codec_type = CODEC_TYPE_VIDEO;
  138. st->codec->codec_id = CODEC_ID_MDEC;
  139. st->codec->codec_tag = 0; /* no fourcc */
  140. st->codec->width = AV_RL16(&sector[0x28]);
  141. st->codec->height = AV_RL16(&sector[0x2A]);
  142. }
  143. /* if this is the first sector of the frame, allocate a pkt */
  144. pkt = &str->channels[channel].tmp_pkt;
  145. if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
  146. if(pkt->data)
  147. av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
  148. av_free_packet(pkt);
  149. if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
  150. return AVERROR(EIO);
  151. pkt->pos= url_ftell(pb) - RAW_CD_SECTOR_SIZE;
  152. pkt->stream_index =
  153. str->channels[channel].video_stream_index;
  154. }
  155. memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
  156. sector + VIDEO_DATA_HEADER_SIZE,
  157. VIDEO_DATA_CHUNK_SIZE);
  158. if (current_sector == sector_count-1) {
  159. pkt->size= frame_size;
  160. *ret_pkt = *pkt;
  161. pkt->data= NULL;
  162. pkt->size= -1;
  163. return 0;
  164. }
  165. }
  166. break;
  167. case CDXA_TYPE_AUDIO:
  168. if(str->channels[channel].audio_stream_index < 0){
  169. int fmt = sector[0x13];
  170. /* allocate a new AVStream */
  171. st = av_new_stream(s, 0);
  172. if (!st)
  173. return AVERROR(ENOMEM);
  174. str->channels[channel].audio_stream_index = st->index;
  175. st->codec->codec_type = CODEC_TYPE_AUDIO;
  176. st->codec->codec_id = CODEC_ID_ADPCM_XA;
  177. st->codec->codec_tag = 0; /* no fourcc */
  178. st->codec->channels = (fmt&1)?2:1;
  179. st->codec->sample_rate = (fmt&4)?18900:37800;
  180. // st->codec->bit_rate = 0; //FIXME;
  181. st->codec->block_align = 128;
  182. av_set_pts_info(st, 64, 128, st->codec->sample_rate);
  183. }
  184. pkt = ret_pkt;
  185. if (av_new_packet(pkt, 2304))
  186. return AVERROR(EIO);
  187. memcpy(pkt->data,sector+24,2304);
  188. pkt->stream_index =
  189. str->channels[channel].audio_stream_index;
  190. return 0;
  191. break;
  192. default:
  193. av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
  194. /* drop the sector and move on */
  195. break;
  196. }
  197. if (url_feof(pb))
  198. return AVERROR(EIO);
  199. }
  200. }
  201. static int str_read_close(AVFormatContext *s)
  202. {
  203. StrDemuxContext *str = s->priv_data;
  204. int i;
  205. for(i=0; i<32; i++){
  206. if(str->channels[i].tmp_pkt.data)
  207. av_free_packet(&str->channels[i].tmp_pkt);
  208. }
  209. return 0;
  210. }
  211. AVInputFormat str_demuxer = {
  212. "psxstr",
  213. NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
  214. sizeof(StrDemuxContext),
  215. str_probe,
  216. str_read_header,
  217. str_read_packet,
  218. str_read_close,
  219. };