[deb_ffmpeg.git] / ffmpeg / libavformat / psxstr.c

/*
 * Sony Playstation (PSX) STR File Demuxer
 * Copyright (c) 2003 The FFmpeg Project
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * PSX STR file demuxer
 * by Mike Melanson (melanson@pcisys.net)
 * This module handles streams that have been ripped from Sony Playstation
 * CD games. This demuxer can handle either raw STR files (which are just
 * concatenations of raw compact disc sectors) or STR files with 0x2C-byte
 * RIFF headers, followed by CD sectors.
 */

#include "libavutil/channel_layout.h"
#include "libavutil/internal.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "internal.h"

#define RIFF_TAG MKTAG('R', 'I', 'F', 'F')
#define CDXA_TAG MKTAG('C', 'D', 'X', 'A')

#define RAW_CD_SECTOR_SIZE      2352
#define RAW_CD_SECTOR_DATA_SIZE 2304
#define VIDEO_DATA_CHUNK_SIZE   0x7E0
#define VIDEO_DATA_HEADER_SIZE  0x38
#define RIFF_HEADER_SIZE        0x2C

#define CDXA_TYPE_MASK     0x0E
#define CDXA_TYPE_DATA     0x08
#define CDXA_TYPE_AUDIO    0x04
#define CDXA_TYPE_VIDEO    0x02

#define STR_MAGIC (0x80010160)

typedef struct StrChannel {
    /* video parameters */
    int video_stream_index;
    AVPacket tmp_pkt;

    /* audio parameters */
    int audio_stream_index;
} StrChannel;

typedef struct StrDemuxContext {

    /* a STR file can contain up to 32 channels of data */
    StrChannel channels[32];
} StrDemuxContext;

static const uint8_t sync_header[12] = {0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};

static int str_probe(AVProbeData *p)
{
    const uint8_t *sector= p->buf;
    const uint8_t *end= sector + p->buf_size;
    int aud=0, vid=0;

    if (p->buf_size < RAW_CD_SECTOR_SIZE)
        return 0;

    if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
        (AV_RL32(&p->buf[8]) == CDXA_TAG)) {

        /* RIFF header seen; skip 0x2C bytes */
        sector += RIFF_HEADER_SIZE;
    }

    while (end - sector >= RAW_CD_SECTOR_SIZE) {
        /* look for CD sync header (00, 0xFF x 10, 00) */
        if (memcmp(sector,sync_header,sizeof(sync_header)))
            return 0;

        if (sector[0x11] >= 32)
            return 0;

        switch (sector[0x12] & CDXA_TYPE_MASK) {
        case CDXA_TYPE_DATA:
        case CDXA_TYPE_VIDEO: {
                int current_sector = AV_RL16(&sector[0x1C]);
                int sector_count   = AV_RL16(&sector[0x1E]);
                int frame_size = AV_RL32(&sector[0x24]);

                if(!(   frame_size>=0
                     && current_sector < sector_count
                     && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
                    return 0;
                }

                /*st->codec->width      = AV_RL16(&sector[0x28]);
                st->codec->height     = AV_RL16(&sector[0x2A]);*/

//                 if (current_sector == sector_count-1) {
                    vid++;
//                 }

            }
            break;
        case CDXA_TYPE_AUDIO:
            if(sector[0x13]&0x2A)
                return 0;
            aud++;
            break;
        default:
            if(sector[0x12] & CDXA_TYPE_MASK)
                return 0;
        }
        sector += RAW_CD_SECTOR_SIZE;
    }
    /* MPEG files (like those ripped from VCDs) can also look like this;
     * only return half certainty */
    if(vid+aud > 3)  return AVPROBE_SCORE_EXTENSION;
    else if(vid+aud) return 1;
    else             return 0;
}

