From e08a0d8431b51d80549f9c6665db764fb031642c Mon Sep 17 00:00:00 2001 From: bnnm Date: Sat, 3 Aug 2019 23:35:10 +0200 Subject: [PATCH] Redo MUSX (.sfx) stream/stream banks/sfx banks and fix various bugs --- src/coding/coding.h | 2 + src/coding/ima_decoder.c | 8 + src/coding/psx_decoder.c | 18 + src/formats.c | 6 +- src/meta/meta.h | 6 +- src/meta/musx.c | 913 +++++++++++++++++++++------------------ src/vgmstream.c | 6 +- src/vgmstream.h | 6 +- 8 files changed, 521 insertions(+), 444 deletions(-) diff --git a/src/coding/coding.h b/src/coding/coding.h index e7114178..2707b2d8 100644 --- a/src/coding/coding.h +++ b/src/coding/coding.h @@ -42,6 +42,7 @@ void decode_h4m_ima(VGMSTREAMCHANNEL * stream, sample_t * outbuf, int channelspa size_t ima_bytes_to_samples(size_t bytes, int channels); size_t ms_ima_bytes_to_samples(size_t bytes, int block_align, int channels); size_t xbox_ima_bytes_to_samples(size_t bytes, int channels); +size_t dat4_ima_bytes_to_samples(size_t bytes, int channels); size_t apple_ima4_bytes_to_samples(size_t bytes, int channels); /* ngc_dsp_decoder */ @@ -87,6 +88,7 @@ int ps_find_loop_offsets_full(STREAMFILE *streamFile, off_t start_offset, size_t size_t ps_find_padding(STREAMFILE *streamFile, off_t start_offset, size_t data_size, int channels, size_t interleave, int discard_empty); size_t ps_bytes_to_samples(size_t bytes, int channels); size_t ps_cfg_bytes_to_samples(size_t bytes, size_t frame_size, int channels); +int ps_check_format(STREAMFILE *streamFile, off_t offset, size_t max); /* psv_decoder */ void decode_hevag(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do); diff --git a/src/coding/ima_decoder.c b/src/coding/ima_decoder.c index fe56cd62..cd033875 100644 --- a/src/coding/ima_decoder.c +++ b/src/coding/ima_decoder.c @@ -1131,6 +1131,14 @@ size_t xbox_ima_bytes_to_samples(size_t bytes, int channels) { + ((bytes % block_align) ? ((bytes % block_align) - 4 * channels) * 2 / channels : 0); /* unlikely (encoder aligns) */ } +size_t dat4_ima_bytes_to_samples(size_t bytes, int channels) { + int block_align = 0x20 * channels; + if (channels <= 0) return 0; + /* DAT4 IMA blocks have a 4 byte header per channel; 2 samples per byte (2 nibbles) */ + return (bytes / block_align) * (block_align - 4 * channels) * 2 / channels + + ((bytes % block_align) ? ((bytes % block_align) - 4 * channels) * 2 / channels : 0); /* unlikely (encoder aligns) */ +} + size_t apple_ima4_bytes_to_samples(size_t bytes, int channels) { int block_align = 0x22 * channels; if (channels <= 0) return 0; diff --git a/src/coding/psx_decoder.c b/src/coding/psx_decoder.c index 884e419d..47c66ac7 100644 --- a/src/coding/psx_decoder.c +++ b/src/coding/psx_decoder.c @@ -342,3 +342,21 @@ size_t ps_cfg_bytes_to_samples(size_t bytes, size_t frame_size, int channels) { return bytes / channels / frame_size * 28; } +/* test PS-ADPCM frames for correctness */ +int ps_check_format(STREAMFILE *streamFile, off_t offset, size_t max) { + off_t max_offset = offset + max; + if (max_offset > get_streamfile_size(streamFile)) + max_offset = get_streamfile_size(streamFile); + + while (offset < max_offset) { + uint8_t predictor = (read_8bit(offset+0x00,streamFile) >> 4) & 0x0f; + uint8_t flags = read_8bit(offset+0x01,streamFile); + + if (predictor > 5 || flags > 7) { + return 0; + } + offset += 0x10; + } + + return 1; +} diff --git a/src/formats.c b/src/formats.c index efb86d4b..ec7155f1 100644 --- a/src/formats.c +++ b/src/formats.c @@ -857,11 +857,7 @@ static const meta_info meta_info_list[] = { {meta_XWB, "Microsoft XWB header"}, {meta_PS2_XA30, "Reflections XA30 PS2 header"}, {meta_MUSC, "Krome MUSC header"}, - {meta_MUSX_V004, "MUSX / Version 004 Header"}, - {meta_MUSX_V005, "MUSX / Version 005 Header"}, - {meta_MUSX_V006, "MUSX / Version 006 Header"}, - {meta_MUSX_V010, "MUSX / Version 010 Header"}, - {meta_MUSX_V201, "MUSX / Version 201 Header"}, + {meta_MUSX, "Eurocom MUSX header"}, {meta_LEG, "Legaia 2 - Duel Saga LEG Header"}, {meta_FILP, "Bio Hazard - Gun Survivor FILp Header"}, {meta_IKM, "MiCROViSiON IKM header"}, diff --git a/src/meta/meta.h b/src/meta/meta.h index 0d26d939..fd625aea 100644 --- a/src/meta/meta.h +++ b/src/meta/meta.h @@ -203,11 +203,7 @@ VGMSTREAM * init_vgmstream_ps2_xa30(STREAMFILE * streamFile); VGMSTREAM * init_vgmstream_musc(STREAMFILE * streamFile); -VGMSTREAM * init_vgmstream_musx_v004(STREAMFILE * streamFile); -VGMSTREAM * init_vgmstream_musx_v005(STREAMFILE * streamFile); -VGMSTREAM * init_vgmstream_musx_v006(STREAMFILE * streamFile); -VGMSTREAM * init_vgmstream_musx_v010(STREAMFILE * streamFile); -VGMSTREAM * init_vgmstream_musx_v201(STREAMFILE * streamFile); +VGMSTREAM * init_vgmstream_musx(STREAMFILE * streamFile); VGMSTREAM * init_vgmstream_leg(STREAMFILE * streamFile); diff --git a/src/meta/musx.c b/src/meta/musx.c index b3f211fd..9a7dd977 100644 --- a/src/meta/musx.c +++ b/src/meta/musx.c @@ -1,224 +1,131 @@ #include "meta.h" -#include "../util.h" +#include "../coding/coding.h" +typedef enum { MFX, MFX_BANK, SFX_BANK, SBNK, FORM } musx_form; +typedef enum { PSX, DSP, XBOX, IMA, DAT } musx_codec; +typedef struct { + int big_endian; + int version; + size_t file_size; -/* MUSX (Version 004) */ -VGMSTREAM * init_vgmstream_musx_v004(STREAMFILE *streamFile) { + int total_subsongs; + int is_old; + + off_t tables_offset; + off_t loops_offset; + off_t stream_offset; + size_t stream_size; + off_t coefs_offset; + + musx_form form; + musx_codec codec; + uint32_t platform; + + int channels; + int sample_rate; + int loop_flag; + int32_t loop_start; + int32_t loop_end; + int32_t num_samples; + int32_t loop_start_sample; + int32_t loop_end_sample; +} musx_header; + +static int parse_musx(STREAMFILE *streamFile, musx_header *musx); + +/* MUSX - from Eurocom's games */ +VGMSTREAM * init_vgmstream_musx(STREAMFILE *streamFile) { VGMSTREAM * vgmstream = NULL; off_t start_offset; - int loop_flag, channel_count; + musx_header musx = {0}; /* checks */ - if (!check_extensions(streamFile, "musx")) - goto fail; - if (read_32bitBE(0x00,streamFile) != 0x4D555358) /* "MUSX" */ - goto fail; - if (read_32bitBE(0x08,streamFile) != 0x04000000) - goto fail; - - loop_flag = (read_32bitLE(0x840,streamFile) != 0xFFFFFFFF); - channel_count = 2; - - /* build the VGMSTREAM */ - vgmstream = allocate_vgmstream(channel_count,loop_flag); - if (!vgmstream) goto fail; - - switch (read_32bitBE(0x10,streamFile)) { - case 0x5053325F: /* PS2_ */ - start_offset = read_32bitLE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = (read_32bitLE(0x0C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x80; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitLE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitLE(0x89C,streamFile))/16/channel_count*28; - } - break; - case 0x47435F5F: /* GC__ */ - start_offset = read_32bitBE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (read_32bitBE(0x2C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitBE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitBE(0x89C,streamFile))/16/channel_count*28; - } - break; - case 0x58425F5F: /* XB__ */ - start_offset = read_32bitLE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 44100; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (read_32bitLE(0x2C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitLE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitLE(0x89C,streamFile))/16/channel_count*28; - } - break; - default: - goto fail; - } - - vgmstream->meta_type = meta_MUSX_V004; - - if (!vgmstream_open_stream(vgmstream,streamFile,start_offset)) - goto fail; - return vgmstream; - -fail: - close_vgmstream(vgmstream); - return NULL; -} - - -/* MUSX (Version 005) [Predator: Concrete Jungle (PS2/Xbox) ] */ -VGMSTREAM * init_vgmstream_musx_v005(STREAMFILE *streamFile) { - VGMSTREAM * vgmstream = NULL; - off_t start_offset; - int loop_flag, channel_count; - - - /* checks */ - /* .sfx: Batman Begins, .musx: header id */ - if (!check_extensions(streamFile, "musx,sfx")) - goto fail; - if (read_32bitBE(0x00,streamFile) != 0x4D555358) /* "MUSX" */ - goto fail; - if (read_32bitBE(0x08,streamFile) != 0x05000000) - goto fail; - - loop_flag = (read_32bitLE(0x840,streamFile) != 0xFFFFFFFF); - channel_count = 2; - - /* build the VGMSTREAM */ - vgmstream = allocate_vgmstream(channel_count,loop_flag); - if (!vgmstream) goto fail; - - switch (read_32bitBE(0x10,streamFile)) { - case 0x5053325F: /* PS2_ */ - start_offset = read_32bitLE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = (read_32bitLE(0x0C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x80; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitLE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitLE(0x89C,streamFile))/16/channel_count*28; - } - break; - case 0x47435F5F: /* GC__ */ - start_offset = read_32bitBE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (read_32bitBE(0x2C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitBE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitBE(0x89C,streamFile))/16/channel_count*28; - } - break; - case 0x58425F5F: /* XB__ */ - start_offset = read_32bitLE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 44100; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (read_32bitLE(0x2C,streamFile))/16/channel_count*28; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitLE(0x890,streamFile))/16/channel_count*28; - vgmstream->loop_end_sample = (read_32bitLE(0x89C,streamFile))/16/channel_count*28; - } - break; - default: - goto fail; - } - - vgmstream->meta_type = meta_MUSX_V005; - - if (!vgmstream_open_stream(vgmstream,streamFile,start_offset)) - goto fail; - return vgmstream; - -fail: - close_vgmstream(vgmstream); - return NULL; -} - - -/* MUSX (Version 006) [Batman Begins (GC)] */ -VGMSTREAM * init_vgmstream_musx_v006(STREAMFILE *streamFile) { - VGMSTREAM * vgmstream = NULL; - off_t start_offset; - int loop_flag, channel_count; - - - /* checks */ - /* .sfx: Batman Begins, .musx: header id */ + /* .sfx: actual extension (extracted from bigfiles with sometimes encrypted names) + * .musx: header id */ if (!check_extensions(streamFile, "sfx,musx")) goto fail; if (read_32bitBE(0x00,streamFile) != 0x4D555358) /* "MUSX" */ goto fail; - if (read_32bitBE(0x08,streamFile) != 0x06000000) + + if (!parse_musx(streamFile, &musx)) goto fail; - loop_flag = (read_32bitLE(0x840,streamFile)!=0xFFFFFFFF); - channel_count = 2; - //todo some files (ex. Batman Begins) have a subsong table at 0x800, not sure what signals it (flags at 0x04/0x14?) + start_offset = musx.stream_offset; /* build the VGMSTREAM */ - vgmstream = allocate_vgmstream(channel_count,loop_flag); + vgmstream = allocate_vgmstream(musx.channels, musx.loop_flag); if (!vgmstream) goto fail; - switch (read_32bitBE(0x10,streamFile)) { - case 0x5053325F: /* PS2_ */ - start_offset = read_32bitLE(0x28,streamFile); - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; + vgmstream->meta_type = meta_MUSX; + vgmstream->sample_rate = musx.sample_rate; + vgmstream->num_streams = musx.total_subsongs; + vgmstream->stream_size = musx.stream_size; + + switch (musx.codec) { + case PSX: + vgmstream->num_samples = ps_bytes_to_samples(musx.stream_size, musx.channels); + vgmstream->loop_start_sample = ps_bytes_to_samples(musx.loop_start, musx.channels); + vgmstream->loop_end_sample = ps_bytes_to_samples(musx.loop_end, musx.channels); + vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = (read_32bitLE(0x0C,streamFile))*28/16/channel_count; vgmstream->layout_type = layout_interleave; vgmstream->interleave_block_size = 0x80; - vgmstream->meta_type = meta_MUSX_V006; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitLE(0x890,streamFile))*28/16/channel_count; - vgmstream->loop_end_sample = (read_32bitLE(0x89C,streamFile))*28/16/channel_count; - } break; - case 0x47435F5F: /* GC__ */ - start_offset = read_32bitBE(0x28,streamFile); - if (start_offset == 0 || start_offset == 0xABABABAB) goto fail; /* some are empty */ - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; + case DAT: + vgmstream->num_samples = dat4_ima_bytes_to_samples(musx.stream_size, musx.channels); + vgmstream->loop_start_sample = dat4_ima_bytes_to_samples(musx.loop_start, musx.channels); + vgmstream->loop_end_sample = dat4_ima_bytes_to_samples(musx.loop_end, musx.channels); + vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (read_32bitBE(0x2C,streamFile))*28/16/channel_count; vgmstream->layout_type = layout_interleave; vgmstream->interleave_block_size = 0x20; - vgmstream->meta_type = meta_MUSX_V006; - if (loop_flag) { - vgmstream->loop_start_sample = (read_32bitBE(0x890,streamFile))*28/16/channel_count; - vgmstream->loop_end_sample = (read_32bitBE(0x89C,streamFile))*28/16/channel_count; - } break; + + case IMA: + vgmstream->num_samples = ima_bytes_to_samples(musx.stream_size, musx.channels); + vgmstream->loop_start_sample = musx.loop_start / 4; /* weird but needed */ + vgmstream->loop_end_sample = musx.loop_end / 4; + + vgmstream->coding_type = coding_DVI_IMA_int; + vgmstream->layout_type = layout_interleave; + vgmstream->interleave_block_size = 0x01; + break; + + case XBOX: + vgmstream->num_samples = xbox_ima_bytes_to_samples(musx.stream_size, musx.channels); + vgmstream->loop_start_sample = xbox_ima_bytes_to_samples(musx.loop_start, musx.channels); + vgmstream->loop_end_sample = xbox_ima_bytes_to_samples(musx.loop_end, musx.channels); + + vgmstream->coding_type = coding_XBOX_IMA; + vgmstream->layout_type = layout_none; + break; + + case DSP: + vgmstream->num_samples = dsp_bytes_to_samples(musx.stream_size, musx.channels); + vgmstream->loop_start_sample = dsp_bytes_to_samples(musx.loop_start, musx.channels); + vgmstream->loop_end_sample = dsp_bytes_to_samples(musx.loop_end, musx.channels); + + vgmstream->coding_type = coding_NGC_DSP; + vgmstream->layout_type = layout_interleave; + vgmstream->interleave_block_size = 0x08; + + dsp_read_coefs(vgmstream,streamFile,musx.coefs_offset+0x1c, 0x60, musx.big_endian); + dsp_read_hist(vgmstream,streamFile,musx.coefs_offset+0x40, 0x60, musx.big_endian); + break; + default: goto fail; } + if (musx.num_samples) + vgmstream->num_samples = musx.num_samples; + if (musx.loop_flag && musx.loop_start_sample) + vgmstream->loop_start_sample = musx.loop_start_sample; + if (musx.loop_flag && musx.loop_end_sample) + vgmstream->loop_end_sample = musx.loop_end_sample; if (!vgmstream_open_stream(vgmstream,streamFile,start_offset)) goto fail; @@ -230,258 +137,416 @@ fail: } -/* MUSX (Version 010) [Dead Space: Extraction (Wii), Rio (PS3), Pirates of the Caribbean: At World's End (PSP)] */ -VGMSTREAM * init_vgmstream_musx_v010(STREAMFILE *streamFile) { - VGMSTREAM * vgmstream = NULL; - char filename[PATH_LIMIT]; - off_t start_offset; - int musx_type; /* determining the decoder by strings like "PS2_", "GC__" and so on */ - //int musx_version; /* 0x08 provides a "version" byte */ - int loop_flag = 0; - int channel_count; +static int parse_musx_stream(STREAMFILE *streamFile, musx_header *musx) { + int32_t (*read_32bit)(off_t,STREAMFILE*) = NULL; + int default_channels, default_sample_rate; - /* check extension, case insensitive */ - streamFile->get_name(streamFile,filename,sizeof(filename)); - if (strcasecmp("musx",filename_extension(filename))) goto fail; - - /* check header */ - if (read_32bitBE(0x00,streamFile) != 0x4D555358) /* "MUSX" */ - goto fail; - if (read_32bitBE(0x800,streamFile) == 0x53424E4B) /* "SBNK", */ // SoundBank, refuse - goto fail; - if (read_32bitBE(0x08,streamFile) != 0x0A000000) /* "0x0A000000" */ - goto fail; - - loop_flag = ((read_32bitLE(0x34,streamFile)!=0x00000000) && - (read_32bitLE(0x34,streamFile)!=0xABABABAB)); - channel_count = 2; - - musx_type=(read_32bitBE(0x10,streamFile)); - - if (musx_type == 0x5749495F && /* WII_ */ - (read_16bitBE(0x40,streamFile) == 0x4441) && /* DA */ - (read_8bit(0x42,streamFile) == 0x54)) /* T */ - { - channel_count = read_32bitLE(0x48,streamFile); - loop_flag = (read_32bitLE(0x64,streamFile) != -1); - } - if (musx_type == 0x5053335F && /* PS3_ */ - (read_16bitBE(0x40,streamFile) == 0x4441) && /* DA */ - (read_8bit(0x42,streamFile) == 0x54)) /* T */ - { - channel_count = read_32bitLE(0x48,streamFile); - loop_flag = (read_32bitLE(0x64,streamFile) != -1); - } - if (0x58455F5F == musx_type) /* XE__ */ - { - loop_flag = 0; + if (musx->big_endian) { + read_32bit = read_32bitBE; + } else { + read_32bit = read_32bitLE; } - /* build the VGMSTREAM */ - vgmstream = allocate_vgmstream(channel_count,loop_flag); - if (!vgmstream) goto fail; - /* fill in the vital statistics */ - switch (musx_type) { - case 0x5053325F: /* PS2_ */ - start_offset = 0x800; - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = read_32bitLE(0x40,streamFile); - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x80; - vgmstream->meta_type = meta_MUSX_V010; - if (loop_flag) - { - vgmstream->loop_start_sample = read_32bitLE(0x44,streamFile); - vgmstream->loop_end_sample = read_32bitLE(0x40,streamFile); + /* autodetect for older versions that have no info */ + if (musx->platform == 0) { + if (musx->big_endian) { + musx->platform = 0x47433032; /* "GC02" (fake) */ + } + else { + off_t offset = musx->stream_offset; + size_t max = 0x5000; + if (max > musx->stream_size) + max = musx->stream_size; + + if (ps_check_format(streamFile, offset, max)) { + musx->platform = 0x5053325F; /* "PS2_" */ + } else { + musx->platform = 0x58423032; /* "XB02" (fake) */ } - break; - case 0x5053505F: /* PSP_ */ - start_offset = 0x800; - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32768; - vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = (read_32bitLE(0xC,streamFile))*28/32; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x80; - vgmstream->meta_type = meta_MUSX_V010; - break; - case 0x5053335F: /* PS3_ */ - start_offset = 0x800; - vgmstream->channels = channel_count; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - vgmstream->meta_type = meta_MUSX_V010; + } + } - if (read_32bitBE(0x40,streamFile)==0x44415438){ - vgmstream->num_samples = read_32bitLE(0x60,streamFile); - vgmstream->sample_rate = read_32bitLE(0x4C,streamFile); - if (loop_flag) - { - vgmstream->loop_start_sample = read_32bitLE(0x64,streamFile); - vgmstream->loop_end_sample = read_32bitLE(0x60,streamFile); + + /* defaults */ + switch(musx->platform) { + + case 0x5053325F: /* "PS2_" */ + default_channels = 2; + default_sample_rate = 32000; + musx->codec = PSX; + break; + + case 0x47435F5F: /* "GC__" */ + default_channels = 2; + default_sample_rate = 32000; + musx->codec = DAT; + break; + + case 0x47433032: /* "GC02" */ + default_channels = 2; + default_sample_rate = 32000; + if (musx->coefs_offset) + musx->codec = DSP; + else + musx->codec = IMA; + break; + + case 0x58425F5F: /* "XB__" */ + default_channels = 2; + default_sample_rate = 44100; + musx->codec = DAT; + break; + + case 0x58423032: /* "XB02" */ + default_channels = 2; + default_sample_rate = 44100; + musx->codec = XBOX; + break; + + case 0x5053505F: /* "PSP_" */ + default_channels = 2; + default_sample_rate = 32768; + musx->codec = PSX; + break; + + case 0x5749495F: /* "WII_" */ + default_channels = 2; + default_sample_rate = 44100; + musx->codec = DAT; + break; + + case 0x5053335F: /* "PS3_" */ + default_channels = 2; + default_sample_rate = 44100; + musx->codec = DAT; + break; + + case 0x58455F5F: /* "XE__" */ + default_channels = 2; + default_sample_rate = 32000; + musx->codec = DAT; + break; + + default: + VGM_LOG("MUSX: unknown platform %x\n", musx->platform); + goto fail; + } + + if (musx->channels == 0) + musx->channels = default_channels; + if (musx->sample_rate == 0) + musx->sample_rate = default_sample_rate; + + + /* parse loops and other info */ + if (musx->tables_offset && musx->loops_offset) { + int i, cues2_count; + off_t cues2_offset; + + /* cue/stream position table thing */ + /* 0x00: cues1 entries (entry size 0x34 or 0x18) + * 0x04: cues2 entries (entry size 0x20 or 0x14) + * 0x08: header size (always 0x14) + * 0x0c: cues2 start + * 0x10: volume? (usually <= 100) */ + + /* find loops (cues1 also seems to have this info but this looks ok) */ + cues2_count = read_32bit(musx->loops_offset+0x04, streamFile); + cues2_offset = musx->loops_offset + read_32bit(musx->loops_offset+0x0c, streamFile); + for (i = 0; i < cues2_count; i++) { + uint32_t type, offset1, offset2; + + if (musx->is_old) { + offset1 = read_32bit(cues2_offset + i*0x20 + 0x04, streamFile); + type = read_32bit(cues2_offset + i*0x20 + 0x08, streamFile); + offset2 = read_32bit(cues2_offset + i*0x20 + 0x14, streamFile); + } else { + offset1 = read_32bit(cues2_offset + i*0x14 + 0x04, streamFile); + type = read_32bit(cues2_offset + i*0x14 + 0x08, streamFile); + offset2 = read_32bit(cues2_offset + i*0x14 + 0x0c, streamFile); } + + /* other types (0x0a, 0x09) look like section/end markers, 0x06/07 only seems to exist once */ + if (type == 0x06 || type == 0x07) { + musx->loop_start = offset2; + musx->loop_end = offset1; + musx->loop_flag = 1; + break; + } + } + } + else if (musx->loops_offset && read_32bitBE(musx->loops_offset, streamFile) != 0xABABABAB) { + /* parse loop table (loop starts are -1 if non-looping) + * 0x00: version? + * 0x04: flags? (&1=loops) + * 0x08: loop start offset? + * 0x0c: loop end offset? + * 0x10: loop end sample + * 0x14: loop start sample + * 0x18: loop end offset + * 0x1c: loop start offset */ + musx->loop_end_sample = read_32bitLE(musx->loops_offset+0x10, streamFile); + musx->loop_start_sample = read_32bitLE(musx->loops_offset+0x14, streamFile); + musx->loop_end = read_32bitLE(musx->loops_offset+0x18, streamFile); + musx->loop_start = read_32bitLE(musx->loops_offset+0x1c, streamFile); + musx->num_samples = musx->loop_end_sample; /* preferable even if not looping as some files have padding */ + musx->loop_flag = (musx->loop_start_sample >= 0); + } + + /* fix some v10 sizes */ + if (musx->stream_size == 0) { + off_t offset; + musx->stream_size = musx->file_size - musx->stream_offset; + + /* remove padding */ + offset = musx->stream_offset + musx->stream_size - 0x04; + while (offset > 0) { + if (read_32bit(offset, streamFile) != 0xABABABAB) + break; + musx->stream_size -= 0x04; + offset -= 0x04; + } + } + + return 1; +fail: + return 0; +} + +static int parse_musx(STREAMFILE *streamFile, musx_header *musx) { + int32_t (*read_32bit)(off_t,STREAMFILE*) = NULL; + int target_subsong = streamFile->stream_index; + + + /* base header is LE */ + /* 0x04: file ID (referenced in external .h, sometimes files are named HC(id).sfx too) */ + musx->version = read_32bitLE(0x08,streamFile); + musx->file_size = read_32bitLE(0x0c,streamFile); + + + switch(musx->version) { + case 201: /* Sphinx and the Cursed Mummy (PS2), Buffy the Vampire Slayer: Chaos Bleeds (PS2/GC/Xbox) */ + case 1: /* Athens 2004 (PS2) */ + musx->platform = 0; /* guess later */ + musx->tables_offset = 0x10; + musx->big_endian = guess_endianness32bit(0x10, streamFile); + musx->is_old = 1; + break; + + case 4: /* Spyro: A Hero's Tail (PS2/Xbox/GC) */ + case 5: /* Predator: Concrete Jungle (PS2/Xbox), Robots (GC) */ + case 6: /* Batman Begins (GC), Ice Age 2 (PS2) */ + musx->platform = read_32bitBE(0x10,streamFile); + /* 0x14: some id/hash? */ + /* 0x18: platform number? */ + /* 0x1c: null */ + musx->tables_offset = 0x20; + musx->big_endian = (musx->platform == 0x47435F5F); /* "GC__" */ + break; + + case 10: /* 007: Quantum of Solace (PS2), Pirates of the Caribbean: At World's End (PSP), GoldenEye 007 (Wii), Rio (PS3) */ + musx->platform = read_32bitBE(0x10,streamFile); + /* 0x14: null */ + /* 0x18: platform number? */ + /* 0x1c: null */ + /* 0x20: hash */ + musx->tables_offset = 0; /* no tables */ + musx->big_endian = (musx->platform == 0x5749495F || musx->platform == 0x5053335F); /* "GC__" / "PS3_" (only after header) */ + break; + + default: + goto fail; + } + + if (musx->big_endian) { + read_32bit = read_32bitBE; + } else { + read_32bit = read_32bitLE; + } + + + /* MUSX has multiple forms which seem external/implicit info so we need some crude autodetection */ + if (musx->tables_offset) { + off_t table1_offset, table2_offset /*, table3_offset, table4_offset*/; + size_t /*table1_size, table2_size, table3_size,*/ table4_size; + + table1_offset = read_32bit(musx->tables_offset+0x00, streamFile); + //table1_size = read_32bit(musx->tables_offset+0x04, streamFile); + table2_offset = read_32bit(musx->tables_offset+0x08, streamFile); + //table2_size = read_32bit(musx->tables_offset+0x0c, streamFile); + //table3_offset = read_32bit(musx->tables_offset+0x10, streamFile); + //table3_size = read_32bit(musx->tables_offset+0x14, streamFile); + //table4_offset = read_32bit(musx->tables_offset+0x18, streamFile); + table4_size = read_32bit(musx->tables_offset+0x1c, streamFile); + + if (table2_offset == 0 || table2_offset == 0xABABABAB) { + /* possibly a collection of IDs */ + goto fail; + } + else if (table4_size != 0 && table4_size != 0xABABABAB) { + /* sfx banks have table1=id table? table2=header table, table=DSP coefs table (optional), table4=data */ + musx->form = SFX_BANK; + } + else if (read_32bit(table1_offset+0x00, streamFile) < 0x9 && + read_32bit(table1_offset+0x08, streamFile) == 0x14 && + read_32bit(table1_offset+0x10, streamFile) <= 100) { + /* streams have a info table with a certain format */ + musx->form = MFX; + } + else if (read_32bit(table1_offset+0x00, streamFile) == 0 && + read_32bit(table1_offset+0x04, streamFile) > read_32bit(table1_offset+0x00, streamFile) && + read_32bit(table1_offset+0x08, streamFile) > read_32bit(table1_offset+0x04, streamFile)) { + /* a list of offsets starting from 0, each stream then has info table at offset */ + musx->form = MFX_BANK; + } + else { + goto fail; + } + } + else { + if (read_32bitBE(0x800,streamFile) == 0x53424E4B) { /* "SBNK" */ + /* SFX_BANK-like sound bank found on v10 Wii games */ + musx->form = SBNK; + } + else if (read_32bitBE(0x800,streamFile) == 0x464F524D) { /* "FORM" */ + /* RIFF-like sound bank found on v10 PSP games */ + musx->form = FORM; + } + else if (read_32bitBE(0x800,streamFile) == 0x45535044) { /* "ESPD" */ + /* projectdetails.sfx */ + goto fail; + } + else { + musx->form = MFX; + } + } + + + /* parse known forms */ + switch(musx->form) { + case MFX: + + if (musx->tables_offset) { + musx->loops_offset = read_32bit(musx->tables_offset+0x00, streamFile); + + musx->stream_offset = read_32bit(musx->tables_offset+0x08, streamFile); + musx->stream_size = read_32bit(musx->tables_offset+0x0c, streamFile); } else { - vgmstream->sample_rate = 44100; - vgmstream->num_samples = (get_streamfile_size(streamFile)-0x800)/2/(0x20)*((0x20-4)*2); - if (loop_flag) - { - vgmstream->loop_start_sample = read_32bitLE(0x44,streamFile); - vgmstream->loop_end_sample = read_32bitLE(0x40,streamFile); - } - } - break; - case 0x5749495F: /* WII_ */ - start_offset = 0x800; - vgmstream->channels = channel_count; - vgmstream->sample_rate = read_32bitLE(0x4C,streamFile); - switch (read_32bitBE(0x40,streamFile)) - { - case 0x44415434: /* DAT4 */ - case 0x44415438: /* DAT8 [GoldenEye 007 (Wii)] */ - vgmstream->coding_type = coding_DAT4_IMA; - break; - default: - goto fail; - } - vgmstream->num_samples = read_32bitLE(0x60,streamFile); - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - vgmstream->meta_type = meta_MUSX_V010; - if (loop_flag) - { - vgmstream->loop_start_sample = read_32bitLE(0x64,streamFile); - vgmstream->loop_end_sample = read_32bitLE(0x60,streamFile); + if (read_32bitBE(0x30, streamFile) != 0xABABABAB) { + uint32_t miniheader = read_32bitBE(0x40, streamFile); + switch(miniheader) { + case 0x44415434: /* "DAT4" */ + case 0x44415438: /* "DAT8" */ + /* found on PS3/Wii (but not always?) */ + musx->stream_size = read_32bitLE(0x44, streamFile); + musx->channels = read_32bitLE(0x48, streamFile); + musx->sample_rate = read_32bitLE(0x4c, streamFile); + musx->loops_offset = 0x50; + break; + default: + musx->loops_offset = 0x30; + break; + } + } + + musx->stream_offset = 0x800; + musx->stream_size = 0; /* read later */ } + if (!parse_musx_stream(streamFile, musx)) + goto fail; break; - case 0x58455F5F: /* XE__ */ - start_offset = 0x800; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_DAT4_IMA; - vgmstream->num_samples = (get_streamfile_size(streamFile)-0x800)/2/(0x20)*((0x20-4)*2); - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x20; - vgmstream->meta_type = meta_MUSX_V010; - + + case MFX_BANK: { + off_t target_offset, base_offset, data_offset; + + musx->total_subsongs = read_32bit(musx->tables_offset+0x04, streamFile) / 0x04; /* size */ + if (target_subsong == 0) target_subsong = 1; + if (target_subsong > musx->total_subsongs || musx->total_subsongs <= 0) goto fail; + + base_offset = read_32bit(musx->tables_offset+0x00, streamFile); + data_offset = read_32bit(musx->tables_offset+0x08, streamFile); + + target_offset = read_32bit(base_offset + (target_subsong - 1)*0x04, streamFile) + data_offset; + + /* 0x00: id? */ + musx->stream_offset = read_32bit(target_offset + 0x04, streamFile) + data_offset; + musx->stream_size = read_32bit(target_offset + 0x08, streamFile); + musx->loops_offset = target_offset + 0x0c; + + /* this looks correct for PS2 and Xbox, not sure about GC */ + musx->channels = 1; + musx->sample_rate = 22050; + + if (!parse_musx_stream(streamFile, musx)) + goto fail; break; + } + + case SFX_BANK: { + off_t target_offset, head_offset, coef_offset, data_offset; + size_t coef_size; + + //unk_offset = read_32bit(musx->tables_offset+0x00, streamFile); /* ids and cue-like config? */ + head_offset = read_32bit(musx->tables_offset+0x08, streamFile); + coef_offset = read_32bit(musx->tables_offset+0x10, streamFile); + coef_size = read_32bit(musx->tables_offset+0x14, streamFile); + data_offset = read_32bit(musx->tables_offset+0x18, streamFile); + + musx->total_subsongs = read_32bit(head_offset+0x00, streamFile); + if (target_subsong == 0) target_subsong = 1; + if (target_subsong > musx->total_subsongs || musx->total_subsongs <= 0) goto fail; + + + if (musx->is_old) { + target_offset = head_offset + 0x04 + (target_subsong - 1)*0x28; + + /* 0x00: flag? */ + musx->stream_offset = read_32bit(target_offset + 0x04, streamFile) + data_offset; + musx->stream_size = read_32bit(target_offset + 0x08, streamFile); + musx->sample_rate = read_32bit(target_offset + 0x0c, streamFile); + /* 0x10: size? */ + /* 0x14: channels? */ + /* 0x18: always 4? */ + musx->coefs_offset = read_32bit(target_offset + 0x1c, streamFile) + coef_offset; /* may be set even for non-GC */ + /* 0x20: null? */ + /* 0x24: sub-id? */ + musx->channels = 1; + } + else { + target_offset = head_offset + 0x04 + (target_subsong - 1)*0x20; + + /* 0x00: flag? */ + musx->stream_offset = read_32bit(target_offset + 0x04, streamFile) + data_offset; + musx->stream_size = read_32bit(target_offset + 0x08, streamFile); + musx->sample_rate = read_32bit(target_offset + 0x0c, streamFile); + /* 0x10: size? */ + musx->coefs_offset = read_32bit(target_offset + 0x14, streamFile) + coef_offset; /* may be set even for non-GC */ + /* 0x18: null? */ + /* 0x1c: sub-id? */ + musx->channels = 1; + } + + + VGM_LOG("to=%lx, %lx, %x\n", target_offset, musx->stream_offset, musx->stream_size); + + if (coef_size == 0) + musx->coefs_offset = 0; /* disable for later detection */ + + if (!parse_musx_stream(streamFile, musx)) + goto fail; + break; + } + default: + VGM_LOG("MUSX: unknown form\n"); goto fail; } - /* 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;ich[i].streamfile = file; - - vgmstream->ch[i].channel_start_offset= - vgmstream->ch[i].offset=start_offset+ - vgmstream->interleave_block_size*i; - - } - } - - return vgmstream; + return 1; fail: - close_vgmstream(vgmstream); - return NULL; -} - - -/* MUSX (Version 201) */ -VGMSTREAM * init_vgmstream_musx_v201(STREAMFILE *streamFile) { - VGMSTREAM * vgmstream = NULL; - char filename[PATH_LIMIT]; - off_t start_offset; - //int musx_version; /* 0x08 provides a "version" byte */ - int loop_flag; - int channel_count; - int loop_detect; - int loop_offsets; - - /* check extension, case insensitive */ - streamFile->get_name(streamFile,filename,sizeof(filename)); - if (strcasecmp("musx",filename_extension(filename))) goto fail; - - /* check header */ - if (read_32bitBE(0x00,streamFile) != 0x4D555358) /* "MUSX" */ - goto fail; - if ((read_32bitBE(0x08,streamFile) != 0xC9000000) && - (read_32bitLE(0x08,streamFile) != 0xC9000000)) /* "0xC9000000" */ - goto fail; - - channel_count = 2; - - loop_detect = read_32bitBE(0x800,streamFile); - switch (loop_detect) { - case 0x02000000: - loop_offsets = 0x8E0; - break; - case 0x03000000: - loop_offsets = 0x880; - break; - case 0x04000000: - loop_offsets = 0x8B4; - break; - case 0x05000000: - loop_offsets = 0x8E8; - break; - case 0x06000000: - loop_offsets = 0x91C; - break; - default: - goto fail; - } - - loop_flag = (read_32bitLE(loop_offsets+0x04,streamFile) !=0x00000000); - start_offset = read_32bitLE(0x18,streamFile); - - /* build the VGMSTREAM */ - vgmstream = allocate_vgmstream(channel_count,loop_flag); - if (!vgmstream) goto fail; - - { - vgmstream->channels = channel_count; - vgmstream->sample_rate = 32000; - vgmstream->coding_type = coding_PSX; - vgmstream->num_samples = read_32bitLE(loop_offsets,streamFile)*28/16/channel_count; - if (loop_flag) { - vgmstream->loop_start_sample = read_32bitLE(loop_offsets+0x10,streamFile)*28/16/channel_count; - vgmstream->loop_end_sample = read_32bitLE(loop_offsets,streamFile)*28/16/channel_count; - } - vgmstream->layout_type = layout_interleave; - vgmstream->interleave_block_size = 0x80; - vgmstream->meta_type = meta_MUSX_V201; - } - - /* 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;ich[i].streamfile = file; - - vgmstream->ch[i].channel_start_offset= - vgmstream->ch[i].offset=start_offset+ - vgmstream->interleave_block_size*i; - - } - } - - return vgmstream; - -fail: - close_vgmstream(vgmstream); - return NULL; + return 0; } diff --git a/src/vgmstream.c b/src/vgmstream.c index fa7e15c8..85109070 100644 --- a/src/vgmstream.c +++ b/src/vgmstream.c @@ -98,11 +98,7 @@ VGMSTREAM * (*init_vgmstream_functions[])(STREAMFILE *streamFile) = { init_vgmstream_xwb, init_vgmstream_ps2_xa30, init_vgmstream_musc, - init_vgmstream_musx_v004, - init_vgmstream_musx_v005, - init_vgmstream_musx_v006, - init_vgmstream_musx_v010, - init_vgmstream_musx_v201, + init_vgmstream_musx, init_vgmstream_leg, init_vgmstream_filp, init_vgmstream_ikm_ps2, diff --git a/src/vgmstream.h b/src/vgmstream.h index f6f55e8d..4f6f98ee 100644 --- a/src/vgmstream.h +++ b/src/vgmstream.h @@ -371,11 +371,7 @@ typedef enum { meta_XWB, /* Microsoft XACT framework (Xbox, X360, Windows) */ meta_PS2_XA30, /* Driver - Parallel Lines (PS2) */ meta_MUSC, /* Krome PS2 games */ - meta_MUSX_V004, /* Spyro Games, possibly more */ - meta_MUSX_V005, /* Spyro Games, possibly more */ - meta_MUSX_V006, /* Spyro Games, possibly more */ - meta_MUSX_V010, /* Spyro Games, possibly more */ - meta_MUSX_V201, /* Sphinx and the cursed Mummy */ + meta_MUSX, meta_LEG, /* Legaia 2 [no header_id] */ meta_FILP, /* Resident Evil - Dead Aim */ meta_IKM,