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 };
StrChannel channels[32]
Definition: psxstr.c:66
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:631
Bytestream IO Context.
Definition: avio.h:111
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:280
const char * fmt
Definition: avisynth_c.h:632
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1447
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4075
int index
stream index in AVFormatContext
Definition: avformat.h:843
int size
Definition: avcodec.h:1423
static int str_read_header(AVFormatContext *s)
Definition: psxstr.c:135
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:204
#define CDXA_TYPE_DATA
Definition: psxstr.c:48
int audio_stream_index
Definition: psxstr.c:60
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1322
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2298
Format I/O context.
Definition: avformat.h:1273
uint8_t
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1232
attribute_deprecated void(* destruct)(struct AVPacket *)
Definition: avcodec.h:1443
#define CDXA_TAG
Definition: psxstr.c:39
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVInputFormat ff_str_demuxer
Definition: psxstr.c:312
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:3741
#define VIDEO_DATA_HEADER_SIZE
Definition: psxstr.c:44
uint8_t * data
Definition: avcodec.h:1422
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:390
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1440
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:538
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:83
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1405
#define RIFF_TAG
Definition: psxstr.c:38
#define RAW_CD_SECTOR_SIZE
Definition: psxstr.c:41
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2322
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:861
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:451
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:450
common internal API header
#define VIDEO_DATA_CHUNK_SIZE
Definition: psxstr.c:43
audio channel layout utility functions
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
int width
picture width / height.
Definition: avcodec.h:1680
#define CDXA_TYPE_VIDEO
Definition: psxstr.c:50
#define RIFF_HEADER_SIZE
Definition: psxstr.c:45
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:620
Stream structure.
Definition: avformat.h:842
AVPacket tmp_pkt
Definition: psxstr.c:57
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static int str_read_packet(AVFormatContext *s, AVPacket *ret_pkt)
Definition: psxstr.c:163
static int str_probe(AVProbeData *p)
Definition: psxstr.c:71
int frame_size
Definition: mxfenc.c:1803
enum AVMediaType codec_type
Definition: avcodec.h:1509
enum AVCodecID codec_id
Definition: avcodec.h:1518
int sample_rate
samples per second
Definition: avcodec.h:2261
AVIOContext * pb
I/O context.
Definition: avformat.h:1315
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1533
static const uint8_t sync_header[12]
Definition: psxstr.c:69
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:458
This structure contains the data a format has to probe a file.
Definition: avformat.h:448
static int flags
Definition: cpu.c:47
int video_stream_index
Definition: psxstr.c:56
#define CDXA_TYPE_AUDIO
Definition: psxstr.c:49
Main libavformat public API header.
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:79
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:894
static int str_read_close(AVFormatContext *s)
Definition: psxstr.c:300
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:480
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
int channels
number of audio channels
Definition: avcodec.h:2262
void * priv_data
Format private data.
Definition: avformat.h:1301
void INT64 start
Definition: avisynth_c.h:553
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:628
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:301
int stream_index
Definition: avcodec.h:1424
#define CDXA_TYPE_MASK
Definition: psxstr.c:47
#define AV_CH_LAYOUT_MONO
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1399