static int str_read_header(AVFormatContext *s)
{
    AVIOContext *pb = s->pb;
    StrDemuxContext *str = s->priv_data;
    unsigned char sector[RAW_CD_SECTOR_SIZE];
    int start;
    int i;

    /* skip over any RIFF header */
    if (avio_read(pb, sector, RIFF_HEADER_SIZE) != RIFF_HEADER_SIZE)
        return AVERROR(EIO);
    if (AV_RL32(&sector[0]) == RIFF_TAG)
        start = RIFF_HEADER_SIZE;
    else
        start = 0;

    avio_seek(pb, start, SEEK_SET);

    for(i=0; i<32; i++){
        str->channels[i].video_stream_index=
        str->channels[i].audio_stream_index= -1;
    }

    s->ctx_flags |= AVFMTCTX_NOHEADER;

    return 0;
}

static int str_read_packet(AVFormatContext *s,
                           AVPacket *ret_pkt)
{
    AVIOContext *pb = s->pb;
    StrDemuxContext *str = s->priv_data;
    unsigned char sector[RAW_CD_SECTOR_SIZE];
    int channel;
    AVPacket *pkt;
    AVStream *st;

    while (1) {

        if (avio_read(pb, sector, RAW_CD_SECTOR_SIZE) != RAW_CD_SECTOR_SIZE)
            return AVERROR(EIO);

        channel = sector[0x11];
        if (channel >= 32)
            return AVERROR_INVALIDDATA;

        switch (sector[0x12] & CDXA_TYPE_MASK) {

        case CDXA_TYPE_DATA:
        case CDXA_TYPE_VIDEO:
            {

                int current_sector = AV_RL16(&sector[0x1C]);
                int sector_count   = AV_RL16(&sector[0x1E]);
                int frame_size = AV_RL32(&sector[0x24]);

                if(!(   frame_size>=0
                     && current_sector < sector_count
                     && sector_count*VIDEO_DATA_CHUNK_SIZE >=frame_size)){
                    av_log(s, AV_LOG_ERROR, "Invalid parameters %d %d %d\n", current_sector, sector_count, frame_size);
                    break;
                }

                if(str->channels[channel].video_stream_index < 0){
                    /* allocate a new AVStream */
                    st = avformat_new_stream(s, NULL);
                    if (!st)
                        return AVERROR(ENOMEM);
                    avpriv_set_pts_info(st, 64, 1, 15);

                    str->channels[channel].video_stream_index = st->index;

                    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
                    st->codec->codec_id   = AV_CODEC_ID_MDEC;
                    st->codec->codec_tag  = 0;  /* no fourcc */
                    st->codec->width      = AV_RL16(&sector[0x28]);
                    st->codec->height     = AV_RL16(&sector[0x2A]);
                }

                /* if this is the first sector of the frame, allocate a pkt */
                pkt = &str->channels[channel].tmp_pkt;

                if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
                    if(pkt->data)
                        av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
                    av_free_packet(pkt);
                    if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
                        return AVERROR(EIO);
                    memset(pkt->data, 0, sector_count*VIDEO_DATA_CHUNK_SIZE);

                    pkt->pos= avio_tell(pb) - RAW_CD_SECTOR_SIZE;
                    pkt->stream_index =
                        str->channels[channel].video_stream_index;
                }

                memcpy(pkt->data + current_sector*VIDEO_DATA_CHUNK_SIZE,
                       sector + VIDEO_DATA_HEADER_SIZE,
                       VIDEO_DATA_CHUNK_SIZE);

                if (current_sector == sector_count-1) {
                    pkt->size= frame_size;
                    *ret_pkt = *pkt;
                    pkt->data= NULL;
                    pkt->size= -1;
                    pkt->buf = NULL;
#if FF_API_DESTRUCT_PACKET
FF_DISABLE_DEPRECATION_WARNINGS
                    pkt->destruct = NULL;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
                    return 0;
                }

            }
            break;

        case CDXA_TYPE_AUDIO:
            if(str->channels[channel].audio_stream_index < 0){
                int fmt = sector[0x13];
                /* allocate a new AVStream */
                st = avformat_new_stream(s, NULL);
                if (!st)
                    return AVERROR(ENOMEM);

                str->channels[channel].audio_stream_index = st->index;

                st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
                st->codec->codec_id    = AV_CODEC_ID_ADPCM_XA;
                st->codec->codec_tag   = 0;  /* no fourcc */
                if (fmt & 1) {
                    st->codec->channels       = 2;
                    st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
                } else {
                    st->codec->channels       = 1;
                    st->codec->channel_layout = AV_CH_LAYOUT_MONO;
                }
                st->codec->sample_rate = (fmt&4)?18900:37800;
            //    st->codec->bit_rate = 0; //FIXME;
                st->codec->block_align = 128;

                avpriv_set_pts_info(st, 64, 18 * 224 / st->codec->channels,
                                    st->codec->sample_rate);
                st->start_time = 0;
            }
            pkt = ret_pkt;
            if (av_new_packet(pkt, 2304))
                return AVERROR(EIO);
            memcpy(pkt->data,sector+24,2304);

            pkt->stream_index =
                str->channels[channel].audio_stream_index;
            pkt->duration = 1;
            return 0;
        default:
            av_log(s, AV_LOG_WARNING, "Unknown sector type %02X\n", sector[0x12]);
            /* drop the sector and move on */
            break;
        }

        if (avio_feof(pb))
            return AVERROR(EIO);
    }
}

