tts-acapela 0.1.0

data/README.rdoc

@@ -0,0 +1,2 @@
+
+= A client for the Acapela TTS server

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+gem 'rspec', '>= 2'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+namespace :gem do
+
+  desc "Builds the gem"
+  task :build do
+    system "gem build *.gemspec && mkdir -p pkg/ && mv *.gem pkg/"
+  end
+
+  desc "Builds and installs the gem"
+  task :install => :build do
+    system "gem install pkg/"
+  end
+
+end
+
+namespace :ext do
+
+  task :create_makefile do
+    chdir("ext") { ruby "extconf.rb" }
+  end
+
+  task :compile => :create_makefile do
+    chdir("ext") { sh "make" }
+  end
+
+  task :move_objects do
+    chdir("ext") do
+      mkdir_p "objs"
+      Dir["*.o"].each do |filename|
+        mv filename, "objs"
+      end
+    end
+  end
+
+  task :build => [ :compile, :move_objects ] do
+
+  end
+
+end
+
+desc "Run all specs in spec/lib directory"
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "spec/lib/**/*_spec.rb"
+end
+
+namespace :spec do
+
+  desc "Run all specs in spec/acceptance directory"
+  RSpec::Core::RakeTask.new(:acceptance => "ext:build") do |task|
+    task.pattern = "spec/acceptance/**/*_spec.rb"
+  end
+
+end

data/ext/acapela.c

