266 lines
8.4 KiB
C
266 lines
8.4 KiB
C
#include "meta.h"
|
|
#include "../coding/coding.h"
|
|
|
|
static uint16_t SsPitchFromNote(int16_t note, int16_t fine, uint8_t center, uint8_t shift);
|
|
|
|
#define VAB_MIN(x,y) ((x)<(y)?(x):(y))
|
|
#define VAB_MAX(x,y) ((x)>(y)?(x):(y))
|
|
#define VAB_CLAMP(x,min,max) VAB_MIN(VAB_MAX(x,min),max)
|
|
|
|
static int read_vabcfg_file(STREAMFILE* sf, int program, int tone, int* note, int* fine, int* uselimits) {
|
|
char filename[PATH_LIMIT];
|
|
off_t txt_offset, file_size;
|
|
STREAMFILE* sf_cfg = NULL;
|
|
size_t file_len, key_len;
|
|
|
|
sf_cfg = open_streamfile_by_filename(sf, ".vab_config");
|
|
if (!sf_cfg) goto fail;
|
|
|
|
get_streamfile_filename(sf, filename, sizeof(filename));
|
|
|
|
txt_offset = read_bom(sf_cfg);
|
|
file_size = get_streamfile_size(sf_cfg);
|
|
file_len = strlen(filename);
|
|
|
|
/* read lines and find target filename, format is (filename): value1, ... valueN */
|
|
while (txt_offset < file_size) {
|
|
char line[0x2000];
|
|
char key[PATH_LIMIT] = { 0 }, val[0x2000] = { 0 };
|
|
int ok, bytes_read, line_ok;
|
|
int cfg_program, cfg_tone, cfg_note, cfg_fine, cfg_limits;
|
|
|
|
bytes_read = read_line(line, sizeof(line), txt_offset, sf_cfg, &line_ok);
|
|
if (!line_ok) goto fail;
|
|
|
|
txt_offset += bytes_read;
|
|
|
|
/* get key/val (ignores lead/trailing spaces, stops at comment/separator) */
|
|
ok = sscanf(line, " %[^\t#:] : %[^\t#\r\n] ", key, val);
|
|
if (ok != 2) /* ignore line if no key=val (comment or garbage) */
|
|
continue;
|
|
|
|
if (key[0] == '*') {
|
|
key_len = strlen(key);
|
|
if (file_len < key_len)
|
|
continue;
|
|
|
|
if (strcmp(filename + (file_len - key_len + 1), key + 1) != 0)
|
|
continue;
|
|
} else {
|
|
if (strcmp(filename, key) != 0)
|
|
continue;
|
|
}
|
|
|
|
ok = sscanf(val, "%d , %d , %d , %d , %d", &cfg_program, &cfg_tone, &cfg_note, &cfg_fine, &cfg_limits);
|
|
if (ok != 5)
|
|
continue;
|
|
|
|
if (cfg_program >= 0 && program != cfg_program)
|
|
continue;
|
|
|
|
if (cfg_tone >= 0 && tone != cfg_tone)
|
|
continue;
|
|
|
|
*note = cfg_note;
|
|
*fine = cfg_fine;
|
|
*uselimits = cfg_limits;
|
|
|
|
close_streamfile(sf_cfg);
|
|
return 1;
|
|
}
|
|
|
|
fail:
|
|
close_streamfile(sf_cfg);
|
|
return 0;
|
|
}
|
|
|
|
/* .VAB - standard PS1 bank format */
|
|
VGMSTREAM* init_vgmstream_vab(STREAMFILE* sf) {
|
|
uint16_t programs, wave_num, pitch;
|
|
uint8_t center, shift, min_note, max_note;
|
|
off_t programs_off, tones_off, waves_off, entry_off, data_offset;
|
|
size_t data_size;
|
|
int target_subsong = sf->stream_index, is_vh = 0, program_num, tone_num = 0, total_subsongs,
|
|
note, fine, uselimits,
|
|
channels, loop_flag, loop_start = 0, loop_end = 0;
|
|
int i;
|
|
STREAMFILE* sf_data = NULL;
|
|
VGMSTREAM* vgmstream = NULL;
|
|
|
|
/* this format is intended for storing samples for sequenced music but
|
|
* some games use it for storing SFX as a hack */
|
|
|
|
/* checks */
|
|
if (!is_id32le(0x00, sf, "VABp"))
|
|
goto fail;
|
|
|
|
if (check_extensions(sf, "vh")) {
|
|
is_vh = 1;
|
|
sf_data = open_streamfile_by_ext(sf, "vb");
|
|
if (!sf_data) goto fail;
|
|
} else if (check_extensions(sf, "vab")) {
|
|
is_vh = 0;
|
|
sf_data = sf;
|
|
} else {
|
|
goto fail;
|
|
}
|
|
|
|
programs = read_u16le(0x12, sf);
|
|
//tones = read_u16le(0x14, sf);
|
|
//waves = read_u16le(0x16, sf);
|
|
|
|
programs_off = 0x20;
|
|
tones_off = programs_off + 128 * 0x10;
|
|
waves_off = tones_off + programs * 16 * 0x20;
|
|
|
|
if (target_subsong == 0) target_subsong = 1;
|
|
if (target_subsong < 0)
|
|
goto fail;
|
|
|
|
total_subsongs = 0;
|
|
program_num = -1;
|
|
for (i = 0; i < programs; i++) {
|
|
uint8_t program_tones;
|
|
int local_target;
|
|
|
|
local_target = target_subsong - total_subsongs - 1;
|
|
entry_off = programs_off + i * 0x10;
|
|
program_tones = read_u8(entry_off + 0x00, sf);
|
|
total_subsongs += program_tones;
|
|
|
|
if (local_target >= 0 && local_target < program_tones) {
|
|
program_num = i;
|
|
tone_num = local_target;
|
|
}
|
|
}
|
|
|
|
if (program_num == -1)
|
|
goto fail;
|
|
|
|
entry_off = tones_off + program_num * 16 * 0x20 + tone_num * 0x20;
|
|
center = read_u8(entry_off + 0x04, sf);
|
|
shift = read_u8(entry_off + 0x05, sf);
|
|
min_note = read_u8(entry_off + 0x06, sf);
|
|
max_note = read_u8(entry_off + 0x07, sf);
|
|
wave_num = read_u16le(entry_off + 0x16, sf);
|
|
|
|
if (read_vabcfg_file(sf, program_num, tone_num, ¬e, &fine, &uselimits)) {
|
|
if (uselimits)
|
|
note = VAB_CLAMP(note, min_note, max_note);
|
|
} else {
|
|
note = VAB_CLAMP(60, min_note, max_note);
|
|
fine = 0;
|
|
}
|
|
|
|
/* play default note */
|
|
pitch = SsPitchFromNote(note, fine, center, shift);
|
|
|
|
data_offset = is_vh ? 0x00 : (waves_off + 256 * 0x02);
|
|
for (i = 0; i < wave_num; i++) {
|
|
data_offset += read_u16le(waves_off + i * 0x02, sf) << 3;
|
|
}
|
|
|
|
data_size = read_u16le(waves_off + i * 0x02, sf) << 3;
|
|
|
|
if (data_size == 0 && center == 0 && shift == 0) {
|
|
// hack for empty sounds in Critical Depth
|
|
vgmstream = init_vgmstream_silence(1, 44100, 44100);
|
|
if (!vgmstream) goto fail;
|
|
|
|
vgmstream->meta_type = meta_VAB;
|
|
vgmstream->num_streams = total_subsongs;
|
|
snprintf(vgmstream->stream_name, STREAM_NAME_SIZE, "%02d/%02d (empty)", program_num, tone_num);
|
|
|
|
if (is_vh) close_streamfile(sf_data);
|
|
return vgmstream;
|
|
}
|
|
|
|
channels = 1;
|
|
loop_flag = ps_find_loop_offsets(sf_data, data_offset, data_size, channels, 0, &loop_start, &loop_end);
|
|
|
|
/* build the VGMSTREAM */
|
|
vgmstream = allocate_vgmstream(channels, loop_flag);
|
|
if (!vgmstream) goto fail;
|
|
|
|
vgmstream->meta_type = meta_VAB;
|
|
vgmstream->coding_type = coding_PSX;
|
|
vgmstream->layout_type = layout_none;
|
|
vgmstream->sample_rate = (pitch * 44100) / 4096; // FIXME: Maybe use actual pitching if implemented.
|
|
vgmstream->num_samples = ps_bytes_to_samples(data_size, channels);
|
|
vgmstream->loop_start_sample = loop_start;
|
|
vgmstream->loop_end_sample = loop_end;
|
|
vgmstream->stream_size = data_size;
|
|
vgmstream->num_streams = total_subsongs;
|
|
snprintf(vgmstream->stream_name, STREAM_NAME_SIZE, "%02d/%02d", program_num, tone_num);
|
|
|
|
if (!vgmstream_open_stream(vgmstream, sf_data, data_offset))
|
|
goto fail;
|
|
|
|
if (is_vh) close_streamfile(sf_data);
|
|
return vgmstream;
|
|
|
|
fail:
|
|
if (is_vh) close_streamfile(sf_data);
|
|
close_vgmstream(vgmstream);
|
|
return NULL;
|
|
}
|
|
|
|
/* Converts VAB note to PS1 pitch value (0-4096 where 4096 is 44100 Hz).
|
|
* Function reversed from PS1 SDK. */
|
|
static uint16_t _svm_ptable[] =
|
|
{
|
|
4096, 4110, 4125, 4140, 4155, 4170, 4185, 4200,
|
|
4216, 4231, 4246, 4261, 4277, 4292, 4308, 4323,
|
|
4339, 4355, 4371, 4386, 4402, 4418, 4434, 4450,
|
|
4466, 4482, 4499, 4515, 4531, 4548, 4564, 4581,
|
|
4597, 4614, 4630, 4647, 4664, 4681, 4698, 4715,
|
|
4732, 4749, 4766, 4783, 4801, 4818, 4835, 4853,
|
|
4870, 4888, 4906, 4924, 4941, 4959, 4977, 4995,
|
|
5013, 5031, 5050, 5068, 5086, 5105, 5123, 5142,
|
|
5160, 5179, 5198, 5216, 5235, 5254, 5273, 5292,
|
|
5311, 5331, 5350, 5369, 5389, 5408, 5428, 5447,
|
|
5467, 5487, 5507, 5527, 5547, 5567, 5587, 5607,
|
|
5627, 5648, 5668, 5688, 5709, 5730, 5750, 5771,
|
|
5792, 5813, 5834, 5855, 5876, 5898, 5919, 5940,
|
|
5962, 5983, 6005, 6027, 6049, 6070, 6092, 6114,
|
|
6137, 6159, 6181, 6203, 6226, 6248, 6271, 6294,
|
|
6316, 6339, 6362, 6385, 6408, 6431, 6455, 6478,
|
|
6501, 6525, 6549, 6572, 6596, 6620, 6644, 6668,
|
|
6692, 6716, 6741, 6765, 6789, 6814, 6839, 6863,
|
|
6888, 6913, 6938, 6963, 6988, 7014, 7039, 7064,
|
|
7090, 7116, 7141, 7167, 7193, 7219, 7245, 7271,
|
|
7298, 7324, 7351, 7377, 7404, 7431, 7458, 7485,
|
|
7512, 7539, 7566, 7593, 7621, 7648, 7676, 7704,
|
|
7732, 7760, 7788, 7816, 7844, 7873, 7901, 7930,
|
|
7958, 7987, 8016, 8045, 8074, 8103, 8133, 8162,
|
|
8192
|
|
};
|
|
|
|
static uint16_t SsPitchFromNote(int16_t note, int16_t fine, uint8_t center, uint8_t shift) {
|
|
|
|
uint32_t pitch;
|
|
int16_t calc, type;
|
|
int32_t add, sfine;//, ret;
|
|
|
|
sfine = fine + shift;
|
|
if (sfine < 0) sfine += 7;
|
|
sfine >>= 3;
|
|
|
|
add = 0;
|
|
if (sfine > 15) {
|
|
add = 1;
|
|
sfine -= 16;
|
|
}
|
|
|
|
calc = add + (note - (center - 60));//((center + 60) - note) + add;
|
|
pitch = _svm_ptable[16 * (calc % 12) + (int16_t)sfine];
|
|
type = calc / 12 - 5;
|
|
|
|
// regular shift
|
|
if (type > 0) return pitch << type;
|
|
// negative shift
|
|
if (type < 0) return pitch >> -type;
|
|
|
|
return pitch;
|
|
}
|