40

I'm wondering if any of the ancient 1980's style text to speech algorithms were saved from oblivion and are still available. It might be nice to hear that vintage sound like what appeared in War Games.

13
  • 3
    Yes, I've seen one on c64. – peterh Dec 6 '20 at 0:58
  • 11
    S.A.M. (Software Automatic Mouth) is available for the Atari 8-bit home computers, the Commodore 64, and (with a hardware addon) the Apple II. en.wikipedia.org/wiki/Software_Automatic_Mouth – Tim Locke Dec 6 '20 at 2:30
  • 1
    There was a chip for it, SP0256 (I still have one). – Peter Mortensen Dec 6 '20 at 14:46
  • 3
    AmigaOS includes speech synthesis and text-to-speech for the Motorola 68000. I think Classic Mac OS too. See also retrocomputing.stackexchange.com/questions/5920/… – Brian H Dec 6 '20 at 15:59
  • 2
    Slightly OT but still worth remembering: 386 DX was "the world's first cyberpunk band" created by Russian artist Alexei Shulgin. He manipulates an antiquated computer with Microsoft Windows version 3.1 and an Intel 386 processor to perform MIDI (Musical Instrument Digital Interface) renditions of popular music hits while a synthesized text-to-speech voice "sings" the lyrics. vimeo.com/20484803 – Joe Dec 16 '20 at 13:32

17 Answers 17

31

Superior Software's "Speech" was a pure software speech synthesizer that ran on the BBC Micro (which used a 2MHz 6502A processor, so had slightly more raw processing power than typical 8-bit machines); it is described in detail on this page, which states it was inspired by similar programs on C64 and Spectrum that achieve it using sound chips (so the Spectrum must have been the 128K version, as the original 16/48K versions had no sound chip) but this system just uses direct control of the built-in speaker to produce the sound.

4
  • The software was also available for the Amstrad CPC, and could be included as a routine in Basic programmes. cpcrulez.fr/… – Mark Williams Dec 6 '20 at 9:04
  • 2
    This was a software product, incidentally, that basically killed all demand for the hardware-based speech synthesis product that was designed in (as an optional extra) to the BBC Micro. Sitting on the so-called "slow bus" next to the main sound chip are a pair of DIP sockets which will accept a TI TTS chip and associated sample ROM. The hardware speech was much higher quality than the "Superior" version, but also cost much more. – Chromatix Dec 6 '20 at 17:38
  • Correct me if I'm wrong but I think "Speech" made use of an accidental feature of the BBC's sound system - I don't know the details. – Rodney Dec 8 '20 at 14:33
  • +1 fascinating to learn about the implementaton in the link bbc.nvg.org/doc/Speech.html - do we know what the bit depth/resolution was? I'd guess it would have been 8 bits per sample or lower. – therobyouknow Dec 11 '20 at 17:12
23

First, there is a major caveat. Most of the iconic early voice synthesizers were not purely software systems. For example, the classic DECTalk system, famously the voice of the late Stephen Hawking, was a discrete unit that connected by serial RS-232. It is effectively a closed box that is sent ASCII text and generates line-level audio. Internally, I vaguely recall reading that it's a mix of a general-purpose processor with dedicated signal processors and audio synthesis hardware. The Ti LPC speech synthesis chips, as used in the Speak and Spell products, were similar. The chips can synthesize basic phonemes and words, and a microcontroller or microprocessor has to do the text analysis and drive the synthesis chip.

The fact is that the classic 8/16 bit processors just don't have enough oomph to pull off speech synthesis in software well, at least in real time. Still, there were a number of respectable attempts. SAM (Software Automatic Mouth) was one of the first, and one of the more popular. It runs on the Commodore 64 and other machines. A clever hacker recently ported the algorithm to Javascript, so you can hear it in your browser.

