| Edinburgh Speech Tools Library |
--- | --- | ---
Prev | Chapter 2. Licence, Installation and Acknowledgements | Next

# Installation

## Release notes

This documentation covers version 1.2.0 of the Edinburgh Speech Tools Library. While previous versions of the speech tools were primarily released solely to support the Festival Speech Synthesis System, the Edinburgh Speech Tools Library now contains sufficiently useful tools that it is of use in its own right.

Although hope that the speech tools has stabilised to a certain extent and less structural changes will occur in future versions we don't guaranteed future compatibility, although every effort will be made to make upgrading as easy as possible. In addition, we warn that while several programs and routines are quite mature, others are young and have not be rigorously tested. Please do not assume these programs work.

## Requirements

In order to compile and install the Edinburgh Speech Tools you need the following

### GNU make

Any recent version, the various make programs that come with different UNIX systems are wildly varying and hence it makes it too difficult to write `Makefile`s which are portable, so we depend on a version of make which is available for all of the platforms we are aiming at.

### A C++ compiler

The system was developed primarily with GNU C++ version 2.7.2, but we also have compiled it successfully with a number of other versions of gcc, Sun CC and Visual C++.

Hopefully we have now sanitized the code sufficiently to to make it possible for ports to other C++ compilers without too much difficulty. But please note C++ is not a fully standardized language and each compiler follows the incomplete standard to various degrees. Often there are many but simple problems when porting to new C++ compilers. We are trying to deal with this by increasing our support. However, it is likely that small changes will be required for C++ compilers we have not yet tested the system under.

However we feel this is stable enough to make it worthwhile attempting ports to other C++ compilers that we haven't tried yet.

Before installing the speech tools it is worth ensuring you have a fully installed and working version of your C++ compiler. Most of the problems people have had in installing the speech tools have been due to incomplete or bad compiler installation. It might be worth checking if the following program works, if you don't know if anyone has used your C++ installation before.

#include <iostream.h> int main (int argc, char **argv) { cout << "Hello world\n"; }

### Supported Systems

We have successfully compiled and tested the speech tools on the following systems, except where specified we include support for both shared and static versions of the libraries:

Sun Sparc Solaris 2.5.1/2.6/2.7
  GCC 2.7.2, GCC 2.8.1, SunCC 4.1, egcs 1.1.1, egcs 1.1.2

Sun Sparc SunOS 4.1.3
  GCC 2.7.2 (static only)

Intel Solaris 2.5.1
  GCC 2.7.2

FreeBSD for Intel 2.1.7, 2.2.1, 2.2.6 (aout), 2.2.8 (aout), 3.x (elf)
  GCC 2.7.2.1 (static only)

Linux (2.0.30) for Intel (RedHat 4.[012]/5.[01]/6.0)
  GCC 2.7.2, GCC 2.7.2/egcs-1.0.2, egcs-1.1.2

Windows NT 4.0, Windows95, Windows 98
  GCC with egcs (from Cygwin b20.1), Visual C++ 5.0. (static only)

As stated before C++ compilers are not standard and it is non-trivial to find the correct dialect which compiles under all. We recommend the use of GCC 2.7.2 if you can use it, it is the most likely one to work. Some of the compilers listed above produce a large number of warnings when compileing the code.

Previous versions of the system have successfully compiled under SGI IRIX 5.3, OSF (Alphas) and HPUX but at time of writing this we have not yet rechecked this version.

### Java Support

The `java` directory contains optional `Java` classes which give some access to speech tools facilities from `Java` programs. This has been created to support the fringe graphical interface. There are two levels of support enabled by the `JAVA` and `JAVA_CPP` options in the `config` file. `JAVA` compiles some very basic classes intended to allow very simple simulation of speech tools facilities in pure `Java` programs. `JAVA_CPP` compiles classes which use the `Java` native interface to provide access to the actual speech tools `C++` classes.

You may (for instance on Solaris using gcc) need to make shared libraries for some compiler support libraries in order to comple the full `JAVA_CPP` support. See Appendix A for details.

### Windows 95/98/NT Port

We have done two ports of this code to Windows machines, one uses the Cygwin package, which provides a Unix like environment under on Win32 systems, the other is a native port using Visual C++.

For our full Windows NT and Windows 95/98 ports we use the Cygnus Cygwin environment (version b20.1) available from http://sourceware.cygnus.com/cygwin/. Windows 98 is significantly more stable than Windows 95, especially when many processes are started and stopped as is the case when compiling with Cygwin. We strongly reccoment 98 rather than 95 be used if at all possible. However with both 95 and 98 you can expect Windows to occasionally lock up or complain it is unable to start new processes or otherwise missbehave. You will be restarting windows regularly. A Windows NT system should not have these problems.

The port using Visual C++ does not provide all of the features of the Unix and Cygwin versions. You will need access to a Unix or Cygwin system to create the makefiles used for the Visual C++ compilation.

Both Cygwin and Visual C++ ports have a number of limitations.

Shared library creation is not supported.
  Creation of Windows `DLL`s is different enough from creation of Unix shared libraries that the support does not carry directly accross, and we haven't yet had time to work on it.

Java not supported
  Because the `Java` support is related to the creation of shared libraries, this is also not yet implemented for Windows.

Command line editing limited
  Because of the limiots of the Windows DOS console window, the command line editing in siod is less reliable (for instance on very long lines).

(Visual C++) Networking not supported
  Networking under Win32 is different from Unix in a number of fairly fundamental ways, we haven't tackled this at all.

There are no doubt other differences we hve not noticed. We don't use Windows for any of our work and so the Windows builds of our systems don't get the extensive use the unix builds do.

