FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
psxstr.c
Go to the documentation of this file.
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 /**
23  * @file
24  * PSX STR file demuxer
25  * by Mike Melanson (melanson@pcisys.net)
26  * This module handles streams that have been ripped from Sony Playstation
27  * CD games. This demuxer can handle either raw STR files (which are just
28  * concatenations of raw compact disc sectors) or STR files with 0x2C-byte
29  * RIFF headers, followed by CD sectors.
30  */
31 
33 #include "libavutil/internal.h"
34 #include "libavutil/intreadwrite.h"
35 #include "avformat.h"
36 #include "internal.h"
37 
38 #define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
39 #define CDXA_TAG MKTAG('C', 'D', 'X', 'A')
40 
41 #define RAW_CD_SECTOR_SIZE 2352
42 #define RAW_CD_SECTOR_DATA_SIZE 2304
43 #define VIDEO_DATA_CHUNK_SIZE 0x7E0
44 #define VIDEO_DATA_HEADER_SIZE 0x38
45 #define RIFF_HEADER_SIZE 0x2C
46 
47 #define CDXA_TYPE_MASK 0x0E
48 #define CDXA_TYPE_DATA 0x08
49 #define CDXA_TYPE_AUDIO 0x04
50 #define CDXA_TYPE_VIDEO 0x02
51 
52 #define STR_MAGIC (0x80010160)
53 
54 typedef struct StrChannel {
55  /* video parameters */
58 
59  /* audio parameters */
61 } StrChannel;
62 
63 typedef struct StrDemuxContext {
64 
65  /* a STR file can contain up to 32 channels of data */
68 
69 static const uint8_t sync_header[12] = {0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};
70 
71 static int str_probe(AVProbeData *p)
72 {
73  const uint8_t *sector= p->buf;
74  const uint8_t *end= sector + p->buf_size;
75  int aud=0, vid=0;
76 
78  return 0;
79 
80  if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
81  (AV_RL32(&p->buf[8]) == CDXA_TAG)) {
82 
83  /* RIFF header seen; skip 0x2C bytes */
84  sector += RIFF_HEADER_SIZE;
85  }
86 
87  while (end - sector >= RAW_CD_SECTOR_SIZE) {
88  /* look for CD sync header (00, 0xFF x 10, 00) */
89  if (memcmp(sector,sync_header,sizeof(sync_header)))
90  return 0;
91 
92  if (sector[0x11] >= 32)
93  return 0;
94 
95  switch (sector[0x12] & CDXA_TYPE_MASK) {
96  case CDXA_TYPE_DATA:
97  case CDXA_TYPE_VIDEO: {
98  int current_sector = AV_RL16(&sector[0x1C]);
99  int sector_count = AV_RL16(&sector[0x1E]);
100  int frame_size = AV_RL32(&sector[0x24]);
101 
102  if(!( frame_size>=0
103  && current_sector < sector_count
104  && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
105  return 0;
106  }
107 
108  /*st->codec->width = AV_RL16(&sector[0x28]);
109  st->codec->height = AV_RL16(&sector[0x2A]);*/
110 
111 // if (current_sector == sector_count-1) {
112  vid++;
113 // }
114 
115  }
116  break;
117  case CDXA_TYPE_AUDIO:
118  if(sector[0x13]&0x2A)
119  return 0;
120  aud++;
121  break;
122  default:
123  if(sector[0x12] & CDXA_TYPE_MASK)
124  return 0;
125  }
126  sector += RAW_CD_SECTOR_SIZE;
127  }
128  /* MPEG files (like those ripped from VCDs) can also look like this;
129  * only return half certainty */
130  if(vid+aud > 3) return AVPROBE_SCORE_EXTENSION;
131  else if(vid+aud) return 1;
132  else return 0;
133 }
134 
136 {
137  AVIOContext *pb = s->pb;
138  StrDemuxContext *str = s->priv_data;
139  unsigned char sector[RAW_CD_SECTOR_SIZE];
140  int start;
141  int i;
142 
143  /* skip over any RIFF header */
144  if (avio_read(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
145  return AVERROR(EIO);
146  if (AV_RL32(&sector[0]) == RIFF_TAG)
147  start = RIFF_HEADER_SIZE;
148  else
149  start = 0;
150 
151  avio_seek(pb, start, SEEK_SET);
152 
153  for(i=0; i<32; i++){
155  str->channels[i].audio_stream_index= -1;
156  }
157 
159 
160  return 0;
161 }
162 
164  AVPacket *ret_pkt)
165 {
166  AVIOContext *pb = s->pb;
167  StrDemuxContext *str = s->priv_data;
168  unsigned char sector[RAW_CD_SECTOR_SIZE];
169  int channel;
170  AVPacket *pkt;
171  AVStream *st;
172 
173  while (1) {
174 
175  if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
176  return AVERROR(EIO);
177 
178  channel = sector[0x11];
179  if (channel >= 32)
180  return AVERROR_INVALIDDATA;
181 
182  switch (sector[0x12] & CDXA_TYPE_MASK) {
183 
184  case CDXA_TYPE_DATA:
185  case CDXA_TYPE_VIDEO:
186  {
187 
188  int current_sector = AV_RL16(&sector[0x1C]);
189  int sector_count = AV_RL16(&sector[0x1E]);
190  int frame_size = AV_RL32(&sector[0x24]);
191 
192  if(!( frame_size>=0
193  && current_sector < sector_count
194  && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
195  av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
196  break;
197  }
198 
199  if(str->channels[channel].video_stream_index < 0){
200  /* allocate a new AVStream */
201  st = avformat_new_stream(s, NULL);
202  if (!st)
203  return AVERROR(ENOMEM);
204  avpriv_set_pts_info(st, 64, 1, 15);
205 
206  str->channels[channel].video_stream_index = st->index;
207 
210  st->codec->codec_tag = 0; /* no fourcc */
211  st->codec->width = AV_RL16(&sector[0x28]);
212  st->codec->height = AV_RL16(&sector[0x2A]);
213  }
214 
215  /* if this is the first sector of the frame, allocate a pkt */
216  pkt = &str->channels[channel].tmp_pkt;
217 
218  if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
219  if(pkt->data)
220  av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
221  av_free_packet(pkt);
222  if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
223  return AVERROR(EIO);
224  memset(pkt->data, 0, sector_count*VIDEO_DATA_CHUNK_SIZE);
225 
226  pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
227  pkt->stream_index =
228  str->channels[channel].video_stream_index;
229  }
230 
231  memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
232  sector + VIDEO_DATA_HEADER_SIZE,
233  VIDEO_DATA_CHUNK_SIZE);
234 
235  if (current_sector == sector_count-1) {
236  pkt->size= frame_size;
237  *ret_pkt = *pkt;
238  pkt->data= NULL;
239  pkt->size= -1;
240  pkt->buf = NULL;
241 #if FF_API_DESTRUCT_PACKET
243  pkt->destruct = NULL;
245 #endif
246  return 0;
247  }
248 
249  }
250  break;
251 
252  case CDXA_TYPE_AUDIO:
253  if(str->channels[channel].audio_stream_index < 0){
254  int fmt = sector[0x13];
255  /* allocate a new AVStream */
256  st = avformat_new_stream(s, NULL);
257  if (!st)
258  return AVERROR(ENOMEM);
259 
260  str->channels[channel].audio_stream_index = st->index;
261 
264  st->codec->codec_tag = 0; /* no fourcc */
265  if (fmt & 1) {
266  st->codec->channels = 2;
268  } else {
269  st->codec->channels = 1;
271  }
272  st->codec->sample_rate = (fmt&4)?18900:37800;
273  // st->codec->bit_rate = 0; //FIXME;
274  st->codec->block_align = 128;
275 
276  avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,
277  st->codec->sample_rate);
278  st->start_time = 0;
279  }
280  pkt = ret_pkt;
281  if (av_new_packet(pkt, 2304))
282  return AVERROR(EIO);
283  memcpy(pkt->data,sector+24,2304);
284 
285  pkt->stream_index =
286  str->channels[channel].audio_stream_index;
287  pkt->duration = 1;
288  return 0;
289  default:
290  av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
291  /* drop the sector and move on */
292  break;
293  }
294 
295  if (avio_feof(pb))
296  return AVERROR(EIO);
297  }
298 }
299 
301 {
302  StrDemuxContext *str = s->priv_data;
303  int i;
304  for(i=0; i<32; i++){
305  if(str->channels[i].tmp_pkt.data)
306  av_free_packet(&str->channels[i].tmp_pkt);
307  }
308 
309  return 0;
310 }
311 
313  .name = "psxstr",
314  .long_name = NULL_IF_CONFIG_SMALL("Sony Playstation STR"),
315  .priv_data_size = sizeof(StrDemuxContext),
321 };