825 lines
30 KiB
C
825 lines
30 KiB
C
#include "meta.h"
|
|
#include "../layout/layout.h"
|
|
#include "../coding/coding.h"
|
|
#include "../util/endianness.h"
|
|
|
|
|
|
typedef enum { PCM, UBI, PSX, DSP, XIMA, ATRAC3, XMA2, MP3, SILENCE } ubi_hx_codec;
|
|
|
|
typedef struct {
|
|
int big_endian;
|
|
int total_subsongs;
|
|
int is_riff;
|
|
|
|
int codec_id;
|
|
ubi_hx_codec codec; /* unified codec */
|
|
int header_index; /* entry number within section2 */
|
|
uint32_t header_offset; /* entry offset within internal .HXx */
|
|
uint32_t header_size; /* entry offset within internal .HXx */
|
|
char class_name[255];
|
|
size_t class_size;
|
|
size_t stream_mode;
|
|
|
|
uint32_t stream_offset; /* data offset within external stream */
|
|
uint32_t stream_size; /* data size within external stream */
|
|
uint32_t cuuid1; /* usually "Res" id1: class (1=Event, 3=Wave), id2: group id+sound id, */
|
|
uint32_t cuuid2; /* others have some complex id (not hash), id1: parent id?, id2: file id? */
|
|
|
|
int loop_flag;
|
|
int channels;
|
|
int sample_rate;
|
|
int num_samples;
|
|
|
|
int is_external;
|
|
char resource_name[0x28]; /* filename to the external stream */
|
|
char internal_name[255]; /* WavRes's assigned name */
|
|
char readable_name[255]; /* final subsong name */
|
|
|
|
} ubi_hx_header;
|
|
|
|
|
|
static int parse_hx(ubi_hx_header* hx, STREAMFILE* sf, int target_subsong);
|
|
static VGMSTREAM* init_vgmstream_ubi_hx_header(ubi_hx_header* hx, STREAMFILE* sf);
|
|
|
|
/* .HXx - banks from Ubisoft's HXAudio engine games [Rayman Arena, Rayman 3, XIII] */
|
|
VGMSTREAM* init_vgmstream_ubi_hx(STREAMFILE* sf) {
|
|
VGMSTREAM* vgmstream = NULL;
|
|
ubi_hx_header hx = {0};
|
|
int target_subsong = sf->stream_index;
|
|
|
|
|
|
/* checks */
|
|
{
|
|
uint32_t name_size = read_u32be(0x04, sf); /* BE/LE, should always be < 0xFF */
|
|
if (name_size == 0 || (name_size & 0x00FFFF00) != 0)
|
|
goto fail;
|
|
}
|
|
|
|
/* .hxd: Rayman M/Arena (all), PK: Out of Shadows (all)
|
|
* .hxc: Rayman 3 (PC), XIII (PC)
|
|
* .hx2: Rayman 3 (PS2), XIII (PS2)
|
|
* .hxg: Rayman 3 (GC), XIII (GC)
|
|
* .hxx: Rayman 3 (Xbox), Rayman 3 HD (X360)
|
|
* .hx3: Rayman 3 HD (PS3) */
|
|
if (!check_extensions(sf, "hxd,hxc,hx2,hxg,hxx,hx3"))
|
|
goto fail;
|
|
|
|
/* .HXx is a slightly less bizarre bank with various resource classes (events, streams, etc, not unlike other Ubi's engines)
|
|
* then an index to those types. Some games leave a companion .bnh with text info, probably leftover from their tools.
|
|
* Game seems to play files by calling linked ids: EventResData (play/stop/etc) > Random/Program/Wav ResData (1..N refs) > FileIdObj */
|
|
|
|
/* HX HEADER */
|
|
hx.big_endian = guess_endian32(0x00, sf);
|
|
if (!parse_hx(&hx, sf, target_subsong))
|
|
goto fail;
|
|
|
|
/* CREATE VGMSTREAM */
|
|
vgmstream = init_vgmstream_ubi_hx_header(&hx, sf);
|
|
return vgmstream;
|
|
|
|
fail:
|
|
close_vgmstream(vgmstream);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void build_readable_name(char* buf, size_t buf_size, ubi_hx_header* hx) {
|
|
const char *grp_name;
|
|
|
|
if (hx->is_external)
|
|
grp_name = hx->resource_name;
|
|
else
|
|
grp_name = "internal";
|
|
|
|
if (hx->internal_name[0])
|
|
snprintf(buf,buf_size, "%s/%i/%08x-%08x/%s/%s", "hx", hx->header_index, hx->cuuid1,hx->cuuid2, grp_name, hx->internal_name);
|
|
else
|
|
snprintf(buf,buf_size, "%s/%i/%08x-%08x/%s", "hx", hx->header_index, hx->cuuid1,hx->cuuid2, grp_name);
|
|
}
|
|
|
|
#define TXT_LINE_MAX 0x1000
|
|
|
|
/* get name */
|
|
static int parse_name_bnh(ubi_hx_header* hx, STREAMFILE* sf, uint32_t cuuid1, uint32_t cuuid2) {
|
|
STREAMFILE* sf_t;
|
|
off_t txt_offset = 0;
|
|
char line[TXT_LINE_MAX];
|
|
char cuuid[40];
|
|
|
|
sf_t = open_streamfile_by_ext(sf,"bnh");
|
|
if (sf_t == NULL) goto fail;
|
|
|
|
snprintf(cuuid,sizeof(cuuid), "cuuid( 0x%08x, 0x%08x )", cuuid1, cuuid2);
|
|
|
|
/* each .bnh line has a cuuid, a bunch of repeated fields and name (sometimes name is filename or "bad name") */
|
|
while (txt_offset < get_streamfile_size(sf)) {
|
|
int line_ok, bytes_read;
|
|
|
|
bytes_read = read_line(line, sizeof(line), txt_offset, sf_t, &line_ok);
|
|
if (!line_ok) break;
|
|
txt_offset += bytes_read;
|
|
|
|
if (strncmp(line,cuuid,31) != 0)
|
|
continue;
|
|
if (bytes_read <= 79)
|
|
goto fail;
|
|
|
|
/* cuuid found, copy name (lines are fixed and always starts from the same position) */
|
|
strcpy(hx->internal_name, &line[79]);
|
|
|
|
close_streamfile(sf_t);
|
|
return 1;
|
|
}
|
|
|
|
fail:
|
|
close_streamfile(sf_t);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* get referenced name from WavRes, using the index again (abridged) */
|
|
static int parse_name(ubi_hx_header* hx, STREAMFILE* sf) {
|
|
read_u32_t read_u32 = hx->big_endian ? read_u32be : read_u32le;
|
|
read_s32_t read_s32 = hx->big_endian ? read_s32be : read_s32le;
|
|
uint32_t index_type, index_offset, offset;
|
|
int i, index_entries;
|
|
char class_name[255];
|
|
|
|
|
|
index_offset = read_u32(0x00, sf);
|
|
index_type = read_u32(index_offset + 0x04, sf);
|
|
index_entries = read_s32(index_offset + 0x08, sf);
|
|
|
|
/* doesn't seem to have names (no way to link) */
|
|
if (index_type == 0x01)
|
|
return 1;
|
|
|
|
offset = index_offset + 0x0c;
|
|
for (i = 0; i < index_entries; i++) {
|
|
off_t header_offset;
|
|
size_t class_size;
|
|
int j, link_count, language_count, is_found = 0;
|
|
uint32_t cuuid1, cuuid2;
|
|
|
|
|
|
class_size = read_u32(offset + 0x00, sf);
|
|
if (class_size > sizeof(class_name)+1) goto fail;
|
|
read_string(class_name,class_size+1, offset + 0x04, sf); /* not null-terminated */
|
|
offset += 0x04 + class_size;
|
|
|
|
cuuid1 = read_u32(offset + 0x00, sf);
|
|
cuuid2 = read_u32(offset + 0x04, sf);
|
|
|
|
header_offset = read_u32(offset + 0x08, sf);
|
|
offset += 0x10;
|
|
|
|
//unknown_count = read_s32(offset + 0x00, sf);
|
|
offset += 0x04;
|
|
|
|
if (index_type == 0x01) {
|
|
goto fail;
|
|
}
|
|
else {
|
|
link_count = read_s32(offset + 0x00, sf);
|
|
offset += 0x04;
|
|
for (j = 0; j < link_count; j++) {
|
|
uint32_t link_id1 = read_u32(offset + 0x00, sf);
|
|
uint32_t link_id2 = read_u32(offset + 0x04, sf);
|
|
|
|
if (link_id1 == hx->cuuid1 && link_id2 == hx->cuuid2) {
|
|
is_found = 1;
|
|
}
|
|
offset += 0x08;
|
|
}
|
|
|
|
language_count = read_s32(offset + 0x00, sf);
|
|
offset += 0x04;
|
|
for (j = 0; j < language_count; j++) {
|
|
uint32_t link_id1 = read_u32(offset + 0x08, sf);
|
|
uint32_t link_id2 = read_u32(offset + 0x0c, sf);
|
|
|
|
if (link_id1 == hx->cuuid1 && link_id2 == hx->cuuid2) {
|
|
is_found = 1;
|
|
}
|
|
|
|
offset += 0x10;
|
|
}
|
|
}
|
|
|
|
/* identify all possible names so unknown platforms fail */
|
|
if (is_found && (
|
|
strcmp(class_name, "CPCWavResData") == 0 ||
|
|
strcmp(class_name, "CPS2WavResData") == 0 ||
|
|
strcmp(class_name, "CGCWavResData") == 0 ||
|
|
strcmp(class_name, "CXBoxWavResData") == 0 ||
|
|
strcmp(class_name, "CPS3WavResData") == 0)) {
|
|
size_t resclass_size, internal_size;
|
|
off_t wavres_offset = header_offset;
|
|
|
|
/* parse WavRes header */
|
|
resclass_size = read_u32(wavres_offset, sf);
|
|
wavres_offset += 0x04 + resclass_size + 0x08 + 0x04; /* skip class + cuiid + flags */
|
|
|
|
internal_size = read_u32(wavres_offset + 0x00, sf);
|
|
/* Xbox has some kind of big size and "flags" has a value of 2, instead of 3/4 like other platforms */
|
|
if (strcmp(class_name, "CXBoxWavResData") == 0 && internal_size > 0x100)
|
|
return 1;
|
|
if (internal_size > sizeof(hx->internal_name)+1)
|
|
goto fail;
|
|
|
|
/* usually 0 in consoles */
|
|
if (internal_size != 0) {
|
|
read_string(hx->internal_name,internal_size+1, wavres_offset + 0x04, sf);
|
|
return 1;
|
|
}
|
|
else {
|
|
parse_name_bnh(hx, sf, cuuid1, cuuid2);
|
|
return 1; /* ignore error */
|
|
}
|
|
}
|
|
}
|
|
|
|
fail:
|
|
vgm_logi("UBI HX: error parsing name at %x (report)\n", index_offset);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* parse a single known header resource at offset */
|
|
static int parse_header(ubi_hx_header* hx, STREAMFILE* sf, uint32_t offset, uint32_t size, int index) {
|
|
read_u32_t read_u32 = hx->big_endian ? read_u32be : read_u32le;
|
|
read_s32_t read_s32 = hx->big_endian ? read_s32be : read_s32le;
|
|
read_u16_t read_u16 = hx->big_endian ? read_u16be : read_u16le;
|
|
off_t riff_offset, riff_size, chunk_offset, stream_adjust = 0, resource_size;
|
|
size_t chunk_size;
|
|
int cue_flag = 0;
|
|
|
|
//todo cleanup/unify common readings
|
|
|
|
//;VGM_LOG("ubi hx: header o=%x, s=%x\n\n", offset, size);
|
|
|
|
hx->header_index = index;
|
|
hx->header_offset = offset;
|
|
hx->header_size = size;
|
|
|
|
hx->class_size = read_u32(offset + 0x00, sf);
|
|
if (hx->class_size > sizeof(hx->class_name)+1) goto fail;
|
|
read_string(hx->class_name,hx->class_size+1, offset + 0x04, sf);
|
|
offset += 0x04 + hx->class_size;
|
|
|
|
hx->cuuid1 = read_u32(offset + 0x00, sf);
|
|
hx->cuuid2 = read_u32(offset + 0x04, sf);
|
|
offset += 0x08;
|
|
|
|
if (strcmp(hx->class_name, "CPCWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CPS2WaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CGCWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CXBoxWaveFileIdObj") == 0) {
|
|
uint32_t flag_type = read_u32(offset + 0x00, sf);
|
|
|
|
if (flag_type == 0x01 || flag_type == 0x02) { /* Rayman Arena */
|
|
uint32_t unk_value = read_u32(offset + 0x04, sf); /* float? */
|
|
if (unk_value != 0x00 && /* common */
|
|
unk_value != 0xbe570a3d && /* Largo Winch: Empire Under Threat (PC)-most */
|
|
unk_value != 0xbf8e147b) { /* Largo Winch: Empire Under Threat (PC)-few */
|
|
VGM_LOG("ubi hx: unknown flag\n");
|
|
goto fail;
|
|
}
|
|
|
|
hx->stream_mode = read_u32(offset + 0x08, sf); /* flag: 0=internal, 1=external */
|
|
/* 0x0c: flag: 0=static, 1=stream */
|
|
offset += 0x10;
|
|
}
|
|
else if (flag_type == 0x03) { /* others */
|
|
/* 0x04: some kind of parent id shared by multiple Waves, or 0 */
|
|
offset += 0x08;
|
|
|
|
if (strcmp(hx->class_name, "CGCWaveFileIdObj") == 0) {
|
|
if (read_u32(offset + 0x00, sf) != read_u32(offset + 0x04, sf))
|
|
goto fail; /* meaning? */
|
|
hx->stream_mode = read_u32(offset + 0x04, sf);
|
|
offset += 0x08;
|
|
}
|
|
else {
|
|
hx->stream_mode = read_u8(offset, sf);
|
|
offset += 0x01;
|
|
}
|
|
}
|
|
else {
|
|
VGM_LOG("ubi hx: unknown flag-type\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* get bizarro adjust (found in XIII external files) */
|
|
if (hx->stream_mode == 0x0a) {
|
|
stream_adjust = read_u32(offset, sf); /* what */
|
|
offset += 0x04;
|
|
}
|
|
|
|
//todo probably a flag: &1=external, &2=stream, &8=has adjust (XIII), &4=??? (XIII PS2, small, mono)
|
|
switch(hx->stream_mode) {
|
|
case 0x00: /* memory (internal file) */
|
|
case 0x02: /* same (no diffs in size/channels/etc?) [Rayman 3 demo (PC)] */
|
|
riff_offset = offset;
|
|
riff_size = read_u32(riff_offset + 0x04, sf) + 0x08;
|
|
break;
|
|
|
|
case 0x01: /* static (smaller external file) */
|
|
case 0x03: /* stream (bigger external file) */
|
|
case 0x07: /* static? */
|
|
case 0x0a: /* static? */
|
|
resource_size = read_u32(offset + 0x00, sf);
|
|
if (resource_size > sizeof(hx->resource_name)+1) goto fail;
|
|
read_string(hx->resource_name,resource_size+1, offset + 0x04, sf);
|
|
|
|
riff_offset = offset + 0x04 + resource_size;
|
|
riff_size = read_u32(riff_offset + 0x04, sf) + 0x08;
|
|
|
|
hx->is_external = 1;
|
|
break;
|
|
|
|
default:
|
|
VGM_LOG("ubi hx: unknown stream mode %x\n", hx->stream_mode);
|
|
goto fail;
|
|
}
|
|
|
|
/* parse pseudo-RIFF "fmt" */
|
|
if (read_u32(riff_offset, sf) != 0x46464952) { /* "RIFF" in machine endianness */
|
|
VGM_LOG("ubi hx: unknown RIFF\n");
|
|
goto fail;
|
|
}
|
|
|
|
hx->is_riff = 1;
|
|
|
|
hx->codec_id = read_u16(riff_offset + 0x14 , sf);
|
|
switch(hx->codec_id) {
|
|
case 0x01: hx->codec = PCM; break;
|
|
case 0x02: hx->codec = UBI; break;
|
|
case 0x03: hx->codec = PSX; break;
|
|
case 0x04: hx->codec = DSP; break;
|
|
case 0x05: hx->codec = XIMA; break;
|
|
case 0x55: hx->codec = MP3; break; /* Largo Winch: Empire Under Threat (PC) */
|
|
default:
|
|
VGM_LOG("ubi hx: unknown codec %x\n", hx->codec_id);
|
|
goto fail;
|
|
}
|
|
hx->channels = read_u16(riff_offset + 0x16, sf);
|
|
hx->sample_rate = read_u32(riff_offset + 0x18, sf);
|
|
|
|
/* find "datx" (external) or "data" (internal) also in machine endianness */
|
|
if (hx->is_external) {
|
|
|
|
if (find_chunk_riff_ve(sf, 0x78746164,riff_offset + 0x0c,riff_size - 0x0c, &chunk_offset,NULL, hx->big_endian)) {
|
|
hx->stream_size = read_u32(chunk_offset + 0x00, sf);
|
|
hx->stream_offset = read_u32(chunk_offset + 0x04, sf) + stream_adjust;
|
|
}
|
|
else if ((flag_type == 0x01 || flag_type == 0x02) && /* Rayman M (not Arena) uses "data" instead */
|
|
find_chunk_riff_ve(sf, 0x61746164,riff_offset + 0x0c,riff_size - 0x0c, &chunk_offset,&chunk_size, hx->big_endian)) {
|
|
hx->stream_size = chunk_size;
|
|
hx->stream_offset = read_u32(chunk_offset + 0x00, sf) + stream_adjust;
|
|
}
|
|
else {
|
|
VGM_LOG("ubi hx: unknown chunk\n");
|
|
goto fail;
|
|
}
|
|
}
|
|
else {
|
|
if (!find_chunk_riff_ve(sf, 0x61746164,riff_offset + 0x0c,riff_size - 0x0c, &chunk_offset,&chunk_size, hx->big_endian)) {
|
|
VGM_LOG("ubi hx: unknown chunk RIFF\n");
|
|
goto fail;
|
|
}
|
|
hx->stream_offset = chunk_offset;
|
|
|
|
if (chunk_size > riff_size - (chunk_offset - riff_offset) || !chunk_size)
|
|
chunk_size = riff_size - (chunk_offset - riff_offset); /* just in case */
|
|
hx->stream_size = chunk_size;
|
|
}
|
|
|
|
/* can contain other RIFF stuff like "cue ", "labl" and "ump3"
|
|
* XIII music uses cue/labl to play/loop dynamic sections */
|
|
}
|
|
else if (strcmp(hx->class_name, "CXBoxStaticHWWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CXBoxStreamHWWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CPS3StaticAC3WaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CPS3StreamAC3WaveFileIdObj") == 0) {
|
|
|
|
hx->stream_offset = read_u32(offset + 0x00, sf);
|
|
hx->stream_size = read_u32(offset + 0x04, sf);
|
|
offset += 0x08;
|
|
|
|
//todo some dummy files have 0 size
|
|
|
|
if (read_u32(offset + 0x00, sf) != 0x01) {
|
|
VGM_LOG("ubi hx: unknown flag non 0x01\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* 0x04: some kind of parent id shared by multiple Waves, or 0 */
|
|
offset += 0x08;
|
|
|
|
hx->stream_mode = read_u8(offset, sf);
|
|
offset += 0x01;
|
|
|
|
if ((strcmp(hx->class_name, "CXBoxStaticHWWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CXBoxStreamHWWaveFileIdObj") == 0) && !hx->big_endian) {
|
|
/* micro header: some mix of channels + block size + sample rate + flags, unsure of which bits */
|
|
hx->codec = XIMA;
|
|
/* 0x00: ? */
|
|
hx->channels = read_u8(offset + 0x01, sf); /* upper 2 bits? */
|
|
switch(hx->channels) {
|
|
case 0x48: hx->channels = 1; break;
|
|
case 0x90: hx->channels = 2; break;
|
|
default:
|
|
VGM_LOG("ubi hx: channel type %x\n", hx->channels);
|
|
goto fail;
|
|
}
|
|
hx->sample_rate = (read_u16(offset + 0x02, sf) & 0x7FFFu) << 1u; /* ??? */
|
|
cue_flag = read_u8(offset + 0x03, sf) & (1 << 7);
|
|
offset += 0x04;
|
|
}
|
|
else if ((strcmp(hx->class_name, "CXBoxStaticHWWaveFileIdObj") == 0 ||
|
|
strcmp(hx->class_name, "CXBoxStreamHWWaveFileIdObj") == 0) && hx->big_endian) {
|
|
/* fake fmt chunk */
|
|
hx->codec = XMA2;
|
|
hx->channels = read_u16(offset + 0x02, sf);
|
|
hx->sample_rate = read_u32(offset + 0x04, sf);
|
|
hx->num_samples = read_s32(offset + 0x18, sf) / 0x02 / hx->channels;
|
|
cue_flag = read_u32(offset + 0x34, sf);
|
|
offset += 0x38;
|
|
}
|
|
else {
|
|
/* MSFC header */
|
|
hx->codec = ATRAC3;
|
|
hx->codec_id = read_u32(offset + 0x04, sf);
|
|
hx->channels = read_u32(offset + 0x08, sf);
|
|
hx->sample_rate = read_u32(offset + 0x10, sf);
|
|
cue_flag = read_u32(offset + 0x40, sf);
|
|
offset += 0x44;
|
|
}
|
|
|
|
/* skip cue table that sometimes exists in streams */
|
|
if (cue_flag) {
|
|
int j;
|
|
|
|
size_t cue_count = read_s32(offset, sf);
|
|
offset += 0x04;
|
|
for (j = 0; j < cue_count; j++) {
|
|
/* 0x00: id? */
|
|
size_t description_size = read_u32(offset + 0x04, sf); /* for next string */
|
|
offset += 0x08 + description_size;
|
|
}
|
|
}
|
|
|
|
|
|
switch(hx->stream_mode) {
|
|
case 0x00: /* static (smaller internal file) [XIII (Xbox)] */
|
|
hx->stream_offset += offset;
|
|
break;
|
|
|
|
case 0x01: /* static (smaller external file) */
|
|
case 0x03: /* stream (bigger external file) */
|
|
case 0x07: /* stream? */
|
|
resource_size = read_u32(offset + 0x00, sf);
|
|
if (resource_size > sizeof(hx->resource_name)+1) goto fail;
|
|
read_string(hx->resource_name,resource_size+1, offset + 0x04, sf);
|
|
|
|
hx->is_external = 1;
|
|
break;
|
|
|
|
default:
|
|
VGM_LOG("ubi hx: unknown stream mode %x\n", hx->stream_mode);
|
|
goto fail;
|
|
}
|
|
}
|
|
else {
|
|
VGM_LOG("ubi hx: unknown type\n");
|
|
goto fail;
|
|
}
|
|
|
|
return 1;
|
|
fail:
|
|
vgm_logi("UBI HX: error parsing header at %x (report)\n", hx->header_offset);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* parse a bank index and its possible audio headers (some info from Droolie's .bms) */
|
|
static int parse_hx(ubi_hx_header* hx, STREAMFILE* sf, int target_subsong) {
|
|
read_u32_t read_u32 = hx->big_endian ? read_u32be : read_u32le;
|
|
read_s32_t read_s32 = hx->big_endian ? read_s32be : read_s32le;
|
|
uint32_t index_offset, offset;
|
|
int i, index_entries;
|
|
char class_name[255];
|
|
uint32_t index_type;
|
|
|
|
|
|
index_offset = read_u32(0x00, sf);
|
|
if (read_u32(index_offset + 0x00, sf) != get_id32be("XDNI")) { /* (INDX in given endianness) */
|
|
VGM_LOG("ubi hx: unknown index\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* usually 0x02, rarely 0x01 [Rayman M demo (PS2)] */
|
|
index_type = read_u32(index_offset + 0x04, sf);
|
|
if (index_type != 0x01 && index_type != 0x02) {
|
|
VGM_LOG("ubi hx: unknown index type\n");
|
|
goto fail;
|
|
}
|
|
|
|
if (target_subsong == 0) target_subsong = 1;
|
|
|
|
index_entries = read_s32(index_offset + 0x08, sf);
|
|
offset = index_offset + 0x0c;
|
|
for (i = 0; i < index_entries; i++) {
|
|
uint32_t header_offset, class_size, header_size;
|
|
int j, unknown_count, link_count, language_count;
|
|
|
|
//;VGM_LOG("ubi hx: index %i at %x\n", i, offset);
|
|
|
|
/* parse index entries: offset to actual header plus some extra info also in the header */
|
|
|
|
class_size = read_u32(offset + 0x00, sf);
|
|
if (class_size > sizeof(class_name)+1) goto fail;
|
|
|
|
read_string(class_name,class_size+1, offset + 0x04, sf); /* not null-terminated */
|
|
offset += 0x04 + class_size;
|
|
|
|
/* 0x00: id1+2 */
|
|
header_offset = read_u32(offset + 0x08, sf);
|
|
header_size = read_u32(offset + 0x0c, sf);
|
|
offset += 0x10;
|
|
|
|
/* not seen */
|
|
unknown_count = read_s32(offset + 0x00, sf);
|
|
if (unknown_count != 0) {
|
|
VGM_LOG("ubi hx: found unknown near %x\n", offset);
|
|
goto fail;
|
|
}
|
|
offset += 0x04;
|
|
|
|
if (index_type == 0x01) {
|
|
link_count = 0;
|
|
language_count = 0;
|
|
}
|
|
else {
|
|
/* ids that this object directly points to (ex. Event > Random) */
|
|
link_count = read_s32(offset + 0x00, sf);
|
|
offset += 0x04 + 0x08 * link_count;
|
|
|
|
/* localized id list of WavRes (can use this list instead of the prev one) */
|
|
language_count = read_s32(offset + 0x00, sf);
|
|
offset += 0x04;
|
|
for (j = 0; j < language_count; j++) {
|
|
/* 0x00: lang code, in reverse endianness: "en ", "fr ", etc */
|
|
/* 0x04: possibly count of ids for this lang */
|
|
/* 0x08: id1+2 */
|
|
|
|
if (read_u32(offset + 0x04, sf) != 1) {
|
|
VGM_LOG("ubi hx: wrong lang count near %x\n", offset);
|
|
goto fail; /* WavRes doesn't have this field */
|
|
}
|
|
offset += 0x10;
|
|
}
|
|
}
|
|
|
|
//todo figure out CProgramResData sequences
|
|
// Format is pretty complex list of values and some offsets in between, then field names
|
|
// then more values and finally a list of linked IDs Links are the same as in the index,
|
|
// but doesn't seem to be a straight sequence list. Seems it can be used for other config too.
|
|
|
|
/* identify all possible names so unknown platforms fail */
|
|
if (strcmp(class_name, "CEventResData") == 0 || /* play/stop/etc event */
|
|
strcmp(class_name, "CProgramResData") == 0 || /* some kind of map/object-like config to make sequences in some cases? */
|
|
strcmp(class_name, "CActorResData") == 0 || /* same? */
|
|
strcmp(class_name, "CRandomResData") == 0 || /* chooses random WavRes from a list */
|
|
strcmp(class_name, "CTreeBank") == 0 || /* points to TreeRes? */
|
|
strcmp(class_name, "CTreeRes") == 0 || /* points to TreeBank? */
|
|
strcmp(class_name, "CSwitchResData") == 0 || /* big list of WavRes */
|
|
strcmp(class_name, "CPCWavResData") == 0 || /* points to WaveFileIdObj */
|
|
strcmp(class_name, "CPS2WavResData") == 0 ||
|
|
strcmp(class_name, "CGCWavResData") == 0 ||
|
|
strcmp(class_name, "CXBoxWavResData") == 0 ||
|
|
strcmp(class_name, "CPS3WavResData") == 0) {
|
|
continue;
|
|
}
|
|
else if (strcmp(class_name, "CPCWaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CPS2WaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CGCWaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CXBoxWaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CXBoxStaticHWWaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CXBoxStreamHWWaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CPS3StaticAC3WaveFileIdObj") == 0 ||
|
|
strcmp(class_name, "CPS3StreamAC3WaveFileIdObj") == 0) {
|
|
;
|
|
}
|
|
else {
|
|
vgm_logi("UBI HX: unknown type: %s (report)\n", class_name);
|
|
goto fail;
|
|
}
|
|
|
|
/* should only exist on non-wave objects (like CProgramResData) */
|
|
if (link_count != 0) {
|
|
vgm_logi("UBI HX: found links in wav object (report)\n");
|
|
goto fail;
|
|
}
|
|
|
|
hx->total_subsongs++;
|
|
if (hx->total_subsongs != target_subsong)
|
|
continue;
|
|
|
|
if (!parse_header(hx, sf, header_offset, header_size, i))
|
|
goto fail;
|
|
if (!parse_name(hx, sf))
|
|
goto fail;
|
|
|
|
build_readable_name(hx->readable_name,sizeof(hx->readable_name), hx);
|
|
}
|
|
|
|
if (target_subsong < 0 || target_subsong > hx->total_subsongs || hx->total_subsongs < 1) goto fail;
|
|
|
|
|
|
return 1;
|
|
fail:
|
|
return 0;
|
|
}
|
|
|
|
|
|
static STREAMFILE* open_hx_streamfile(ubi_hx_header* hx, STREAMFILE* sf) {
|
|
STREAMFILE* sb = NULL;
|
|
|
|
|
|
if (!hx->is_external)
|
|
return NULL;
|
|
|
|
sb = open_streamfile_by_filename(sf, hx->resource_name);
|
|
if (sb == NULL) {
|
|
vgm_logi("UBI HX: external file '%s' not found (put together)\n", hx->resource_name);
|
|
goto fail;
|
|
}
|
|
|
|
/* streams often have a "RIFF" with "fmt" and "data" but stream offset/size is already adjusted to skip them */
|
|
|
|
return sb;
|
|
fail:
|
|
return NULL;
|
|
}
|
|
|
|
static VGMSTREAM* init_vgmstream_ubi_hx_header(ubi_hx_header* hx, STREAMFILE* sf) {
|
|
STREAMFILE* temp_sf = NULL;
|
|
STREAMFILE* sb = NULL;
|
|
VGMSTREAM* vgmstream = NULL;
|
|
|
|
|
|
if (hx->is_external) {
|
|
temp_sf = open_hx_streamfile(hx, sf);
|
|
if (temp_sf == NULL) goto fail;
|
|
sb = temp_sf;
|
|
}
|
|
else {
|
|
sb = sf;
|
|
}
|
|
|
|
/* very rarely a game uses Ubi ADPCM, but data is empty and has missing header [Rayman 3 demo 3 (PC) fixe.hxc#84] */
|
|
if (hx->is_riff && hx->codec == UBI) { //todo improve
|
|
if (read_u32le(hx->stream_offset, sb) == 0x02) {
|
|
hx->codec = SILENCE;
|
|
}
|
|
}
|
|
|
|
/* build the VGMSTREAM */
|
|
vgmstream = allocate_vgmstream(hx->channels, hx->loop_flag);
|
|
if (!vgmstream) goto fail;
|
|
|
|
vgmstream->meta_type = meta_UBI_HX;
|
|
vgmstream->sample_rate = hx->sample_rate;
|
|
vgmstream->num_streams = hx->total_subsongs;
|
|
vgmstream->stream_size = hx->stream_size;
|
|
|
|
switch(hx->codec) {
|
|
case PCM:
|
|
vgmstream->coding_type = hx->big_endian ? coding_PCM16BE : coding_PCM16LE;
|
|
vgmstream->layout_type = layout_interleave;
|
|
vgmstream->interleave_block_size = 0x02;
|
|
|
|
vgmstream->num_samples = pcm_bytes_to_samples(hx->stream_size, hx->channels, 16);
|
|
break;
|
|
|
|
case UBI:
|
|
vgmstream->codec_data = init_ubi_adpcm(sb, hx->stream_offset, hx->stream_size, vgmstream->channels);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_UBI_ADPCM;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
vgmstream->num_samples = ubi_adpcm_get_samples(vgmstream->codec_data);
|
|
|
|
/* XIII has 6-bit stereo music, Rayman 3 4-bit music, both use 6-bit mono) */
|
|
break;
|
|
|
|
case PSX:
|
|
vgmstream->coding_type = coding_PSX;
|
|
vgmstream->layout_type = layout_interleave;
|
|
vgmstream->interleave_block_size = 0x10;
|
|
|
|
vgmstream->num_samples = ps_bytes_to_samples(hx->stream_size, hx->channels);
|
|
break;
|
|
|
|
case DSP:
|
|
vgmstream->coding_type = coding_NGC_DSP;
|
|
vgmstream->layout_type = layout_interleave;
|
|
vgmstream->interleave_block_size = 0x08;
|
|
|
|
/* dsp header at start offset */
|
|
vgmstream->num_samples = read_s32be(hx->stream_offset + 0x00, sb);
|
|
dsp_read_coefs_be(vgmstream, sb, hx->stream_offset + 0x1c, 0x60);
|
|
dsp_read_hist_be (vgmstream, sb, hx->stream_offset + 0x40, 0x60);
|
|
hx->stream_offset += 0x60 * hx->channels;
|
|
hx->stream_size -= 0x60 * hx->channels;
|
|
break;
|
|
|
|
case XIMA:
|
|
vgmstream->coding_type = coding_XBOX_IMA;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
vgmstream->num_samples = xbox_ima_bytes_to_samples(hx->stream_size, hx->channels);
|
|
break;
|
|
|
|
#ifdef VGM_USE_FFMPEG
|
|
case XMA2: {
|
|
int bytes, block_count, block_size;
|
|
uint8_t buf[0x200];
|
|
|
|
block_size = 0x800;
|
|
block_count = hx->stream_size / block_size;
|
|
|
|
bytes = ffmpeg_make_riff_xma2(buf,0x200, hx->num_samples, hx->stream_size, hx->channels, hx->sample_rate, block_count, block_size);
|
|
vgmstream->codec_data = init_ffmpeg_header_offset(sb, buf,bytes, hx->stream_offset,hx->stream_size);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
vgmstream->num_samples = hx->num_samples;
|
|
|
|
xma_fix_raw_samples_ch(vgmstream, sb, hx->stream_offset,hx->stream_size, hx->channels, 0,0);
|
|
break;
|
|
}
|
|
|
|
case ATRAC3: {
|
|
int block_align, encoder_delay;
|
|
|
|
encoder_delay = 1024 + 69*2;
|
|
switch(hx->codec_id) {
|
|
case 4: block_align = 0x60 * vgmstream->channels; break;
|
|
case 5: block_align = 0x98 * vgmstream->channels; break;
|
|
case 6: block_align = 0xC0 * vgmstream->channels; break;
|
|
default: goto fail;
|
|
}
|
|
|
|
vgmstream->num_samples = atrac3_bytes_to_samples(hx->stream_size, block_align) - encoder_delay;
|
|
|
|
vgmstream->codec_data = init_ffmpeg_atrac3_raw(sb, hx->stream_offset, hx->stream_size, vgmstream->num_samples,vgmstream->channels,vgmstream->sample_rate, block_align, encoder_delay);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->coding_type = coding_FFmpeg;
|
|
vgmstream->layout_type = layout_none;
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
#ifdef VGM_USE_MPEG
|
|
case MP3: {
|
|
mpeg_custom_config cfg = {0};
|
|
|
|
cfg.skip_samples = 0; /* ? */
|
|
|
|
vgmstream->codec_data = init_mpeg_custom(sb, hx->stream_offset, &vgmstream->coding_type, vgmstream->channels, MPEG_STANDARD, &cfg);
|
|
if (!vgmstream->codec_data) goto fail;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
vgmstream->num_samples = mpeg_get_samples_clean(sb, hx->stream_offset, hx->stream_size, NULL, NULL, 1);
|
|
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
case SILENCE: /* special hack */
|
|
vgmstream->coding_type = coding_SILENCE;
|
|
vgmstream->layout_type = layout_none;
|
|
|
|
vgmstream->num_samples = ps_bytes_to_samples(hx->stream_size, hx->channels);
|
|
break;
|
|
default:
|
|
goto fail;
|
|
}
|
|
|
|
strcpy(vgmstream->stream_name, hx->readable_name);
|
|
|
|
if (!vgmstream_open_stream(vgmstream, sb, hx->stream_offset))
|
|
goto fail;
|
|
close_streamfile(temp_sf);
|
|
return vgmstream;
|
|
|
|
fail:
|
|
close_streamfile(temp_sf);
|
|
close_vgmstream(vgmstream);
|
|
return NULL;
|
|
}
|