7
  • 2
    There's an LGR Oddware episode on the DECTalk PC which includes a history lesson if anyone wants to know more. – ssokolow Dec 6 '20 at 3:05
  • 2
    DECTalk is also interesting because the high-level protocol it used is still widely used in a number of places. You can get USB TTS units today that present as a serial port and use the DECTalk protocol, and it’s also possible to find embedded modules like the EMIC 2 that provide a TTL serial interface and use the DECTalk protocol. – Austin Hemmelgarn Dec 6 '20 at 15:43
  • 2
    The DECTalk hardware was definitely not 8-bit, though. The DTC-01 used a 68000 and a TMS32010 DSP, while the cost-reduced DTC-03 used the Intel 80186 with the same DSP (source, DTC-01 schematic). They're still much in demand as assistive technology devices. – scruss Dec 6 '20 at 17:14
  • 1
    It's not well know, but DEC had a preliminary version of DECTalk that ran on the Rainbow (without the appliance, AFAIK). I don't think that was ever released, however, this site claims to have found something that may be it: hackaday.io/project/… – RBarryYoung Dec 6 '20 at 19:25
  • 1
    @RBarryYoung alas, that's the Windows software version, much later than the Rainbow. DECTalk as software on Windows is well known. The Rainbow's 8088 would have been a real push to run the DECTalk model at any speed, as that TI DSP did a lot of heavy lifting. – scruss Dec 6 '20 at 22:26
20

There existed a Russian text-to-speech program written for the Elektronika BK-0010 in the early 1980s, whose length was 023500 bytes == 10048, mentioned in a list of application programs for the BK-0010 under the name of ГОВОРУН ("Chatterer", after a talking bird in a childrens' book/cartoon The Mystery of the Third Planet).

Its sound quality was barely recognizable for an untrained ear, partially because the computer had only a 1-bit manipulated buzzer, but reportedly it had been written by request of the All-Union Society of the Blind, and it took the members of the target audience about 10-15 minutes to get accustomed to it and to start using it productively.

The trick was to record the phonemes using as narrow a frequency band as necessary for marginal recognition, and to encode each phoneme using as low a frequency as possible for that specific phoneme. This process has made some phonemes, like S and F, sound pretty much the same, allowing to save more memory by folding them.

Needless to say, there was the phonetic alphabet spelling mode, switchable by a keypress, and "repeat last word" and/or "repeat last sentence" keys as well.

3
  • "All-Union", cool. Did it support many languages or Russian only? – OmarL Dec 6 '20 at 7:56
  • @OmarL just a clarification: "All-Union" means that it operated across the whole territory of the USSR (where the first letter stands for Union). – IMil Dec 7 '20 at 0:03
  • 4
    @IMil Of course, as in всесоюзный, right? – OmarL Dec 7 '20 at 6:53
17

Is the 68000 a 16-bit CPU? :) To some it is, and therefore Say, from 1985, for the Commodore Amiga counts. It can be found on the Workbench disk. For more reading, look up the narrator.device interface on the AmigaOS wiki: https://wiki.amigaos.net/wiki/Narrator_Device

And here's Steamed Hams recreated using Say: https://www.youtube.com/watch?v=Rx6mJ4XY0oQ

13

see:

In there are TTS engines for ZX Spectrum (1bit digital sound, no DAC, no FPU, no mul/div instructions, ~3.5 MHz 8bit Z80 CPU):

  1. Kecal 1.0

    very simple asm, (portable to C/C++ see the link below), very low demands on CPU. It is not very good quality

  2. Kecal 2.3

    much improved quality

  3. ZX Fone

    its slightly worse than Kecal 2.3

  4. Hlasovy program

    this one is very good quality (much better than Kecal 2.3, you can recognize the words easily). Its just 801 Bytes of assembly code.

also see:

[Edit1] C++ port of Hlasový program

I am happily announcing that I successfully disassembled and port the awesome ancient TTS engine from Voicesoft into C++. For simplicity I added sound API header void sound_out(bool on); that must be implemented in order to use this. It should simply add a sample to sound buffer (or synchronize with time and output to sound port). Here the ported code:

