#include "meta.h" #include "../coding/coding.h" #include "../util/cri_utf.h" /* ACB (Atom Cue sheet Binary) - CRI container of memory audio, often together with a .awb wave bank */ VGMSTREAM* init_vgmstream_acb(STREAMFILE* sf) { VGMSTREAM* vgmstream = NULL; STREAMFILE* temp_sf = NULL; uint32_t subfile_offset; uint32_t subfile_size; utf_context* utf = NULL; /* checks */ if (!is_id32be(0x00,sf, "@UTF")) goto fail; if (!check_extensions(sf, "acb")) goto fail; /* .acb is a cue sheet that uses @UTF (CRI's generic table format) to store row/columns * with complex info (cues, sequences, spatial info, etc). It can store a memory .awb * (our target here), or reference external/streamed .awb (loaded elsewhere) * we only want .awb with actual waves but may use .acb to get names */ { int rows; const char* name; uint32_t offset = 0, size = 0; uint32_t table_offset = 0x00; utf = utf_open(sf, table_offset, &rows, &name); if (!utf) goto fail; if (rows != 1 || strcmp(name, "Header") != 0) goto fail; if (!utf_query_data(utf, 0, "AwbFile", &offset, &size)) goto fail; subfile_offset = table_offset + offset; subfile_size = size; /* column exists but can be empty */ if (subfile_size == 0) { vgm_logi("ACB: bank has no subsongs (ignore)\n"); goto fail; } } //;VGM_LOG("acb: subfile offset=%lx + %x\n", subfile_offset, subfile_size); temp_sf = setup_subfile_streamfile(sf, subfile_offset,subfile_size, "awb"); if (!temp_sf) goto fail; if (is_id32be(0x00, temp_sf, "CPK ")) { vgmstream = init_vgmstream_cpk_memory(temp_sf, sf); /* older */ if (!vgmstream) goto fail; } else { vgmstream = init_vgmstream_awb_memory(temp_sf, sf); /* newer */ if (!vgmstream) goto fail; } /* name-loading for this for memory .awb will be called from init_vgmstream_awb/cpk_memory */ utf_close(utf); close_streamfile(temp_sf); return vgmstream; fail: utf_close(utf); close_streamfile(temp_sf); close_vgmstream(vgmstream); return NULL; } /* ************************************** */ /* extra config for .acb with lots of sounds, since there is a lot of IO back and forth, * ex. +7000 acb+awb subsongs in Ultra Despair Girls (PC) */ //TODO: could pre-load all sections first, but needs cache for multiple subsongs (+semaphs, if multiple read the same thing) #define ACB_TABLE_BUFFER_CUENAME 0x4000 #define ACB_TABLE_BUFFER_CUE 0x2000 #define ACB_TABLE_BUFFER_BLOCKSEQUENCE 0x8000 #define ACB_TABLE_BUFFER_BLOCK 0x8000 #define ACB_TABLE_BUFFER_SEQUENCE 0x4000 #define ACB_TABLE_BUFFER_TRACK 0x1000 #define ACB_TABLE_BUFFER_TRACKCOMMAND 0x2000 #define ACB_TABLE_BUFFER_SYNTH 0x4000 #define ACB_TABLE_BUFFER_WAVEFORM 0x4000 #define ACB_MAX_NAMELIST 255 #define ACB_MAX_NAME 1024 /* even more is possible in rare cases [Senran Kagura Burst Re:Newal (PC)] */ #define ACB_MAX_BUFFER 0x8000 static STREAMFILE* setup_acb_streamfile(STREAMFILE* sf, size_t buffer_size) { STREAMFILE* new_sf = NULL; new_sf = reopen_streamfile(sf, buffer_size); return new_sf; } typedef struct { uint16_t CueIndex; const char* CueName; } CueName_t; typedef struct { uint8_t ReferenceType; uint16_t ReferenceIndex; } Cue_t; typedef struct { uint16_t NumTracks; uint32_t TrackIndex_offset; uint32_t TrackIndex_size; uint16_t NumBlocks; uint32_t BlockIndex_offset; uint32_t BlockIndex_size; } BlockSequence_t; typedef struct { uint16_t NumTracks; uint32_t TrackIndex_offset; uint32_t TrackIndex_size; } Block_t; typedef struct { uint16_t NumTracks; uint32_t TrackIndex_offset; uint32_t TrackIndex_size; //uint16_t ActionTrackStartIndex; //uint16_t NumActionTracks; uint8_t Type; } Sequence_t; typedef struct { uint16_t EventIndex; } Track_t; typedef struct { uint32_t Command_offset; uint32_t Command_size; } TrackCommand_t; typedef struct { uint8_t Type; uint32_t ReferenceItems_offset; uint32_t ReferenceItems_size; } Synth_t; typedef struct { uint16_t Id; uint16_t PortNo; uint8_t Streaming; } Waveform_t; typedef struct { STREAMFILE* acbFile; /* original reference, don't close */ /* keep track of these tables so they can be closed when done */ utf_context* Header; utf_context* CueNames; STREAMFILE* CueNameSf; STREAMFILE* CueSf; STREAMFILE* BlockSequenceSf; STREAMFILE* BlockSf; STREAMFILE* SequenceSf; STREAMFILE* TrackSf; STREAMFILE* TrackCommandSf; STREAMFILE* SynthSf; STREAMFILE* WaveformSf; Cue_t* Cue; CueName_t* CueName; BlockSequence_t* BlockSequence; Block_t* Block; Sequence_t* Sequence; Track_t* Track; TrackCommand_t* TrackCommand; Synth_t* Synth; Waveform_t* Waveform; int Cue_rows; int CueName_rows; int BlockSequence_rows; int Block_rows; int Sequence_rows; int Track_rows; int TrackCommand_rows; int Synth_rows; int Waveform_rows; /* config */ int is_memory; int target_waveid; int target_port; /* to avoid infinite/circular references (AtomViewer crashes otherwise) */ int synth_depth; int sequence_depth; /* name stuff */ int16_t cuename_index; const char* cuename_name; int awbname_count; int16_t awbname_list[ACB_MAX_NAMELIST]; char name[ACB_MAX_NAME]; } acb_header; static int open_utf_subtable(acb_header* acb, STREAMFILE* *TableSf, utf_context* *Table, const char* TableName, int* rows, int buffer) { uint32_t offset = 0; /* already loaded */ if (*Table != NULL) return 1; if (!utf_query_data(acb->Header, 0, TableName, &offset, NULL)) goto fail; *TableSf = setup_acb_streamfile(acb->acbFile, buffer); if (!*TableSf) goto fail; *Table = utf_open(*TableSf, offset, rows, NULL); if (!*Table) goto fail; //;VGM_LOG("acb: loaded table %s\n", TableName); return 1; fail: return 0; } //todo safeops, avoid recalc lens static void acb_cat(char* dst, int dst_max, const char* src) { int dst_len = strlen(dst); int src_len = strlen(dst); if (dst_len + src_len > dst_max - 1) return; strcat(dst, src); } static void acb_cpy(char* dst, int dst_max, const char* src) { int src_len = strlen(dst); if (src_len > dst_max - 1) return; strcpy(dst, src); } static void add_acb_name(acb_header* acb, int8_t Streaming) { if (!acb->cuename_name) { //;VGM_LOG("acb: no name\n"); return; } /* ignore name repeats */ if (acb->awbname_count) { int i; for (i = 0; i < acb->awbname_count; i++) { if (acb->awbname_list[i] == acb->cuename_index) return; } } /* since waveforms can be reused by cues, multiple names are a thing */ if (acb->awbname_count) { acb_cat(acb->name, sizeof(acb->name), "; "); acb_cat(acb->name, sizeof(acb->name), acb->cuename_name); } else { acb_cpy(acb->name, sizeof(acb->name), acb->cuename_name); } if (Streaming == 2 && acb->is_memory) { acb_cat(acb->name, sizeof(acb->name), " [pre]"); } acb->awbname_list[acb->awbname_count] = acb->cuename_index; acb->awbname_count++; if (acb->awbname_count >= ACB_MAX_NAMELIST) acb->awbname_count = ACB_MAX_NAMELIST - 1; /* ??? */ //;VGM_LOG("acb: found cue for waveid=%i: %s\n", acb->target_waveid, acb->cuename_name); } /*****************************************************************************/ /* OBJECT HANDLERS */ static int preload_acb_waveform(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Waveform_rows; int i, c_Id, c_MemoryAwbId, c_StreamAwbId, c_StreamAwbPortNo, c_Streaming; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->WaveformSf, &Table, "WaveformTable", p_rows, ACB_TABLE_BUFFER_WAVEFORM)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Waveform=%i\n", *p_rows); acb->Waveform = malloc(*p_rows * sizeof(Waveform_t)); if (!acb->Waveform) goto fail; c_Id = utf_get_column(Table, "Id"); c_MemoryAwbId = utf_get_column(Table, "MemoryAwbId"); c_StreamAwbId = utf_get_column(Table, "StreamAwbId"); c_StreamAwbPortNo = utf_get_column(Table, "StreamAwbPortNo"); c_Streaming = utf_get_column(Table, "Streaming"); for (i = 0; i < *p_rows; i++) { Waveform_t* r = &acb->Waveform[i]; if (!utf_query_col_u16(Table, i, c_Id, &r->Id)) { /* older versions use Id */ if (acb->is_memory) { utf_query_col_u16(Table, i, c_MemoryAwbId, &r->Id); r->PortNo = 0xFFFF; } else { utf_query_col_u16(Table, i, c_StreamAwbId, &r->Id); utf_query_col_u16(Table, i, c_StreamAwbPortNo, &r->PortNo); /* assumed default 0 if doesn't exist */ } } else { r->PortNo = 0xFFFF; } utf_query_col_u8(Table, i, c_Streaming, &r->Streaming); } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Waveform preload\n"); utf_close(Table); return 0; } static int load_acb_waveform(acb_header* acb, uint16_t Index) { Waveform_t* r; if (!preload_acb_waveform(acb)) goto fail; if (Index > acb->Waveform_rows) goto fail; r = &acb->Waveform[Index]; //;VGM_LOG("acb: Waveform[%i]: Id=%i, PortNo=%i, Streaming=%i\n", Index, r->Id, r->PortNo, r->Streaming); /* not found but valid */ if (r->Id != acb->target_waveid) return 1; /* correct AWB port (check ignored if set to -1) */ if (acb->target_port >= 0 && r->PortNo != 0xFFFF && r->PortNo != acb->target_port) return 1; /* must match our target's (0=memory, 1=streaming, 2=memory (prefetch)+stream) */ if ((acb->is_memory && r->Streaming == 1) || (!acb->is_memory && r->Streaming == 0)) return 1; /* aaand finally get name (phew) */ add_acb_name(acb, r->Streaming); return 1; fail: VGM_LOG("acb: failed Waveform %i\n", Index); return 0; } /*****************************************************************************/ /* define here for Synths pointing to Sequences */ static int load_acb_sequence(acb_header* acb, uint16_t Index); static int preload_acb_synth(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Synth_rows; int i, c_Type, c_ReferenceItems; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->SynthSf, &Table, "SynthTable", p_rows, ACB_TABLE_BUFFER_SYNTH)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Synth=%i\n", *p_rows); acb->Synth = malloc(*p_rows * sizeof(Synth_t)); if (!acb->Synth) goto fail; c_Type = utf_get_column(Table, "Type"); c_ReferenceItems = utf_get_column(Table, "ReferenceItems"); for (i = 0; i < *p_rows; i++) { Synth_t* r = &acb->Synth[i]; utf_query_col_u8(Table, i, c_Type, &r->Type); utf_query_col_data(Table, i, c_ReferenceItems, &r->ReferenceItems_offset, &r->ReferenceItems_size); /* CommandIndex: references SynthCommand[i], defines how index is used? */ } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Synth preload\n"); utf_close(Table); return 0; } static int load_acb_synth(acb_header* acb, uint16_t Index) { Synth_t* r; int i, count; if (!preload_acb_synth(acb)) goto fail; if (Index > acb->Synth_rows) goto fail; r = &acb->Synth[Index]; //;VGM_LOG("acb: Synth[%i]: Type=%x, ReferenceItems={%x,%x}\n", Index, r->Type, r->ReferenceItems_offset, r->ReferenceItems_size); acb->synth_depth++; /* sometimes 2 (ex. Yakuza 6) or even 3 (Street Fighter vs Tekken) */ if (acb->synth_depth > 3) { VGM_LOG("acb: Synth depth too high\n"); goto fail; } //todo .CommandIndex > CommandTable /* Cue.ReferenceType 2 uses Synth.Type, while 3 always sets it to 0 and uses Sequence.Type instead * Both look the same and probably affect which item in the ReferenceItems list is picked: * - 0: polyphonic (1 item) * - 1: sequential (1 to N?) * - 2: shuffle (1 from N?) * - 3: random (1 from N?) * - 4: random no repeat * - 5: switch game variable * - 6: combo sequential * - 7: switch selector * - 8: track transition by selector * - other: undefined? * Since we want to find all possible Waveforms that could match our id, we ignore Type and just parse all ReferenceItems. */ count = r->ReferenceItems_size / 0x04; for (i = 0; i < count; i++) { uint16_t item_type = read_u16be(r->ReferenceItems_offset + i*0x04 + 0x00, acb->SynthSf); uint16_t item_index = read_u16be(r->ReferenceItems_offset + i*0x04 + 0x02, acb->SynthSf); //;VGM_LOG("acb: Synth.ReferenceItem: type=%x, index=%x\n", item_type, item_index); switch(item_type) { case 0x00: /* no reference */ count = 0; break; case 0x01: /* Waveform (most common) */ if (!load_acb_waveform(acb, item_index)) goto fail; break; case 0x02: /* Synth, possibly random (rare, found in Sonic Lost World with ReferenceType 2) */ if (!load_acb_synth(acb, item_index)) goto fail; break; case 0x03: /* Sequence of Synths w/ % in Synth.TrackValues (rare, found in Sonic Lost World with ReferenceType 2) */ if (!load_acb_sequence(acb, item_index)) goto fail; break; /* others: same as cue's ReferenceType? */ case 0x06: /* this seems to point to Synth but results don't make sense (rare, from Sonic Lost World) */ default: /* undefined/crashes AtomViewer */ VGM_LOG("acb: unknown Synth.ReferenceItem type %x at %x + %x\n", item_type, r->ReferenceItems_offset, r->ReferenceItems_size); count = 0; /* force end without failing */ break; } } acb->synth_depth--; return 1; fail: VGM_LOG("acb: failed Synth %i\n", Index); return 0; } /*****************************************************************************/ static int load_acb_command_tlvs(acb_header* acb, STREAMFILE* sf, uint32_t Command_offset, uint32_t Command_size) { uint16_t tlv_code, tlv_type, tlv_index; uint8_t tlv_size; uint32_t pos = 0; uint32_t max_pos = Command_size; /* read a (name)Command multiple TLV data */ while (pos < max_pos) { tlv_code = read_u16be(Command_offset + pos + 0x00, sf); tlv_size = read_u8 (Command_offset + pos + 0x02, sf); pos += 0x03; /* There are around 160 codes (some unused), with things like set volume, pan, stop, mute, and so on. * Multiple commands are linked and only "note on" seems to point so other objects, so maybe others * apply to current object (since there is "note off" without reference. */ switch(tlv_code) { case 2000: /* noteOn */ case 2003: /* noteOnWithNo plus 16b (null?) [rare, ex. PES 2014] */ if (tlv_size < 0x04) { VGM_LOG("acb: TLV with unknown size\n"); break; } tlv_type = read_u16be(Command_offset + pos + 0x00, sf); /* ReferenceItem */ tlv_index = read_u16be(Command_offset + pos + 0x02, sf); //;VGM_LOG("acb: TLV at %x: type %x, index=%x\n", offset, tlv_type, tlv_index); /* same as Synth's ReferenceItem type? */ switch(tlv_type) { case 0x02: /* Synth (common) */ if (!load_acb_synth(acb, tlv_index)) goto fail; break; case 0x03: /* Sequence (common, ex. Yakuza 6, Yakuza Kiwami 2) */ if (!load_acb_sequence(acb, tlv_index)) goto fail; break; default: VGM_LOG("acb: unknown TLV type %x at %x + %x\n", tlv_type, Command_offset + pos, tlv_size); max_pos = 0; /* force end without failing */ break; } break; case 2004: /* noteOnWithDuration */ /* same as the above plus extra field */ //;VGM_LOG("acb: TLV at %x: usable code %i?\n", offset-0x03, tlv_code); break; case 33: /* mute */ case 124: /* stopAtLoopEnd */ case 1000: /* noteOff */ case 1251: /* sequenceCallbackWithId */ case 1252: /* sequenceCallbackWithString */ case 1253: /* sequenceCallbackWithIdAndString */ case 2002: /* setSynthOrWaveform */ case 4051: /* transitionTrack */ case 7102: /* muteTrackAction */ case 7100: /* startAction */ case 7101: /* stopAction */ /* may be needed? */ //;VGM_LOG("acb: TLV at %x: check code %i?\n", offset-0x03, tlv_code); break; case 0: /* no-op */ case 998: /* sequenceStartRandom (plays following note ons in random?)*/ case 999: /* sequenceStart (plays following note ons in sequence?) */ default: /* ignore others */ break; } pos += tlv_size; } return 1; fail: VGM_LOG("acb: failed Command TLVs\n"); return 0; } /*****************************************************************************/ static int preload_acb_trackcommand(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->TrackCommand_rows; int i, c_Command; if (*p_rows) return 1; /* load either TrackEvent (>=v1.28) or Command (<=v1.27) */ if (!open_utf_subtable(acb, &acb->TrackCommandSf, &Table, "TrackEventTable", p_rows, ACB_TABLE_BUFFER_TRACKCOMMAND)) { if (!open_utf_subtable(acb, &acb->TrackCommandSf, &Table, "CommandTable", p_rows, ACB_TABLE_BUFFER_TRACKCOMMAND)) goto fail; } if (!*p_rows) return 1; //;VGM_LOG("acb: preload TrackEvent/Command=%i\n", *p_rows); acb->TrackCommand = malloc(*p_rows * sizeof(TrackCommand_t)); if (!acb->TrackCommand) goto fail; c_Command = utf_get_column(Table, "Command"); for (i = 0; i < *p_rows; i++) { TrackCommand_t* r = &acb->TrackCommand[i]; utf_query_col_data(Table, i, c_Command, &r->Command_offset, &r->Command_size); } utf_close(Table); return 1; fail: VGM_LOG("acb: failed TrackEvent/Command preload\n"); utf_close(Table); return 0; } static int load_acb_trackcommand(acb_header* acb, uint16_t Index) { TrackCommand_t* r; if (!preload_acb_trackcommand(acb)) goto fail; if (Index > acb->TrackCommand_rows) goto fail; r = &acb->TrackCommand[Index]; //;VGM_LOG("acb: TrackEvent/Command[%i]: Command={%x,%x}\n", Index, r->Command_offset, r->Command_size); /* read Command's TLVs */ if (!load_acb_command_tlvs(acb, acb->TrackCommandSf, r->Command_offset, r->Command_size)) goto fail; return 1; fail: VGM_LOG("acb: failed TrackCommand %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_track(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Track_rows; int i, c_EventIndex; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->TrackSf, &Table, "TrackTable", p_rows, ACB_TABLE_BUFFER_CUE)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Track=%i\n", *p_rows); acb->Track = malloc(*p_rows * sizeof(Track_t)); if (!acb->Track) goto fail; c_EventIndex = utf_get_column(Table, "EventIndex"); for (i = 0; i < *p_rows; i++) { Track_t* r = &acb->Track[i]; utf_query_col_u16(Table, i, c_EventIndex, &r->EventIndex); /* TargetType: changes ACB target? */ /* CommandIndex: references TrackCommand[i], defines how index is used? */ } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Track preload\n"); utf_close(Table); return 0; } static int load_acb_track(acb_header* acb, uint16_t Index) { Track_t* r; if (!preload_acb_track(acb)) goto fail; if (Index > acb->Track_rows) goto fail; r = &acb->Track[Index]; //;VGM_LOG("acb: Track[%i]: EventIndex=%i\n", Index, r->EventIndex); //todo CommandIndex? /* happens with some odd track without anything useful */ if (r->EventIndex == 65535) return 1; if (!load_acb_trackcommand(acb, r->EventIndex)) goto fail; return 1; fail: VGM_LOG("acb: failed Track %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_sequence(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Sequence_rows; int i, c_NumTracks, c_TrackIndex, c_Type; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->SequenceSf, &Table, "SequenceTable", p_rows, ACB_TABLE_BUFFER_SEQUENCE)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Sequence=%i\n", *p_rows); acb->Sequence = malloc(*p_rows * sizeof(Sequence_t)); if (!acb->Sequence) goto fail; c_NumTracks = utf_get_column(Table, "NumTracks"); c_TrackIndex = utf_get_column(Table, "TrackIndex"); //c_ActionTrackStartIndex = utf_get_column(Table, "ActionTrackStartIndex"); //c_NumActionTracks = utf_get_column(Table, "NumActionTracks"); c_Type = utf_get_column(Table, "Type"); for (i = 0; i < *p_rows; i++) { Sequence_t* r = &acb->Sequence[i]; utf_query_col_u16(Table, i, c_NumTracks, &r->NumTracks); utf_query_col_data(Table, i, c_TrackIndex, &r->TrackIndex_offset, &r->TrackIndex_size); //utf_query_col_u16(Table, i, c_ActionTrackStartIndex, &r->ActionTrackStartIndex); //utf_query_col_u16(Table, i, c_NumActionTracks, &r->NumActionTracks); utf_query_col_u8(Table, i, c_Type, &r->Type); /* CommandIndex: references SequenceCommand[i], defines how index is used? */ } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Sequence preload\n"); utf_close(Table); return 0; } static int load_acb_sequence(acb_header* acb, uint16_t Index) { Sequence_t* r; int i; if (!preload_acb_sequence(acb)) goto fail; if (Index > acb->Sequence_rows) goto fail; r = &acb->Sequence[Index]; //;VGM_LOG("acb: Sequence[%i]: NumTracks=%i, TrackIndex={%x, %x}, Type=%x\n", Index, r->NumTracks, r->TrackIndex_offset, r->TrackIndex_size, r->Type); //TODO most unknown types can be found in Ultra Despair Girls (PC) acb->sequence_depth++; if (acb->sequence_depth > 3) { VGM_LOG("acb: Sequence depth too high\n"); goto fail; /* max Sequence > Sequence > Sequence > Synth > Waveform (ex. Yakuza 6) */ } #if 0 /* reference to ActionTrack[i..] */ if (r->NumActionTracks) { VGM_LOG_ONCE("ACB: ignored ActionTrack[%i~%i]\n", r->ActionTrackStartIndex, r->NumActionTracks); } #endif if (r->NumTracks * 0x02 > r->TrackIndex_size) { /* padding may exist */ VGM_LOG("acb: wrong Sequence.TrackIndex size\n"); goto fail; } /* read Tracks inside Sequence */ switch(r->Type) { /* types affect which item in the TrackIndex list is picked (see load_acb_synth) */ case 0: /* polyphonic (TrackIndex only) */ case 1: /* sequential (TrackIndex only) */ case 3: /* random (TrackIndex + TrackValues = int percent) */ case 4: /* random no repeat (TrackIndex + TrackValues = int percent) */ default: for (i = 0; i < r->NumTracks; i++) { int16_t TrackIndex_index = read_s16be(r->TrackIndex_offset + i*0x02, acb->SequenceSf); if (!load_acb_track(acb, TrackIndex_index)) goto fail; } break; //default: // VGM_LOG_ONCE("ACB: unknown Sequence.Type=%x\n", r->Type); // break; } acb->sequence_depth--; return 1; fail: VGM_LOG("acb: failed Sequence %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_block(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Block_rows; int i, c_NumTracks, c_TrackIndex; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->BlockSf, &Table, "BlockTable", p_rows, ACB_TABLE_BUFFER_BLOCK)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Block=%i\n", *p_rows); acb->Block = malloc(*p_rows * sizeof(Block_t)); if (!acb->Block) goto fail; c_NumTracks = utf_get_column(Table, "NumTracks"); c_TrackIndex = utf_get_column(Table, "TrackIndex"); for (i = 0; i < *p_rows; i++) { Block_t* r = &acb->Block[i]; utf_query_col_u16(Table, i, c_NumTracks, &r->NumTracks); utf_query_col_data(Table, i, c_TrackIndex, &r->TrackIndex_offset, &r->TrackIndex_size); //todo .ActionTrackStartIndex/NumActionTracks > ? } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Block preload\n"); utf_close(Table); return 0; } static int load_acb_block(acb_header* acb, uint16_t Index) { Block_t* r; int i; if (!preload_acb_block(acb)) goto fail; if (Index > acb->Block_rows) goto fail; r = &acb->Block[Index]; //;VGM_LOG("acb: Block[%i]: NumTracks=%i, TrackIndex={%x, %x}\n", Index, r->NumTracks, r->TrackIndex_offset, r->TrackIndex_size); if (r->NumTracks * 0x02 > r->TrackIndex_size) { /* padding may exist */ VGM_LOG("acb: wrong Block.TrackIndex size\n"); goto fail; } /* read Tracks inside Block */ for (i = 0; i < r->NumTracks; i++) { int16_t TrackIndex_index = read_s16be(r->TrackIndex_offset + i*0x02, acb->BlockSf); if (!load_acb_track(acb, TrackIndex_index)) goto fail; } return 1; fail: VGM_LOG("acb: failed Block %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_blocksequence(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->BlockSequence_rows; int i, c_NumTracks, c_TrackIndex, c_NumBlocks, c_BlockIndex; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->BlockSequenceSf, &Table, "BlockSequenceTable", p_rows, ACB_TABLE_BUFFER_BLOCKSEQUENCE)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload BlockSequence=%i\n", *p_rows); acb->BlockSequence = malloc(*p_rows * sizeof(BlockSequence_t)); if (!acb->BlockSequence) goto fail; c_NumTracks = utf_get_column(Table, "NumTracks"); c_TrackIndex = utf_get_column(Table, "TrackIndex"); c_NumBlocks = utf_get_column(Table, "NumBlocks"); c_BlockIndex = utf_get_column(Table, "BlockIndex"); for (i = 0; i < *p_rows; i++) { BlockSequence_t* r = &acb->BlockSequence[i]; utf_query_col_u16(Table, i, c_NumTracks, &r->NumTracks); utf_query_col_data(Table, i, c_TrackIndex, &r->TrackIndex_offset, &r->TrackIndex_size); utf_query_col_u16(Table, i, c_NumBlocks, &r->NumBlocks); utf_query_col_data(Table, i, c_BlockIndex, &r->BlockIndex_offset, &r->BlockIndex_size); } utf_close(Table); return 1; fail: VGM_LOG("acb: failed BlockSequence preload\n"); utf_close(Table); return 0; } static int load_acb_blocksequence(acb_header* acb, uint16_t Index) { BlockSequence_t* r; int i; if (!preload_acb_blocksequence(acb)) goto fail; if (Index > acb->BlockSequence_rows) goto fail; r = &acb->BlockSequence[Index]; //;VGM_LOG("acb: BlockSequence[%i]: NumTracks=%i, TrackIndex={%x, %x}, NumBlocks=%i, BlockIndex={%x, %x}\n", Index, r->NumTracks, r->TrackIndex_offset,r->TrackIndex_size, r->NumBlocks, r->BlockIndex_offset, r->BlockIndex_size); if (r->NumTracks * 0x02 > r->TrackIndex_size) { /* padding may exist */ VGM_LOG("acb: wrong BlockSequence.TrackIndex size\n"); goto fail; } /* read Tracks inside BlockSequence */ for (i = 0; i < r->NumTracks; i++) { int16_t TrackIndex_index = read_s16be(r->TrackIndex_offset + i*0x02, acb->BlockSequenceSf); if (!load_acb_track(acb, TrackIndex_index)) goto fail; } if (r->NumBlocks * 0x02 > r->BlockIndex_size) { VGM_LOG("acb: wrong BlockSequence.BlockIndex size\n"); goto fail; } /* read Blocks inside BlockSequence */ for (i = 0; i < r->NumBlocks; i++) { int16_t BlockIndex_index = read_s16be(r->BlockIndex_offset + i*0x02, acb->BlockSequenceSf); if (!load_acb_block(acb, BlockIndex_index)) goto fail; } return 1; fail: VGM_LOG("acb: failed BlockSequence %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_cue(acb_header* acb) { utf_context* Table = NULL; int* p_rows = &acb->Cue_rows; int i, c_ReferenceType, c_ReferenceIndex; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->CueSf, &Table, "CueTable", p_rows, ACB_TABLE_BUFFER_CUE)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload Cue=%i\n", *p_rows); acb->Cue = malloc(*p_rows * sizeof(Cue_t)); if (!acb->Cue) goto fail; c_ReferenceType = utf_get_column(Table, "ReferenceType"); c_ReferenceIndex = utf_get_column(Table, "ReferenceIndex"); for (i = 0; i < *p_rows; i++) { Cue_t* r = &acb->Cue[i]; utf_query_col_u8(Table, i, c_ReferenceType, &r->ReferenceType); utf_query_col_u16(Table, i, c_ReferenceIndex, &r->ReferenceIndex); } utf_close(Table); return 1; fail: VGM_LOG("acb: failed Cue preload\n"); utf_close(Table); return 0; } static int load_acb_cue(acb_header* acb, uint16_t Index) { Cue_t* r; /* read Cue[Index] */ if (!preload_acb_cue(acb)) goto fail; if (Index > acb->Cue_rows) goto fail; r = &acb->Cue[Index]; //;VGM_LOG("acb: Cue[%i]: ReferenceType=%i, ReferenceIndex=%i\n", Index, r->ReferenceType, r->ReferenceIndex); /* usually older games use older references but not necessarily */ switch(r->ReferenceType) { case 0x01: /* Cue > Waveform (ex. PES 2015) */ if (!load_acb_waveform(acb, r->ReferenceIndex)) goto fail; break; case 0x02: /* Cue > Synth > Waveform (ex. Ukiyo no Roushi) */ if (!load_acb_synth(acb, r->ReferenceIndex)) goto fail; break; case 0x03: /* Cue > Sequence > Track > Command > Synth > Waveform (ex. Valkyrie Profile anatomia, Yakuza Kiwami 2) */ if (!load_acb_sequence(acb, r->ReferenceIndex)) goto fail; break; case 0x08: /* Cue > BlockSequence > Track / Block > Track > Command > Synth > Waveform (ex. Sonic Lost World, Kandagawa Jet Girls, rare) */ if (!load_acb_blocksequence(acb, r->ReferenceIndex)) goto fail; break; case 0x00: /* none */ case 0x04: /* "track" */ case 0x05: /* "outsideLink" */ case 0x06: /* "insideLinkSynth" (ex. PES 2014) */ case 0x07: /* "insideLinkSequence" (ex. PES 2014) */ case 0x09: /* "insideLinkBlockSequence" */ case 0x0a: /* "eventCue_UnUse" */ case 0x0b: /* "soundGenerator" */ default: VGM_LOG_ONCE("ACB: unknown Cue.ReferenceType=%x, Cue.ReferenceIndex=%x\n", r->ReferenceType, r->ReferenceIndex); break; /* ignore and continue */ } return 1; fail: VGM_LOG("acb: failed Cue %i\n", Index); return 0; } /*****************************************************************************/ static int preload_acb_cuename(acb_header* acb) { utf_context* Table = acb->CueNames; int* p_rows = &acb->CueName_rows; int i, c_CueIndex, c_CueName; if (*p_rows) return 1; if (!open_utf_subtable(acb, &acb->CueNameSf, &Table, "CueNameTable", p_rows, ACB_TABLE_BUFFER_CUENAME)) goto fail; if (!*p_rows) return 1; //;VGM_LOG("acb: preload CueName=%i\n", *p_rows); acb->CueName = malloc(*p_rows * sizeof(CueName_t)); if (!acb->CueName) goto fail; c_CueIndex = utf_get_column(Table, "CueIndex"); c_CueName = utf_get_column(Table, "CueName"); for (i = 0; i < *p_rows; i++) { CueName_t* r = &acb->CueName[i]; utf_query_col_u16(Table, i, c_CueIndex, &r->CueIndex); utf_query_col_string(Table, i, c_CueName, &r->CueName); } //utf_close(Table); /* keep this table around since we need CueName pointers */ return 1; fail: VGM_LOG("acb: failed CueName preload\n"); return 0; } static int load_acb_cuename(acb_header* acb, uint16_t Index) { CueName_t* r; if (!preload_acb_cuename(acb)) goto fail; if (Index > acb->CueName_rows) goto fail; r = &acb->CueName[Index]; //;VGM_LOG("acb: CueName[%i]: CueIndex=%i, CueName=%s\n", Index, r->CueIndex, r->CueName); /* save as will be needed if references waveform */ acb->cuename_index = Index; acb->cuename_name = r->CueName; if (!load_acb_cue(acb, r->CueIndex)) goto fail; return 1; fail: VGM_LOG("acb: failed CueName %i\n", Index); return 0; } /*****************************************************************************/ /* Normally games load a .acb + .awb, and asks the .acb to play a cue by name or index. * Since we only care for actual waves, to get its name we need to find which cue uses our wave. * Multiple cues can use the same wave (meaning multiple names), and one cue may use multiple waves. * There is no easy way to map cue name <> wave name so basically we parse the whole thing. * * .acb are created in CRI Atom Craft, where user defines N Cues with CueName each, then link somehow * to a Waveform (.awb=streamed or memory .acb=internal, data 'material' encoded in some format), * depending on reference types. Typical links are: * - CueName > Cue > Waveform (type 1) * - CueName > Cue > Synth > Waveform (type 2) * - CueName > Cue > Sequence > Track > Command > Synth > Waveform (type 3, <=v1.27) * - CueName > Cue > Sequence > Track > Command > Synth > Synth > Waveform (type 3, <=v1.27) * - CueName > Cue > Sequence > Track > TrackEvent > Command > Synth > Waveform (type 3, >=v1.28) * - CueName > Cue > Sequence > Track > TrackEvent > Command > Synth > Synth > Waveform (type 3, >=v1.28) * - CueName > Cue > Sequence > Track > TrackEvent > Command > Sequence > (...) > Synth > Waveform (type 3, >=v1.28) * - CueName > Cue > Block > Track > Command > Synth > Synth > Waveform (type 8) * - others should be possible * Atom Craft may only target certain .acb versions so some links are later removed * Not all cues to point to Waveforms, some are just config events/commands. * .acb link to .awb by name (loaded manually), though they have a checksum/hash/header to validate. * * .acb can contain info for multiple .awb, that are loaded sequentially and assigned "port numbers" (0 to N). * Both Wave ID and port number must be passed externally to find appropriate song name. * * To improve performance we pre-read each table objects's useful fields. Extra complex files may include +8000 objects, * per table, meaning it uses a decent chunk of memory, but having to re-read with streamfiles is much slower. */ void load_acb_wave_name(STREAMFILE* sf, VGMSTREAM* vgmstream, int waveid, int port, int is_memory) { acb_header acb = {0}; int i; if (!sf || !vgmstream || waveid < 0) return; //;VGM_LOG("acb: find waveid=%i, port=%i\n", waveid, port); acb.acbFile = sf; acb.Header = utf_open(acb.acbFile, 0x00, NULL, NULL); if (!acb.Header) goto fail; acb.target_waveid = waveid; acb.target_port = port; acb.is_memory = is_memory; /* read all possible cue names and find which waveids are referenced by it */ preload_acb_cuename(&acb); for (i = 0; i < acb.CueName_rows; i++) { if (!load_acb_cuename(&acb, i)) goto fail; } /* meh copy */ if (acb.awbname_count > 0) { strncpy(vgmstream->stream_name, acb.name, STREAM_NAME_SIZE); vgmstream->stream_name[STREAM_NAME_SIZE - 1] = '\0'; } /* done */ fail: utf_close(acb.Header); utf_close(acb.CueNames); close_streamfile(acb.CueNameSf); close_streamfile(acb.CueSf); close_streamfile(acb.BlockSequenceSf); close_streamfile(acb.BlockSf); close_streamfile(acb.SequenceSf); close_streamfile(acb.TrackSf); close_streamfile(acb.TrackCommandSf); close_streamfile(acb.SynthSf); close_streamfile(acb.WaveformSf); free(acb.CueName); free(acb.Cue); free(acb.BlockSequence); free(acb.Block); free(acb.Sequence); free(acb.Track); free(acb.TrackCommand); free(acb.Synth); free(acb.Waveform); }