static int str_read_close(AVFormatContext *s)
{
    StrDemuxContext *str = s->priv_data;
    int i;
    for(i=0; i<32; i++){
        if(str->channels[i].tmp_pkt.data)
            av_free_packet(&str->channels[i].tmp_pkt);
    }

    return 0;
}

AVInputFormat ff_str_demuxer = {
    .name           = "psxstr",
    .long_name      = NULL_IF_CONFIG_SMALL("Sony Playstation STR"),
    .priv_data_size = sizeof(StrDemuxContext),
    .read_probe     = str_probe,
    .read_header    = str_read_header,
    .read_packet    = str_read_packet,
    .read_close     = str_read_close,
    .flags          = AVFMT_NO_BYTE_SEEK,
};
Commit	Line	Data
2ba45a60 DM	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
	32	#include "libavutil/channel_layout.h"
	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 */
	56	int video_stream_index;
	57	AVPacket tmp_pkt;
	58
	59	/* audio parameters */
	60	int audio_stream_index;
	61	} StrChannel;
	62
	63	typedef struct StrDemuxContext {
	64
65	/* a STR file can contain up to 32 channels of data */
66	StrChannel channels[32];
67	} StrDemuxContext;
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
77	if (p->buf_size < RAW_CD_SECTOR_SIZE)
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
135	static int str_read_header(AVFormatContext *s)
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++){
154	str->channels[i].video_stream_index=
155	str->channels[i].audio_stream_index= -1;
156	}
157
158	s->ctx_flags \|= AVFMTCTX_NOHEADER;
159
160	return 0;
161	}
162
163	static int str_read_packet(AVFormatContext *s,
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
208	st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
209	st->codec->codec_id = AV_CODEC_ID_MDEC;
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
242	FF_DISABLE_DEPRECATION_WARNINGS
243	pkt->destruct = NULL;
244	FF_ENABLE_DEPRECATION_WARNINGS
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
262	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
263	st->codec->codec_id = AV_CODEC_ID_ADPCM_XA;
264	st->codec->codec_tag = 0; /* no fourcc */
265	if (fmt & 1) {
266	st->codec->channels = 2;
267	st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
268	} else {
269	st->codec->channels = 1;
270	st->codec->channel_layout = AV_CH_LAYOUT_MONO;
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
300	static int str_read_close(AVFormatContext *s)
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
312	AVInputFormat ff_str_demuxer = {
313	.name = "psxstr",
314	.long_name = NULL_IF_CONFIG_SMALL("Sony Playstation STR"),
315	.priv_data_size = sizeof(StrDemuxContext),
316	.read_probe = str_probe,
317	.read_header = str_read_header,
318	.read_packet = str_read_packet,
319	.read_close = str_read_close,
320	.flags = AVFMT_NO_BYTE_SEEK,
321	};