//---------------------------------------------------------------------------
//---  ZX Hlasovy program Voicesoft 1985  -----------------------------------    
//--- ported to C++ by Spektre ver: 1.000 -----------------------------------
//---------------------------------------------------------------------------
#ifndef _speech_h
#define _speech_h
//---------------------------------------------------------------------------
// API:
void sound_out(bool on);    // you need to code this function (should add a sample to sound output)
void say_text(char *txt);   // say null terminated text, "a'c'" -> "áč"
//---------------------------------------------------------------------------
// internals:
void say_char(char chr);    // internal function for single character (do not use it !!!)
void say_wait(WORD ws);     // internal wait (do not use it !!!)
//---------------------------------------------------------------------------
// vars:
bool _sound_on=false;       // global state of the reproductor/sound output
//---------------------------------------------------------------------------
// config: (recomputed for 44100 Hz samplerate)
const static BYTE t_speed=5;        // [samples] speech speed (pitch)
const static WORD t_pause=183;      // [samples] pause between chars
const static WORD t_space=2925;     // [samples] pause ` `
const static WORD t_comma=5851;     // [samples] pause `,`
//---------------------------------------------------------------------------
// tables:
const static BYTE tab_char0[52]=    //  0..25 normal alphabet A..Z
    {                               // 26..51 diacritic alphabet A..Z
    0x00,0x02,0x06,0x0a,0x0e,0x10,0x12,0x16,0x1a,0x1c,0x22,0x26,0x2a,0x2e,0x32,
    0x34,0x38,0x42,0x48,0x4a,0x4e,0x50,0x50,0x56,0x1a,0x5c,0x64,0x66,0x70,0x74,
    0x7a,0x7c,0xc2,0x84,0x86,0xc2,0xc2,0xc2,0x88,0x8c,0x92,0x94,0xc2,0x9e,0xa6,
    0xa8,0xae,0xb0,0xc2,0xc2,0x86,0xbc
    };
const static BYTE tab_char1[196]=
    {
    0x36,0x81,0x34,0x19,0x31,0xab,0x18,0x19,0x91,0xc3,0x34,0x19,0x31,0xe0,0x36,
    0x84,0x92,0xe3,0x35,0x19,0x51,0x9c,0x31,0x31,0x34,0x96,0x36,0x87,0x33,0x3a,
    0x32,0x3d,0x32,0xc0,0x18,0x19,0x51,0x9c,0x33,0x22,0x31,0xb1,0x31,0x31,0x36,
    0xa5,0x31,0x31,0x36,0xa8,0x36,0x8a,0x18,0x19,0x31,0xab,0x18,0x19,0x51,0x1c,
    0x34,0x31,0x32,0x34,0x32,0xb7,0x22,0x10,0x13,0x19,0x21,0xae,0x92,0xc3,0x18,
    0x19,0x31,0xe0,0x36,0x8d,0x34,0x31,0x32,0x34,0x32,0xb7,0x18,0x19,0x71,0x1c,
    0x92,0xc3,0x32,0x31,0x32,0x43,0x32,0x44,0x32,0xc5,0x3f,0x81,0x34,0x19,0x31,
    0x2b,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x18,0x19,0x91,0xd3,0x33,0x19,0x71,0x6d,
    0x32,0x93,0x3e,0x84,0x92,0x63,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x92,0xf3,0x3e,
    0x87,0x31,0x31,0x36,0x25,0x31,0x31,0x35,0x25,0x32,0x93,0x3e,0x8a,0x18,0x19,
    0x31,0x2b,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x13,0x19,0x32,0x60,0x13,0x19,0x71,
    0xdd,0x92,0xd3,0x18,0x19,0x71,0x6d,0x32,0x93,0x3e,0x8d,0x34,0x31,0x32,0x34,
    0x32,0x37,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x32,0x53,0x32,0x54,0x32,0xd5,0x1a,
    0x99
    };