@@ -0,0 +1,163 @@
+#include "acapela.h"
+
+// private functions
+
+VALUE notConnectedErrorClass;
+VALUE responseErrorClass;
+VALUE valueErrorClass;
+
+void checkConnection(const char* methodName, VALUE self) {
+  if (acapela_connected(self) == Qfalse)
+    rb_raise(notConnectedErrorClass, "method '%s' can just be executed with a open connection", methodName);
+}
+
+void checkResponse(const char* action, nscRESULT response) {
+  if (response != NSC_OK)
+    rb_raise(responseErrorClass, "error %d while performing action '%s'\n", response, action);
+}
+
+int callback_speech_data(
+  const unsigned char *data,
+  unsigned int dataSize,
+  PNSC_SOUND_DATA soundData,
+  void *instanceData
+) {
+    fwrite(data, dataSize, 1, (FILE*)instanceData);
+    return 0;
+}
+
+void initializeExecutionData(NSC_EXEC_DATA* executionData, FILE *file) {
+  executionData->pfnSpeechData = callback_speech_data;
+  executionData->pfnSpeechEvent = NULL;
+  executionData->ulEventFilter = NSC_EVTBIT_TEXT;
+  executionData->bEventSynchroReq = 1;
+  executionData->vsSoundData.uiSize = 0;
+  executionData->vsSoundData.pSoundBuffer = NULL;
+  executionData->pAppInstanceData = (void*)file;
+}
+
+// public functions
+
+void Init_acapela() {
+  VALUE ttsModule = rb_define_module("TTS");
+  VALUE acapelaClass = rb_define_class_under(ttsModule, "Acapela", rb_cObject);
+  notConnectedErrorClass = rb_const_get(acapelaClass, rb_intern("NotConnectedError"));
+  responseErrorClass = rb_const_get(acapelaClass, rb_intern("ResponseError"));
+  valueErrorClass = rb_const_get(acapelaClass, rb_intern("ValueError"));
+
+  rb_define_method(acapelaClass, "connect", acapela_connect, 0);
+  rb_define_method(acapelaClass, "connected?", acapela_connected, 0);
+  rb_define_method(acapelaClass, "disconnect", acapela_disconnect, 0);
+  rb_define_method(acapelaClass, "voices", acapela_voices, 0);
+  rb_define_method(acapelaClass, "synthesize", acapela_synthesize, 1);
+}
+
+VALUE acapela_connect(VALUE self) {
+  nscHSRV *serverHandle;
+  nscHANDLE *dispatcherHandle;
+
+  if (acapela_connected(self) == Qtrue)
+    return Qfalse;
+
+  VALUE host = rb_ivar_get(self, rb_intern("@host"));
+  VALUE commandPort = rb_ivar_get(self, rb_intern("@command_port"));
+  VALUE dataPort = rb_ivar_get(self, rb_intern("@data_port"));
+
+  serverHandle = (nscHSRV*)malloc(sizeof(nscHSRV));
+  checkResponse("connecting", nscCreateServerContextEx(NSC_AF_INET, NUM2INT(commandPort), NUM2INT(dataPort), StringValuePtr(host), serverHandle));
+  rb_ivar_set(self, rb_intern("@connection"), (VALUE)serverHandle);
+
+  dispatcherHandle = (nscHANDLE*)malloc(sizeof(nscHANDLE));
+  checkResponse("creating dispatcher", nscCreateDispatcher(dispatcherHandle));
+  rb_ivar_set(self, rb_intern("@dispatcher"), (VALUE)dispatcherHandle);
+
+  return Qtrue;
+}
+
+VALUE acapela_connected(VALUE self) {
+  return rb_ivar_get(self, rb_intern("@connection")) == Qnil ? Qfalse : Qtrue;
+}
+
+VALUE acapela_disconnect(VALUE self) {
+  nscHSRV *serverHandle;
+  nscHANDLE *dispatcherHandle;
+
+  if (acapela_connected(self) == Qfalse)
+    return Qfalse;
+
+  dispatcherHandle = (nscHANDLE*)rb_ivar_get(self, rb_intern("@dispatcher"));
+  checkResponse("deleting dispatcher", nscDeleteDispatcher(*dispatcherHandle));
+  rb_ivar_set(self, rb_intern("@dispatcher"), Qnil);
+  free(dispatcherHandle);
+
+  serverHandle = (nscHSRV*)rb_ivar_get(self, rb_intern("@connection"));
+  checkResponse("disconnecting", nscReleaseServerContext(*serverHandle));
+  rb_ivar_set(self, rb_intern("@connection"), Qnil);
+  free(serverHandle);
+
+  return Qtrue;
+}
+
+VALUE acapela_voices(VALUE self) {
+  VALUE result;
+
+  nscRESULT response;
+  nscHSRV *serverHandle;
+
+  nscHANDLE voiceHandle;
+  NSC_FINDVOICE_DATA voice;
+
+  checkConnection("voices", self);
+
+  serverHandle = (nscHSRV*)rb_ivar_get(self, rb_intern("@connection"));
+
+  result = rb_ary_new();
+  response = nscFindFirstVoice(*serverHandle, NULL, 0, 0, 0, &voice, &voiceHandle);
+  while (response == NSC_OK) {
+    rb_ary_push(result, rb_str_new2(voice.cVoiceName));
+    response = nscFindNextVoice(voiceHandle, &voice);
+  }
+  nscCloseFindVoice(voiceHandle);
+
+  return result;
+}
+
+VALUE acapela_synthesize(VALUE self, VALUE text) {
+  VALUE result;
+
+  nscRESULT response;
+  nscHSRV* serverHandle;
+  nscHANDLE* dispatcherHandle;
+  VALUE voice;
+  int sampleFrequency;
+  nscHANDLE ttsHandle;
+  NSC_EXEC_DATA executionData;
+  char* filename;
+  FILE* file;
+  nscCHANID channelId;
+
+  checkConnection("synthesize", self);
+
+  serverHandle = (nscHSRV*)rb_ivar_get(self, rb_intern("@connection"));
+  dispatcherHandle = (nscHANDLE*)rb_ivar_get(self, rb_intern("@dispatcher"));
+  voice = rb_ivar_get(self, rb_intern("@voice"));
+  sampleFrequency = rb_ivar_get(self, rb_intern("@sample_frequency"));
+
+  checkResponse("opening channel", nscInitChannel(*serverHandle, StringValuePtr(voice), NUM2INT(sampleFrequency), 0, *dispatcherHandle, &channelId));
+  checkResponse("lock channel", nscLockChannel(*serverHandle, channelId, *dispatcherHandle, &ttsHandle));
+  checkResponse("add text", nscAddTextEx(ttsHandle, "UTF-8", StringValuePtr(text), strlen(StringValuePtr(text)), NULL));
+
+  filename = tmpnam(NULL);
+  file = fopen(filename, "w");
+  initializeExecutionData(&executionData, file);
+  checkResponse("execute channel", nscExecChannel(ttsHandle, &executionData));
+  fclose(file);
+
+  checkResponse("unlock channel", nscUnlockChannel(ttsHandle));
+  checkResponse("closing channel", nscCloseChannel(*serverHandle, channelId));
+
+  VALUE fileClass = rb_const_get(rb_cObject, rb_intern("File"));
+  result = rb_funcall(fileClass, rb_intern("new"), 1, rb_str_new2(filename));
+
+  return result;
+}

