CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Speech synthesis

From Rosetta Code
Task
Speech synthesis
You are encouraged to solve this task according to the task description, using any language you may know.

Render the text       This is an example of speech synthesis      as speech.

AutoHotkey[edit]

Works with: AutoHotkey_L
talk := ComObjCreate("sapi.spvoice")
talk.Speak("This is an example of speech synthesis.")

BASIC256[edit]

say "Goodbye, World for the " + 123456 + "th time."
say "This is an example of speech synthesis."

BBC BASIC[edit]

This calls the SAPI5 API directly, it does not need an external program.

      SPF_ASYNC = 1
ON ERROR SYS `CoUninitialize` : PRINT 'REPORT$ : END
ON CLOSE SYS `CoUninitialize` : QUIT
 
SYS "LoadLibrary","OLE32.DLL" TO O%
SYS "GetProcAddress",O%,"CoInitialize" TO `CoInitialize`
SYS "GetProcAddress",O%,"CoUninitialize" TO `CoUninitialize`
SYS "GetProcAddress",O%,"CoCreateInstance" TO `CoCreateInstance`
 
SYS `CoInitialize`,0
voice% = FN_voice_create
PROC_voice_speak(voice%, "This is an example of speech synthesis")
PROC_voice_wait(voice%)
PROC_voice_free(voice%)
SYS `CoUninitialize`
END
 
DEF FN_voice_create
LOCAL C%, D%, F%, I%, M%, P%, V%
DIM C% LOCAL 15, I% LOCAL 15
C%!0 = &96749377 : C%!4 = &11D23391 : C%!8 = &C000E39E : C%!12 = &9673794F
I%!0 = &6C44DF74 : I%!4 = &499272B9 : I%!8 = &99EFECA1 : I%!12 = &D422046E
SYS `CoCreateInstance`, C%, 0, 5, I%, ^V%
IF V%=0 ERROR 100, "SAPI5 not available"
= V%
 
DEF PROC_voice_speak(V%, M$)
DIM M% LOCAL 2*LENM$+1
SYS "MultiByteToWideChar", 0, 0, M$, -1, M%, LENM$+1
SYS !(!V%+80), V%, M%, SPF_ASYNC, 0
ENDPROC
 
DEF PROC_voice_wait(V%)
SYS !(!V%+128), V%
ENDPROC
 
DEF PROC_voice_free(V%)
SYS !(!V%+8), V%
ENDPROC

Batch File[edit]

Sorry for cheating. This is Batch/JScript hybrid.

@set @dummy=0 /*
::Batch File section
@echo off
cscript //e:jscript //nologo "%~f0" "%~1"
exit /b
::*/
//The JScript section
var objVoice = new ActiveXObject("SAPI.SpVoice");
objVoice.speak(WScript.Arguments(0));
Output:

Saved as SPEAK.BAT

>SPEAK "This is an example of speech synthesis"

>

C[edit]

Following shining examples of execing external programs around here:

