add godot instrument sample data support

Author: anokta

platforms/godot/godot.cpp

@@ -16,6 +16,7 @@ void initialize_barelymusiciangodot(ModuleInitializationLevel level) {
   ClassDB::register_internal_class<barely::godot::BarelyEngineNode>();
   ClassDB::register_class<barely::godot::BarelyAudioStream>();
   ClassDB::register_class<barely::godot::BarelyEngine>();
+  ClassDB::register_class<barely::godot::BarelySliceResource>();
   ClassDB::register_class<barely::godot::BarelyInstrument>();
   ::godot::Engine::get_singleton()->register_singleton("BarelyEngine",
                                                        memnew(barely::godot::BarelyEngine));

platforms/godot/instrument.cpp

@@ -3,16 +3,25 @@
 #include <barelymusician.h>
 
 #include "godot/engine.h"
+#include "godot_cpp/classes/audio_frame.hpp"
+#include "godot_cpp/classes/audio_stream_playback.hpp"
+#include "godot_cpp/classes/audio_stream_wav.hpp"
 #include "godot_cpp/core/class_db.hpp"
 #include "godot_cpp/core/object.hpp"
 
 namespace barely::godot {
 
+using ::godot::AudioFrame;
+using ::godot::AudioStreamPlayback;
+using ::godot::AudioStreamWAV;
+using ::godot::Callable;
 using ::godot::ClassDB;
 using ::godot::D_METHOD;
 using ::godot::MethodInfo;
+using ::godot::Object;
 using ::godot::PropertyHint;
 using ::godot::PropertyInfo;
+using ::godot::Ref;
 using ::godot::StringName;
 using ::godot::Variant;
 
@@ -23,6 +32,39 @@ using ::godot::Variant;
   ClassDB::bind_method(D_METHOD(BARELY_STR(set_##name), #name), &BarelyInstrument::set_##name); \
   ClassDB::bind_method(D_METHOD(BARELY_STR(get_##name)), &BarelyInstrument::get_##name);
 #define BARELY_SET_DEFAULT_GODOT_INSTRUMENT_CONTROL(Name, name, type, default) set_##name(default);
+#define BARELY_SET_GODOT_INSTRUMENT_CONTROL(Name, name, type, default) set_##name(name##_);
+
+void BarelySliceResource::set_root_pitch(float root_pitch) {
+  if (root_pitch_ != root_pitch) {
+    root_pitch_ = root_pitch;
+    emit_signal("slice_changed");
+  }
+}
+
+void BarelySliceResource::set_stream(const Ref<AudioStreamWAV>& stream) {
+  if (stream_ != stream) {
+    stream_ = stream;
+    emit_signal("slice_changed");
+  }
+}
+
+void BarelySliceResource::_bind_methods() {
+  ClassDB::bind_method(D_METHOD("set_stream", "stream"), &BarelySliceResource::set_stream);
+  ClassDB::bind_method(D_METHOD("get_stream"), &BarelySliceResource::get_stream);
+
+  ClassDB::bind_method(D_METHOD("set_root_pitch", "root_pitch"),
+                       &BarelySliceResource::set_root_pitch);
+  ClassDB::bind_method(D_METHOD("get_root_pitch"), &BarelySliceResource::get_root_pitch);
+
+  ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "stream", PropertyHint::PROPERTY_HINT_RESOURCE_TYPE,
+                            "AudioStreamWAV"),
+               "set_stream", "get_stream");
+  ADD_PROPERTY(
+      PropertyInfo(Variant::FLOAT, "root_pitch", PropertyHint::PROPERTY_HINT_RANGE, "-4,4,0.01"),
+      "set_root_pitch", "get_root_pitch");
+
+  ADD_SIGNAL(MethodInfo("slice_changed"));
+}
 
 BarelyInstrument::BarelyInstrument() {
   ::BarelyEngine* engine = BarelyEngine::get_singleton()->get();
@@ -65,12 +107,27 @@ bool BarelyInstrument::is_note_on(float pitch) const {
   return is_note_on;
 }
 
+void BarelyInstrument::set_slice(const Ref<BarelySliceResource>& slice) {
+  if (slice_.is_valid()) {
+    slice_->disconnect("slice_changed", Callable(this, "_on_slice_changed"));
+  }
+  slice_ = slice;
+  if (slice_.is_valid()) {
+    slice_->connect("slice_changed", Callable(this, "_on_slice_changed"), Object::CONNECT_DEFERRED);
+  }
+  _on_slice_changed();
+}
+
 void BarelyInstrument::_bind_methods() {
   ClassDB::bind_method(D_METHOD("set_all_notes_off"), &BarelyInstrument::set_all_notes_off);
   ClassDB::bind_method(D_METHOD("set_note_off", "pitch"), &BarelyInstrument::set_note_off);
   ClassDB::bind_method(D_METHOD("set_note_on", "pitch", "gain", "pitch_shift"),
                        &BarelyInstrument::set_note_on, DEFVAL(1.0f), DEFVAL(0.0f));
   ClassDB::bind_method(D_METHOD("is_note_on", "pitch"), &BarelyInstrument::is_note_on);
+  ClassDB::bind_method(D_METHOD("set_slice", "slice"), &BarelyInstrument::set_slice);
+  ClassDB::bind_method(D_METHOD("get_slice"), &BarelyInstrument::get_slice);
+
+  ClassDB::bind_method(D_METHOD("_on_slice_changed"), &BarelyInstrument::_on_slice_changed);
 
   BARELY_BIND_GODOT_ENUM_VALUE(ArpMode, None, "ARP_MODE_NONE");
   BARELY_BIND_GODOT_ENUM_VALUE(ArpMode, Up, "ARP_MODE_UP");
@@ -109,9 +166,14 @@ void BarelyInstrument::_bind_methods() {
   ADD_PROPERTY(
       PropertyInfo(Variant::FLOAT, "release", PropertyHint::PROPERTY_HINT_RANGE, "0,8,0.01"),
       "set_release", "get_release");
+
   ADD_PROPERTY(PropertyInfo(Variant::INT, "slice_mode", PropertyHint::PROPERTY_HINT_ENUM,
                             "Sustain,Loop,Once"),
                "set_slice_mode", "get_slice_mode");
+  ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "slice", PropertyHint::PROPERTY_HINT_RESOURCE_TYPE,
+                            "BarelySliceResource"),
+               "set_slice", "get_slice");
+
   ADD_PROPERTY(
       PropertyInfo(Variant::FLOAT, "osc_mix", PropertyHint::PROPERTY_HINT_RANGE, "0,1,0.01"),
       "set_osc_mix", "get_osc_mix");
@@ -190,4 +252,72 @@ void BarelyInstrument::_handle_note_event(BarelyEventType type, float pitch) {
   }
 }
 
+void BarelyInstrument::_on_slice_changed() {
+  if (!slice_buffer_.empty()) {
+    BarelyInstrument_SetSampleData(BarelyEngine::get_singleton()->get(), instrument_id_, nullptr,
+                                   0);
+    slice_buffer_.clear();  // TODO(#181): This is not thread safe although should be ok for now.
+  }
+
+  if (slice_.is_null()) {
+    return;
+  }
+
+  Ref<AudioStreamWAV> stream = slice_->get_stream();
+  if (stream.is_null()) {
+    return;
+  }
+
+  const auto& data = stream->get_data();
+  const uint8_t* bytes = data.ptr();
+  const int byte_count = data.size();
+
+  const auto format = stream->get_format();
+  const int32_t sample_rate = stream->get_mix_rate();
+
+  if (format == AudioStreamWAV::FORMAT_16_BITS) {
+    const int16_t* pcm_bytes = (int16_t*)bytes;
+    const int count = byte_count / sizeof(int16_t);
+    slice_buffer_.resize(count);
+    for (int i = 0; i < count; ++i) {
+      static constexpr float kMaxSample = 32768.0f;
+      slice_buffer_[i] = pcm_bytes[i] / kMaxSample;
+    }
+  } else if (format == AudioStreamWAV::FORMAT_8_BITS) {
+    slice_buffer_.resize(byte_count);
+    for (int i = 0; i < byte_count; ++i) {
+      static constexpr float kMaxSample = 128.0f;
+      slice_buffer_[i] = (bytes[i] - 128) / kMaxSample;
+    }
+  } else if (format == AudioStreamWAV::FORMAT_QOA) {
+    Ref<AudioStreamPlayback> playback = stream->instantiate_playback();
+    if (!playback.is_valid()) {
+      return;
+    }
+    playback->start(0.0);
+
+    const float length = stream->get_length();
+    slice_buffer_.reserve(static_cast<int32_t>(length * static_cast<float>(sample_rate)));
+
+    static constexpr int kQoaFrameCount = 512;
+    while (playback->is_playing()) {
+      const auto frames = playback->mix_audio(1.0f, kQoaFrameCount);
+      if (frames.size() == 0) {
+        break;
+      }
+      for (int i = 0; i < static_cast<int>(frames.size()); ++i) {
+        const auto& frame = frames.ptr()[i];
+        slice_buffer_.push_back(0.5f * (frame.x + frame.y));
+      }
+    }
+  } else {
+    return;  // TODO(#181): Support all formats.
+  }
+
+  const BarelySlice sample_data{slice_buffer_.data(), slice_buffer_.size(), sample_rate,
+                                slice_->get_root_pitch()};
+  BarelyInstrument_SetSampleData(BarelyEngine::get_singleton()->get(), instrument_id_, &sample_data,
+                                 1);
+}
+
 }  // namespace barely::godot

platforms/godot/instrument.h

@@ -6,6 +6,7 @@
 #include <cstdint>
 
 #include "godot/engine.h"
+#include "godot_cpp/classes/audio_stream_wav.hpp"
 #include "godot_cpp/classes/node.hpp"
 #include "godot_cpp/classes/wrapped.hpp"
 
@@ -54,6 +55,22 @@ namespace barely::godot {
   }                                                                                                \
   type get_##name() const { return name##_; }
 
+class BarelySliceResource : public ::godot::Resource {
+ public:
+  void set_stream(const ::godot::Ref<::godot::AudioStreamWAV>& stream);
+  void set_root_pitch(float root_pitch);
+
+  ::godot::Ref<::godot::AudioStreamWAV> get_stream() const { return stream_; }
+  float get_root_pitch() const { return root_pitch_; }
+
+ private:
+  GDCLASS(BarelySliceResource, ::godot::Resource);
+  static void _bind_methods();
+
+  ::godot::Ref<::godot::AudioStreamWAV> stream_;
+  float root_pitch_ = 0.0f;
+};
+
 class BarelyInstrument : public ::godot::Node {
  public:
   BarelyInstrument();
@@ -64,14 +81,20 @@ class BarelyInstrument : public ::godot::Node {
   void set_note_on(float pitch, float gain = 1.0f, float pitch_shift = 0.0f);
   bool is_note_on(float pitch) const;
 
+  void set_slice(const ::godot::Ref<BarelySliceResource>& slice);
+  ::godot::Ref<BarelySliceResource> get_slice() const { return slice_; }
+
  private:
   GDCLASS(BarelyInstrument, ::godot::Node);
   static void _bind_methods();
 
   static void _note_event_callback(BarelyEventType type, float pitch, void* user_data);
   void _handle_note_event(BarelyEventType type, float pitch);
+  void _on_slice_changed();
 
   uint32_t instrument_id_ = 0;
+  ::godot::Ref<BarelySliceResource> slice_;
+  std::vector<float> slice_buffer_;  // TODO(#181): Remove heap allocation.
 
   BARELY_GODOT_INSTRUMENT_CONTROLS(BARELY_DECLARE_GODOT_INSTRUMENT_CONTROL);
 };

platforms/godot/project/demo/data/sample.wav

@@ -0,0 +1,24 @@
+[remap]
+
+importer="wav"
+type="AudioStreamWAV"
+uid="uid://vvwdk6lors0g"
+path="res://.godot/imported/sample.wav-6b134728960717e0b3e9490ee37cba43.sample"
+
+[deps]
+
+source_file="res://demo/data/sample.wav"
+dest_files=["res://.godot/imported/sample.wav-6b134728960717e0b3e9490ee37cba43.sample"]
+
+[params]
+
+force/8_bit=false
+force/mono=false
+force/max_rate=false
+force/max_rate_hz=44100
+edit/trim=false
+edit/normalize=false
+edit/loop_mode=0
+edit/loop_begin=0
+edit/loop_end=-1
+compress/mode=2

platforms/godot/project/demo/data/sample.wav.import

@@ -17,13 +17,12 @@ func _ready():
 	BarelyEngine.delay_feedback = 0.2
 	BarelyEngine.delay_ping_pong = 0.5
 	BarelyEngine.reverb_room_size = 0.4
-#	
+#
 	instrument.note_on.connect(_on_note_on)
 	instrument.note_off.connect(_on_note_off)
-	
+
 	audioStreamPlayer.stream = BarelyAudioStream.new()
 	audioStreamPlayer.play()
-	
 
 func _input(event):
 	if event is InputEventKey and event.pressed:
@@ -65,9 +64,9 @@ func _unhandled_input(event):
 		if active_notes.has(key_string):
 			instrument.set_note_off(active_notes[key_string])
 			active_notes.erase(key_string)
-			
+
 func _on_note_on(pitch):
 	print("NoteOn(%.2f)\n" % pitch)
-			
+
 func _on_note_off(pitch):
 	print("NoteOff(%.2f)\n" % pitch)

platforms/godot/project/demo/instrument_demo.gd

@@ -1,6 +1,10 @@
 [gd_scene format=3 uid="uid://fm3yw7k5t227"]
 
 [ext_resource type="Script" uid="uid://cx2ediq5nfg22" path="res://demo/instrument_demo.gd" id="1"]
+[ext_resource type="AudioStream" uid="uid://vvwdk6lors0g" path="res://demo/data/sample.wav" id="2_sv68r"]
+
+[sub_resource type="BarelySliceResource" id="BarelySliceResource_sv68r"]
+stream = ExtResource("2_sv68r")
 
 [sub_resource type="LabelSettings" id="LabelSettings_8q8q8"]
 
@@ -9,6 +13,8 @@ script = ExtResource("1")
 
 [node name="Instrument" type="BarelyInstrument" parent="." unique_id=1430736698]
 gain = 0.9
+slice_mode = 1
+slice = SubResource("BarelySliceResource_sv68r")
 osc_shape = 0.2
 delay_send = 0.1
 reverb_send = 0.5