const static BYTE tab_char2[262]=
    {
    0x1a,0x99,0xe1,0xc3,0xe1,0xc7,0x8f,0x0f,0xf8,0x03,0x0f,0x07,0xc1,0xe3,0xff,
    0x40,0x17,0xff,0x00,0x03,0xf8,0x7c,0xc1,0xf1,0xf8,0x03,0xfe,0x00,0x7f,0xfc,
    0x00,0x03,0xf8,0x0f,0x09,0xf1,0xfe,0x03,0xef,0x40,0x17,0xff,0x00,0x03,0xe1,
    0x5c,0x35,0xc5,0xaa,0x35,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x8e,0x38,0x73,
    0xcf,0xf8,0x78,0xc3,0xdf,0x1c,0xf1,0xc7,0xfe,0x03,0xc0,0xff,0x00,0x00,0xff,
    0xf8,0x00,0x7f,0xf8,0x03,0xff,0xf0,0x01,0xff,0xe0,0x03,0xaa,0xca,0x5a,0xd5,
    0x21,0x3d,0xfe,0x1f,0xf8,0x00,0x00,0x1f,0xff,0xfc,0x20,0x00,0x00,0x03,0xff,
    0xff,0x08,0x79,0x00,0x02,0xff,0xe1,0xc7,0x1f,0xe0,0x03,0xff,0xd0,0x01,0xff,
    0xf0,0x03,0x7f,0x01,0xfa,0x5f,0xc0,0x07,0xf8,0x0f,0xc0,0xff,0x00,0x42,0xaa,
    0xa5,0x55,0x5a,0xaa,0xaa,0x5a,0xa5,0x5a,0xaa,0x55,0x55,0xaa,0xaa,0xa5,0x55,
    0xaa,0x5a,0xaa,0xa5,0x55,0xaa,0xaa,0xa5,0x55,0xaa,0xaa,0x55,0xa5,0xa5,0xaa,
    0xa5,0xb7,0x66,0x6c,0xd8,0xf9,0xb3,0x6c,0xad,0x37,0x37,0x66,0xfc,0x9b,0x87,
    0xf6,0xc0,0xd3,0xb6,0x60,0xf7,0xf7,0x3e,0x4d,0xfb,0xfe,0x5d,0xb7,0xde,0x46,
    0xf6,0x96,0xb4,0x4f,0xaa,0xa9,0x55,0xaa,0xaa,0xa5,0x69,0x59,0x9a,0x6a,0x95,
    0x55,0x95,0x55,0x6a,0xa5,0x55,0xa9,0x4d,0x66,0x6a,0x92,0xec,0xa5,0x55,0xd2,
    0x96,0x55,0xa2,0xba,0xcd,0x00,0x66,0x99,0xcc,0x67,0x31,0x8e,0x66,0x39,0xa6,
    0x6b,0x19,0x66,0x59,0xc6,0x71,0x09,0x67,0x19,0xcb,0x01,0x71,0xcc,0x73,0x19,
    0x99,0xcc,0xc6,0x67,0x19,0x9a,0xc6,
    };
const static BYTE tab_char3[5]={ 0x00,0x2e,0x5a,0x5e,0xfe };
//---------------------------------------------------------------------------
void say_text(char *txt)
    {
    WORD hl;
    BYTE a,b,c;
    for (b=0xBB,hl=0;;hl++)     // process txt
        {
        a=b;                    // a,c char from last iteration
        c=b;
        if (!a) break;          // end of txt
        b=txt[hl];              // b actual char
        if ((b>='a')&&(b<='z')) b=b+'A'-'a'; // must be uppercase
        a=c;
        if ((a>='A')&&(a<='Z'))
            {
            // handle diacritic
            if (a!='C'){ a=b; if (a!='\'') a=c; else{ a=c; a+=0x1A; b=0xBB; }}
            else{
                a=b;
                if (a=='H'){ a+=0x1A; b=0xBB; }
                 else{ if (a!='\'') a=c; else{ a=c; a+=0x1A; b=0xBB; }}
                }
            // syntetize sound
            say_char(a);
            continue;
            }
        if (a==',')say_wait(t_comma);
        if (a==' ')say_wait(t_space);
        }
    }
//----------------------------------------------------------------------
void say_wait(WORD ws)
    {
    for (;ws;ws--) sound_out(_sound_on);
    }
