beeps 0.3.8 → 0.3.10

data/include/beeps/generator.h

@@ -4,6 +4,7 @@
 #define __BEEPS_GENERATOR_H__
 
 
+#include <list>
 #include <beeps/processor.h>
 
 
@@ -11,6 +12,72 @@ namespace Beeps
 {
 
 
+	class Value : public Generator
+	{
+
+		typedef Generator Super;
+
+		public:
+
+			enum Type
+			{
+				TYPE_NONE = 0, LINEAR
+			};
+
+			struct Point
+			{
+
+				float value;
+
+				float time;
+
+				Point (float value, float time);
+
+			};// Point
+
+			typedef std::vector<Point> PointList;
+
+			typedef PointList::      iterator       iterator;
+
+			typedef PointList::const_iterator const_iterator;
+
+			Value (float value = 0, Type type = LINEAR);
+
+			virtual ~Value ();
+
+			virtual void set_type (Type type);
+
+			virtual Type     type () const;
+
+			virtual void set_value (float value);
+
+			virtual void insert    (float value, float time);
+
+			virtual void clear ();
+
+			virtual       iterator begin ();
+
+			virtual const_iterator begin () const;
+
+			virtual       iterator end ();
+
+			virtual const_iterator end () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+		private:
+
+			virtual void generate (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual int max_segment_size_for_process (
+				double sample_rate, uint nsamples) const override;
+
+	};// Value
+
+
 	class Oscillator : public Generator
 	{
 
@@ -95,6 +162,23 @@ namespace Beeps
 
 		public:
 
+			struct Note
+			{
+
+				Processor::Ref processor;
+
+				float offset, duration;
+
+				Note (Processor* processor, float offset, float duration);
+
+			};// Note
+
+			typedef std::list<Note> NoteList;
+
+			typedef NoteList::      iterator       iterator;
+
+			typedef NoteList::const_iterator const_iterator;
+
 			Sequencer ();
 
 			virtual ~Sequencer ();
@@ -107,6 +191,14 @@ namespace Beeps
 
 			virtual float    time_scale () const;
 
+			virtual       iterator begin ();
+
+			virtual const_iterator begin () const;
+
+			virtual       iterator end ();
+
+			virtual const_iterator end () const;
+
 			virtual operator bool () const override;
 
 			struct Data;
@@ -193,6 +285,35 @@ namespace Beeps
 	};// MicIn
 
 
+	class TextIn : public Generator
+	{
+
+		typedef Generator Super;
+
+		public:
+
+			TextIn (const char* text = NULL, double sample_rate = 0);
+
+			virtual ~TextIn ();
+
+			virtual void synthesize (const char* text);
+
+			virtual double sample_rate () const;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+		protected:
+
+			virtual void generate (
+				Context* context, Signals* signals, uint* offset) override;
+
+	};// TextIn
+
+
 }// Beeps
 
 

data/include/beeps/ruby/generator.h

@@ -9,6 +9,8 @@
 #include <beeps/generator.h>
 
 
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Value)
+
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Oscillator)
 
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Sequencer)
@@ -17,11 +19,16 @@ RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::FileIn)
 
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::MicIn)
 
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::TextIn)
+
 
 namespace Beeps
 {
 
 
+	BEEPS_EXPORT Rucy::Class value_class ();
+	// class Beeps::Value
+
 	BEEPS_EXPORT Rucy::Class oscillator_class ();
 	// class Beeps::Oscillator
 
@@ -34,6 +41,9 @@ namespace Beeps
 	BEEPS_EXPORT Rucy::Class mic_in_class ();
 	// class Beeps::MicIn
 
+	BEEPS_EXPORT Rucy::Class text_in_class ();
+	// class Beeps::TextIn
+
 
 }// Beeps
 
