Merge pull request CPJKU#353 from CPJKU/fluidsynth

Export wav using fluidsynth

Author: manoskary

.gitignore

@@ -152,3 +152,6 @@ static
 
 # phdocs
 phdocs.txt
+
+# fluidsynth default soundfont
+partitura/assets/MuseScore_General.sf*

partitura/__init__.py

@@ -22,7 +22,7 @@
 from .io.importnakamura import load_nakamuramatch, load_nakamuracorresp
 from .io.importparangonada import load_parangonada_csv
 from .io.exportparangonada import save_parangonada_csv, save_csv_for_parangonada
-from .io.exportaudio import save_wav
+from .io.exportaudio import save_wav, save_wav_fluidsynth
 from .io.exportmei import save_mei
 from .display import render
 from . import musicanalysis
@@ -61,5 +61,7 @@
     "load_nakamuracorresp",
     "load_parangonada_csv",
     "save_parangonada_csv",
+    "save_wav",
+    "save_wav_fluidsynth",
     "render",
 ]

partitura/io/exportaudio.py

@@ -1,8 +1,7 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
-This module contains methods to synthesize Partitura object to wav using
-additive synthesis
+This module contains methods to synthesize Partitura object to wav.
 """
 from typing import Union, Optional, Callable, Dict, Any
 import numpy as np
@@ -13,10 +12,18 @@
 from partitura.performance import PerformanceLike
 
 from partitura.utils.synth import synthesize, SAMPLE_RATE, A4
+from partitura.utils.fluidsynth import (
+    synthesize_fluidsynth,
+    DEFAULT_SOUNDFONT,
+    HAS_FLUIDSYNTH,
+)
 
 from partitura.utils.misc import PathLike
 
-__all__ = ["save_wav"]
+__all__ = [
+    "save_wav",
+    "save_wav_fluidsynth",
+]
 
 
 def save_wav(
@@ -89,8 +96,76 @@ def save_wav(
         bpm=bpm,
     )
 
+    if out is not None:
+        # convert to 16bit integers (save as PCM 16 bit)
+        # (some DAWs cannot load audio files that are float64,
+        # e.g., Logic)
+        amplitude = np.iinfo(np.int16).max
+        if abs(audio_signal).max() <= 1:
+            # convert to 16bit integers (save as PCM 16 bit)
+            amplitude = np.iinfo(np.int16).max
+            audio_signal *= amplitude
+        wavfile.write(out, samplerate, audio_signal.astype(np.int16))
+
+    else:
+        return audio_signal
+
+
+def save_wav_fluidsynth(
+    input_data: Union[ScoreLike, PerformanceLike, np.ndarray],
+    out: Optional[PathLike] = None,
+    samplerate: int = SAMPLE_RATE,
+    soundfont: PathLike = DEFAULT_SOUNDFONT,
+    bpm: Union[float, np.ndarray, Callable] = 60,
+) -> Optional[np.ndarray]:
+    """
+    Export a score (a `Score`, `Part`, `PartGroup` or list of `Part` instances),
+    a performance (`Performance`, `PerformedPart` or list of `PerformedPart` instances)
+    as a WAV file using fluidsynth
+
+    Parameters
+    ----------
+    input_data : ScoreLike, PerformanceLike or np.ndarray
+        A partitura object with note information.
+    out : PathLike or None
+        Path of the output Wave file. If None, the method outputs
+        the audio signal as an array (see `audio_signal` below).
+    samplerate: int
+        The sample rate of the audio file in Hz. The default is 44100Hz.
+    soundfont : PathLike
+        Path to the soundfont in SF2/SF3 format for fluidsynth.
+    bpm : float, np.ndarray, callable
+        The bpm to render the output (if the input is a score-like object).
+        See `partitura.utils.music.performance_notearray_from_score_notearray`
+        for more information on this parameter.
+
+    Returns
+    -------
+    audio_signal : np.ndarray
+       Audio signal as a 1D array. Only returned if `out` is None.
+    """
+
+    if not HAS_FLUIDSYNTH:
+        raise ImportError("Fluidsynth is not installed!")
+
+    audio_signal = synthesize_fluidsynth(
+        note_info=input_data,
+        samplerate=samplerate,
+        soundfont=soundfont,
+        bpm=bpm,
+    )
+
     if out is not None:
         # Write audio signal
-        wavfile.write(out, samplerate, audio_signal)
+
+        # convert to 16bit integers (save as PCM 16 bit)
+        # (some DAWs cannot load audio files that are float64,
+        # e.g., Logic)
+        amplitude = np.iinfo(np.int16).max
+        if abs(audio_signal).max() <= 1:
+            # convert to 16bit integers (save as PCM 16 bit)
+            amplitude = np.iinfo(np.int16).max
+            audio_signal *= amplitude
+        wavfile.write(out, samplerate, audio_signal.astype(np.int16))
     else:
         return audio_signal

partitura/io/exportmatch.py

@@ -395,7 +395,7 @@ def matchfile_from_alignment(
             onset=onset,
             offset=offset,
             velocity=pnote["velocity"],
-            channel=pnote.get("channel", 1),
+            channel=pnote.get("channel", 0),
             track=pnote.get("track", 0),
         )
         pnote_sort_info[pnote["id"]] = (

partitura/io/importmatch.py

@@ -394,7 +394,7 @@ def performed_part_from_match(
                 sound_off=midi_ticks_to_seconds(note.Offset, mpq, ppq),
                 velocity=note.Velocity,
                 track=getattr(note, "Track", 0),
-                channel=getattr(note, "Channel", 1),
+                channel=getattr(note, "Channel", 0),
             )
         )
     # Set first note_on to zero in ticks and seconds if first_note_at_zero

partitura/musicanalysis/performance_codec.py

@@ -819,12 +819,13 @@ def get_matched_notes(spart_note_array, ppart_note_array, alignment):
             else:
                 p_id = al["performance_id"]
 
-            p_idx = int(np.where(ppart_note_array["id"] == p_id)[0])
+            p_idx = np.where(ppart_note_array["id"] == p_id)[0]
 
             s_idx = np.where(spart_note_array["id"] == al["score_id"])[0]
 
-            if len(s_idx) > 0:
+            if len(s_idx) > 0 and len(p_idx) > 0:
                 s_idx = int(s_idx)
+                p_idx = int(p_idx)
                 matched_idxs.append((s_idx, p_idx))
 
     return np.array(matched_idxs)