## Building It

### Configuration

All compile-time configuration for the system is done through the user definable file `config/config`. You must create this file before you can compile the library. An example is given in `config/config-dist`, copy it and change its permissions to give write access

`unix$` `cd config` `unix$` `cp config-dist config` `unix$` `chmod +w config`

In many cases no further changes will be required, but it might be worth checking the contents of this file just in case. Where possible the system will automatically config itself.

Type

`unix$` `gnumake info`

This will create the local config files and display what it thinks your system is.

If this is not suitable for your machine then edit your `config/config`. In most cases the default will be the best option. If you are unsure about what you should change you probabaly shouldn't change anything.

As of 1.3.1 due to conflicts in copyright we have dropped GNU Readline support and replaced it with a differently licenced alternative which does not imposes the restrictions of the GPL. editline is a free command line editor library. We have added substantially to it, including support for long lines, incremental search and completion. However as it has not yet been testsed on many systems it is still optional, though is on by default.

For Linux we now fully supported shared libraries and even recommend them. However if you are going to do alot of development and don't understand the consequences of shared libraries and getting LD_LIBRARY_PATH correct (or what that is) we recommend you compile unshared, the default. If you are going to simply run the speech tools (and festival) then shared is a reasonable option. Uncomment the line in the config file

# SHARED = 1

Shared support under Solaris is complete for all the speech tools. If you need to exec festival scripts using a version of festival built with shared libaries, you must either execute them from a featureful shell (e.g. `bash`), install the shared libraries in a standard place or explicitly set LD_LIBRARY_PATH. Solaris's standard shell doesn't support script excutaiton of shells within shells.

Simple choices for common set ups are given near the top of this file. But for some sub-systems you will also need to change pathnames for external library support.

At present read `config/ReadMe` for details of changing basic configuration.

On systems (and versions of systems) we have not yet encountered you may need to create `config/systems/<PROCESSOR>_<OS><OSVERSION>.mak` files. Often you need only copy an existing one (other version or similar system) to get it to work. Typically the only real differences are when there are major differences in the default C++ compiler (e.g. RedHat 5.0 to RedHat 5.1). If you do need to add a new systems configuration file please let as know so we can include it in the standard distribution.

### Compilation

Once you have configured `config/config` you can compile the system.

`unix$` `gnumake`

Note this must be GNU make, which may be called make on your system, or gmake or gnumake. This will compile all library functions and all the executables. If you wish to only compile the library itself then use

`unix$` `gnumake make_library`

Note that if you compile with `-g` (uncommenting `DEBUG = 1` is `config/config` the library and the corresponding binaries will be large. Particulary the executables, you will need in order of 150 megabytes to compile the system, if your C++ libraries are not compiled as shared libraries. If you compile without `-g` the whole library directory is about 12 megabytes on Linux (which has shared libraries for `libstdc++` or about 26 megabytes of Sparc Solaris (which does not have a shared library `libstdc++` by default). This is almost entirely due to the size of the executables. C++ does not make small binaries.

In general we have made the system compile with no warnings. However for some compilers this has proved to be near impossible. SunOS include files have a number of system declarations missing, so many system functions (e.g. `fprintf`) will appear to be undeclared. Sun's CC compiler also likes to complain about missing source for some code even though the code exists within our system and is deliberately in separate files ro make it modular.

To test the system after compilation

`unix$` `gnumake test`

### Installing the system

All executables are linked to from `speech_tools/bin` and you should add that to your `PATH` in order to use them.

Include files are `speech_tools/include/` and the three generated libraries are `speech_tools/lib/libestools.a`, `speech_tools/lib/libestbase.a` and `speech_tools/lib/libestring.a`. For most cases a three will be required.

If space is a preminium, compiled with the shared option (binaries will be then be substantially smaller) and you can delete all `.o` files

Some aspects of the system have further dependencies which depend of the option selected at compile time. Specifically the readline libraries and Netaudio libraries.

### Building on Windows 95/98/NT

There are two ways to build the system under Windows. The Cygwin system provides a unix-like environment in which you can perform a compilation as described in the previous sections. Cygwin is probably the best choice if you can use that route.

Visual C++ provides an environment much further from the Unix systems our code is developed on, this places some limits on the Visual C++ port, especially in areas relating to networking. The remainder of this section describes how to compile with Visual C++.

#### Creating `VCMakefile`s

We compile using the nmake program which comes with Visual C++. This is a fairly standard make implementation, but is not as flexible as the GNU make we use for our normal builds. So, in order to compile with nmake new `Makefile`s are needed. These can be created from the Unix makefiles using GNU make:

`unix$` `gnumake VCMakefile` Creating VCMakefile for . Creating VCMakefile for include Creating VCMakefile for include/unix [...]

Obviously you will need either a unix machine or the Cygwin system to do this. Sharing the compilation directory between unix and Windows machines, for instance using samba

#### Configuration

As for unix compilations, the Visual C++ compilation process is controlled by a configuration file. In this case it is called `vc_config_make_rules`. A version is included in the distribution, as `vc_config_make_rules-dist`, copy this into place as follows:

`unix$` `cd config` `unix$` `cp vc_config_make_rules-dist vc_config_make_rules` `unix$` `chmod +w vc_config_make_rules`

You probably don't need to change this default configuration.

#### Building

To build the system:

`unix$` `nmake /nologo /fVCMakefile`

This should build the libraries and executables, and also the test programs in `testsuite`. However there is currently no way to automatically test the system, Indeed some of the test programs will fail under Visual C++ due to differences in file nameing conventions.

Prev | Home | Next
What is new | Up | Executable Programs