//----------------------------------------------------------------------
void say_char(char chr) // chr =  < `A` , `Z`+26 >
    {
    WORD hl,hl0,cy,cy0;
    BYTE a,b,c,ws;
    hl=tab_char0[chr-'A'];
    for (;;)
        {
        c =tab_char1[hl  ]&0x0F;
        c|=tab_char1[hl+1]&0x80;
        for (;;)
            {
            a=tab_char1[hl];
            a=(a>>5)&7;
            cy=a&1;
            hl0=hl;
            if (a!=0)
                {
                b=tab_char3[a];
                hl=hl0;
                a=tab_char1[hl+1];
                hl0=hl;
                cy0=(a>>7)&1;
                a=((a<<1)&254)|cy;
                cy=cy0;
                hl=a;
                a=0x80;
                for (;;)
                    {
                    _sound_on=(a&tab_char2[hl]);
                    for (ws=t_speed;ws;ws--) sound_out(_sound_on);
                    b--;
                    if (!b) break;
                    cy=a&1;     
                    a=((a>>1)&127)|(cy<<7);
                    if (!cy) continue;
                    hl++;
                    }
                }
            a^=a;
            say_wait(t_pause);
            c--;
            a=c&0x0F;
            hl=hl0; 
            if (a==0) break;
            }
        cy0=(c>>7)&1;
        a=((c<<1)&254)|cy;
        cy=cy0;
        if (cy) return;
        hl+=2;
        }
    }
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

It does not use any libs,files or whatever... If your environment does not have BYTE,WORD then use unsigned int instead... I tried it with 44100Hz sampling rate on PC and the sound is superior to any other TTS I tried over the years.

The sound is quite good even on AVR32 (however need a normal reproduktor instead of the small beepers).

In case you're interested how it works see this:

Where much more in depth analysis (up to the last bit of data) and much more didactical code and data can be found for this.

Here a small win32/waveout demo for testing just do not forget to write the text phoneticaly... have fun:

It responds to these keys:

  • [enter ] will send text from edit box to TTS
  • [up arrow] will return last string to edit box
  • [escape ] clears the edit box
3
  • Speaking about the ZX Spectrum, do not forget to mention the Currah MicroSpeech Synthesizer, a hardware speech box: en.wikipedia.org/wiki/… – Martin Maly Dec 7 '20 at 16:20
  • @MartinMaly Hard to say if that one is considered "running" on 8/16 bit as it includes dedicates speech processor its more like "connecting" instead. btw. I am in process of porting the Hlasovy program into C++ I want to try it on AVR32 as the Tiny Speech Synth and Kecal 1.0 did not sound good on it and #4 sounds superior to any usable TSS I found. I am maybe in 75% of code. but still I will fight with tables and also hit a small wall with balconing (goto statements) and carry behavior on rotations (I forgot few asm instructions exact meaning). Once done will post it somewhere. – Spektre Dec 7 '20 at 19:54
  • @MartinMaly I did the porting to C++... it worked both on PC and even on AVR32 ... with lots of CPU power to spare ... – Spektre Dec 10 '20 at 19:43
7

Of course there was the Acorn Speech System for the BBC Micro.
This required two Texas Instruments chips to be fitted below the keyboard, so was not a pure software solution.

Acorn Speech Manual Cover

Different to most of the other answers in that it took phoneme input rather than pure text but that meant that it gave much clearer, comprehensible audio than many of its competitors.
Back in the day I used it do provide alarms in a process automation setting. It was deemed much safer to have a call like Crane A Descending, or "Crane B Ascending" than to have a range of different bleeps that everyone forgot which was which.

It famously used the digitized voice of Kenneth Kendall, a BBC newsreader at the time. He also appeared in the film 2001: A Space Odyssey, playing a BBC newsreader.

6

