From fbd8e94e4181a097500ee06b899f617455ffa6d7 Mon Sep 17 00:00:00 2001 From: bnnm Date: Sat, 24 Mar 2018 12:08:16 +0100 Subject: [PATCH] Add Yamaha/NXAP ADPCM decoder --- src/coding/aica_decoder.c | 135 ++++++++++++++++++++++++++++++++------ src/coding/coding.h | 5 +- src/formats.c | 3 + src/vgmstream.c | 21 ++++++ src/vgmstream.h | 2 + 5 files changed, 145 insertions(+), 21 deletions(-) diff --git a/src/coding/aica_decoder.c b/src/coding/aica_decoder.c index 556f1986..a87506ea 100644 --- a/src/coding/aica_decoder.c +++ b/src/coding/aica_decoder.c @@ -3,44 +3,39 @@ /* fixed point (.8) amount to scale the current step size by */ /* part of the same series as used in MS ADPCM "ADPCMTable" */ -static const unsigned int scale_step[16] = -{ +static const unsigned int scale_step[16] = { 230, 230, 230, 230, 307, 409, 512, 614, 230, 230, 230, 230, 307, 409, 512, 614 }; /* expand an unsigned four bit delta to a wider signed range */ -static const int scale_delta[16] = -{ +static const int scale_delta[16] = { 1, 3, 5, 7, 9, 11, 13, 15, -1, -3, -5, -7, -9,-11,-13,-15 }; -/* Yamaha AICA ADPCM (as seen in Dreamcast) */ +/* Yamaha AICA ADPCM, as seen in Dreamcast. Possibly like RIFF codec 0x20 or used in older arcade sound chips. */ void decode_aica(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do) { - int i; - int32_t sample_count; + int i, sample_count; + int32_t hist1 = stream->adpcm_history1_16; - uint32_t step_size = stream->adpcm_step_index; + int step_size = stream->adpcm_step_index; for (i=first_sample,sample_count=0; ioffset+i/2,stream->streamfile) >> - (i&1?4:0) - )&0xf; + int sample_nibble, sample_decoded, sample_delta; + off_t byte_offset = (stream->offset) + i/2; + int nibble_shift = (i&1?4:0); /* low nibble first */ - int32_t sample_delta = (int32_t)step_size * scale_delta[sample_nibble]; - int32_t new_sample; - - new_sample = hist1 + sample_delta/8; - - outbuf[sample_count] = clamp16(new_sample); + /* Yamaha/AICA expand, but same result as IMA's (((delta * 2 + 1) * step) >> 3) */ + sample_nibble = ((read_8bit(byte_offset,stream->streamfile) >> nibble_shift))&0xf; + sample_delta = (step_size * scale_delta[sample_nibble]) / 8; + sample_decoded = hist1 + sample_delta; + outbuf[sample_count] = clamp16(sample_decoded); hist1 = outbuf[sample_count]; - step_size = (step_size * scale_step[sample_nibble])/0x100; + step_size = (step_size * scale_step[sample_nibble]) >> 8; if (step_size < 0x7f) step_size = 0x7f; if (step_size > 0x6000) step_size = 0x6000; } @@ -48,3 +43,103 @@ void decode_aica(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, stream->adpcm_history1_16 = hist1; stream->adpcm_step_index = step_size; } + +/* Yamaha ADPCM, in headered frames like MS-IMA. Possibly originated from Yamaha's SMAF tools + * (Windows ACM encoder/decoder was given in their site). Some info from Rockbox's yamaha_adpcm.c */ +void decode_yamaha(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do, int channel) { + int i, sample_count, num_frame; + int32_t hist1 = stream->adpcm_history1_32; + int step_size = stream->adpcm_step_index; + + /* external interleave */ + int block_samples = (0x40 - 0x04*channelspacing) * 2 / channelspacing; + num_frame = first_sample / block_samples; + first_sample = first_sample % block_samples; + + /* header (hist+step) */ + if (first_sample == 0) { + off_t header_offset = stream->offset + 0x40*num_frame + 0x04*channel; + + hist1 = read_16bitLE(header_offset+0x00,stream->streamfile); + step_size = read_16bitLE(header_offset+0x02,stream->streamfile); + if (step_size < 0x7f) step_size = 0x7f; + if (step_size > 0x6000) step_size = 0x6000; + } + + /* decode nibbles (layout: varies) */ + for (i=first_sample,sample_count=0; ioffset + 0x40*num_frame + 0x04*channelspacing) + i : /* stereo: one nibble per channel */ + (stream->offset + 0x40*num_frame + 0x04*channelspacing) + i/2; /* mono: consecutive nibbles */ + int nibble_shift = (channelspacing == 2) ? + (!(channel&1) ? 0:4) : + (!(i&1) ? 0:4); /* even = low, odd = high */ + + /* Yamaha/AICA expand, but same result as IMA's (((delta * 2 + 1) * step) >> 3) */ + sample_nibble = (read_8bit(byte_offset,stream->streamfile) >> nibble_shift)&0xf; + sample_delta = (step_size * scale_delta[sample_nibble]) / 8; + sample_decoded = hist1 + sample_delta; + + outbuf[sample_count] = clamp16(sample_decoded); + hist1 = outbuf[sample_count]; + + step_size = (step_size * scale_step[sample_nibble]) >> 8; + if (step_size < 0x7f) step_size = 0x7f; + if (step_size > 0x6000) step_size = 0x6000; + } + + stream->adpcm_history1_32 = hist1; + stream->adpcm_step_index = step_size; +} + +/* Yamaha ADPCM with unknown expand variation (noisy), step size is double of normal Yamaha? */ +void decode_yamaha_nxap(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do) { + int i, sample_count, num_frame; + int32_t hist1 = stream->adpcm_history1_32; + int step_size = stream->adpcm_step_index; + + /* external interleave */ + int block_samples = (0x40 - 0x4) * 2; + num_frame = first_sample / block_samples; + first_sample = first_sample % block_samples; + + /* header (hist+step) */ + if (first_sample == 0) { + off_t header_offset = stream->offset + 0x40*num_frame; + + hist1 = read_16bitLE(header_offset+0x00,stream->streamfile); + step_size = read_16bitLE(header_offset+0x02,stream->streamfile); + if (step_size < 0x7f) step_size = 0x7f; + if (step_size > 0x6000) step_size = 0x6000; + } + + /* decode nibbles (layout: all nibbles from one channel) */ + for (i=first_sample,sample_count=0; ioffset + 0x40*num_frame + 0x04) + i/2; + int nibble_shift = (i&1?4:0); /* low nibble first */ + + /* Yamaha expand? */ + sample_nibble = (read_8bit(byte_offset,stream->streamfile) >> nibble_shift)&0xf; + sample_delta = (step_size * scale_delta[sample_nibble] / 4) / 8; //todo not ok + sample_decoded = hist1 + sample_delta; + + outbuf[sample_count] = clamp16(sample_decoded); + hist1 = outbuf[sample_count]; + + step_size = (step_size * scale_step[sample_nibble]) >> 8; + if (step_size < 0x7f) step_size = 0x7f; + if (step_size > 0x6000) step_size = 0x6000; + } + + stream->adpcm_history1_32 = hist1; + stream->adpcm_step_index = step_size; +} + +size_t yamaha_bytes_to_samples(size_t bytes, int channels) { + int block_align = 0x40; + + return (bytes / block_align) * (block_align - 0x04*channels) * 2 / channels + + ((bytes % block_align) ? ((bytes % block_align) - 0x04*channels) * 2 / channels : 0); +} diff --git a/src/coding/coding.h b/src/coding/coding.h index 028c75ff..4485c515 100644 --- a/src/coding/coding.h +++ b/src/coding/coding.h @@ -117,8 +117,11 @@ void decode_msadpcm_stereo(VGMSTREAM * vgmstream, sample * outbuf, int32_t first void decode_msadpcm_mono(VGMSTREAM * vgmstream, sample * outbuf, int32_t first_sample, int32_t samples_to_do); long msadpcm_bytes_to_samples(long bytes, int block_size, int channels); -/* aica_decoder */ +/* yamaha_decoder */ void decode_aica(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do); +void decode_yamaha(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do, int channel); +void decode_yamaha_nxap(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do); +size_t yamaha_bytes_to_samples(size_t bytes, int channels); /* nds_procyon_decoder */ void decode_nds_procyon(VGMSTREAMCHANNEL * stream, sample * outbuf, int channelspacing, int32_t first_sample, int32_t samples_to_do); diff --git a/src/formats.c b/src/formats.c index 4b516075..2b3f7ee5 100644 --- a/src/formats.c +++ b/src/formats.c @@ -498,6 +498,8 @@ static const coding_info coding_info_list[] = { {coding_MSADPCM, "Microsoft 4-bit ADPCM"}, {coding_WS, "Westwood Studios VBR ADPCM"}, {coding_AICA, "Yamaha AICA 4-bit ADPCM"}, + {coding_YAMAHA, "Yamaha 4-bit ADPCM"}, + {coding_YAMAHA_NXAP, "Yamaha NXAP 4-bit ADPCM"}, {coding_NDS_PROCYON, "Procyon Studio Digital Sound Elements NDS 4-bit APDCM"}, {coding_L5_555, "Level-5 0x555 4-bit ADPCM"}, {coding_SASSC, "Activision / EXAKT SASSC 8-bit DPCM"}, @@ -965,6 +967,7 @@ static const meta_info meta_info_list[] = { {meta_WAVE, "EngineBlack .WAVE header"}, {meta_WAVE_segmented, "EngineBlack .WAVE header (segmented)"}, {meta_SMV, "Cho Aniki Zero .SMV header"}, + {meta_NXAP, "Nex NXAP header"}, #ifdef VGM_USE_MP4V2 {meta_MP4, "AAC header"}, diff --git a/src/vgmstream.c b/src/vgmstream.c index 4ae505d7..68f70c26 100644 --- a/src/vgmstream.c +++ b/src/vgmstream.c @@ -1048,6 +1048,10 @@ int get_vgmstream_samples_per_frame(VGMSTREAM * vgmstream) { return vgmstream->ws_output_size; case coding_AICA: return 2; + case coding_YAMAHA: + return (0x40-0x04*vgmstream->channels) * 2 / vgmstream->channels; + case coding_YAMAHA_NXAP: + return (0x40-0x04) * 2; case coding_NDS_PROCYON: return 30; case coding_L5_555: @@ -1210,6 +1214,9 @@ int get_vgmstream_frame_size(VGMSTREAM * vgmstream) { return vgmstream->current_block_size; case coding_AICA: return 0x01; + case coding_YAMAHA: + case coding_YAMAHA_NXAP: + return 0x40; case coding_NDS_PROCYON: return 0x10; case coding_L5_555: @@ -1808,6 +1815,20 @@ void decode_vgmstream(VGMSTREAM * vgmstream, int samples_written, int samples_to samples_to_do); } break; + case coding_YAMAHA: + for (chan=0;chanchannels;chan++) { + decode_yamaha(&vgmstream->ch[chan],buffer+samples_written*vgmstream->channels+chan, + vgmstream->channels,vgmstream->samples_into_block, + samples_to_do, chan); + } + break; + case coding_YAMAHA_NXAP: + for (chan=0;chanchannels;chan++) { + decode_yamaha_nxap(&vgmstream->ch[chan],buffer+samples_written*vgmstream->channels+chan, + vgmstream->channels,vgmstream->samples_into_block, + samples_to_do); + } + break; case coding_NDS_PROCYON: for (chan=0;chanchannels;chan++) { decode_nds_procyon(&vgmstream->ch[chan],buffer+samples_written*vgmstream->channels+chan, diff --git a/src/vgmstream.h b/src/vgmstream.h index 7dde8b39..33365e15 100644 --- a/src/vgmstream.h +++ b/src/vgmstream.h @@ -146,6 +146,8 @@ typedef enum { coding_MSADPCM, /* Microsoft ADPCM */ coding_WS, /* Westwood Studios VBR ADPCM */ coding_AICA, /* Yamaha AICA ADPCM */ + coding_YAMAHA, /* Yamaha ADPCM */ + coding_YAMAHA_NXAP, /* Yamaha ADPCM (NXAP variation) */ coding_NDS_PROCYON, /* Procyon Studio ADPCM */ coding_L5_555, /* Level-5 0x555 ADPCM */ coding_SASSC, /* Activision EXAKT SASSC DPCM */