255 lines
9.5 KiB
C
255 lines
9.5 KiB
C
#include "meta.h"
|
|
#include "../coding/coding.h"
|
|
#include "../util/chunks.h"
|
|
|
|
|
|
/* SGXD - Sony/SCEI's format (SGB+SGH / SGD / SGX) */
|
|
VGMSTREAM* init_vgmstream_sgxd(STREAMFILE* sf) {
|
|
VGMSTREAM* vgmstream = NULL;
|
|
STREAMFILE* sf_head = NULL;
|
|
STREAMFILE* sf_body = NULL;
|
|
off_t start_offset, data_offset, chunk_offset, name_offset = 0;
|
|
size_t stream_size;
|
|
uint32_t base1_offset, base2_offset, base3_offset;
|
|
|
|
int is_sgx, is_sgd = 0;
|
|
int loop_flag, channels, codec, sample_rate;
|
|
int32_t num_samples, loop_start_sample, loop_end_sample;
|
|
int total_subsongs, target_subsong = sf->stream_index;
|
|
|
|
|
|
/* for plugins that start with .sgb */
|
|
if (check_extensions(sf,"sgb")) {
|
|
sf_head = open_streamfile_by_ext(sf, "sgh");
|
|
if (!sf_head) goto fail;
|
|
}
|
|
else {
|
|
sf_head = sf;
|
|
}
|
|
|
|
if (!is_id32be(0x00,sf_head, "SGXD"))
|
|
goto fail;
|
|
|
|
/* checks */
|
|
/* .sgx: header+data (Genji)
|
|
* .sgd: header+data (common)
|
|
* .sgh+sgd: header+data (streams) */
|
|
if (!check_extensions(sf,"sgx,sgd,sgb"))
|
|
goto fail;
|
|
|
|
/* SGXD base (size 0x10), always LE even on PS3 */
|
|
/* 0x04: SGX = full header size
|
|
SGD/SGH = bank name offset (part of NAME table, usually same as filename) */
|
|
/* 0x08: SGX = first chunk offset? (0x10)
|
|
SGD/SGH = full header size */
|
|
/* 0x0c: SGX/SGH = full data size with padding /
|
|
SGD = full data size ^ (1<<31) with padding */
|
|
base1_offset = read_u32le(0x04, sf_head);
|
|
base2_offset = read_u32le(0x08, sf_head);
|
|
base3_offset = read_u32le(0x0c, sf_head);
|
|
|
|
is_sgx = base2_offset == 0x10; /* fixed size */
|
|
is_sgd = base3_offset & (1 << 31); /* flag */
|
|
|
|
/* Ogg SGXD don't have flag (probably due to codec hijack, or should be split), allow since it's not so obvious */
|
|
if (!(is_sgx || is_sgd) && get_streamfile_size(sf_head) != base2_offset) /* sgh but wrong header size must be sgd */
|
|
is_sgd = 1;
|
|
|
|
/* for plugins that start with .sgh (and don't check extensions) */
|
|
if (!(is_sgx || is_sgd) && sf == sf_head) {
|
|
sf_body = open_streamfile_by_ext(sf, "sgb");
|
|
if (!sf_body) goto fail;
|
|
}
|
|
else {
|
|
sf_body = sf;
|
|
}
|
|
|
|
|
|
if (is_sgx) {
|
|
data_offset = base1_offset;
|
|
} else if (is_sgd) {
|
|
data_offset = base2_offset;
|
|
} else {
|
|
data_offset = 0x00;
|
|
}
|
|
|
|
|
|
/* Format per chunk:
|
|
* - 0x00: id
|
|
* - 0x04: SGX: unknown; SGD/SGH: chunk length
|
|
* - 0x08: null
|
|
* - 0x0c: entries */
|
|
|
|
/* typical chunks (with some entry info):
|
|
* - WAVE: wave data (see below)
|
|
* - RGND: programs info, notably:
|
|
* - 0x18: min note range
|
|
* - 0x19: max note range
|
|
* - 0x1C: root note
|
|
* - 0x1d: fine tuning
|
|
* - 0x34: WAVE id
|
|
* > sample_rate = wave_sample_rate * (2 ^ (1/12)) ^ (target_note - root_note)
|
|
* - NAME: strings for other chunks
|
|
* - 0x00: sub-id?
|
|
* - 0x02: type? (possibly: 0000=bank, 0x2xxx=SEQD/WAVE, 0x3xxx=WSUR, 0x4xxx=BUSS, 0x6xxx=CONF)
|
|
* - 0x04: absolute offset
|
|
* - SEQD: related to SFX (sequences?), entries seem to be offsets to name offset + sequence offset
|
|
* > sequence format seems to be 1 byte type (0=sfx, 1=music) + midi without header
|
|
* (default tick resolution of 960 pulses per quarter note). They use Midi Time Code
|
|
* (like 30fps with around 196 ticks per frame), and same controller event for looping as old SEQs (CC 99).
|
|
* - WSUR: ?
|
|
* - WMKR: ?
|
|
* - CONF: ? (name offset + config offset)
|
|
* - BUSS: bus config? */
|
|
|
|
/* WAVE chunk (size 0x10 + files * 0x38 + optional padding) */
|
|
if (is_sgx) { /* position after chunk+size */
|
|
if (!is_id32be(0x10,sf_head, "WAVE"))
|
|
goto fail;
|
|
chunk_offset = 0x18;
|
|
} else {
|
|
if (!find_chunk_le(sf_head, get_id32be("WAVE"),0x10,0, &chunk_offset, NULL))
|
|
goto fail;
|
|
}
|
|
|
|
/* check multi-streams (usually only SE containers; Puppeteer) */
|
|
total_subsongs = read_s32le(chunk_offset+0x04,sf_head);
|
|
if (target_subsong == 0) target_subsong = 1;
|
|
if (target_subsong < 0 || target_subsong > total_subsongs || total_subsongs < 1) goto fail;
|
|
|
|
/* read stream header */
|
|
{
|
|
uint32_t stream_offset;
|
|
chunk_offset += 0x08 + 0x38 * (target_subsong-1); /* position in target header*/
|
|
|
|
/* 0x00: ? (00/01/02) */
|
|
if (!is_sgx) /* meaning unknown in .sgx; offset 0 = not a stream (a RGND sample) */
|
|
name_offset = read_u32le(chunk_offset+0x04,sf_head);
|
|
codec = read_u8(chunk_offset+0x08,sf_head);
|
|
channels = read_u8(chunk_offset+0x09,sf_head);
|
|
/* 0x0a: null */
|
|
sample_rate = read_s32le(chunk_offset+0x0c,sf_head);
|
|
|
|
/* 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, RGND related?) x2 */
|
|
/* 0x1c: null */
|
|
|
|
num_samples = read_s32le(chunk_offset+0x20,sf_head);
|
|
loop_start_sample = read_s32le(chunk_offset+0x24,sf_head);
|
|
loop_end_sample = read_s32le(chunk_offset+0x28,sf_head);
|
|
stream_size = read_u32le(chunk_offset+0x2c,sf_head); /* stream size (without padding) / interleave (for type3) */
|
|
|
|
if (is_sgx) {
|
|
stream_offset = 0x0;
|
|
} else{
|
|
stream_offset = read_u32le(chunk_offset+0x30,sf_head);
|
|
}
|
|
/* 0x34: SGX = unknown
|
|
* SGD/SGH = stream size (with padding) / interleave */
|
|
|
|
loop_flag = loop_start_sample != -1 && loop_end_sample != -1;
|
|
start_offset = data_offset + stream_offset;
|
|
}
|
|
|
|
|
|
/* build the VGMSTREAM */
|
|
vgmstream = allocate_vgmstream(channels,loop_flag);
|
|
if (!vgmstream) goto fail;
|
|
|
|
vgmstream->sample_rate = sample_rate;
|
|
vgmstream->num_samples = num_samples;
|
|
vgmstream->loop_start_sample = loop_start_sample;
|
|
vgmstream->loop_end_sample = loop_end_sample;
|
|
vgmstream->num_streams = total_subsongs;
|
|
vgmstream->stream_size = stream_size;
|
|
vgmstream->meta_type = meta_SGXD;
|
|
if (name_offset)
|
|
read_string(vgmstream->stream_name,STREAM_NAME_SIZE, name_offset,sf_head);
|
|
|
|
switch (codec) {
|
|
|
|
case 0x01: /* PCM [LocoRoco Cocoreccho! (PS3)] (rare, locoloco_psn#279) */
|
|
vgmstream->coding_type = coding_PCM16BE;
|
|
vgmstream->layout_type = layout_interleave;
|
|
vgmstream->interleave_block_size = 0x02;
|
|
break;
|
|
|
|
#ifdef VGM_USE_VORBIS
|
|
case 0x02: /* Ogg Vorbis [Ni no Kuni: Wrath of the White Witch Remastered (PC)] (codec hijack?) */
|
|
vgmstream->codec_data = init_ogg_vorbis(sf_body, start_offset, stream_size, NULL);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_OGG_VORBIS;
|
|
vgmstream->layout_type = layout_none;
|
|
break;
|
|
#endif
|
|
case 0x03: /* PS-ADPCM [Genji (PS3), Ape Escape Move (PS3)]*/
|
|
vgmstream->coding_type = coding_PSX;
|
|
vgmstream->layout_type = layout_interleave;
|
|
if (!is_sgd) {
|
|
vgmstream->interleave_block_size = 0x10;
|
|
} else { /* this only seems to happen with SFX */
|
|
vgmstream->interleave_block_size = stream_size;
|
|
}
|
|
|
|
/* a few files in LocoRoco set 0 stream size/samples, use an empty file for now */
|
|
if (vgmstream->num_samples == 0)
|
|
vgmstream->num_samples = 28;
|
|
break;
|
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
case 0x04: { /* ATRAC3plus [Kurohyo 1/2 (PSP), BraveStory (PSP)] */
|
|
vgmstream->codec_data = init_ffmpeg_atrac3_riff(sf_body, start_offset, NULL);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
/* SGXD's sample rate has priority over RIFF's sample rate (may not match) */
|
|
/* loop/sample values are relative (without skip) vs RIFF (with skip), matching "smpl" otherwise */
|
|
break;
|
|
}
|
|
#endif
|
|
case 0x05: /* Short PS-ADPCM [Afrika (PS3), LocoRoco Cocoreccho! (PS3)] */
|
|
vgmstream->coding_type = coding_PSX_cfg;
|
|
vgmstream->layout_type = layout_interleave;
|
|
vgmstream->interleave_block_size = 0x4;
|
|
vgmstream->codec_config = 1; /* needs extended table */
|
|
|
|
break;
|
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
case 0x06: { /* AC3 [Tokyo Jungle (PS3), Afrika (PS3)] */
|
|
vgmstream->codec_data = init_ffmpeg_offset(sf_body, start_offset, stream_size);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
/* PS3 AC3 consistently has 256 encoder delay samples, and there are ~1000-2000 samples after num_samples.
|
|
* Skipping them marginally improves full loops in some Tokyo Jungle tracks (ex. a_1.sgd). */
|
|
ffmpeg_set_skip_samples(vgmstream->codec_data, 256);
|
|
|
|
/* SGXD loop/sample values are relative (without skip samples), no need to adjust */
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
VGM_LOG("SGDX: unknown codec %i\n", codec);
|
|
goto fail;
|
|
}
|
|
|
|
if (!vgmstream_open_stream(vgmstream, sf_body, start_offset))
|
|
goto fail;
|
|
|
|
if (sf != sf_head) close_streamfile(sf_head);
|
|
if (sf != sf_body) close_streamfile(sf_body);
|
|
return vgmstream;
|
|
|
|
fail:
|
|
if (sf != sf_head) close_streamfile(sf_head);
|
|
if (sf != sf_body) close_streamfile(sf_body);
|
|
close_vgmstream(vgmstream);
|
|
return NULL;
|
|
}
|