Another such program from the early ’80s was the Software Automatic Mouth. I also had hazy memories of a demo of The Voice by Muse Software, for Apple ][e. (“Merry Christmas from Santa and the voice of Muse ....”)

2
  • 1
    For the 'Merry Christmas' part, that wasn't SAM but rather 'The Voice' from Muse Software. There were a few demos on the disk and that sounds exactly like the Santa demo. Unlike SAM which was a phonetic text-to-speech, The Voice was simply a primitive sampler that used the cassette port. – bjb Dec 9 '20 at 17:29
  • 1
    @bjb Thanks! It's been a very long time. – Davislor Dec 9 '20 at 18:44
5

The Texas Instruments TI-99/4A could do text-to-speech if you had the Terminal Emulator II cartridge and the Solid State Speech Synthesizer. (More information about the latter can be found in the manual.)

Solid State Speech Synthesizer

5

For the 1980's Microbee (z80) there was a hardware module named "Bee Talker" which plugged into a parallel port. It looks nearly exactly like the "Beethoven" unit in this image (seen sitting next to the "keyboard"), except it was labelled "Beetalker":

Microbee Computer

It had a simple Text-to-Speech software interface that came with the module. Whatever you typed in the console would be somewhat weirdly converted to speech. I don't remember exactly what worked well, but sometimes you had to phonetically misspell the word to get the desired result.

The module has been re-released should you want to connect it to an Arduino or whatever.

EDIT: Finally found a better image:

beetalker & beethoven

1
  • 2
    Thanks! Looks like this is based on the very popular SP0256-AL2 chip from the 1980s. It's good they've released it in a dual MicroBee/Arduino compatible module this time round – scruss Dec 9 '20 at 2:40
5

You can find various incarnations of the formant synthesizer underlying DECTalk here

I doubt you could get satisfactory results on an 8-bit processor. 16-bit, yes (though you may need to rewrite the floating point code as fixed point). I assume the original Macintalk used a fairly similar algorithm, though I never saw that source code. MacinTalk 3 ("Fred" and related voices), that has been available on Macs for more than 30 years, uses a similar method.

Klatt also wrote a fairly readable book describing a somewhat earlier system.

Ultimately, it's probably memory that is the limiting factor for a 1980s system. Processing power of 16 bit processors is OK for formant synthesis, but in English, you're never going to have very accurate pronunciation without a large dictionary or an enormous rule set.

4

Here is an online version of S.A.M. for c64, you can type some text onto the web page and tape the audio: https://discordier.github.io/sam/

There are music plugins also based on mac and atari st which are designed for music enhancements on top of the original speech engine code: https://www.youtube.com/watch?v=FmaeI5eoeH0&ab_channel=PlogueArtetTechnologie%2CInc. there are demo versions of it someplace on the web.

4

The IIgs has enough hardware to pull off pretty good software only speech using SmoothTalker. The speech engine from SmoothTalker was used in a number of other IIgs programs including the Talking series for reading and math. Even a typing program for the IIgs used speech, my daughter used it and the speech is pretty good by current standards.

1
3

War Games... was not actually computer generated

You mention the War Games voice. It was not an artificial voice, but an actor. He said the sentences with words in reversed order, which were edited later. Ref:

What you've been asking for: "...saved from oblivion and are still available"

Yes! Thanks to the 8bit guy for the information. You can:

This does compile and work on a modern machine.

Software-only solutions, of the era

It looks like there is a full software-based solution (I have not tested it): https://cpcrulez.fr/applications_music-superior_software-speech__MANUEL__ENGLISH.htm

Common solution at the time: 8-bit speaking machines often used dedicated optional chips

As mentioned in one comment, during the 8bit era, common solutions used dedicated chips.

Example: the SSA-1 for the Amstrad CPC

Typically, it was a multi-tier solution.

Below is outlined the example of SSA-1 the Amstrad CPC:

  • the early (high-level) part of the text-to-speech was done on the host computer CPU, and transformed regular (English) text into a series of allophones (typically, 64 different) -- this could be bypassed using an API that provides a way to directly request a series of allophones. On the Amstrad CPC, both options were available: user was offered to load specific software, made additional commands "RSX" available from Basic, (and therefore from assembly code, too, although assembly production would typically directly target the next step because they don't need to parse generic English sentence, only pronounced pre-defined utterances).
  • allophones codes were transmitted to the chip, one byte per allophone, via regular I/O interchip communication
  • on the chip, a real-time microcontroller turned allophone codes into low-level vocal tract simulation parameters, and tuned in real time the hardware registers to command the next step
  • dedicated hardware performed the digital computation of the vocal tract model, and output a PCM signal
  • a digital-to-analog step provided analog output signal at line level
  • an amplifier brings signal to speaker level.

All those steps (including the speakers) are integrated in the SSA-1 solution for the Amstrad CPC. In the very first step, the solution is software running on the host computer, the rest is extra hardware.

More details on the SSA-1: Amstrad SSA-1 Speech Synthesizer - CPCWiki

2

The early days of audio on IBM PC compatibles have a few examples of speech synthesis. These qualify for your 16-bit category as the 8088 and 80286 were 16-bit CPUs (though the 8088 was crippled by an 8-bit data bus).

The Covox Speech Thing was a parallel port DAC intended to be used with software-based speech synthesis. I assume such a program came with it, given that while there were a decent number of programs that supported it, I never ran across anything to do with speech synthesis.

Creative Labs shipped a program called Dr Sbaitso with the original Sound Blaster cards. It was essentially an ELIZA chat-bot coupled to a speech synthesiser (all done in software). Being an 8-bit ISA card that worked in an original 16-bit IBM PC, this definitely qualifies.

The later Sound Blaster 16 ASP and Sound Blaster AWE32 included the Advanced Signal Processor chip, which provided hardware-accelerated speech synthesis capabilities, but didn't get much, if any, use outside of Creative's own software. Whether these two qualify is debatable, given they're 16-bit ISA cards that probably would work in a 286, but which came out when everyone was using 32-bit 386 or 486 CPUs.

The OPL2 FM synthesiser chip that powered the Adlib and early Sound Blaster cards' music capabilities included a Composite Sine Modelling mode that could be used for hardware-assisted speech synthesis, but as far as I know it was never used. Adlib's programming guide from 1987 mentions the feature, then promptly dismisses it saying there are better-quality methods available.

There were certainly a few programs that could produce speech through the PC Speaker, but I have no idea if they were synthesising it or just playing back samples, and I don't remember any names, anyway.

2

Sure; e.g. the Naval Research Laboratory published a document (NRL-7948) in 1976 entitled: "Automatic Translation of English Text to Phonetics by Means of Letter-to-Sound Rules" (a copy here)

This was within the capability of 8-bit machines. (I myself have implemented the algorithm a few times on microcontrollers - in this case, the rules took just over 8,000 bytes. You'll need a little more for the code that runs them.)

This performs the text-to-speech operation, converting English text to a phoneme sequence that would then be fed into the synthesis device. This part was usually hardware.

Edit: If you're curious about the results using this ruleset, here is sample output from text-to-speech'ing the lyrics to The Doors 'Hello'. There are a few mispronunciations that are amusing; e.g. 'sky' is pronounced as we would 'ski'.

2
  • 1
    these same rules are implemented in the GI SP0256-AL2 chipset that were a feature of 8-bit computer addons – scruss Dec 28 '20 at 21:23
  • 1
    @scruss indeed! however a minor note: the 'CTS0256' was the chip that did the text-to-speech (and did implement the NRL algorithm). The SP0256-AL2 just did the sound synthesis part. Those parts are nearly unobtainium today. – ziggurat29 Dec 28 '20 at 21:37
1

If you want a decent history of speech synthesis check out this video by the 8 bit guy

1

The original 1984 Macintosh (which ran on a Motorola 68000) had Macintalk. It ran reasonably well. It voiced one of the characters in the movie WALL-E. It shows up in a large number of pop culture places. Check out the In Popular Culture section of https://en.m.wikipedia.org/wiki/PlainTalk

I bet if I pulled my 1984 Mac out of the closet and found the right diskette, I could convince it to talk. It was a pretty amazing party trick back in the day

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.