2010-10-19 04:16:08 +02:00
|
|
|
#include "meta.h"
|
|
|
|
#include "../util.h"
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
|
|
|
|
/* utils to fix AT3 looping */
|
|
|
|
typedef struct {
|
|
|
|
int32_t fact_samples;
|
|
|
|
int32_t loop_start_sample;
|
|
|
|
int32_t loop_end_sample;
|
|
|
|
int32_t skip_samples;
|
|
|
|
} at3_riff_info;
|
|
|
|
static int get_at3_riff_info(at3_riff_info* info, STREAMFILE *streamFile, int32_t offset);
|
|
|
|
|
|
|
|
|
|
|
|
/* Sony's SGB+SGH / SGD / SGX (variations of the same format)
|
|
|
|
* PS3: Genji (SGX only), Folklore, Afrika, Tokyo Jungle
|
|
|
|
* PSP: Brave Story, Sarugetchu Sarusaru Daisakusen, Kurohyo 1/2
|
|
|
|
*
|
|
|
|
* Contains header + chunks, usually:
|
|
|
|
* WAVE: stream(s) header of ADPCM, AC3, ATRAC3plus, etc
|
|
|
|
* NAME: stream name(s)
|
|
|
|
* WSUR, WMRK, BUSS: unknown
|
|
|
|
* RGND, SEQD: unknown (related to SE)
|
|
|
|
* Then data, containing the original header if applicable (ex. AT3 RIFF).
|
|
|
|
* The SGDX header has priority over it (ex. some ATRAC3plus files have 48000 while the data RIFF 44100)
|
|
|
|
*/
|
|
|
|
VGMSTREAM * init_vgmstream_ps3_sgdx(STREAMFILE *streamFile) {
|
2010-10-19 04:16:08 +02:00
|
|
|
VGMSTREAM * vgmstream = NULL;
|
2016-12-04 17:51:35 +01:00
|
|
|
STREAMFILE * streamHeader = NULL;
|
2017-01-27 23:39:52 +01:00
|
|
|
int32_t stream_size = 0;
|
2013-05-27 05:55:50 +02:00
|
|
|
char filename[PATH_LIMIT];
|
2010-10-19 04:16:08 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
off_t start_offset, data_offset;
|
2010-10-19 04:16:08 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
int i;
|
|
|
|
int is_sgx, is_sgd, is_sgb;
|
2010-10-19 04:16:08 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
int chunk_offset;
|
|
|
|
int total_streams;
|
|
|
|
int target_stream = 0; /* usually only SE use substreams */
|
2010-11-22 02:45:39 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
|
|
ffmpeg_codec_data *ffmpeg_data = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* check extension, case insensitive */
|
|
|
|
streamFile->get_name(streamFile,filename,sizeof(filename));
|
|
|
|
is_sgx = strcasecmp("sgx",filename_extension(filename))==0;
|
|
|
|
is_sgd = strcasecmp("sgd",filename_extension(filename))==0;
|
|
|
|
is_sgb = strcasecmp("sgb",filename_extension(filename))==0;
|
|
|
|
if ( !(is_sgx || is_sgd || is_sgb) )
|
2010-10-19 04:16:08 +02:00
|
|
|
goto fail;
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* SGB+SGH: use SGH as header; otherwise use the current file as header */
|
|
|
|
if (is_sgb) {
|
|
|
|
char fileheader[PATH_LIMIT];
|
2010-10-19 04:16:08 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
strcpy(fileheader,filename);
|
|
|
|
strcpy(fileheader+strlen(fileheader)-3,"sgh");
|
2010-10-19 04:16:08 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
streamHeader = streamFile->open(streamFile,fileheader,STREAMFILE_DEFAULT_BUFFER_SIZE);
|
|
|
|
if (!streamHeader) goto fail;
|
|
|
|
} else {
|
|
|
|
streamHeader = streamFile;
|
2010-10-19 04:16:08 +02:00
|
|
|
}
|
|
|
|
|
2011-03-23 09:06:05 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* SGXD chunk (size 0x10) */
|
|
|
|
if (read_32bitBE(0x00,streamHeader) != 0x53475844) /* "SGXD" */
|
|
|
|
goto fail;
|
|
|
|
/* 0x04 SGX: full header_size; SGD/SGH: unknown header_size (counting from 0x0/0x8/0x10, varies) */
|
|
|
|
/* 0x08 SGX: first chunk offset? (0x10); SGD/SGH: full header_size */
|
|
|
|
/* 0x0c SGX/SGH: full data size with padding; SGD: full data size + 0x80000000 with padding */
|
|
|
|
if (is_sgb) {
|
|
|
|
data_offset = 0x00;
|
|
|
|
} else if ( is_sgx ) {
|
|
|
|
data_offset = read_32bitLE(0x04,streamHeader);
|
|
|
|
} else {
|
|
|
|
data_offset = read_32bitLE(0x08,streamHeader);
|
|
|
|
}
|
2011-03-23 09:06:05 +01:00
|
|
|
|
2011-03-23 10:28:25 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
chunk_offset = 0x10;
|
|
|
|
/* WAVE chunk (size 0x10 + files * 0x38 + optional padding) */
|
|
|
|
/* the format reads chunks until header_size, but we only want WAVE in the first position meaning BGM */
|
|
|
|
if (read_32bitBE(chunk_offset+0x00,streamHeader) != 0x57415645) /* "WAVE" */
|
|
|
|
goto fail;
|
|
|
|
/* 0x04 SGX: unknown; SGD/SGH: chunk length */
|
|
|
|
/* 0x08 null */
|
2011-03-23 10:28:25 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* usually only SE containers have multiple streams but just in case... */
|
|
|
|
total_streams = read_32bitLE(chunk_offset+0x0c,streamHeader);
|
|
|
|
if (target_stream+1 > total_streams)
|
2011-03-23 10:28:25 +01:00
|
|
|
goto fail;
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* read stream (skip until target_stream) */
|
|
|
|
chunk_offset += 0x10;
|
|
|
|
{
|
|
|
|
int stream_loop_flag;
|
|
|
|
int stream_type;
|
|
|
|
int stream_channels;
|
|
|
|
int32_t stream_sample_rate;
|
|
|
|
int32_t stream_num_samples, stream_loop_start_sample, stream_loop_end_sample;
|
|
|
|
off_t stream_start_offset;
|
|
|
|
|
|
|
|
for (i=0; i < total_streams; i++) {
|
|
|
|
if (i != target_stream) {
|
|
|
|
chunk_offset += 0x38; /* next file */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 0x00 ? (00/01/02) */
|
|
|
|
/* 0x04 sometimes global offset to wave_name */
|
|
|
|
stream_type = read_8bit(chunk_offset+0x08,streamHeader);
|
|
|
|
stream_channels = read_8bit(chunk_offset+0x09,streamHeader);
|
|
|
|
/* 0x0a null */
|
|
|
|
stream_sample_rate = read_32bitLE(chunk_offset+0x0c,streamHeader);
|
|
|
|
|
|
|
|
/* 0x10 info_type: meaning of the next value
|
|
|
|
* (00=null, 30/40=data size without padding (ADPCM, ATRAC3plus), 80/A0=block size (AC3) */
|
|
|
|
/* 0x14 info_value (see above) */
|
|
|
|
/* 0x18 unknown (ex. 0x0008/0010/3307/CC02/etc)x2 */
|
|
|
|
/* 0x1c null */
|
|
|
|
|
|
|
|
stream_num_samples = read_32bitLE(chunk_offset+0x20,streamHeader);
|
|
|
|
stream_loop_start_sample = read_32bitLE(chunk_offset+0x24,streamHeader);
|
|
|
|
stream_loop_end_sample = read_32bitLE(chunk_offset+0x28,streamHeader);
|
|
|
|
stream_size = read_32bitLE(chunk_offset+0x2c,streamHeader); /* stream size (without padding) / interleave (for type3) */
|
|
|
|
|
|
|
|
if (is_sgx) {
|
|
|
|
stream_start_offset = 0x0; /* TODO unknown (not seen multi SGX) */
|
|
|
|
} else{
|
|
|
|
stream_start_offset = read_32bitLE(chunk_offset+0x30,streamHeader);
|
|
|
|
}
|
|
|
|
/* 0x34 SGX: unknown; SGD/SGH: stream size (with padding) / interleave */
|
|
|
|
|
|
|
|
stream_loop_flag = stream_loop_start_sample!=0xffffffff && stream_loop_end_sample!=0xffffffff;
|
|
|
|
chunk_offset += 0x38; /* next file */
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2011-03-23 10:28:25 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* build the VGMSTREAM */
|
|
|
|
vgmstream = allocate_vgmstream(stream_channels,stream_loop_flag);
|
|
|
|
if (!vgmstream) goto fail;
|
|
|
|
|
|
|
|
/* fill in the vital statistics */
|
|
|
|
vgmstream->num_samples = stream_num_samples;
|
|
|
|
vgmstream->sample_rate = stream_sample_rate;
|
|
|
|
vgmstream->channels = stream_channels;
|
|
|
|
if (stream_loop_flag) {
|
|
|
|
vgmstream->loop_start_sample = stream_loop_start_sample;
|
|
|
|
vgmstream->loop_end_sample = stream_loop_end_sample;
|
|
|
|
}
|
2011-03-23 10:28:25 +01:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
vgmstream->meta_type = meta_PS3_SGDX;
|
|
|
|
|
|
|
|
switch (stream_type) {
|
|
|
|
case 0x03: /* PSX ADPCM */
|
|
|
|
vgmstream->coding_type = coding_PSX;
|
|
|
|
vgmstream->layout_type = layout_interleave;
|
2017-01-27 23:39:52 +01:00
|
|
|
if (is_sgx || is_sgb) {
|
2016-12-04 17:51:35 +01:00
|
|
|
vgmstream->interleave_block_size = 0x10;
|
2017-01-27 23:39:52 +01:00
|
|
|
} else { //todo this only seems to happen with SFX
|
2016-12-04 17:51:35 +01:00
|
|
|
vgmstream->interleave_block_size = stream_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
|
|
case 0x04: /* ATRAC3plus */
|
|
|
|
{
|
|
|
|
at3_riff_info info;
|
|
|
|
|
2017-01-27 23:39:52 +01:00
|
|
|
ffmpeg_data = init_ffmpeg_offset(streamFile, data_offset, stream_size);
|
2016-12-04 17:51:35 +01:00
|
|
|
if ( !ffmpeg_data ) goto fail;
|
|
|
|
|
|
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
/*vgmstream->meta_type = meta_FFmpeg;*/
|
|
|
|
vgmstream->codec_data = ffmpeg_data;
|
|
|
|
|
|
|
|
/* manually fix looping due to FFmpeg bugs */
|
|
|
|
if (stream_loop_flag && get_at3_riff_info(&info, streamFile, data_offset)) {
|
|
|
|
if (vgmstream->num_samples == info.fact_samples) { /* use if looks normal */
|
|
|
|
/* todo use "skip samples"; for now we just use absolute loop values */
|
|
|
|
vgmstream->loop_start_sample = info.loop_start_sample;
|
|
|
|
vgmstream->loop_end_sample = info.loop_end_sample;
|
|
|
|
vgmstream->num_samples += info.skip_samples; /* to ensure it always reaches loop_end */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
2016-12-21 23:00:34 +01:00
|
|
|
case 0x05: /* Short VAG ADPCM */
|
2017-01-08 01:09:20 +01:00
|
|
|
vgmstream->coding_type = coding_PSX_cfg;
|
2016-12-21 23:00:34 +01:00
|
|
|
vgmstream->layout_type = layout_interleave;
|
|
|
|
vgmstream->interleave_block_size = 0x4;
|
2016-12-04 17:51:35 +01:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
|
|
case 0x06: /* AC3 */
|
2017-01-27 23:39:52 +01:00
|
|
|
ffmpeg_data = init_ffmpeg_offset(streamFile, data_offset, stream_size);
|
2016-12-04 17:51:35 +01:00
|
|
|
if ( !ffmpeg_data ) goto fail;
|
|
|
|
|
|
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
/*vgmstream->meta_type = meta_FFmpeg;*/
|
|
|
|
vgmstream->codec_data = ffmpeg_data;
|
|
|
|
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-03-23 10:28:25 +01:00
|
|
|
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
start_offset = data_offset + stream_start_offset;
|
|
|
|
/* open the file for reading */
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
STREAMFILE * file;
|
|
|
|
file = streamFile->open(streamFile,filename,STREAMFILE_DEFAULT_BUFFER_SIZE);
|
|
|
|
if (!file) goto fail;
|
|
|
|
|
|
|
|
for (i=0; i < vgmstream->channels; i++) {
|
|
|
|
vgmstream->ch[i].streamfile = file;
|
|
|
|
vgmstream->ch[i].channel_start_offset =
|
|
|
|
vgmstream->ch[i].offset =
|
|
|
|
start_offset + vgmstream->interleave_block_size * i;
|
|
|
|
}
|
2011-03-23 10:28:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
|
2011-03-23 10:28:25 +01:00
|
|
|
return vgmstream;
|
|
|
|
|
|
|
|
fail:
|
2016-12-04 17:51:35 +01:00
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
|
|
if (ffmpeg_data) {
|
|
|
|
free_ffmpeg(ffmpeg_data);
|
|
|
|
vgmstream->codec_data = NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (is_sgb && streamHeader) close_streamfile(streamHeader);
|
|
|
|
if (vgmstream) close_vgmstream(vgmstream);
|
2011-05-31 17:01:04 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/**
|
|
|
|
* AT3 RIFF headers have a "skip samples at the beginning" value that the decoder should use,
|
|
|
|
* and absolute loop values. However the SGDX header loop values assume those samples are skipped.
|
|
|
|
*
|
|
|
|
* FFmpeg doesn't support/export this, so we have to manually get the absolute values to fix looping.
|
|
|
|
*/
|
|
|
|
static int get_at3_riff_info(at3_riff_info* info, STREAMFILE *streamFile, int32_t offset) {
|
|
|
|
off_t current_chunk, riff_size;
|
|
|
|
int data_found = 0;
|
2011-05-31 17:01:04 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
memset(info, 0, sizeof(at3_riff_info));
|
|
|
|
|
|
|
|
if (read_32bitBE(offset+0x0,streamFile)!=0x52494646 /* "RIFF" */
|
|
|
|
&& read_32bitBE(offset+0x8,streamFile)!=0x57415645 ) /* "WAVE" */
|
2011-05-31 17:01:04 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* read chunks */
|
|
|
|
riff_size = read_32bitLE(offset+0x4,streamFile);
|
|
|
|
current_chunk = offset + 0xc;
|
|
|
|
|
|
|
|
while (!data_found && current_chunk < riff_size) {
|
|
|
|
uint32_t chunk_type = read_32bitBE(current_chunk,streamFile);
|
|
|
|
off_t chunk_size = read_32bitLE(current_chunk+4,streamFile);
|
|
|
|
|
|
|
|
switch(chunk_type) {
|
|
|
|
case 0x736D706C: /* smpl */
|
|
|
|
if (read_32bitLE(current_chunk+0x24, streamFile)==0
|
|
|
|
|| read_32bitLE(current_chunk+0x2c+0x4, streamFile)!=0 )
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
info->loop_start_sample = read_32bitLE(current_chunk+0x2c+0x8, streamFile);
|
|
|
|
info->loop_end_sample = read_32bitLE(current_chunk+0x2c+0xc,streamFile);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x66616374: /* fact */
|
|
|
|
if (chunk_size == 0x8) {
|
|
|
|
info->fact_samples = read_32bitLE(current_chunk+0x8, streamFile);
|
|
|
|
info->skip_samples = read_32bitLE(current_chunk+0xc, streamFile);
|
|
|
|
} else if (chunk_size == 0xc) {
|
|
|
|
info->fact_samples = read_32bitLE(current_chunk+0x8, streamFile);
|
|
|
|
info->skip_samples = read_32bitLE(current_chunk+0x10, streamFile);
|
|
|
|
} else {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x64617461: /* data */
|
|
|
|
data_found = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2011-05-31 17:01:04 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
current_chunk += 8+chunk_size;
|
|
|
|
}
|
2011-05-31 17:01:04 +02:00
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
if (!data_found)
|
|
|
|
goto fail;
|
2011-05-31 17:01:04 +02:00
|
|
|
|
|
|
|
|
2016-12-04 17:51:35 +01:00
|
|
|
/* found */
|
|
|
|
return 1;
|
2011-05-31 17:01:04 +02:00
|
|
|
|
|
|
|
fail:
|
2016-12-04 17:51:35 +01:00
|
|
|
/* not found */
|
|
|
|
return 0;
|
|
|
|
|
2011-03-23 10:28:25 +01:00
|
|
|
}
|