libavformat/psxstr.c

   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 psxstr.c
  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
  32 #include "avformat.h"
  33
  34 //#define PRINTSTUFF
  35
  36 #define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
  37 #define CDXA_TAG MKTAG('C', 'D', 'X', 'A')
  38
  39 #define RAW_CD_SECTOR_SIZE 2352
  40 #define RAW_CD_SECTOR_DATA_SIZE 2304
  41 #define VIDEO_DATA_CHUNK_SIZE 0x7E0
  42 #define VIDEO_DATA_HEADER_SIZE 0x38
  43 #define RIFF_HEADER_SIZE 0x2C
  44
  45 #define CDXA_TYPE_MASK     0x0E
  46 #define CDXA_TYPE_DATA     0x08
  47 #define CDXA_TYPE_AUDIO    0x04
  48 #define CDXA_TYPE_VIDEO    0x02
  49
  50 #define STR_MAGIC (0x80010160)
  51
  52 typedef struct StrChannel {
  53
  54     int type;
  55 #define STR_AUDIO 0
  56 #define STR_VIDEO 1
  57
  58     /* video parameters */
  59     int width;
  60     int height;
  61     int video_stream_index;
  62
  63     /* audio parameters */
  64     int sample_rate;
  65     int channels;
  66     int bits;
  67     int audio_stream_index;
  68 } StrChannel;
  69
  70 typedef struct StrDemuxContext {
  71
  72     /* a STR file can contain up to 32 channels of data */
  73     StrChannel channels[32];
  74
  75     /* only decode the first audio and video channels encountered */
  76     int video_channel;
  77     int audio_channel;
  78
  79     int64_t pts;
  80
  81     unsigned char *video_chunk;
  82     AVPacket tmp_pkt;
  83 } StrDemuxContext;
  84
  85 static const char sync_header[12] = {0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};
  86
  87 static int str_probe(AVProbeData *p)
  88 {
  89     int start;
  90
  91     /* need at least 0x38 bytes to validate */
  92     if (p->buf_size < 0x38)
  93         return 0;
  94
  95     if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
  96         (AV_RL32(&p->buf[8]) == CDXA_TAG)) {
  97
  98         /* RIFF header seen; skip 0x2C bytes */
  99         start = RIFF_HEADER_SIZE;
 100     } else
 101         start = 0;
 102
 103     /* look for CD sync header (00, 0xFF x 10, 00) */
 104     if (memcmp(p->buf+start,sync_header,sizeof(sync_header)))
 105         return 0;
 106
 107     /* MPEG files (like those ripped from VCDs) can also look like this;
 108      * only return half certainty */
 109     return 50;
 110 }
 111
 112 #if 0
 113 static void dump(unsigned char *buf,size_t len)
 114 {
 115     int i;
 116     for(i=0;i<len;i++) {
 117         if ((i&15)==0) av_log(NULL, AV_LOG_DEBUG, "%04x  ",i);
 118         av_log(NULL, AV_LOG_DEBUG, "%02x ",buf[i]);
 119         if ((i&15)==15) av_log(NULL, AV_LOG_DEBUG, "\n");
 120     }
 121     av_log(NULL, AV_LOG_DEBUG, "\n");
 122 }
 123 #endif
 124
 125 static int str_read_header(AVFormatContext *s,
 126                            AVFormatParameters *ap)
 127 {
 128     ByteIOContext *pb = s->pb;
 129     StrDemuxContext *str = s->priv_data;
 130     AVStream *st;
 131     unsigned char sector[RAW_CD_SECTOR_SIZE];
 132     int start;
 133     int i;
 134     int channel;
 135
 136     /* initialize context members */
 137     str->pts = 0;
 138     str->audio_channel = -1;  /* assume to audio or video */
 139     str->video_channel = -1;
 140     str->video_chunk = NULL;
 141
 142
 143     /* skip over any RIFF header */
 144     if (get_buffer(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     url_fseek(pb, start, SEEK_SET);
 152
 153     /* check through the first 32 sectors for individual channels */
 154     for (i = 0; i < 32; i++) {
 155         if (get_buffer(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
 156             return AVERROR(EIO);
 157
 158 //printf("%02x %02x %02x %02x\n",sector[0x10],sector[0x11],sector[0x12],sector[0x13]);
 159
 160         channel = sector[0x11];
 161         if (channel >= 32)
 162             return AVERROR_INVALIDDATA;
 163
 164         switch (sector[0x12] & CDXA_TYPE_MASK) {
 165
 166         case CDXA_TYPE_DATA:
 167         case CDXA_TYPE_VIDEO:
 168             /* check if this channel gets to be the dominant video channel */
 169             if (str->video_channel == -1) {
 170                 /* qualify the magic number */
 171                 if (AV_RL32(&sector[0x18]) != STR_MAGIC)
 172                     break;
 173                 str->video_channel = channel;
 174                 str->channels[channel].type = STR_VIDEO;
 175                 str->channels[channel].width = AV_RL16(&sector[0x28]);
 176                 str->channels[channel].height = AV_RL16(&sector[0x2A]);
 177
 178                 /* allocate a new AVStream */
 179                 st = av_new_stream(s, 0);
 180                 if (!st)
 181                     return AVERROR(ENOMEM);
 182                 av_set_pts_info(st, 64, 1, 15);
 183
 184                 str->channels[channel].video_stream_index = st->index;
 185
 186                 st->codec->codec_type = CODEC_TYPE_VIDEO;
 187                 st->codec->codec_id = CODEC_ID_MDEC;
 188                 st->codec->codec_tag = 0;  /* no fourcc */
 189                 st->codec->width = str->channels[channel].width;
 190                 st->codec->height = str->channels[channel].height;
 191             }
 192             break;
 193
 194         case CDXA_TYPE_AUDIO:
 195             /* check if this channel gets to be the dominant audio channel */
 196             if (str->audio_channel == -1) {
 197                 int fmt;
 198                 str->audio_channel = channel;
 199                 str->channels[channel].type = STR_AUDIO;
 200                 str->channels[channel].channels =
 201                     (sector[0x13] & 0x01) ? 2 : 1;
 202                 str->channels[channel].sample_rate =
 203                     (sector[0x13] & 0x04) ? 18900 : 37800;
 204                 str->channels[channel].bits =
 205                     (sector[0x13] & 0x10) ? 8 : 4;
 206
 207                 /* allocate a new AVStream */
 208                 st = av_new_stream(s, 0);
 209                 if (!st)
 210                     return AVERROR(ENOMEM);
 211                 av_set_pts_info(st, 64, 128, str->channels[channel].sample_rate);
 212
 213                 str->channels[channel].audio_stream_index = st->index;
 214
 215                 fmt = sector[0x13];
 216                 st->codec->codec_type = CODEC_TYPE_AUDIO;
 217                 st->codec->codec_id = CODEC_ID_ADPCM_XA;
 218                 st->codec->codec_tag = 0;  /* no fourcc */
 219                 st->codec->channels = (fmt&1)?2:1;
 220                 st->codec->sample_rate = (fmt&4)?18900:37800;
 221             //    st->codec->bit_rate = 0; //FIXME;
 222                 st->codec->block_align = 128;
 223             }
 224             break;
 225
 226         default:
 227             /* ignore */
 228             break;
 229         }
 230     }
 231
 232 if (str->video_channel != -1)
 233   av_log (s, AV_LOG_DEBUG, " video channel = %d, %d x %d %d\n", str->video_channel,
 234     str->channels[str->video_channel].width,
 235     str->channels[str->video_channel].height,str->channels[str->video_channel].video_stream_index);
 236 if (str->audio_channel != -1)
 237    av_log (s, AV_LOG_DEBUG, " audio channel = %d, %d Hz, %d channels, %d bits/sample %d\n",
 238     str->audio_channel,
 239     str->channels[str->audio_channel].sample_rate,
 240     str->channels[str->audio_channel].channels,
 241     str->channels[str->audio_channel].bits,str->channels[str->audio_channel].audio_stream_index);
 242
 243     /* back to the start */
 244     url_fseek(pb, start, SEEK_SET);
 245
 246     return 0;
 247 }
 248
 249 static int str_read_packet(AVFormatContext *s,
 250                            AVPacket *ret_pkt)
 251 {
 252     ByteIOContext *pb = s->pb;
 253     StrDemuxContext *str = s->priv_data;
 254     unsigned char sector[RAW_CD_SECTOR_SIZE];
 255     int channel;
 256     int packet_read = 0;
 257     int ret = 0;
 258     AVPacket *pkt;
 259
 260     while (!packet_read) {
 261
 262         if (get_buffer(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
 263             return AVERROR(EIO);
 264
 265         channel = sector[0x11];
 266         if (channel >= 32)
 267             return AVERROR_INVALIDDATA;
 268
 269         switch (sector[0x12] & CDXA_TYPE_MASK) {
 270
 271         case CDXA_TYPE_DATA:
 272         case CDXA_TYPE_VIDEO:
 273             /* check if this the video channel we care about */
 274             if (channel == str->video_channel) {
 275
 276                 int current_sector = AV_RL16(&sector[0x1C]);
 277                 int sector_count   = AV_RL16(&sector[0x1E]);
 278                 int frame_size = AV_RL32(&sector[0x24]);
 279                 int bytes_to_copy;
 280 //        printf("%d %d %d\n",current_sector,sector_count,frame_size);
 281                 /* if this is the first sector of the frame, allocate a pkt */
 282                 pkt = &str->tmp_pkt;
 283                 if (current_sector == 0) {
 284                     if (av_new_packet(pkt, frame_size))
 285                         return AVERROR(EIO);
 286
 287                     pkt->pos= url_ftell(pb) - RAW_CD_SECTOR_SIZE;
 288                     pkt->stream_index =
 289                         str->channels[channel].video_stream_index;
 290                //     pkt->pts = str->pts;
 291
 292                     /* if there is no audio, adjust the pts after every video
 293                      * frame; assume 15 fps */
 294                    if (str->audio_channel != -1)
 295                        str->pts += (90000 / 15);
 296                 }
 297
 298                 /* load all the constituent chunks in the video packet */
 299                 bytes_to_copy = frame_size - current_sector*VIDEO_DATA_CHUNK_SIZE;
 300                 if (bytes_to_copy>0) {
 301                     if (bytes_to_copy>VIDEO_DATA_CHUNK_SIZE) bytes_to_copy=VIDEO_DATA_CHUNK_SIZE;
 302                     memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
 303                         sector + VIDEO_DATA_HEADER_SIZE, bytes_to_copy);
 304                 }
 305                 if (current_sector == sector_count-1) {
 306                     *ret_pkt = *pkt;
 307                     return 0;
 308                 }
 309
 310             }
 311             break;
 312
 313         case CDXA_TYPE_AUDIO:
 314 #ifdef PRINTSTUFF
 315 printf (" dropping audio sector\n");
 316 #endif
 317 #if 1
 318             /* check if this the video channel we care about */
 319             if (channel == str->audio_channel) {
 320                 pkt = ret_pkt;
 321                 if (av_new_packet(pkt, 2304))
 322                     return AVERROR(EIO);
 323                 memcpy(pkt->data,sector+24,2304);
 324
 325                 pkt->stream_index =
 326                     str->channels[channel].audio_stream_index;
 327                 //pkt->pts = str->pts;
 328                 return 0;
 329             }
 330 #endif
 331             break;
 332         default:
 333             /* drop the sector and move on */
 334 #ifdef PRINTSTUFF
 335 printf (" dropping other sector\n");
 336 #endif
 337             break;
 338         }
 339
 340         if (url_feof(pb))
 341             return AVERROR(EIO);
 342     }
 343
 344     return ret;
 345 }
 346
 347 static int str_read_close(AVFormatContext *s)
 348 {
 349     StrDemuxContext *str = s->priv_data;
 350
 351     av_free(str->video_chunk);
 352
 353     return 0;
 354 }
 355
 356 AVInputFormat str_demuxer = {
 357     "psxstr",
 358     "Sony Playstation STR format",
 359     sizeof(StrDemuxContext),
 360     str_probe,
 361     str_read_header,
 362     str_read_packet,
 363     str_read_close,
 364 };