Free speech dispatcher software for linux

speechd-el is an Emacs client to Speech Dispatcher, BrlTTY, and other alternative output devices.
speechd-el provides a complex speech/Braille interface to Emacs, and is focused especially on (but not limited to) blind and visually impaired users.
It allows the user to work with Emacs without looking on the screen, using the speech and Braille output.
Enhancements:
- The output mechanism was modularized and redesigned to support multiple output devices.
- The most important impact of this change is BrlTTY support, which works in a way similar to how speech output works.
- This means that speechd-el can be used with both Speech Dispatcher and BrlTTY now.

XML::Filter::Dispatcher is a path based event dispatching with DOM support.

SYNOPSIS

use XML::Filter::Dispatcher qw( :all );

my $f = XML::Filter::Dispatcher->new(
Rules => [
foo => &handle_foo_start_tag,
@bar => &handle_bar_attr,

## Send any elts and their contents to $handler
snarf//self::node() => $handler,

## Print the text of all elements
description
=> [ string() => sub { push @out, xvalue } ],
],

Vars => {
"id" => [ string => "12a" ],
},
);

WARNING: Beta code alert.

A SAX2 filter that dispatches SAX events based on "EventPath" patterns as the SAX events arrive. The SAX events are not buffered or converted to an in-memory document representation like a DOM tree. This provides for low lag operation because the actions associated with each pattern are executed as soon as possible, usually in an elements start_element() event method.

This differs from traditional XML pattern matching tools like XPath and XSLT (which is XPath-based) which require the entire document to be built in memory (as a "DOM tree") before queries can be executed. In SAX terms, this means that they have to build a DOM tree from SAX events and delay pattern matching until the end_document() event method is called.

XML::Filter::Dispatcher::Compiler can compile rulesets in to code.

SYNOPSIS

use XML::Filter::Dispatcher::Compiler qw( xinline );

my $c = XML::Filter::Dispatcher::Compiler->new( ... )

my $code = $c->compile(
Package => "My::Filter",
Rules => [
a/b/c => xinline q{warn "found a/b/c"},
],
Output => "lib/My/Filter.pm", ## optional
);

Most of the options from XML::Filter::Dispatcher are accepted.

NOTE: you cannot pass code references to compile() if you want to write the $code to disk, they will not survive. If you want to eval $code, this is ok.

METHODS

xinline

Hints to X::F::D that the string is inlinable code. This is a requirement when using the compiler and is so far (v.52) ignored elswhere. In xinlined code, $self refers to the current dispatcher and $e refers to the current events data. Or you can get that yourself in $_[0] and $_[1] as in a normal SAX event handling method.

compile

Accepts options that extend and override any previously set for the duration of the compile(), including the ruleset to compile.

Speegle Define is a Firefox extension that gives a spoken definition of a word using Speegle Speech Technology. You highlight the word you would like explained with highlight left click on any internet page you are reading.

Right click and choose "Audio Definition" from the pop up menu and its definition will be read back to you in English through your speakers or headphones.

GNOME Speechs purpose is to provide a simple general API for producing text-to-speech output.
The GNOME Speech 1.0 API is currently under development, and it will provide API for both text-to-speech output as well as speech input. It will be heavily influenced by the Java Speech API, both the existing 1.0 specification, and the new 2.0 one which is currently under development.
GNOME Speech 0.4 is made up of three basic parts:
- IDL interface definitions
- libgnomespeech - Convenience library for speech driver development
- Java package to aid in developing GNOME Speech drivers in Java
- Sample driver implementations

Log::Dispatch::Config is a Log4j for Perl.

SYNOPSIS

use Log::Dispatch::Config;
Log::Dispatch::Config->configure(/path/to/log.conf);

my $dispatcher = Log::Dispatch::Config->instance;
$dispatcher->debug(this is debug message);
$dispatcher->emergency(something *bad* happened!);

# automatic reloading conf file, when modified
Log::Dispatch::Config->configure_and_watch(/path/to/log.conf);

# or if you write your own config parser:
use Log::Dispatch::Configurator::XMLSimple;

my $config = Log::Dispatch::Configurator::XMLSimple->new(log.xml);
Log::Dispatch::Config->configure($config);

Log::Dispatch::Config is a subclass of Log::Dispatch and provides a way to configure Log::Dispatch object with configulation file (default, in AppConfig format). I mean, this is log4j for Perl, not with all API compatibility though.

METHOD

This module has a class method configure which parses config file for later creation of the Log::Dispatch::Config singleton instance. (Actual construction of the object is done in the first instance call).

So, what you should do is call configure method once in somewhere (like startup.pl in mod_perl), then you can get configured dispatcher instance via Log::Dispatch::Config->instance.

KTTS - KDE Text-to-Speech is a subsystem within the KDE desktop for conversion of text to audible speech.
KTTS is currently under development and aims to become the standard subsystem for all KDE applications to provide speech output.
Main features:
User Features:
- Speak any text from the KDE clipboard.
- Speak any plain text file.
- Speak all or any portion of a text file from Kate.
- Speak all or any portion of an HTML page from Konqueror.
- Use as the speech backend for KMouth and KSayIt.
- Speak KDE notifications (KNotify).
- Long text is parsed into sentences. User may backup by sentence or paragraph, replay, pause, and stop playing.
- Audio output via aRts or GStreamer (version 0.8.7 or later)
Programmer Features:
- Priority system for screen reader outputs, warnings and messages, while still playing regular texts.
- Plugin-based architecture for support of a wide variety of speech synthesis engines and drivers.
- Permit generation of speech from the command line (or via shell scripts) using the KDE DCOP utilities.
- Provide a lightweight and easily usable interface for applications to generate speech output.
- Applications need not be concerned about contention over the speech device.
- FUTURE: Provide support for speech markup languages, such as VoiceXML, Sable, Java Speech Markup Language (JSML), and Speech Markup Meta-language (SMML).
- FUTURE: Provide limited support for embedded speech markers.
- Asynchronous to prevent system blocking.