data/ext/acapela.h

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ruby.h"
+#include "nscube.h"
+
+void Init_acapela();
+
+VALUE acapela_connect(VALUE self);
+VALUE acapela_connected(VALUE self);
+VALUE acapela_disconnect(VALUE self);
+VALUE acapela_voices(VALUE self);
+VALUE acapela_synthesize(VALUE self, VALUE text);

data/ext/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+extension_name = "acapela"
+
+dir_config extension_name, "/opt/Acapela/TelecomTTS/include"
+
+found_nscube = find_library "nscube", "nscCreateServerContext", "/opt/Acapela/TelecomTTS/lib"
+
+if found_nscube
+  create_makefile extension_name
+else
+  puts "library 'nscube' is required, but wasn't found.\n"
+  exit 1
+end

data/lib/tts-acapela.rb

@@ -0,0 +1,7 @@
+
+module TTS
+
+  autoload :Acapela, File.join(File.dirname(__FILE__), "tts", "acapela")
+  autoload :Cache, File.join(File.dirname(__FILE__), "tts", "cache")
+
+end

data/lib/tts/acapela.rb

@@ -0,0 +1,41 @@
+
+module TTS
+
+  class Acapela
+
+    class Error < StandardError; end
+    class NotConnectedError < Error; end
+    class ResponseError < Error; end
+    class ValueError < Error; end
+    class VoiceNotSupportedError < Error; end
+
+    attr_accessor :host
+    attr_accessor :command_port
+    attr_accessor :data_port
+    attr_accessor :voice
+    attr_reader   :sample_frequency
+    attr_accessor :cache_directory
+
+    def initialize(options = { })
+      self.host             = options[:host]             || "127.0.0.1"
+      self.command_port     = options[:command_port]     || 6666
+      self.data_port        = options[:data_port]        || 6665
+      self.voice            = options[:voice]
+      self.sample_frequency = options[:sample_frequency] || 22050
+      self.cache_directory  = options[:cache_directory]  || "/tmp"
+    end
+
+    def sample_frequency=(value)
+      raise ValueError, "sample frequency #{value} is not supported. try 22050, 16000, 11025 or 8000." unless [ 22050, 16000, 11025, 8000 ].include?(value)
+      @sample_frequency = value
+    end
+
+    def settings_stamp
+      "#{@voice}#{@sample_frequency}"
+    end
+
+  end
+
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "ext", "acapela"))

data/lib/tts/cache.rb

@@ -0,0 +1,41 @@
+require 'digest/md5'
+require 'fileutils'
+
+module TTS
+
+  class Cache
+
+    attr_accessor :tts
+    attr_accessor :cache_directory
+
+    def initialize(tts, cache_directory)
+      @tts, @cache_directory = tts, cache_directory
+      FileUtils.mkdir_p @cache_directory
+    end
+
+    def clear
+      FileUtils.rm Dir[File.join(@cache_directory, "*.pcm")]
+    end
+
+    def synthesize(text)
+      cache_filename = cache_path(text)
+      unless File.exists?(cache_filename)
+        file = @tts.synthesize text
+        FileUtils.mv file.path, cache_filename
+      end
+      File.new cache_filename
+    end
+
+    private
+
+    def cache_path(text)
+      File.join @cache_directory, cache_filename(text)
+    end
+
+    def cache_filename(text)
+      Digest::MD5.hexdigest("#{text}#{@tts.settings_stamp}") + ".pcm"
+    end
+
+  end
+
+end

