Cool_Tools/vgmstream
1
0
Fork 0
mirror of https://github.com/vgmstream/vgmstream.git synced 2024-11-28 08:20:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #926 from bnnm/xsh-lyn-etc

Browse Source 
- Fix .sgt DMSG with streams
- Fix Ubi Lyn .wav MPEG last interleave
- Fix EA .WVE with PCM8 [Madden NHL 97 (PC)]
- Add HCA key [m HOLD'EM (Android)]
- Add .xsh+xsd/xss [KS's Pro Surfer (Xbox)]
- Fix CLI smpl chunk with subsongs
- Fix some Ubi BAO [Just Dance (Wii)]
This commit is contained in:
bnnm 2021-08-22 13:20:44 +02:00 committed by GitHub
commit 49dfc218a8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 649 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -58,7 +58,7 @@ export RMF SHELL CC AR STRIP WINDRES DLLTOOL
###############################################################################
### build defs
DEF_CFLAGS += -ffast-math -O3 -Wall -Werror=format-security -Wlogical-op -Wdeclaration-after-statement -Wvla -Wimplicit-function-declaration -Wignored-qualifiers
DEF_CFLAGS += -ffast-math -O3 -Wall -Werror=format-security -Wdeclaration-after-statement -Wvla -Wimplicit-function-declaration -Wignored-qualifiers
VGM_DEBUG_FLAGS = 0
ifeq ($(VGM_DEBUG_FLAGS),1)
@ -67,6 +67,7 @@ ifeq ($(VGM_DEBUG_FLAGS),1)
DEF_CFLAGS += -Wall
DEF_CFLAGS += -Wextra
DEF_CFLAGS += -Wno-sign-compare
DEF_CFLAGS += -Wlogical-op
#DEF_CFLAGS += -pedantic -Wconversion -std=gnu90
#DEF_CFLAGS += -Wfloat-equal
DEF_CFLAGS += -Wdisabled-optimization -Wunsafe-loop-optimizations -Wswitch-default
@ -77,6 +78,7 @@ ifeq ($(VGM_DEBUG_FLAGS),1)
DEF_CFLAGS += -Wredundant-decls -Wmissing-include-dirs -Wmissing-declarations
#DEF_CFLAGS += -Wshadow
#DEF_CFLAGS += -Wstack-protector -fstack-protector
STRIP = echo
endif
LIBS_CFLAGS=

2
README.md
View File

@ -150,7 +150,7 @@ Since XMPlay supports Winamp plugins you may also use `in_vgmstream.dll` instead
Because the XMPlay MP3 decoder incorrectly tries to play some vgmstream extensions,
you need to manually fix it by going to **options > plugins > input > vgmstream**
and in the "priority filetypes" put: `ahx,asf,awc,ckd,fsb,genh,msf,p3d,rak,scd,txth,xvag`
and in the "priority filetypes" put: `ahx,asf,awc,ckd,fsb,genh,lwav,msf,p3d,rak,scd,txth,xvag`
XMPlay cannot support subsongs due to player limitations (with any plugin), try
using *TXTP* instead (explained below).

6
cli/vgmstream_cli.c
View File

@ -377,7 +377,11 @@ static void apply_config(VGMSTREAM* vgmstream, cli_config* cfg) {
cfg->lwav_loop_end = vgmstream->loop_end_sample;
cfg->lwav_loop_end--; /* from spec, +1 is added when reading "smpl" */
}
else {
/* reset for subsongs */
cfg->lwav_loop_start = 0;
cfg->lwav_loop_end = 0;
}
}
/* only allowed if manually active */
if (cfg->play_forever) {

2
src/coding/coding.h
View File

@ -444,8 +444,10 @@ typedef struct {
int channels; /* max channels */
int fsb_padding; /* fsb padding mode */
int chunk_size; /* size of a data portion */
int max_chunks;
int data_size; /* playable size */
int interleave; /* size of stream interleave */
int interleave_last;
int encryption; /* encryption mode */
int big_endian;
int skip_samples;

22
src/coding/mpeg_custom_utils.c
View File

@ -51,6 +51,7 @@ int mpeg_custom_setup_init_default(STREAMFILE* sf, off_t start_offset, mpeg_code
}
break;
//todo simplify/unify XVAG/P3D/SCD/LYN and just feed arbitrary chunks to the decoder
case MPEG_P3D:
case MPEG_SCD:
if (data->config.interleave <= 0)
@ -61,7 +62,8 @@ int mpeg_custom_setup_init_default(STREAMFILE* sf, off_t start_offset, mpeg_code
if (data->config.interleave <= 0)
goto fail; /* needs external fixed size */
data->default_buffer_size = data->config.interleave;
//todo simplify/unify XVAG/P3D/SCD/LYN and just feed arbitrary chunks to the decoder
if (data->default_buffer_size < data->config.interleave_last)
data->default_buffer_size = data->config.interleave_last;
break;
case MPEG_STANDARD:
@ -179,7 +181,6 @@ int mpeg_custom_parse_frame_default(VGMSTREAMCHANNEL* stream, mpeg_codec_data* d
case MPEG_P3D: /* fixed interleave, not frame-aligned (ie. blocks may end/start in part of a frame) */
case MPEG_SCD:
case MPEG_LYN:
current_interleave = data->config.interleave;
/* check if current interleave block is short */
@ -197,6 +198,23 @@ int mpeg_custom_parse_frame_default(VGMSTREAMCHANNEL* stream, mpeg_codec_data* d
current_data_size = current_interleave;
break;
case MPEG_LYN:
/* after N interleaves last block is bigger */
if (ms->current_size_count < data->config.max_chunks)
current_interleave = data->config.interleave;
else if (ms->current_size_count == data->config.max_chunks)
current_interleave = data->config.interleave_last;
else
goto fail;
current_interleave_pre = current_interleave*num_stream;
current_interleave_post = current_interleave*(data->streams_size-1) - current_interleave_pre;
//VGM_LOG("o=%lx, %i: %x, %x, %x, %x\n", stream->offset, num_stream, ms->current_size_count, current_interleave, current_interleave_pre, current_interleave_post );
current_data_size = current_interleave;
ms->current_size_count++;
break;
default: /* standard frames (CBR or VBR) */
if ( !mpeg_get_frame_info(stream->streamfile, stream->offset, &info) )
goto fail;

6
src/coding/mpeg_decoder.c
View File

@ -144,7 +144,11 @@ mpeg_codec_data* init_mpeg_custom(STREAMFILE* sf, off_t start_offset, coding_t*
if (channels <= 0 || channels > 16) goto fail; /* arbitrary max */
if (channels < data->channels_per_frame) goto fail;
//todo simplify/unify XVAG/P3D/SCD/LYN and just feed arbitrary chunks to the decoder
if (data->default_buffer_size > 0x10000) goto fail; /* max for some Ubi Lyn */
/* max for some Ubi Lyn */
if (data->default_buffer_size > 0x20000) {
VGM_LOG("MPEG: buffer size too big %x\n", data->default_buffer_size);
goto fail;
}
/* init streams */

4
src/coding/relic_decoder_lib.c
View File

@ -238,9 +238,9 @@ static void init_dequantization(float* scales) {
static int unpack_frame(uint8_t* buf, int buf_size, float* freq1, float* freq2, const float* scales, uint8_t* exponents, int freq_size) {
uint8_t flags, cb_bits, ev_bits, ei_bits, qv_bits;
int qv;
int qv, pos;
uint8_t ev;
uint8_t move, pos;
uint8_t move;
uint32_t bit_offset, max_offset;
int i, j;
int freq_half = freq_size >> 1;

9
src/formats.c
View File

@ -155,7 +155,7 @@ static const char* extension_list[] = {
"de2",
"dec",
"diva",
"dmsg",
"dmsg", //fake extension/header id for .sgt (to be removed)
"ds2", //txth/reserved [Star Wars Bounty Hunter (GC)]
"dsb",
"dsf",
@ -402,7 +402,7 @@ static const char* extension_list[] = {
"rad",
"rak",
"ras",
"raw",
"raw", //txth/reserved [Madden NHL 97 (PC)-pcm8u]
"rda", //FFmpeg/reserved [Rhythm Destruction (PC)]
"rkv",
"rnd",
@ -464,6 +464,7 @@ static const char* extension_list[] = {
"sfx",
"sgb",
"sgd",
"sgt",
"sgx",
"sl3",
"slb", //txth/reserved [THE Nekomura no Hitobito (PS2)]
@ -611,6 +612,7 @@ static const char* extension_list[] = {
"xma2",
"xmu",
"xnb",
"xsh",
"xsf",
"xse",
"xsew",
@ -1114,7 +1116,7 @@ static const meta_info meta_info_list[] = {
{meta_HIS, "Her Interactive HIS header"},
{meta_PS2_AST, "KOEI AST header"},
{meta_CAPDSP, "Capcom DSP header"},
{meta_DMSG, "RIFF/DMSGsegh header"},
{meta_DMSG, "Microsoft RIFF DMSG header"},
{meta_PONA_3DO, "Policenauts BGM header"},
{meta_PONA_PSX, "Policenauts BGM header"},
{meta_NGC_DSP_AAAP, "Acclaim Austin AAAp DSP header"},
@ -1357,6 +1359,7 @@ static const meta_info meta_info_list[] = {
{meta_PIFF_TPCM, "Tantalus PIFF TPCM header"},
{meta_WXD_WXH, "Relic WXD+WXH header"},
{meta_BNK_RELIC, "Relic BNK header"},
{meta_XSH_XSD_XSS, "Treyarch XSH+XSD/XSS header"},
};
void get_vgmstream_coding_description(VGMSTREAM* vgmstream, char* out, size_t out_size) {

36
src/layout/blocked.c
View File

@ -1,6 +1,7 @@
#include "layout.h"
#include "../vgmstream.h"
#include "../decode.h"
#include "../coding/coding.h"
/* Decodes samples for blocked streams.
@ -216,3 +217,38 @@ void block_update(off_t block_offset, VGMSTREAM * vgmstream) {
break;
}
}
void blocked_count_samples(VGMSTREAM* vgmstream, STREAMFILE* sf, off_t offset) {
int block_samples;
off_t max_offset = get_streamfile_size(sf);
vgmstream->next_block_offset = offset;
do {
block_update(vgmstream->next_block_offset, vgmstream);
if (vgmstream->current_block_samples < 0 || vgmstream->current_block_size == 0xFFFFFFFF)
break;
if (vgmstream->current_block_samples) {
block_samples = vgmstream->current_block_samples;
}
else {
switch(vgmstream->coding_type) {
case coding_PCM16_int: block_samples = pcm16_bytes_to_samples(vgmstream->current_block_size, 1); break;
case coding_PCM8_int:
case coding_PCM8_U_int: block_samples = pcm8_bytes_to_samples(vgmstream->current_block_size, 1); break;
case coding_XBOX_IMA: block_samples = xbox_ima_bytes_to_samples(vgmstream->current_block_size, 1); break;
case coding_NGC_DSP: block_samples = dsp_bytes_to_samples(vgmstream->current_block_size, 1); break;
case coding_PSX: block_samples = ps_bytes_to_samples(vgmstream->current_block_size,1); break;
default:
VGM_LOG("BLOCKED: missing codec\n");
return;
}
}
vgmstream->num_samples += block_samples;
}
while (vgmstream->next_block_offset < max_offset);
block_update(offset, vgmstream); /* reset */
}

11
src/layout/blocked_ea_wve_ad10.c
View File

@ -6,11 +6,14 @@
void block_update_ea_wve_ad10(off_t block_offset, VGMSTREAM* vgmstream) {
STREAMFILE* sf = vgmstream->ch[0].streamfile;
int i;
size_t block_size, channel_size = 0, interleave = 0;
uint32_t block_id;
size_t channel_size = 0, interleave = 0;
uint32_t block_id, block_size;
block_id = read_32bitBE(block_offset+0x00, sf);
block_size = read_32bitBE(block_offset+0x04, sf);
int flag_be = (vgmstream->codec_config & 0x01);
uint32_t (*read_u32)(off_t,STREAMFILE*) = flag_be ? read_u32be : read_u32le;
block_id = read_u32be(block_offset+0x00, sf);
block_size = read_u32 (block_offset+0x04, sf);
/* accept "Ad10/Ad11" audio block/footer */
if (block_id == 0x41643130 || block_id == 0x41643131) {

1
src/layout/layout.h
View File

@ -7,6 +7,7 @@
/* blocked layouts */
void render_vgmstream_blocked(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
void block_update(off_t block_offset, VGMSTREAM* vgmstream);
void blocked_count_samples(VGMSTREAM* vgmstream, STREAMFILE* sf, off_t offset);
void block_update_ast(off_t block_ofset, VGMSTREAM* vgmstream);
void block_update_mxch(off_t block_ofset, VGMSTREAM* vgmstream);

1
src/libvgmstream.vcxproj
View File

@ -589,6 +589,7 @@
<ClCompile Include="meta\xpcm.c" />
<ClCompile Include="meta\xps.c" />
<ClCompile Include="meta\xse.c" />
<ClCompile Include="meta\xsh_xsd_xss.c" />
<ClCompile Include="meta\xss.c" />
<ClCompile Include="meta\xssb.c" />
<ClCompile Include="meta\xvag.c" />

3
src/libvgmstream.vcxproj.filters
View File

@ -1828,6 +1828,9 @@
<ClCompile Include="meta\xse.c">
<Filter>meta\Source Files</Filter>
</ClCompile>
<ClCompile Include="meta\xsh_xsd_xss.c">
<Filter>meta\Source Files</Filter>
</ClCompile>
<ClCompile Include="meta\x360_cxs.c">
<Filter>meta\Source Files</Filter>
</ClCompile>

16
src/meta/cpk.c
View File

@ -28,9 +28,9 @@ VGMSTREAM* init_vgmstream_cpk_memory(STREAMFILE* sf, STREAMFILE* sf_acb) {
/* checks */
if (!check_extensions(sf, "awb"))
goto fail;
if (read_u32be(0x00,sf) != 0x43504B20) /* "CPK " */
if (!is_id32be(0x00,sf, "CPK "))
goto fail;
if (read_u32be(0x10,sf) != 0x40555446) /* "@UTF" */
if (!is_id32be(0x10,sf, "@UTF"))
goto fail;
/* 04: 0xFF? */
/* 08: 0x02A0? */
@ -176,23 +176,21 @@ VGMSTREAM* init_vgmstream_cpk_memory(STREAMFILE* sf, STREAMFILE* sf_acb) {
//;VGM_LOG("CPK: subfile offset=%lx + %x, id=%i\n", subfile_offset, subfile_size, subfile_id);
if ((read_u32be(subfile_offset,sf) & 0x7f7f7f7f) == 0x48434100) { /* "HCA\0" */
if ((read_u32be(subfile_offset,sf) & 0x7f7f7f7f) == get_id32be("HCA\0")) {
type = HCA;
extension = "hca";
}
else if (read_u32be(subfile_offset,sf) == 0x43574156) { /* "CWAV" */
else if (is_id32be(subfile_offset,sf, "CWAV")) {
type = CWAV;
extension = "bcwav";
}
else if (read_u16be(subfile_offset, sf) == 0x8000) {
off_t test_offset = subfile_offset + read_u16be(subfile_offset + 0x02, sf) + 0x04;
if (read_u16be(test_offset - 0x06, sf) != 0x2863 || /* "(c" */
read_u32be(test_offset - 0x04, sf) != 0x29435249) /* ")CRI" */
goto fail;
type = ADX;
extension = "adx";
}
else {
goto fail;
}
temp_sf = setup_subfile_streamfile(sf, subfile_offset, subfile_size, extension);
if (!temp_sf) goto fail;

219
src/meta/dmsg_segh.c
View File

@ -1,110 +1,159 @@
#include "meta.h"
#include "../util.h"
#include "../coding/coding.h"
/* DMSG
found in: Nightcaster II - Equinox
2010-01-05 (manakoAT): Seems it's a corrupted "SGT" file, but I'm not sure...
*/
VGMSTREAM * init_vgmstream_dmsg(STREAMFILE *streamFile) {
typedef struct {
uint32_t type;
uint32_t size;
uint32_t offset;
off_t current;
off_t max;
int le_type;
int be_size;
int full_size;
} chunk_t;
static int next_chunk(chunk_t* chunk, STREAMFILE* sf) {
uint32_t (*read_u32type)(off_t,STREAMFILE*) = !chunk->le_type ? read_u32be : read_u32le;
uint32_t (*read_u32size)(off_t,STREAMFILE*) = chunk->be_size ? read_u32be : read_u32le;
if (chunk->max == 0)
chunk->max = get_streamfile_size(sf);
if (chunk->current >= chunk->max)
return 0;
/* can be used to signal "stop" */
if (chunk->current < 0)
return 0;
chunk->type = read_u32type(chunk->current + 0x00,sf);
chunk->size = read_u32size(chunk->current + 0x04,sf);
chunk->offset = chunk->current + 0x04 + 0x04;
chunk->current += chunk->full_size ? chunk->size : 0x08 + chunk->size;
//;VGM_LOG("CHUNK: %x, %x, %x\n", dc.offset, chunk->type, chunk->size);
/* read past data */
if (chunk->type == 0xFFFFFFFF || chunk->size == 0xFFFFFFFF)
return 0;
/* empty chunk with 0 size, seen in some formats (XVAG uses it as end marker, Wwise doesn't) */
if (chunk->type == 0 || chunk->size == 0)
return 0;
/* more chunks remain */
return 1;
}
enum {
CHUNK_RIFF = 0x52494646, /* "RIFF" */
CHUNK_LIST = 0x4C495354, /* "LIST" */
CHUNK_segh = 0x73656768, /* "segh" */
};
/* DMSG - DirectMusic Segment with streams [Nightcaster II: Equinox (Xbox), Wildfire (PC)] */
VGMSTREAM* init_vgmstream_dmsg(STREAMFILE* sf) {
VGMSTREAM* vgmstream = NULL;
char filename[PATH_LIMIT];
int loop_flag = 0;
int frequency;
int channel_count;
int dataBuffer = 0;
int Founddata = 0;
size_t file_size;
off_t current_chunk;
off_t start_offset;
//int loop_flag, channels, sample_rate;
//int found_data = 0;
//int32_t num_samples, loop_start, loop_end;
//off_t start_offset;
off_t offset = 0, name_offset = 0, name_size = 0;
/* check extension, case insensitive */
streamFile->get_name(streamFile,filename,sizeof(filename));
if (strcasecmp("dmsg",filename_extension(filename))) goto fail;
/* check header */
if (read_32bitBE(0x00,streamFile) != 0x52494646) /* "RIFF" */
goto fail;
if (read_32bitBE(0x08,streamFile) != 0x444D5347) /* "DMSG" */
goto fail;
if (read_32bitBE(0x0C,streamFile) != 0x73656768) /* "segh" */
goto fail;
if (read_32bitBE(0x10,streamFile) != 0x38000000) /* "0x38" */
/* checks */
/* .sgt: common
* .dmsg: header id */
if (!check_extensions(sf, "sgt,dmsg"))
goto fail;
/* scan file until we find a "data" string */
file_size = get_streamfile_size(streamFile);
if (!is_id32be(0x00,sf, "RIFF"))
goto fail;
if (!is_id32be(0x08,sf, "DMSG"))
goto fail;
/* A DirectMusic segment usually has lots of chunks then data pointing to .dls soundbank.
* This accepts .sgt with a RIFF WAVE inside (less common). */
{
current_chunk = 0;
/* Start at 0 and loop until we reached the
file size, or until we found a "data string */
while (!Founddata && current_chunk < file_size) {
dataBuffer = (read_32bitBE(current_chunk,streamFile));
if (dataBuffer == 0x64617461) { /* "data" */
/* if "data" string found, retrieve the needed infos */
Founddata = 1;
/* We will cancel the search here if we have a match */
chunk_t rc = {0};
chunk_t dc = {0};
rc.current = 0x0c;
while (next_chunk(&rc, sf)) {
switch(rc.type) {
/* "segh" has loopnum/samplesloop */
case CHUNK_segh:
//todo: missing TMusicTime format
/* 0x00: dwRepeats (>0 or -1=inf)
* 0x04: mtLength
* 0x08: mtPlayStart
* 0x0c: mtLoopStart
* 0x10: mtLoopEnd
* 0x14: dwResolution
* 0x18: rtLength (optional)
* .. */
break;
case CHUNK_LIST:
if (is_id32be(rc.offset + 0x00, sf, "UNFO") && is_id32be(rc.offset + 0x04, sf, "UNAM")) {
name_offset = rc.offset + 0x0c;
name_size = read_u32le(rc.offset + 0x08, sf);
}
break;
case CHUNK_RIFF:
if (!is_id32be(rc.offset, sf, "DMCN"))
goto fail;
dc.current = rc.offset + 0x04;
while (next_chunk(&dc, sf)) {
switch(dc.type) {
case CHUNK_LIST:
/* abridged, there are some sublists */
if (is_id32be(dc.offset + 0x00, sf, "cosl") && is_id32be(dc.offset + 0x30, sf, "WAVE")) {
offset = dc.offset + 0x34;
dc.current = -1;
rc.current = -1;
}
break;
default:
break;
}
}
break;
default:
break;
}
/* else we will increase the search offset by 1 */
current_chunk = current_chunk + 1;
}
}
if (Founddata == 0) {
if (!offset)
goto fail;
} else if (Founddata == 1) {
channel_count = (uint16_t)read_16bitLE(current_chunk-0x10,streamFile);
frequency = read_32bitLE(current_chunk-0xE,streamFile);
}
loop_flag = 1;
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(channel_count,loop_flag);
/* subfile has a few extra chunks (guid, wavh) but otherwise standard (seen PCM and MS-ADPCM, with fact chunks) */
{
STREAMFILE* temp_sf = NULL;
off_t subfile_offset = offset;
size_t subfile_size = read_u32le(offset + 0x04, sf) + 0x08;
temp_sf = setup_subfile_streamfile(sf, subfile_offset, subfile_size, "wav");
if (!temp_sf) goto fail;
vgmstream = init_vgmstream_riff(temp_sf);
close_streamfile(temp_sf);
if (!vgmstream) goto fail;
/* fill in the vital statistics */
if (Founddata == 0) {
goto fail;
} else if (Founddata == 1) {
start_offset = current_chunk+0x8;
vgmstream->channels = channel_count;
vgmstream->sample_rate = frequency;
vgmstream->coding_type = coding_PCM16LE;
vgmstream->num_samples = (read_32bitLE(current_chunk+0x4,streamFile)/2/channel_count);
if (loop_flag) {
vgmstream->loop_start_sample = 0;
vgmstream->loop_end_sample = (read_32bitLE(current_chunk+0x4,streamFile)/2/channel_count);
}
}
if (channel_count == 1) {
vgmstream->layout_type = layout_none;
} else if (channel_count > 1) {
vgmstream->layout_type = layout_interleave;
vgmstream->interleave_block_size = 0x2;
}
vgmstream->meta_type = meta_DMSG;
/* 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<channel_count;i++) {
vgmstream->ch[i].streamfile = file;
vgmstream->ch[i].channel_start_offset=
vgmstream->ch[i].offset=start_offset+
vgmstream->interleave_block_size*i;
}
if (name_offset) {
if (name_size >= STREAM_NAME_SIZE)
name_size = STREAM_NAME_SIZE;
read_string_utf16le(vgmstream->stream_name,name_size, name_offset, sf);
}
return vgmstream;
}
/* clean up anything we may have opened */
fail:
if (vgmstream) close_vgmstream(vgmstream);
close_vgmstream(vgmstream);
return NULL;
}

54
src/meta/ea_wve_ad10.c
View File

@ -2,49 +2,63 @@
#include "../coding/coding.h"
#include "../layout/layout.h"
/* EA WVE (Ad10) - from Electronic Arts PS movies [Wing Commander 3/4 (PS)] */
VGMSTREAM * init_vgmstream_ea_wve_ad10(STREAMFILE *streamFile) {
/* EA WVE (Ad10) - from early Electronic Arts movies [Wing Commander 3/4 (PS1), Madden NHL 97 (PC)-w95] */
VGMSTREAM* init_vgmstream_ea_wve_ad10(STREAMFILE* sf) {
VGMSTREAM* vgmstream = NULL;
off_t start_offset;
int loop_flag, channel_count;
int loop_flag, channels;
int big_endian, is_ps1;
/* checks */
if (!check_extensions(streamFile, "wve"))
/* .wve: common
* .mov: Madden NHL 97 (also uses .wve) */
if (!check_extensions(sf, "wve,mov"))
goto fail;
start_offset = 0x00;
if (read_32bitBE(start_offset, streamFile) != 0x41643130 && /* "Ad10" */
read_32bitBE(start_offset, streamFile) != 0x41643131) /* "Ad11" (last block, but could be first) */
if (!is_id32be(0x00, sf, "AABB") && /* video block */
!is_id32be(0x00, sf, "Ad10") && /* audio block */
!is_id32be(0x00, sf, "Ad11")) /* last audio block, but could be first */
goto fail;
big_endian = guess_endianness32bit(0x04, sf);
if (is_id32be(0x00, sf, "AABB"))
start_offset += big_endian ? read_u32be(0x04, sf) : read_u32le(0x04, sf);
loop_flag = 0;
if (ps_check_format(sf, start_offset + 0x08, 0x40)) {
/* no header = no channels, but seems if the first PS-ADPCM header is 00 then it's mono, somehow
* (ex. Wing Commander 3 intro / Wing Commander 4 = stereo, rest of Wing Commander 3 = mono) */
channel_count = read_8bit(start_offset+0x08,streamFile) != 0 ? 2 : 1;
channels = read_u8(start_offset + 0x08,sf) != 0 ? 2 : 1;
is_ps1 = 1;
VGM_LOG("ps1");
}
else {
channels = 1;
is_ps1 = 0;
}
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(channel_count, loop_flag);
vgmstream = allocate_vgmstream(channels, loop_flag);
if (!vgmstream) goto fail;
vgmstream->sample_rate = 22050;
vgmstream->meta_type = meta_EA_WVE_AD10;
vgmstream->coding_type = coding_PSX;
vgmstream->layout_type = layout_blocked_ea_wve_ad10;
vgmstream->codec_config = big_endian;
if (is_ps1)
vgmstream->coding_type = coding_PSX;
else
vgmstream->coding_type = coding_PCM8_U_int;
if (!vgmstream_open_stream(vgmstream,streamFile,start_offset))
if (!vgmstream_open_stream(vgmstream, sf, start_offset))
goto fail;
/* calc num_samples manually */
{
vgmstream->next_block_offset = start_offset;
do {
block_update(vgmstream->next_block_offset,vgmstream);
vgmstream->num_samples += ps_bytes_to_samples(vgmstream->current_block_size, 1);
}
while (vgmstream->next_block_offset < get_streamfile_size(streamFile));
block_update(start_offset, vgmstream);
}
blocked_count_samples(vgmstream, sf, start_offset);
return vgmstream;

3
src/meta/hca_keys.h
View File

@ -719,6 +719,9 @@ static const hcakey_info hcakey_list[] = {
// Mini 4WD Hyper Dash Grand Prix (Android)
{7957824642808300098}, // 6E6FDF59AB704242
// m HOLD'EM (Android)
{369211553984367}, // 00014FCBC385AF6F
};
#endif/*_HCA_KEYS_H_*/

3
src/meta/meta.h
View File

@ -4,6 +4,7 @@
#include "../vgmstream.h"
VGMSTREAM* init_vgmstream_silence(int channels, int sample_rate, int32_t num_samples);
VGMSTREAM* init_vgmstream_silence_container(int total_subsongs);
VGMSTREAM* init_vgmstream_adx(STREAMFILE* sf);
@ -959,4 +960,6 @@ VGMSTREAM* init_vgmstream_wxd_wxh(STREAMFILE* sf);
VGMSTREAM* init_vgmstream_bnk_relic(STREAMFILE* sf);
VGMSTREAM* init_vgmstream_xsh_xsd_xss(STREAMFILE* sf);
#endif /*_META_H*/

117
src/meta/riff.c
View File

@ -27,8 +27,8 @@ static void parse_adtl(off_t adtl_offset, off_t adtl_length, STREAMFILE* sf, lon
off_t current_chunk = adtl_offset+0x04;
while (current_chunk < adtl_offset + adtl_length) {
uint32_t chunk_type = read_32bitBE(current_chunk+0x00,sf);
off_t chunk_size = read_32bitLE(current_chunk+0x04,sf);
uint32_t chunk_type = read_u32be(current_chunk+0x00,sf);
uint32_t chunk_size = read_u32le(current_chunk+0x04,sf);
if (current_chunk+0x08+chunk_size > adtl_offset+adtl_length)
return;
@ -81,7 +81,7 @@ typedef struct {
off_t size;
uint32_t codec;
int sample_rate;
int channel_count;
int channels;
uint32_t block_size;
int bps;
off_t extra_size;
@ -95,38 +95,38 @@ typedef struct {
int is_at9;
} riff_fmt_chunk;
static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fmt_chunk* fmt, int mwv) {
int32_t (*read_32bit)(off_t,STREAMFILE*) = big_endian ? read_32bitBE : read_32bitLE;
int16_t (*read_16bit)(off_t,STREAMFILE*) = big_endian ? read_16bitBE : read_16bitLE;
static int read_fmt(int big_endian, STREAMFILE* sf, off_t offset, riff_fmt_chunk* fmt, int mwv) {
uint32_t (*read_u32)(off_t,STREAMFILE*) = big_endian ? read_u32be : read_u32le;
uint16_t (*read_u16)(off_t,STREAMFILE*) = big_endian ? read_u16be : read_u16le;
fmt->offset = current_chunk;
fmt->size = read_32bit(current_chunk+0x04,sf);
fmt->offset = offset;
fmt->size = read_u32(offset+0x04,sf);
/* WAVEFORMAT */
fmt->codec = (uint16_t)read_16bit(current_chunk+0x08,sf);
fmt->channel_count = read_16bit(current_chunk+0x0a,sf);
fmt->sample_rate = read_32bit(current_chunk+0x0c,sf);
//fmt->avg_bps = read_32bit(current_chunk+0x10,sf);
fmt->block_size = read_16bit(current_chunk+0x14,sf);
fmt->bps = read_16bit(current_chunk+0x16,sf);
fmt->codec = read_u16(offset+0x08,sf);
fmt->channels = read_u16(offset+0x0a,sf);
fmt->sample_rate = read_u32(offset+0x0c,sf);
//fmt->avg_bps = read_u32(offset+0x10,sf);
fmt->block_size = read_u16(offset+0x14,sf);
fmt->bps = read_u16(offset+0x16,sf);
/* WAVEFORMATEX */
if (fmt->size >= 0x10) {
fmt->extra_size = read_16bit(current_chunk+0x18,sf);
fmt->extra_size = read_u16(offset+0x18,sf);
/* 0x1a+ depends on codec (ex. coef table for MSADPCM, samples_per_frame in MS-IMA, etc) */
}
/* WAVEFORMATEXTENSIBLE */
if (fmt->codec == 0xFFFE && fmt->extra_size >= 0x16) {
//fmt->extra_samples = read_16bit(current_chunk+0x1a,sf); /* valid_bits_per_sample or samples_per_block */
fmt->channel_layout = read_32bit(current_chunk+0x1c,sf);
//fmt->extra_samples = read_u16(offset+0x1a,sf); /* valid_bits_per_sample or samples_per_block */
fmt->channel_layout = read_u32(offset+0x1c,sf);
/* 0x10 guid at 0x20 */
/* happens in various .at3/at9, may be a bug in their encoder b/c MS's defs set mono as FC */
if (fmt->channel_count == 1 && fmt->channel_layout == speaker_FL) { /* other channels are fine */
if (fmt->channels == 1 && fmt->channel_layout == speaker_FL) { /* other channels are fine */
fmt->channel_layout = speaker_FC;
}
/* happens in few at3p, may be a bug in older tools as other games have ok flags [Ridge Racer 7 (PS3)] */
if (fmt->channel_count == 6 && fmt->channel_layout == 0x013f) {
if (fmt->channels == 6 && fmt->channel_layout == 0x013f) {
fmt->channel_layout = 0x3f;
}
}
@ -134,8 +134,8 @@ static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fm
switch (fmt->codec) {
case 0x00: /* Yamaha AICA ADPCM [Headhunter (DC), Bomber hehhe (DC), Rayman 2 (DC)] (unofficial) */
if (fmt->bps != 4) goto fail;
if (fmt->block_size != 0x02*fmt->channel_count &&
fmt->block_size != 0x01*fmt->channel_count) goto fail;
if (fmt->block_size != 0x02*fmt->channels &&
fmt->block_size != 0x01*fmt->channels) goto fail;
fmt->coding_type = coding_AICA_int;
fmt->interleave = 0x01;
break;
@ -161,7 +161,7 @@ static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fm
if (!msadpcm_check_coefs(sf, fmt->offset + 0x08 + 0x14))
goto fail;
}
else if (fmt->bps == 16 && fmt->block_size == 0x02 * fmt->channel_count && fmt->size == 0x14) {
else if (fmt->bps == 16 && fmt->block_size == 0x02 * fmt->channels && fmt->size == 0x14) {
fmt->coding_type = coding_IMA; /* MX vs ATV Unleashed (PC) codec hijack */
}
else {
@ -201,9 +201,9 @@ static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fm
case 0x0300: /* IMA ADPCM [Chrono Ma:gia (Android)] (unofficial) */
if (fmt->bps != 4) goto fail;
if (fmt->block_size != 0x0400*fmt->channel_count) goto fail;
if (fmt->block_size != 0x0400*fmt->channels) goto fail;
if (fmt->size != 0x14) goto fail;
if (fmt->channel_count != 1) goto fail; /* not seen */
if (fmt->channels != 1) goto fail; /* not seen */
fmt->coding_type = coding_DVI_IMA;
/* real 0x300 is "Fujitsu FM Towns SND" with block align 0x01 */
break;
@ -218,25 +218,21 @@ static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fm
case 0x6771: /* Ogg Vorbis (mode 3+) */
fmt->coding_type = coding_OGG_VORBIS;
break;
#else
goto fail;
#endif
case 0x0270: /* ATRAC3 */
#ifdef VGM_USE_FFMPEG
case 0x0270: /* ATRAC3 */
fmt->coding_type = coding_FFmpeg;
fmt->is_at3 = 1;
break;
#else
goto fail;
#endif
case 0xFFFE: { /* WAVEFORMATEXTENSIBLE (see ksmedia.h for known GUIDs) */
uint32_t guid1 = (uint32_t)read_32bit (current_chunk+0x20,sf);
uint32_t guid2 = ((uint16_t)read_16bit (current_chunk+0x24,sf) << 16u) |
((uint16_t)read_16bit (current_chunk+0x26,sf));
uint32_t guid3 = (uint32_t)read_32bitBE(current_chunk+0x28,sf);
uint32_t guid4 = (uint32_t)read_32bitBE(current_chunk+0x2c,sf);
uint32_t guid1 = read_u32 (offset+0x20,sf);
uint32_t guid2 = (read_u16 (offset+0x24,sf) << 16u) |
(read_u16 (offset+0x26,sf));
uint32_t guid3 = read_u32be(offset+0x28,sf);
uint32_t guid4 = read_u32be(offset+0x2c,sf);
//;VGM_LOG("RIFF: guid %08x %08x %08x %08x\n", guid1, guid2, guid3, guid4);
/* PCM GUID (0x00000001,0000,0010,80,00,00,AA,00,38,9B,71) */
@ -254,32 +250,30 @@ static int read_fmt(int big_endian, STREAMFILE* sf, off_t current_chunk, riff_fm
/* ATRAC3plus GUID (0xE923AABF,CB58,4471,A1,19,FF,FA,01,E4,CE,62) */
if (guid1 == 0xE923AABF && guid2 == 0xCB584471 && guid3 == 0xA119FFFA && guid4 == 0x01E4CE62) {
#ifdef VGM_USE_MAIATRAC3PLUS
uint16_t bztmp = read_16bit(current_chunk+0x32,sf);
#ifdef VGM_USE_FFMPEG
fmt->coding_type = coding_FFmpeg;
fmt->is_at3p = 1;
break;
#elif defined(VGM_USE_MAIATRAC3PLUS)
uint16_t bztmp = read_u16(offset+0x32,sf);
bztmp = (bztmp >> 8) | (bztmp << 8);
fmt->coding_type = coding_AT3plus;
fmt->block_size = (bztmp & 0x3FF) * 8 + 8; /* should match fmt->block_size */
fmt->is_at3p = 1;
break;
#elif defined(VGM_USE_FFMPEG)
fmt->coding_type = coding_FFmpeg;
fmt->is_at3p = 1;
break;
#else
goto fail;
#endif
}
#ifdef VGM_USE_ATRAC9
/* ATRAC9 GUID (0x47E142D2,36BA,4D8D,88,FC,61,65,4F,8C,83,6C) */
if (guid1 == 0x47E142D2 && guid2 == 0x36BA4D8D && guid3 == 0x88FC6165 && guid4 == 0x4F8C836C) {
#ifdef VGM_USE_ATRAC9
fmt->coding_type = coding_ATRAC9;
fmt->is_at9 = 1;
break;
#else
goto fail;
#endif
}
#endif
goto fail; /* unknown GUID */
}
@ -370,7 +364,7 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
/* some games have wonky sizes, selectively fix to catch bad rips and new mutations */
if (file_size != riff_size + 0x08) {
uint16_t codec = read_16bitLE(0x14,sf);
uint16_t codec = read_u16le(0x14,sf);
if (codec == 0x6771 && riff_size + 0x08 + 0x01 == file_size)
riff_size += 0x01; /* [Shikkoku no Sharnoth (PC)] (Sony Sound Forge?) */
@ -397,11 +391,10 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
riff_size += 0x18; /* [F1 2011 (Vita)] (adds a "pada" chunk but RIFF size wasn't updated) */
else if (mwv) {
int channels = read_16bitLE(0x16, sf); /* [Dragon Quest VIII (PS2), Rogue Galaxy (PS2)] */
int channels = read_u16le(0x16, sf); /* [Dragon Quest VIII (PS2), Rogue Galaxy (PS2)] */
size_t file_size_fixed = riff_size + 0x08 + 0x04 * (channels - 1);
if (file_size_fixed <= file_size && file_size - file_size_fixed < 0x10)
{
if (file_size_fixed <= file_size && file_size - file_size_fixed < 0x10) {
/* files inside HD6/DAT are also padded to 0x10 so need to fix file_size */
file_size = file_size_fixed;
riff_size = file_size - 0x08;
@ -617,7 +610,7 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(fmt.channel_count,loop_flag);
vgmstream = allocate_vgmstream(fmt.channels,loop_flag);
if (!vgmstream) goto fail;
vgmstream->sample_rate = fmt.sample_rate;
@ -661,7 +654,7 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
/* samples, codec init (after setting coding to ensure proper close on failure) */
switch (fmt.coding_type) {
case coding_PCM16LE:
vgmstream->num_samples = pcm_bytes_to_samples(data_size, fmt.channel_count, 16);
vgmstream->num_samples = pcm_bytes_to_samples(data_size, fmt.channels, 16);
break;
case coding_PCM8_U:
@ -670,7 +663,7 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
case coding_L5_555:
if (!mwv) goto fail;
vgmstream->num_samples = data_size / 0x12 / fmt.channel_count * 32;
vgmstream->num_samples = data_size / 0x12 / fmt.channels * 32;
/* coefs */
{
@ -684,7 +677,7 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
read_32bitLE(mwv_pflt_offset+0x04, sf) < 8 + filter_count * 4 * filter_order)
goto fail;
for (ch = 0; ch < fmt.channel_count; ch++) {
for (ch = 0; ch < fmt.channels; ch++) {
for (i = 0; i < filter_count * filter_order; i++) {
int coef = read_32bitLE(mwv_pflt_offset+0x10+i*0x04, sf);
vgmstream->ch[ch].adpcm_coef_3by32[i] = coef;
@ -695,31 +688,31 @@ VGMSTREAM* init_vgmstream_riff(STREAMFILE* sf) {
break;
case coding_MSADPCM:
vgmstream->num_samples = msadpcm_bytes_to_samples(data_size, fmt.block_size, fmt.channel_count);
vgmstream->num_samples = msadpcm_bytes_to_samples(data_size, fmt.block_size, fmt.channels);
if (fact_sample_count && fact_sample_count < vgmstream->num_samples)
vgmstream->num_samples = fact_sample_count;
break;
case coding_MS_IMA:
vgmstream->num_samples = ms_ima_bytes_to_samples(data_size, fmt.block_size, fmt.channel_count);
vgmstream->num_samples = ms_ima_bytes_to_samples(data_size, fmt.block_size, fmt.channels);
if (fact_sample_count && fact_sample_count < vgmstream->num_samples)
vgmstream->num_samples = fact_sample_count;
break;
case coding_AICA:
case coding_AICA_int:
vgmstream->num_samples = yamaha_bytes_to_samples(data_size, fmt.channel_count);
vgmstream->num_samples = yamaha_bytes_to_samples(data_size, fmt.channels);
break;
case coding_XBOX_IMA:
vgmstream->num_samples = xbox_ima_bytes_to_samples(data_size, fmt.channel_count);
vgmstream->num_samples = xbox_ima_bytes_to_samples(data_size, fmt.channels);
if (fact_sample_count && fact_sample_count < vgmstream->num_samples)
vgmstream->num_samples = fact_sample_count; /* some (converted?) Xbox games have bigger fact_samples */
break;
case coding_IMA:
case coding_DVI_IMA:
vgmstream->num_samples = ima_bytes_to_samples(data_size, fmt.channel_count);
vgmstream->num_samples = ima_bytes_to_samples(data_size, fmt.channels);
break;
#ifdef VGM_USE_FFMPEG
@ -873,7 +866,7 @@ fail:
static int is_ue4_msadpcm(STREAMFILE* sf, riff_fmt_chunk* fmt, int fact_sample_count, off_t start) {
/* multichannel ok */
if (fmt->channel_count < 2)
if (fmt->channels < 2)
goto fail;
/* UE4 class is "ADPCM", assume it's the extension too */
@ -902,7 +895,7 @@ static int is_ue4_msadpcm(STREAMFILE* sf, riff_fmt_chunk* fmt, int fact_sample_c
/* their encoder doesn't calculate optimal coefs and uses fixed values every frame
* (could do it for fmt size 0x36 too but maybe they'll fix it in the future) */
while (offset <= max_offset) {
if (read_8bit(offset+0x00, sf) != 0 || read_16bitLE(offset+0x01, sf) != 0x00E6)
if (read_u8(offset+0x00, sf) != 0 || read_u16le(offset+0x01, sf) != 0x00E6)
goto fail;
offset += fmt->block_size;
}
@ -916,7 +909,7 @@ fail:
/* for maximum annoyance later UE4 versions (~v4.2x?) interleave single frames instead of
* half interleave, but don't have flags to detect so we need some heuristics */
static size_t get_ue4_msadpcm_interleave(STREAMFILE* sf, riff_fmt_chunk* fmt, off_t start, size_t size) {
size_t v1_interleave = size / fmt->channel_count;
size_t v1_interleave = size / fmt->channels;
size_t v2_interleave = fmt->block_size;
uint8_t nibbles1[0x08] = {0};
uint8_t nibbles2[0x08] = {0};
@ -927,7 +920,7 @@ static size_t get_ue4_msadpcm_interleave(STREAMFILE* sf, riff_fmt_chunk* fmt, of
return v1_interleave;
/* 6ch only observed in later versions [Fortnite (PC)], not padded */
if (fmt->channel_count > 2)
if (fmt->channels > 2)
return v2_interleave;
read_streamfile(nibbles1, start + size - 0x08, sizeof(nibbles2), sf);
@ -1053,7 +1046,7 @@ VGMSTREAM* init_vgmstream_rifx(STREAMFILE* sf) {
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(fmt.channel_count,loop_flag);
vgmstream = allocate_vgmstream(fmt.channels,loop_flag);
if (!vgmstream) goto fail;
vgmstream->sample_rate = fmt.sample_rate;

16
src/meta/silence.c
View File

@ -27,3 +27,19 @@ fail:
close_vgmstream(vgmstream);
return NULL;
}
/* silent stream - for containers that have dummy streams but it's a hassle to detect/filter out */
VGMSTREAM* init_vgmstream_silence_container(int total_subsongs) {
VGMSTREAM* vgmstream = NULL;
vgmstream = init_vgmstream_silence(0, 0, 0);
if (!vgmstream) goto fail;
vgmstream->num_streams = total_subsongs;
snprintf(vgmstream->stream_name, STREAM_NAME_SIZE, "%s", "dummy");
return vgmstream;
fail:
close_vgmstream(vgmstream);
return NULL;
}

11
src/meta/ubi_bao.c
View File

@ -35,6 +35,7 @@ typedef struct {
int audio_fix_psx_samples;
int audio_external_and;
int audio_loop_and;
int audio_ignore_resource_size;
off_t sequence_sequence_loop;
off_t sequence_sequence_single;
@ -1116,8 +1117,11 @@ static int parse_offsets(ubi_bao_header* bao, STREAMFILE* sf) {
read_string(bao->resource_name,255, resources_offset + 0x04+0x04 + name_offset, sf);
if (bao->stream_size != resource_size - bao->stream_skip + bao->prefetch_size) {
VGM_ASSERT(bao->stream_size != resource_size - bao->stream_skip + bao->prefetch_size,
"UBI BAO: stream vs resource size mismatch at %lx\n", offset+0x10*i);
VGM_LOG("UBI BAO: stream vs resource size mismatch at %lx (%x vs %x, %x, %x)\n", offset+0x10*i, bao->stream_size, resource_size, bao->stream_skip, bao->prefetch_size);
/* rarely resource has more data than stream (sometimes a few bytes, others +0x100000)
* sometimes short song versions, but not accessed? no samples/sizes/cues/etc in header seem to refer to that [Just Dance (Wii)] */
if (!bao->cfg.audio_ignore_resource_size || bao->prefetch_size)
goto fail;
}
break;
@ -1755,6 +1759,9 @@ static int config_bao_version(ubi_bao_header* bao, STREAMFILE* sf) {
bao->cfg.codec_map[0x09] = RAW_DSP;
bao->cfg.file_type = UBI_FORGE_b;
if (version == 0x0022000D) /* Just Dance (Wii) oddity */
bao->cfg.audio_ignore_resource_size = 1;
return 1;
case 0x00220015: /* James Cameron's Avatar: The Game (PSP)-package */

127
src/meta/ubi_lyn.c
View File

@ -5,38 +5,40 @@
/* LyN RIFF - from Ubisoft LyN engine games [Red Steel 2 (Wii), Adventures of Tintin (Multi), From Dust (Multi), Just Dance 3/4 (multi)] */
VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
VGMSTREAM* init_vgmstream_ubi_lyn(STREAMFILE* sf) {
VGMSTREAM * vgmstream = NULL;
off_t start_offset, first_offset = 0xc;
off_t fmt_offset, data_offset, fact_offset;
size_t fmt_size, data_size, fact_size;
int loop_flag, channel_count, sample_rate, codec;
int loop_flag, channels, sample_rate, codec;
int num_samples;
/* checks */
/* .sns: Red Steel 2, .wav: Tintin, .son: From Dust */
if (!check_extensions(streamFile,"sns,wav,lwav,son"))
/* .sns: Red Steel 2
* .wav: Tintin, Just Dance
* .son: From Dust */
if (!check_extensions(sf,"sns,wav,lwav,son"))
goto fail;
/* a slightly eccentric RIFF with custom codecs */
if (read_32bitBE(0x00,streamFile) != 0x52494646 || /* "RIFF" */
read_32bitBE(0x08,streamFile) != 0x57415645) /* "WAVE" */
if (!is_id32be(0x00,sf, "RIFF") ||
!is_id32be(0x08,sf, "WAVE"))
goto fail;
if (read_32bitLE(0x04,streamFile)+0x04+0x04 != get_streamfile_size(streamFile))
if (read_32bitLE(0x04,sf) + 0x04 + 0x04 != get_streamfile_size(sf))
goto fail;
if (!find_chunk(streamFile, 0x666d7420,first_offset,0, &fmt_offset,&fmt_size, 0, 0)) /* "fmt " */
if (!find_chunk(sf, 0x666d7420,first_offset,0, &fmt_offset,&fmt_size, 0, 0)) /* "fmt " */
goto fail;
if (!find_chunk(streamFile, 0x64617461,first_offset,0, &data_offset,&data_size, 0, 0)) /* "data" */
if (!find_chunk(sf, 0x64617461,first_offset,0, &data_offset,&data_size, 0, 0)) /* "data" */
goto fail;
/* always found, even with PCM (LyN subchunk seems to contain the engine version, ex. 0x0d/10) */
if (!find_chunk(streamFile, 0x66616374,first_offset,0, &fact_offset,&fact_size, 0, 0)) /* "fact" */
if (!find_chunk(sf, 0x66616374,first_offset,0, &fact_offset,&fact_size, 0, 0)) /* "fact" */
goto fail;
if (fact_size != 0x10 || read_32bitBE(fact_offset+0x04, streamFile) != 0x4C794E20) /* "LyN " */
if (fact_size != 0x10 || read_32bitBE(fact_offset+0x04, sf) != 0x4C794E20) /* "LyN " */
goto fail;
num_samples = read_32bitLE(fact_offset+0x00, streamFile);
num_samples = read_32bitLE(fact_offset+0x00, sf);
/* sometimes there is a LySE chunk */
@ -44,9 +46,9 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
{
if (fmt_size < 0x12)
goto fail;
codec = (uint16_t)read_16bitLE(fmt_offset+0x00,streamFile);
channel_count = read_16bitLE(fmt_offset+0x02,streamFile);
sample_rate = read_32bitLE(fmt_offset+0x04,streamFile);
codec = read_u16le(fmt_offset+0x00,sf);
channels = read_u16le(fmt_offset+0x02,sf);
sample_rate = read_s32le(fmt_offset+0x04,sf);
/* 0x08: average bytes, 0x0c: block align, 0x0e: bps, etc */
/* fake WAVEFORMATEX, used with > 2ch */
@ -54,10 +56,10 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
if (fmt_size < 0x28)
goto fail;
/* fake GUID with first value doubling as codec */
codec = read_32bitLE(fmt_offset+0x18,streamFile);
if (read_32bitBE(fmt_offset+0x1c,streamFile) != 0x00001000 &&
read_32bitBE(fmt_offset+0x20,streamFile) != 0x800000AA &&
read_32bitBE(fmt_offset+0x24,streamFile) != 0x00389B71) {
codec = read_32bitLE(fmt_offset+0x18,sf);
if (read_32bitBE(fmt_offset+0x1c,sf) != 0x00001000 &&
read_32bitBE(fmt_offset+0x20,sf) != 0x800000AA &&
read_32bitBE(fmt_offset+0x24,sf) != 0x00389B71) {
goto fail;
}
}
@ -70,7 +72,7 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(channel_count,loop_flag);
vgmstream = allocate_vgmstream(channels, loop_flag);
if (!vgmstream) goto fail;
vgmstream->sample_rate = sample_rate;
@ -99,7 +101,7 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
};
int i, ch;
for (ch = 0; ch < channel_count; ch++) {
for (ch = 0; ch < channels; ch++) {
for (i = 0; i < 16; i++) {
vgmstream->ch[ch].adpcm_coef[i] = coef[i];
}
@ -114,27 +116,27 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
layered_layout_data* data = NULL;
int i;
if (read_32bitLE(start_offset+0x00,streamFile) != 1) /* id? */
if (read_32bitLE(start_offset+0x00,sf) != 1) /* id? */
goto fail;
interleave_size = read_32bitLE(start_offset+0x04,streamFile);
interleave_size = read_32bitLE(start_offset+0x04,sf);
/* interleave is adjusted so there is no smaller last block, it seems */
vgmstream->coding_type = coding_OGG_VORBIS;
vgmstream->layout_type = layout_layered;
/* init layout */
data = init_layout_layered(channel_count);
data = init_layout_layered(channels);
if (!data) goto fail;
vgmstream->layout_data = data;
/* open each layer subfile */
for (i = 0; i < channel_count; i++) {
for (i = 0; i < channels; i++) {
STREAMFILE* temp_sf = NULL;
size_t logical_size = read_32bitLE(start_offset+0x08 + 0x04*i,streamFile);
off_t layer_offset = start_offset + 0x08 + 0x04*channel_count; //+ interleave_size*i;
size_t logical_size = read_32bitLE(start_offset+0x08 + 0x04*i,sf);
off_t layer_offset = start_offset + 0x08 + 0x04*channels; //+ interleave_size*i;
temp_sf = setup_ubi_lyn_streamfile(streamFile, layer_offset, interleave_size, i, channel_count, logical_size);
temp_sf = setup_ubi_lyn_streamfile(sf, layer_offset, interleave_size, i, channels, logical_size);
if (!temp_sf) goto fail;
data->layers[i] = init_vgmstream_ogg_vorbis(temp_sf);
@ -155,17 +157,23 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
#ifdef VGM_USE_MPEG
case 0x5051: { /* MPEG (PS3/PC), interleaved 1ch */
mpeg_custom_config cfg = {0};
int i;
int i, frame_samples;
cfg.interleave = read_32bitLE(start_offset+0x04,streamFile);
cfg.chunk_size = read_32bitLE(start_offset+0x08,streamFile); /* frame size (not counting MPEG padding?) */
/* 0x00: id? (2=Tintin, 3=Michael Jackson), 0x0c: frame per interleave, 0x10: samples per frame */
/* 0x00: config? (related to chunk size? 2=Tintin, some JD4?, 3=Michael Jackson, JD4) */
cfg.interleave = read_u32le(start_offset+0x04,sf);
/* 0x08: CBR frame size (not counting MPEG padding) */
/* 0x0c: bps (32) */
frame_samples = read_s32le(start_offset+0x10,sf);
/* skip seek tables and find actual start */
/* table: entries per channel (1 per chunk, but not chunk-aligned?) */
/* - 0x00: offset but same for both channels? */
/* - 0x04: flag? (-1~-N) */
/* - 0x06: flag? (-1~-N) */
start_offset += 0x14;
data_size -= 0x14;
for (i = 0; i < channel_count; i++) {
int entries = read_32bitLE(start_offset,streamFile);
for (i = 0; i < channels; i++) {
int entries = read_s32le(start_offset,sf);
start_offset += 0x04 + entries*0x08;
data_size -= 0x04 + entries*0x08;
@ -173,8 +181,25 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
cfg.data_size = data_size;
//todo data parsing looks correct but some files decode a bit wrong at the end (ex. Tintin: Music~Boss~Allan~Victory~02)
vgmstream->codec_data = init_mpeg_custom(streamFile, start_offset, &vgmstream->coding_type, vgmstream->channels, MPEG_LYN, &cfg);
/* last interleave is half remaining data */
cfg.max_chunks = (cfg.data_size / (cfg.interleave * channels));
/* somehow certain interleaves don't work:
* - 0xB400: 0x2D00 ko, 0xE100 ok (max-1)
* - 0x8000: 0x3ec7 ko, 0xbec7 ok (max-1)
* - 0x8000: 0x5306 ok, 0xd306 ko (max-1) !!!
* (doesn't seem related to anything like data size/frame samples/sample rate/etc) */
cfg.max_chunks--;
cfg.interleave_last = (cfg.data_size - cfg.max_chunks * cfg.interleave * channels) / channels;
if (cfg.interleave <= 0x8000 && cfg.interleave_last > 0xD000) {
cfg.max_chunks++;
cfg.interleave_last = (cfg.data_size - cfg.max_chunks * cfg.interleave * channels) / channels;
}
/* for some reason num_samples may be +1 or +2 of max possible samples (no apparent meaning) */
vgmstream->num_samples = vgmstream->num_samples / frame_samples * frame_samples;
vgmstream->loop_end_sample = vgmstream->num_samples;
vgmstream->codec_data = init_mpeg_custom(sf, start_offset, &vgmstream->coding_type, vgmstream->channels, MPEG_LYN, &cfg);
if (!vgmstream->codec_data) goto fail;
vgmstream->layout_type = layout_none;
@ -192,13 +217,13 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
/* skip standard XMA header + seek table */
/* 0x00: version? no apparent differences (0x1=Just Dance 4, 0x3=others) */
chunk_offset = start_offset + 0x04 + 0x04;
chunk_size = read_32bitLE(start_offset + 0x04, streamFile);
seek_size = read_32bitLE(chunk_offset+chunk_size, streamFile);
chunk_size = read_32bitLE(start_offset + 0x04, sf);
seek_size = read_32bitLE(chunk_offset+chunk_size, sf);
start_offset += (0x04 + 0x04 + chunk_size + 0x04 + seek_size);
data_size -= (0x04 + 0x04 + chunk_size + 0x04 + seek_size);
bytes = ffmpeg_make_riff_xma_from_fmt_chunk(buf,0x100, chunk_offset,chunk_size, data_size, streamFile, 1);
vgmstream->codec_data = init_ffmpeg_header_offset(streamFile, buf,bytes, start_offset,data_size);
bytes = ffmpeg_make_riff_xma_from_fmt_chunk(buf,0x100, chunk_offset,chunk_size, data_size, sf, 1);
vgmstream->codec_data = init_ffmpeg_header_offset(sf, buf,bytes, start_offset,data_size);
if ( !vgmstream->codec_data ) goto fail;
vgmstream->coding_type = coding_FFmpeg;
vgmstream->layout_type = layout_none;
@ -212,7 +237,7 @@ VGMSTREAM * init_vgmstream_ubi_lyn(STREAMFILE *streamFile) {
}
if ( !vgmstream_open_stream(vgmstream,streamFile,start_offset) )
if ( !vgmstream_open_stream(vgmstream,sf,start_offset) )
goto fail;
return vgmstream;
@ -223,7 +248,7 @@ fail:
/* LyN RIFF in containers */
VGMSTREAM * init_vgmstream_ubi_lyn_container(STREAMFILE *streamFile) {
VGMSTREAM * init_vgmstream_ubi_lyn_container(STREAMFILE *sf) {
VGMSTREAM *vgmstream = NULL;
STREAMFILE *temp_sf = NULL;
off_t subfile_offset;
@ -233,29 +258,29 @@ VGMSTREAM * init_vgmstream_ubi_lyn_container(STREAMFILE *streamFile) {
* data before the RIFF. Might as well support them in case the RIFF wasn't extracted. */
/* checks */
if (!check_extensions(streamFile,"sns,wav,lwav,son"))
if (!check_extensions(sf,"sns,wav,lwav,son"))
goto fail;
/* find "RIFF" position */
if (read_32bitBE(0x00,streamFile) == 0x4C795345 && /* "LySE" */
read_32bitBE(0x14,streamFile) == 0x52494646) { /* "RIFF" */
if (read_32bitBE(0x00,sf) == 0x4C795345 && /* "LySE" */
read_32bitBE(0x14,sf) == 0x52494646) { /* "RIFF" */
subfile_offset = 0x14; /* Adventures of Tintin */
}
else if (read_32bitBE(0x20,streamFile) == 0x4C795345 && /* "LySE" */
read_32bitBE(0x34,streamFile) == 0x52494646) { /* "RIFF" */
else if (read_32bitBE(0x20,sf) == 0x4C795345 && /* "LySE" */
read_32bitBE(0x34,sf) == 0x52494646) { /* "RIFF" */
subfile_offset = 0x34; /* Michael Jackson The Experience (Wii) */
}
else if (read_32bitLE(0x00,streamFile)+0x20 == get_streamfile_size(streamFile) &&
read_32bitBE(0x20,streamFile) == 0x52494646) { /* "RIFF" */
else if (read_32bitLE(0x00,sf)+0x20 == get_streamfile_size(sf) &&
read_32bitBE(0x20,sf) == 0x52494646) { /* "RIFF" */
subfile_offset = 0x20; /* Red Steel 2, From Dust */
}
else {
goto fail;
}
subfile_size = read_32bitLE(subfile_offset+0x04,streamFile) + 0x04+0x04;
subfile_size = read_32bitLE(subfile_offset+0x04,sf) + 0x04+0x04;
temp_sf = setup_subfile_streamfile(streamFile, subfile_offset, subfile_size, NULL);
temp_sf = setup_subfile_streamfile(sf, subfile_offset, subfile_size, NULL);
if (!temp_sf) goto fail;
vgmstream = init_vgmstream_ubi_lyn(temp_sf);

170
src/meta/xsh_xsd_xss.c Normal file
View File

@ -0,0 +1,170 @@
#include "meta.h"
#include "../coding/coding.h"
/* XSH+XSD/XSS - from Treyarch games [Spider-Man 2002 (Xbox), Kelly Slater's Pro Surfer (Xbox)] */
VGMSTREAM* init_vgmstream_xsh_xsd_xss(STREAMFILE* sf) {
VGMSTREAM* vgmstream = NULL;
STREAMFILE* sf_body = NULL;
uint32_t offset;
uint32_t stream_type, stream_offset, stream_size;
uint32_t name_offset, name_size;
uint32_t flags;
int32_t num_samples;
int version = 0;
int loop_flag, channels, codec, sample_rate;
int total_subsongs, target_subsong = sf->stream_index;
/* checks */
if (!check_extensions(sf, "xsh"))
goto fail;
version = read_u32le(0x00, sf);
if (read_u32le(0x04, sf) != 0)
goto fail;
total_subsongs = read_u32le(0x08, sf);
if (target_subsong == 0) target_subsong = 1;
if (target_subsong < 0 || target_subsong > total_subsongs || total_subsongs < 1) goto fail;
switch(version) {
case 0x009D:
offset = 0x0c + (target_subsong-1) * 0x60;
name_offset = offset + 0x00;
name_size = 0x20;
stream_type = read_u32le(offset + 0x20,sf);
stream_offset = read_u32le(offset + 0x24,sf);
stream_size = read_u32le(offset + 0x28,sf);
flags = read_u32le(offset + 0x34,sf);
/* 0x38: flags? */
num_samples = 0;
offset = offset + 0x3c;
break;
case 0x0100:
offset = 0x0c + (target_subsong-1) * 0x64;
name_offset = offset + 0x00;
name_size = 0x20;
stream_type = read_u32le(offset + 0x20,sf);
stream_offset = read_u32le(offset + 0x24,sf);
stream_size = read_u32le(offset + 0x28,sf);
flags = read_u32le(offset + 0x34,sf);
num_samples = read_u32le(offset + 0x38,sf);
/* 0x3c: flags? */
offset = offset + 0x40;
break;
default:
goto fail;
}
loop_flag = 0;
if (stream_type < 0 || stream_type > 2)
goto fail;
/* 0x00: floats x4 (volume/pan/etc? usually 1.0, 1.0, 10.0, 10.0) */
codec = read_u16le(offset + 0x10,sf);
channels = read_u16le(offset + 0x12,sf);
sample_rate = read_u32le(offset + 0x14,sf);
/* 0x18: avg bitrate */
/* 0x1c: block size */
/* 0x1e: bps */
/* 0x20: 2? */
if (stream_type == 0) {
vgmstream = init_vgmstream_silence_container(total_subsongs);
if (!vgmstream) goto fail;
close_streamfile(sf_body);
return vgmstream;
}
if (flags & 0x04) {
char filename[255];
switch (version) {
case 0x009D:
/* stream is a named .xss, with stream_offset/size = 0 (Spider-Man) */
read_string(filename, name_size, name_offset,sf);
strcat(filename, ".xss");
sf_body = open_streamfile_by_filename(sf,filename);
if (!sf_body) {
VGM_LOG("XSH: can't find %s\n", filename);
goto fail;
}
/* xss is playable externally, so this is mostly for show */
vgmstream = init_vgmstream_riff(sf_body);
if (!vgmstream) goto fail;
vgmstream->num_streams = total_subsongs;
read_string(vgmstream->stream_name, name_size, name_offset,sf);
close_streamfile(sf_body);
return vgmstream;
//break;
case 0x0100:
/* bigfile with all streams (Kelly Slater) */
snprintf(filename, sizeof(filename), "%s", "STREAMS.XSS");
sf_body = open_streamfile_by_filename(sf,filename);
if (!sf_body) {
VGM_LOG("XSH: can't find %s\n", filename);
goto fail;
}
break;
default:
goto fail;
}
}
else {
sf_body = open_streamfile_by_ext(sf,"xsd");
if (!sf_body) {
VGM_LOG("XSH: can't find XSD");
goto fail;
}
}
/* build the VGMSTREAM */
vgmstream = allocate_vgmstream(channels, loop_flag);
if (!vgmstream) goto fail;
vgmstream->meta_type = meta_XSH_XSD_XSS;
vgmstream->sample_rate = sample_rate;
vgmstream->num_streams = total_subsongs;
vgmstream->stream_size = stream_size;
switch(codec) {
case 0x0069:
vgmstream->coding_type = coding_XBOX_IMA;
vgmstream->layout_type = layout_none;
if (!num_samples)
num_samples = xbox_ima_bytes_to_samples(stream_size, channels);
vgmstream->num_samples = num_samples;
break;
}
read_string(vgmstream->stream_name, name_size, name_offset,sf);
if (!vgmstream_open_stream(vgmstream, sf_body, stream_offset))
goto fail;
close_streamfile(sf_body);
return vgmstream;
fail:
close_streamfile(sf_body);
close_vgmstream(vgmstream);
return NULL;
}

1
src/vgmstream.c
View File

@ -528,6 +528,7 @@ VGMSTREAM* (*init_vgmstream_functions[])(STREAMFILE* sf) = {
init_vgmstream_piff_tpcm,
init_vgmstream_wxd_wxh,
init_vgmstream_bnk_relic,
init_vgmstream_xsh_xsd_xss,
/* lowest priority metas (should go after all metas, and TXTH should go before raw formats) */
init_vgmstream_txth, /* proper parsers should supersede TXTH, once added */

2
src/vgmstream.h
View File

@ -743,6 +743,8 @@ typedef enum {
meta_PIFF_TPCM,
meta_WXD_WXH,
meta_BNK_RELIC,
meta_XSH_XSD_XSS,
} meta_t;
/* standard WAVEFORMATEXTENSIBLE speaker positions */