Support 8bit wav files in adpcmtool and nsstool

Automatic conversion of wav files into adpcm now supports 8bit
sample rate, signed or unsigned.

Author: dciabrin

tools/adpcmtool.py

@@ -141,10 +141,23 @@ def _decode_sample(self, adpcm4):
 
         return decoded_sample12
 
-    def encode(self, pcm16s):
-        self.reset()
-        # ADPCM-A encodes 12-bits samples, so downscale the input first
+    def encode_u8(self, pcm8s):
+        # ADPCM-A expects 12-bits input samples
+        pcm12s = [(s-128) << 4 for s in pcm8s]
+        return self.encode(pcm12s)
+
+    def encode_s8(self, pcm8s):
+        # ADPCM-A expects 12-bits input samples
+        pcm12s = [s << 4 for s in pcm8s]
+        return self.encode(pcm12s)
+
+    def encode_s16(self, pcm16s):
+        # ADPCM-A expects 12-bits input samples
         pcm12s = [s >> 4 for s in pcm16s]
+        return self.encode(pcm12s)
+
+    def encode(self, pcm12s):
+        self.reset()
         # YM2610 only plays back multiples of 256 bytes
         # (512 adpcm samples). If the input is not aligned, add some padding
         ceil = ((len(pcm12s)+511)//512)*512;
@@ -241,6 +254,19 @@ def _decode_sample(self, adpcm4):
 
         return decoded_sample16
 
+    def encode_u8(self, pcm8s):
+        # ADPCM-B expects 16-bits input samples
+        pcm16s = [(s-128) << 8 for s in pcm8s]
+        return self.encode(pcm16s)
+
+    def encode_s8(self, pcm8s):
+        # ADPCM-B expects 16-bits input samples
+        pcm16s = [s << 8 for s in pcm8s]
+        return self.encode(pcm16s)
+
+    def encode_s16(self, pcm16s):
+        return self.encode(pcm16s)
+
     def encode(self, pcm16s):
         self.reset()
         # YM2610 only plays back multiples of 256 bytes
@@ -264,8 +290,8 @@ def encode(input, output, codec):
         # input sanity checks
         if w.getnchannels() > 1:
             error("Only mono WAV file is supported")
-        if w.getsampwidth() != 2:
-            error("Only 16bits per sample is supported")
+        if w.getsampwidth() not in [1, 2]:
+            error("Only 8bits or 16bits per sample is supported")
         if w.getcomptype() != 'NONE':
             error("Only uncompressed WAV file is supported")
         wavrate = w.getframerate()
@@ -286,10 +312,14 @@ def encode(input, output, codec):
         w.close()
 
     insize = len(rawdata)
-    samples = struct.unpack('<%dh' % (insize >> 1), rawdata)
-    dbg("Input is %s bytes long, or %d PCM samples" % (insize, insize >> 1))
-    # encode input 16-bits samples into ADPCM-A or ADPCM-B 4-bits samples
-    adpcms = codec.encode(list(samples))
+    dbg("Input is %s bytes long, or %d PCM samples" % (insize, insize/w.getsampwidth()))
+    # encode input samples into ADPCM-A or ADPCM-B 4-bits samples
+    if w.getsampwidth() == 1:
+        samples = struct.unpack('<%dB' % (insize), rawdata)
+        adpcms = codec.encode_u8(list(samples))
+    else:
+        samples = struct.unpack('<%dh' % (insize>>1), rawdata)
+        adpcms = codec.encode_s16(list(samples))
     # pack the resulting adpcm samples into bytes (2 samples per byte)
     adpcms_packed = [(adpcms[i] << 4 | adpcms[i+1]) for i in range(0, len(adpcms), 2)]
     outsize = len(adpcms_packed)

tools/furtool.py

@@ -290,7 +290,14 @@ class adpcm_b_sample:
 
 
 @dataclass
-class pcm_sample:
+class pcm8_sample:
+    name: str = ""
+    data: bytearray = field(default=b"", repr=False)
+    frequency: int = 0
+    loop: bool = False
+
+@dataclass
+class pcm16_sample:
     name: str = ""
     data: bytearray = field(default=b"", repr=False)
     frequency: int = 0
@@ -564,7 +571,7 @@ def compile_macro_sequence(keys, blocks, loadbits):
 
 
 def get_sample_format(smp, sample, itype):
-    if isinstance(smp[sample],pcm_sample):
+    if type(smp[sample]) in [pcm8_sample, pcm16_sample]:
         # the sample is encoded in PCM, so it has to be converted
         # to be played back on the hardware.
         warning("sample '%s' is encoded in PCM, converting to ADPCM-%s"%\
@@ -677,6 +684,9 @@ def read_sample(prefix, bs, sample_idx):
     elif stype == 16: # PCM16 (requires conversion to ADPCM)
         data_bytes = adpcm_samples * 2
         data_padding = 0  # adpcmtool codecs automatically adds padding
+    elif stype == 8: # PCM8 (requires conversion to ADPCM)
+        data_bytes = adpcm_samples
+        data_padding = 0  # adpcmtool codecs automatically adds padding
     else:
         error("sample '%s' is of unsupported type: %d"%(str(name), stype))
     bs.u1()  # unused loop direction
@@ -688,17 +698,24 @@ def read_sample(prefix, bs, sample_idx):
     insname = "%s_%02x_%s"%(prefix, sample_idx, re.sub(r"\W|^(?=\d)", "_", name).lower())
     ins = {5: adpcm_a_sample,
            6: adpcm_b_sample,
-           16: pcm_sample}[stype](insname, data)
+           8: pcm8_sample,
+           16: pcm16_sample}[stype](insname, data)
     ins.loop = loop_start != -1 and loop_end != -1
     ins.frequency = c4_freq
+
     return ins
 
 
 def convert_sample(pcm_sample, totype):
     codec = {37: ym2610_adpcma,
              38: ym2610_adpcmb}[totype]()
-    pcm16s = unpack('<%dh' % (len(pcm_sample.data)>>1), pcm_sample.data)
-    adpcms=codec.encode(pcm16s)
+    if isinstance(pcm_sample, pcm8_sample):
+        # NOTE: PCM8 seems to always be signed in Furnace
+        pcm8s = unpack('<%db' % (len(pcm_sample.data)), pcm_sample.data)
+        adpcms=codec.encode_s8(pcm8s)
+    else:
+        pcm16s = unpack('<%dh' % (len(pcm_sample.data)>>1), pcm_sample.data)
+        adpcms=codec.encode_s16(pcm16s)
     adpcms_packed = [(adpcms[i] << 4 | adpcms[i+1]) for i in range(0, len(adpcms), 2)]
     # convert sample to the right class
     converted = {37: adpcm_a_sample,
@@ -723,7 +740,7 @@ def check_for_unused_samples(smp, bs):
     # module might have unused samples, leave them in the output
     # if these are pcm_samples, convert them to adpcm_a to avoid errors
     for i,s in enumerate(smp):
-        if isinstance(s, pcm_sample):
+        if type(s) in [pcm8_sample, pcm16_sample]:
             smp[i] = convert_sample(s, 37)
 
 def asm_fm_instrument(ins, fd):

tools/vromtool.py

@@ -135,14 +135,21 @@ def convert_to_adpcm(sample, path):
     try:
         w = wave.open(path, 'rb')
         assert w.getnchannels() == 1, "Only mono WAV file is supported"
-        assert w.getsampwidth() == 2, "Only 16bits per sample is supported"
         assert w.getcomptype() == 'NONE', "Only uncompressed WAV file is supported"
         nframes = w.getnframes()
         data = w.readframes(nframes)
     except Exception as e:
         error("Could not convert sample '%s' to ADPCM: %s"%(path, e))
-    pcm16s = unpack('<%dh' % (len(data)>>1), data)
-    adpcms=codec.encode(pcm16s)
+
+    if w.getsampwidth() == 1:
+        # WAV file format, 8bits is always unsigned
+        pcm8s = unpack('<%dB' % (len(data)), data)
+        adpcms=codec.encode_u8(pcm8s)
+    else:
+        # WAV file format, 16bits is always signed
+        pcm16s = unpack('<%dh' % (len(data)>>1), data)
+        adpcms=codec.encode_s16(pcm16s)
+
     adpcms_packed = [(adpcms[i] << 4 | adpcms[i+1]) for i in range(0, len(adpcms), 2)]
     return bytes(adpcms_packed)