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