@@ -42,6 +52,12 @@ namespace Rucy
 {
 
 
+	template <> inline Class
+	get_ruby_class<Beeps::Value> ()
+	{
+		return Beeps::value_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Beeps::Oscillator> ()
 	{
@@ -66,6 +82,12 @@ namespace Rucy
 		return Beeps::mic_in_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Beeps::TextIn> ()
+	{
+		return Beeps::text_in_class();
+	}
+
 
 }// Rucy
 

data/include/beeps/signals.h

@@ -33,6 +33,8 @@ namespace Beeps
 
 			bool empty () const;
 
+			bool full() const;
+
 			const Sample* samples () const;
 
 			operator bool () const;

data/lib/beeps/ext.rb

@@ -1 +1 @@
-require 'beeps/native'
+require 'beeps_ext'

data/lib/beeps/processor.rb

@@ -45,6 +45,32 @@ module Beeps
   end# Processor
 
 
+  class Value
+
+    include Enumerable
+
+    const_symbol_accessor :type, **{
+      none:   TYPE_NONE,
+      linear: LINEAR
+    }
+
+    def initialize(value, type = :linear, **kwargs, &block)
+      super(**kwargs, &block)
+      self.value, self.type = value, type
+    end
+
+    universal_accessor :type
+
+    def each_value(&block)
+      return enum_for :each_value unless block
+      each_value!(&block)
+    end
+
+    alias each each_value
+
+  end# Value
+
+
   class Oscillator
 
     include Enumerable
@@ -74,14 +100,33 @@ module Beeps
     alias freq  frequency
 
     def each_sample(&block)
-      block ? each_sample!(&block) : enum_for(:each_sample!)
+      return enum_for :each_sample unless block
+      each_sample!(&block)
     end
 
     alias each each_sample
 
+    def samples()
+      to_a
+    end
+
   end# Oscillator
 
 
+  class Sequencer
+
+    include Enumerable
+
+    def each_note(&block)
+      return enum_for :each_note unless block
+      each_note!(&block)
+    end
+
+    alias each each_note
+
+  end# Sequencer
+
+
   class FileIn
 
     def initialize(path = nil, **kwargs, &block)
@@ -94,6 +139,16 @@ module Beeps
   end# FileIn
 
 
+  class TextIn
+
+    def initialize(text = nil, **kwargs, &block)
+      super(**kwargs, &block)
+      synthesize text if text
+    end
+
+  end# TextIn
+
+
   class Gain
 
     def initialize(gain = 1, **kwargs, &block)

data/src/osx/signals.h

@@ -0,0 +1,23 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_OSX_SIGNALS_H__
+#define __BEEPS_SRC_OSX_SIGNALS_H__
+
+
+#import <AVFoundation/AVFoundation.h>
+#include "../signals.h"
+
+
+namespace Beeps
+{
+
+
+	Signals Signals_create (AVAudioPCMBuffer* buffer, uint capacity = 0);
+
+	void Signals_append (Signals* to, AVAudioPCMBuffer* buffer);
+
+
+}// Beeps
+
+
+#endif//EOH

data/src/osx/signals.mm

@@ -1,8 +1,7 @@
 // -*- c++ -*-
-#include "../signals.h"
+#include "signals.h"
 
 
-#import <AVFoundation/AVFoundation.h>
 #include "beeps/exception.h"
 
 
@@ -24,6 +23,70 @@ namespace Beeps
 	}
 
 
+	Signals
+	Signals_create (AVAudioPCMBuffer* buffer, uint capacity)
+	{
+		if (!buffer)
+			argument_error(__FILE__, __LINE__);
+
+		uint nchannels = buffer.format.channelCount;
+		if (nchannels <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid nchannels %d", nchannels);
+
+		uint nsamples = buffer.frameLength;
+		if (nsamples <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid buffer length %d", nsamples);
+
+		const float* const* channels = buffer.floatChannelData;
+		if (!channels)
+			beeps_error(__FILE__, __LINE__, "failed to get channel data");
+
+		return Signals_create(
+			channels, nsamples, nchannels, (uint) buffer.format.sampleRate, capacity);
+	}
+
+	static uint
+	get_next_capacity (const Signals& signals, uint nsamples)
+	{
+		uint cap = signals.capacity();
+		while (cap < nsamples) cap *= 2;
+		return cap;
+	}
+
+	void
+	Signals_append (Signals* to, AVAudioPCMBuffer* buffer)
+	{
+		if (!buffer)
+			argument_error(__FILE__, __LINE__);
+
+		uint nchannels = buffer.format.channelCount;
+		if (nchannels <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid nchannels %d", nchannels);
+		if (nchannels != to->nchannels())
+			beeps_error(__FILE__, __LINE__, "nchannels does not match", nchannels);
+
+		uint nsamples = buffer.frameLength;
+		if (nsamples <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid buffer length %d", nsamples);
+
+		const float* const* channels = buffer.floatChannelData;
+		if (!channels)
+			beeps_error(__FILE__, __LINE__, "failed to get channel data");
+
+		uint new_nsamples = to->nsamples() + nsamples;
+		if (new_nsamples > to->capacity())
+			Signals_set_capacity(to, get_next_capacity(*to, new_nsamples));
+
+		for (uint channel = 0; channel < nchannels; ++channel)
+		{
+			Sample* p = Signals_at(to, to->nsamples(), channel);
+			for (uint i = 0; i < nsamples; ++i, p += nchannels)
+				*p = channels[channel][i];
+		}
+
+		Signals_set_nsamples(to, new_nsamples);
+	}
+
 	static AVAudioPCMBuffer*
 	load_buffer (const char* path)
 	{
@@ -64,19 +127,7 @@ namespace Beeps
 		AVAudioPCMBuffer* buffer = load_buffer(path);
 		if (!buffer) return Signals();
 
-		uint nchannels = buffer.format.channelCount;
-		if (nchannels <= 0)
-			beeps_error(__FILE__, __LINE__, "invalid nchannels %d", nchannels);
-
-		uint len = buffer.frameLength;
-		if (len <= 0)
-			beeps_error(__FILE__, __LINE__, "invalid buffer length %d", len);
-
-		const float* const* data = buffer.floatChannelData;
-		if (!data)
-			beeps_error(__FILE__, __LINE__, "failed to get channel data");
-
-		return Signals_create(data, len, nchannels, (uint) buffer.format.sampleRate);
+		return Signals_create(buffer);
 	}
 
 

data/src/osx/text_in.mm

@@ -0,0 +1,133 @@
+// -*- c++ -*-
+#include "beeps/generator.h"
+
+
+#include <deque>
+#import <Foundation/Foundation.h>
+#include "beeps/exception.h"
+#include "beeps/debug.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	typedef Xot::Ref<TextIn> TextInRef;
+
+
+	struct TextIn::Data
+	{
+
+		double sample_rate = 0;
+
+		bool finished      = false;
+
+		Signals signals;
+
+	};// TextIn::Data
+
+
+	TextIn::TextIn (const char* text, double sample_rate)
+	{
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->sample_rate = sample_rate;
+
+		if (text) synthesize(text);
+	}
+
+	TextIn::~TextIn ()
+	{
+	}
+
+	void
+	TextIn::synthesize (const char* text)
+	{
+		if (@available(macOS 10.15, *))
+		{
+			TextInRef pthis            = this;
+			AVSpeechSynthesizer* synth = [[AVSpeechSynthesizer alloc] init];
+
+			NSString* str = [NSString stringWithUTF8String: text];
+			auto* utt     = [[[AVSpeechUtterance alloc] initWithString: str] autorelease];
+			utt.voice     = [AVSpeechSynthesisVoice voiceWithLanguage: @"ja-JP"];
+			utt.rate      = 0.5;
+
+			[synth writeUtterance: utt
+				toBufferCallback: ^(AVAudioBuffer* buffer)
+				{
+					auto finish = [&]()
+					{
+						pthis->self->finished = true;
+						[synth release];
+					};
+
+					if (![buffer isKindOfClass: AVAudioPCMBuffer.class])
+						return finish();
+
+					AVAudioPCMBuffer* pcmbuf = (AVAudioPCMBuffer*) buffer;
+					if (pcmbuf.frameLength == 0)
+						return finish();
+
+					[pcmbuf retain];
+					dispatch_async(dispatch_get_main_queue(), ^()
+					{
+						if (!pthis->self->signals)
+							pthis->self->signals = Signals_create(pcmbuf, 4096);
+						else
+							Signals_append(&pthis->self->signals, pcmbuf);
+						[pcmbuf release];
+					});
+				}];
+		}
+		else
+			not_implemented_error(__FILE__, __LINE__);
+	}
+
+	double
+	TextIn::sample_rate () const
+	{
+		return self->sample_rate;
+	}
+
+	TextIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->sample_rate > 0;
+	}
+
+	void
+	TextIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		if (self->signals)
+		{
+			if (signals->sample_rate() != self->signals.sample_rate())
+			{
+				beeps_error(
+					__FILE__, __LINE__,
+					"sample_rate does not match: %f and %f",
+					signals->sample_rate(),
+					self->signals.sample_rate());
+			}
+
+			uint copied_size = Signals_copy(signals, self->signals);
+			Signals_shift(&self->signals, copied_size);
+			*offset += copied_size;
+		}
+
+		if (!self->finished)
+		{
+			uint fill_size = signals->capacity() - signals->nsamples();
+			Signals_fill(signals, fill_size, 0, signals->nsamples());
+			*offset += fill_size;
+		}
+	}
+
+
+}// Beeps

data/src/sdl/beeps.cpp

@@ -0,0 +1,19 @@
+#include "../beeps.h"
+
+
+namespace Beeps
+{
+
+
+	void
+	Beeps_init ()
+	{
+	}
+
+	void
+	Beeps_fin ()
+	{
+	}
+
+
+}// Beeps

data/src/sdl/signals.cpp

@@ -0,0 +1,18 @@
+#include "../signals.h"
+
+
+#include "beeps/exception.h"
+
+
+namespace Beeps
+{
+
+
+	Signals
+	Signals_load (const char* path)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Beeps

data/src/sdl/text_in.cpp

@@ -0,0 +1,61 @@
+#include "beeps/generator.h"
+
+
+#include "beeps/exception.h"
+#include "../signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct TextIn::Data
+	{
+
+		double sample_rate = 0;
+
+	};// TextIn::Data
+
+
+	TextIn::TextIn (const char* text, double sample_rate)
+	{
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->sample_rate = sample_rate;
+
+		if (text) synthesize(text);
+	}
+
+	TextIn::~TextIn ()
+	{
+	}
+
+	void
+	TextIn::synthesize (const char* text)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	double
+	TextIn::sample_rate () const
+	{
+		return self->sample_rate;
+	}
+
+	TextIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->sample_rate > 0;
+	}
+
+	void
+	TextIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+	}
+
+
+}// Beeps