data/spec/acceptance/acapela_spec.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+describe TTS::Acapela do
+
+  before :each do
+    @acapela = described_class.new :host => "46.51.190.56"
+  end
+
+  shared_examples_for "a method that need an open connection" do
+
+    it "should raise an #{TTS::Acapela::NotConnectedError} if disconnected" do
+      @acapela.disconnect
+      lambda do
+        do_call
+      end.should raise_error(TTS::Acapela::NotConnectedError);
+    end
+
+  end
+
+  describe "connect" do
+
+    after :each do
+      @acapela.disconnect
+    end
+
+    it "should change the state to connected" do
+      lambda do
+        @acapela.connect
+      end.should change(@acapela, :connected?).from(false).to(true)
+    end
+
+    it "should not raise an error if it's already connected" do
+      @acapela.connect
+      lambda do
+        @acapela.connect
+      end.should_not raise_error
+    end
+
+  end
+
+  describe "disconnect" do
+
+    before :each do
+      @acapela.connect
+    end
+
+    it "should change the state to disconnected" do
+      lambda do
+        @acapela.disconnect
+      end.should change(@acapela, :connected?).from(true).to(false)
+    end
+
+    it "should not raise an error if it's already disconnected" do
+      @acapela.disconnect
+      lambda do
+        @acapela.disconnect
+      end.should_not raise_error
+    end
+
+  end
+
+  describe "voices" do
+
+    before :each do
+      @acapela.connect
+    end
+
+    after :each do
+      @acapela.disconnect
+    end
+
+    def do_call
+      @acapela.voices
+    end
+
+    it_should_behave_like "a method that need an open connection"
+
+    it "should return an array of voices" do
+      voices = do_call
+      voices.should be_instance_of(Array)
+      voices.should == [
+        "julia22k", "klaus22k", "lucy22k", "bruno22k", "claire22k", "julie22k",
+        "peter22k", "sarah22k", "rachel22k", "justine22k", "graham22k", "alice22k"
+      ]
+    end
+
+  end
+
+  describe "synthesize" do
+
+    before :each do
+      @acapela.connect
+      @acapela.voice = "sarah22k"
+    end
+
+    after :each do
+      File.delete @file.path if @file
+      @acapela.disconnect
+    end
+
+    def do_call(text = "Hallo Welt")
+      @acapela.synthesize text
+    end
+
+    it_should_behave_like "a method that need an open connection"
+
+    it "should return a file with the synthesized text" do
+      @file = do_call
+      @file.should be_instance_of(File)
+    end
+
+    context "with voice 'julia22k'" do
+
+      before :each do
+        @acapela.voice = "julia22k"
+      end
+
+      it "should return the correct file" do
+        @file = do_call
+        md5 = Digest::MD5.hexdigest File.read(@file.path)
+        md5.should == "7e50b6c1666ec97be6c84b9dacf0ef89"
+      end
+
+    end
+
+    context "with voice 'lucy22k'" do
+
+      before :each do
+        @acapela.voice = "lucy22k"
+      end
+
+      it "should return the correct file" do
+        @file = do_call
+        md5 = Digest::MD5.hexdigest File.read(@file.path)
+        md5.should == "8288953a25090a2089b86ac324e582dc"
+      end
+
+    end
+
+    context "with a text with special characters" do
+
+      it "should return the correct file" do
+        @file = do_call "Schönhauser-Allee"
+        `cp #{@file.path} /home/phifty/Desktop/test.pcm`
+        md5 = Digest::MD5.hexdigest File.read(@file.path)
+        md5.should == "bf3ab75c5b55b4815e810ac6b0c83ee0"
+      end
+
+    end
+
+  end
+
+end

data/spec/acceptance/cached_acapela_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+describe TTS::Cache do
+
+  before :each do
+    @acapela = TTS::Acapela.new :host => "46.51.190.56", :voice => "julia22k", :sample_frequency => 22050
+    @acapela.connect
+
+    @cache = described_class.new @acapela, "/tmp/cache"
+  end
+
+  after :each do
+    @cache.clear
+    @acapela.disconnect
+  end
+
+  describe "synthesize" do
+
+    before :each do
+      @cache_filename = "/tmp/cache/58bb7452ad8aaa2a25509ec076cc979d.pcm"
+    end
+
+    context "for a new request" do
+
+      before :each do
+        @cache.clear
+      end
+
+      it "should create a new cache file" do
+        File.exists?(@cache_filename).should be_false
+        @cache.synthesize "Hallo"
+        File.exists?(@cache_filename).should be_true
+      end
+
+      it "should return the right file" do
+        file = @cache.synthesize "Hallo"
+        file.path.should == @cache_filename
+      end
+
+    end
+
+    context "for a cached request" do
+
+      before :each do
+        @cache.synthesize "Hallo"
+      end
+
+      it "should not create a new cache file" do
+        File.exists?(@cache_filename).should be_true
+        @cache.synthesize "Hallo"
+        File.exists?(@cache_filename).should be_true
+      end
+
+      it "should return the right file" do
+        file = @cache.synthesize "Hallo"
+        file.path.should == @cache_filename
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/tts/acapela_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+
+describe TTS::Acapela do
+
+  before :each do
+    @acapela = described_class.new :voice => "julia22k", :sample_frequency => 22050
+  end
+
+  describe "sample_frequency=" do
+
+    it "should set the sample frequency" do
+      @acapela.sample_frequency = 22050
+      @acapela.sample_frequency == 22050
+    end
+
+    it "should raise an #{TTS::Acapela::ValueError} on an invalid value" do
+      lambda do
+        @acapela.sample_frequency = 5
+      end.should raise_error(TTS::Acapela::ValueError)
+
+      lambda do
+        @acapela.sample_frequency = "invalid"
+      end.should raise_error(TTS::Acapela::ValueError)
+    end
+
+  end
+
+  describe "settings_stamp" do
+
+    it "should return a string with a snapshort of the synthesize-settings" do
+      @acapela.settings_stamp.should == "julia22k22050"
+    end
+
+  end
+
+end