Library: POSIX
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
void talk(const char *s)
{
pid_t pid;
int status;
 
pid = fork();
if (pid < 0) {
perror("fork");
exit(1);
}
 
if (pid == 0) {
execlp("espeak", "espeak", s, (void*)0);
perror("espeak");
_exit(1);
}
 
waitpid(pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
exit(1);
}
 
int main()
{
talk("This is an example of speech synthesis.");
return 0;
}

C#[edit]

You need to 'Add Reference' to the COM "Microsoft Speech Object Library" in your Preferences.

using SpeechLib;
 
namespace Speaking_Computer
{
public class Program
{
private static void Main()
{
var voice = new SpVoice();
voice.Speak("This is an example of speech synthesis.");
}
}
}

Clojure[edit]

(use 'speech-synthesis.say)
(say "This is an example of speech synthesis.")

Go[edit]

Here's a library solution, but using a library written from scratch in Go.

package main
 
import (
"go/build"
"log"
"path/filepath"
 
"github.com/unixpickle/gospeech"
"github.com/unixpickle/wav"
)
 
const pkgPath = "github.com/unixpickle/gospeech"
const input = "This is an example of speech synthesis."
 
func main() {
p, err := build.Import(pkgPath, ".", build.FindOnly)
if err != nil {
log.Fatal(err)
}
d := filepath.Join(p.Dir, "dict/cmudict-IPA.txt")
dict, err := gospeech.LoadDictionary(d)
if err != nil {
log.Fatal(err)
}
phonetics := dict.TranslateToIPA(input)
synthesized := gospeech.DefaultVoice.Synthesize(phonetics)
wav.WriteFile(synthesized, "output.wav")
}

Groovy[edit]

Mac only:

'say "This is an example of speech synthesis."'.execute()

Haskell[edit]

 
import System
 
say x = system $ "espeak " ++ show x
 
main = say "This is an example of speech synthesis."
 

JavaScript[edit]

Works with: JScript
var voice = new ActiveXObject("SAPI.SpVoice");
voice.speak("This is an example of speech synthesis.");

Liberty BASIC[edit]

Assumes that 'espeak' is available at the path shown.

 
nomainwin
run "C:\Program Files\eSpeak\command_line\espeak "; chr$( 34); "This is an example of speech synthesis."; chr$( 34)
end
 

Another dll has been posted to do the same job, at LB Community Wiki

Locomotive Basic[edit]

Both hardware and software-only speech synthesizers exist for the CPC. A software-only solution, Speech 1.1 by Superior Software (1986), supplies three BASIC extension commands (RSXes), "|say", "|speak", and "|pitch":

|say,"This is an example of speech synthesis."

Mathematica[edit]

Speak["This is an example of speech synthesis."]

PARI/GP[edit]

Define a function that is using espeak package from Linux.

speak(txt,opt="")=extern(concat(["espeak ",opt," \"",txt,"\""]));

Now let it speak:

speak("This is an example of speech synthesis")

A monster speech tongue-twister:

speak("The seething sea ceaseth and thus the seething sea sufficeth us.","-p10 -s100")

A foreign language "Zungenbrecher":

speak("Fischers Fritz fischt frische Fische.","-vmb/mb-de2 -s130")

Perl[edit]

use Speech::Synthesis;
 
($engine) = Speech::Synthesis->InstalledEngines();
($voice) = Speech::Synthesis->InstalledVoices(engine => $engine);
 
Speech::Synthesis
->new(engine => $engine, voice => $voice->{id})
->speak("This is an example of speech synthesis.");

Perl 6[edit]

run 'espeak', 'This is an example of speech synthesis.';

PicoLisp[edit]

(call 'espeak "This is an example of speech synthesis.")

PowerShell[edit]

 
Add-Type -AssemblyName System.Speech
 
$anna = New-Object System.Speech.Synthesis.SpeechSynthesizer
 
$anna.Speak("I'm sorry Dave, I'm afraid I can't do that.")
$anna.Dispose()
 

Python[edit]

 
import pyttsx
 
engine = pyttsx.init()
engine.say("It was all a dream.")
engine.runAndWait()
 

Racket[edit]

Should work on all platforms.

 
#lang racket
(require racket/lazy-require)
(lazy-require [ffi/com (com-create-instance com-release com-invoke)])
(define (speak text)
(cond [(eq? 'windows (system-type))
(define c (com-create-instance "SAPI.SpVoice"))
(com-invoke c "Speak" text)
(com-release c)]
[(ormap find-executable-path '("say" "espeak"))
=> (λ(exe) (void (system* exe text)))]
[else (error 'speak "I'm speechless!")]))
(speak "This is an example of speech synthesis.")
 

REXX[edit]

Programming note:   This REXX program uses a freeware program   NIRCMD   to interface with the Microsoft Windows speech synthesizer program   SAM,   a text to speech using a male voice.   SAM can possibly be configured to use other voices with later releases of Windows.   More recent Microsoft Windows have another speech synthesizer program:   ANNA.

/*REXX program uses a C.L. command to invoke Windows SAM for speech synthesis.*/
parse arg t; t=space(t) /*get the (optional) text from the C.L.*/
if t=='' then signal done /*Nothing to say? Then exit program.*/
 
homedrive=value('HOMEDRIVE',,'SYSTEM') /*get HOMEDRIVE location of \TEMP */
tmp =value('TEMP',,'SYSTEM') /* " TEMP directory name. */
if homedrive=='' then homedrive='C:' /*use the default if none was found. */
if tmp=='' then tmp=homedrive'\TEMP' /* " " " " " " " */
/*code could be added here to get a ···*/
/* ··· unique name for the TEMP file.*/
tFN='SPEAK_IT'; tFT='$$$' /*use this name for the TEMP's fileID.*/
tFID=homedrive||'\TEMP\' || tFN"."tFT /*create temporary name for the output.*/
call lineout tFID,t /*write text ──► temporary output file.*/
call lineout tFID /*close the output file just to be neat*/
'NIRCMD' "speak file" tFID /*NIRCMD invokes Microsoft's Sam voice*/
'ERASE' tFID /*clean up (delete) the TEMP file.*/
 
done: /*stick a fork in it, we're all done. */

Note:   The name of the above REXX program is   speak.rex
usage   using the command:

speak This is an example of speech synthesis. 

Ruby[edit]

Using this module to encapsulate operating system lookup

module OperatingSystem
require 'rbconfig'
module_function
def operating_system
case RbConfig::CONFIG["host_os"]
when /linux/i
:linux
when /cygwin|mswin|mingw|windows/i
:windows
when /darwin/i
:mac
when /solaris/i
:solaris
else
nil
end
end
def linux?; operating_system == :linux; end
def windows?; operating_system == :windows; end
def mac?; operating_system == :mac; end
end
Library: win32-utils
Works with: Ruby version 1.9

Uses espeak on Linux, say on Mac, and the win32 SAPI library on Windows.

load 'operating_system.rb'
 
def speak(text)
if OperatingSystem.windows?
require 'win32/sapi5'
v = Win32::SpVoice.new
v.Speak(text)
elsif OperatingSystem.mac?
IO.popen(["say"], "w") {|pipe| pipe.puts text}
else
# Try to run "espeak". No OperatingSystem check: "espeak" is
# for Linux but is also an optional package for BSD.
IO.popen(["espeak", "-stdin"], "w") {|pipe| pipe.puts text}
end
end
 
speak 'This is an example of speech synthesis.'

Scala[edit]

Library: FreeTTS version 1.2
import javax.speech.Central
import javax.speech.synthesis.{Synthesizer, SynthesizerModeDesc}
 
object ScalaSpeaker extends App {
 
def speech(text: String) = {
if (!text.trim.isEmpty) {
val VOICENAME = "kevin16"
 
System.setProperty("freetts.voices", "com.sun.speech.freetts.en.us.cmu_us_kal.KevinVoiceDirectory")
Central.registerEngineCentral("com.sun.speech.freetts.jsapi.FreeTTSEngineCentral")
 
val synth = Central.createSynthesizer(null)
synth.allocate()
 
val desc = synth.getEngineModeDesc match {case g2: SynthesizerModeDesc => g2}
 
synth.getSynthesizerProperties.setVoice(desc.getVoices.find(_.toString == VOICENAME).get)
synth.speakPlainText(text, null)
 
synth.waitEngineState(Synthesizer.QUEUE_EMPTY)
synth.deallocate()
}
}
 
speech( """Thinking of Holland
|I see broad rivers
|slowly chuntering
|through endless lowlands,
|rows of implausibly
|airy poplars
|standing like tall plumes
|against the horizon;
|and sunk in the unbounded
|vastness of space
|homesteads and boweries
|dotted across the land,
|copses, villages,
|couchant towers,
|churches and elm-trees,
|bound in one great unity.
|There the sky hangs low,
|and steadily the sun
|is smothered in a greyly
|iridescent smirr,
|and in every province
|the voice of water
|with its lapping disasters
|is feared and hearkened."
"".stripMargin)
}

Sidef[edit]

func text2speech(text, lang='en') {
Sys.run("espeak -v #{lang} -w /dev/stdout #{text.escape} | aplay");
}
text2speech("This is an example of speech synthesis.");

Swift[edit]

OS X comes with a program called "say," that does speech.

import Foundation
 
let task = NSTask()
task.launchPath = "/usr/bin/say"
task.arguments = ["This is an example of speech synthesis."]
task.launch()

Tcl[edit]

This just passes the string into the Festival system:

exec festival --tts << "This is an example of speech synthesis."

Alternatively, on MacOS X, you'd use the system say program:

exec say << "This is an example of speech synthesis."

On Windows, there is a service available by COM for speech synthesis:

Library: tcom
package require tcom
 
set msg "This is an example of speech synthesis."
set voice [::tcom::ref createobject Sapi.SpVoice]
$voice Speak $msg 0

Putting these together into a helper procedure, we get:

proc speak {msg} {
global tcl_platform
if {$tcl_platform(platform) eq "windows"} {
package require tcom
set voice [::tcom::ref createobject Sapi.SpVoice]
$voice Speak $msg 0
} elseif {$tcl_platform(os) eq "Darwin"} {
exec say << $msg
} else {
exec festival --tts << $msg
}
}
speak "This is an example of speech synthesis."

UNIX Shell[edit]

Here we use the open source espeak tool:

Works with: Bourne Shell
Works with: bash
#!/bin/sh
espeak "This is an example of speech synthesis."

VBScript[edit]

 
Dim message, sapi
message = "This is an example of speech synthesis."
Set sapi = CreateObject("sapi.spvoice")
sapi.Speak message
 

ZX Spectrum Basic[edit]

This example makes use of the Currah Speech Synthesizer peripheral device.

10 LET s$="(th)is is an exampul of sp(ee)(ch) sin(th)esis":PAUSE 1