data/spec/lib/tts/cache_spec.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+
+describe TTS::Cache do
+
+  before :each do
+    FileUtils.stub(:mkdir_p)
+
+    @acapela = mock TTS::Acapela, :settings_stamp => "julia22k22050"
+
+    @cache = described_class.new @acapela, "/tmp/cache"
+  end
+
+  describe "initialize" do
+
+    it "should try to create the cache directory" do
+      FileUtils.should_receive(:mkdir_p).with("/tmp/cache")
+      described_class.new @acapela, "/tmp/cache"
+    end
+
+  end
+
+  describe "clear" do
+
+    before :each do
+      FileUtils.stub(:rm)
+    end
+
+    it "should remove all *.pcm files from the cache directory" do
+      FileUtils.should_receive(:rm).with(Dir["/tmp/cache/*.pcm"])
+      @cache.clear
+    end
+
+  end
+
+  describe "synthesize" do
+
+    before :each do
+      @cache_filename = "/tmp/cache/58bb7452ad8aaa2a25509ec076cc979d.pcm"
+
+      @cached_file = mock File
+      File.stub(:new).and_return(@cached_file)
+
+      @file = mock File, :path => "/tmp/file"
+      @acapela.stub(:synthesize).and_return(@file)
+    end
+
+    def do_synthesize(text = "Hallo")
+      @cache.synthesize text
+    end
+
+    context "for a new request" do
+
+      before :each do
+        File.stub(:exists?).and_return(false)
+        FileUtils.stub(:mv)
+      end
+
+      it "should check the existance of the right file" do
+        File.should_receive(:exists?).with(@cache_filename).and_return(true)
+        do_synthesize
+      end
+
+      it "should synthesize a new file" do
+        @acapela.should_receive(:synthesize).with("Hallo").and_return(@file)
+        file = do_synthesize
+        file.should == @cached_file
+      end
+
+      it "should move the synthesized file to the cache" do
+        FileUtils.should_receive(:mv).with(@file.path, @cache_filename)
+        do_synthesize
+      end
+
+      it "should return the synthesized and cached file" do
+        file = do_synthesize
+        file.should == @cached_file
+      end
+
+    end
+
+    context "for a cached request" do
+
+      before :each do
+        File.stub(:exists?).and_return(true)
+      end
+
+      it "should check the existance of the right file" do
+        File.should_receive(:exists?).with(@cache_filename).and_return(true)
+        do_synthesize
+      end
+
+      it "should not synthesize a new file" do
+        @acapela.should_not_receive(:synthesize)
+        do_synthesize
+      end
+
+      it "should return the cached file" do
+        file = do_synthesize
+        file.should == @cached_file
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+gem 'rspec', '>= 2'
+require 'rspec'
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "tts-acapela"))

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: tts-acapela
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Philipp Brüll
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-12-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70207859994280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *70207859994280
+description: It uses the native nscapi library to connect to the server.
+email: b.phifty@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- Rakefile
+- ext/acapela.c
+- ext/acapela.h
+- ext/extconf.rb
+- lib/tts/acapela.rb
+- lib/tts/cache.rb
+- lib/tts-acapela.rb
+- spec/acceptance/acapela_spec.rb
+- spec/acceptance/cached_acapela_spec.rb
+- spec/lib/tts/acapela_spec.rb
+- spec/lib/tts/cache_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tts-acapela
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A client for the Acapela TTS server.
+test_files:
+- spec/acceptance/acapela_spec.rb
+- spec/acceptance/cached_acapela_spec.rb
+- spec/lib/tts/acapela_spec.rb
+- spec/lib/tts/cache_spec.rb