Gibt es ein Text-zu-Sprache-Programm, das auf einer 8- oder 16-Bit-CPU ausgeführt wird?
Ich frage mich, ob irgendein Text-zu-Sprache-Algorithmus im Stil der alten 1980er Jahre vor dem Vergessen bewahrt wurde und noch verfügbar ist. Es könnte schön sein, diesen Vintage-Sound zu hören, wie er in War Games erschien.
Antworten
"Speech" von Superior Software war ein reiner Software-Sprachsynthesizer, der auf dem BBC Micro lief (der einen 2-MHz-6502A-Prozessor verwendete und daher etwas mehr rohe Verarbeitungsleistung als typische 8-Bit-Maschinen hatte). Auf dieser Seite wird ausführlich beschrieben , dass es von ähnlichen Programmen auf C64 und Spectrum inspiriert wurde, die es mit Soundchips erreichen (das Spectrum muss also die 128K-Version gewesen sein, da die ursprünglichen 16 / 48K-Versionen keinen Soundchip hatten). Dieses System verwendet jedoch nur die direkte Steuerung des eingebauten Lautsprechers, um den Ton zu erzeugen.
Erstens gibt es eine große Einschränkung. Die meisten der legendären frühen Sprachsynthesizer waren keine reinen Softwaresysteme. Zum Beispiel war das klassische DECTalk- System, bekannt als die Stimme des verstorbenen Stephen Hawking, eine diskrete Einheit, die über den seriellen RS-232 verbunden war. Es ist praktisch eine geschlossene Box, die ASCII-Text sendet und Audio auf Zeilenebene erzeugt. Intern erinnere ich mich vage an die Lektüre, dass es sich um eine Mischung aus einem Allzweckprozessor mit dedizierten Signalprozessoren und Audiosynthesehardware handelt. Die Ti LPC-Sprachsynthesechips , wie sie in den Speak and Spell-Produkten verwendet wurden, waren ähnlich. Die Chips können grundlegende Phoneme und Wörter synthetisieren, und ein Mikrocontroller oder Mikroprozessor muss die Textanalyse durchführen und den Synthesechip ansteuern.
Tatsache ist, dass die klassischen 8/16-Bit-Prozessoren einfach nicht genug Power haben, um die Sprachsynthese in Software zumindest in Echtzeit gut durchzuführen. Dennoch gab es eine Reihe von respektablen Versuchen. SAM (Software Automatic Mouth) war einer der ersten und einer der beliebtesten. Es läuft auf dem Commodore 64 und anderen Computern. Ein cleverer Hacker hat den Algorithmus kürzlich auf Javascript portiert, damit Sie ihn in Ihrem Browser hören können .
Es gab ein russisches Text-to-Speech-Programm, das Anfang der 1980er Jahre für die Elektronika BK-0010 geschrieben wurde und dessen Länge 023500 Bytes == 10048 betrug. Es wurde in einer Liste von Anwendungsprogrammen für die BK-0010 unter dem Namen ГОВОРУН (") erwähnt. Chatterer ", nach einem sprechenden Vogel in einem Kinderbuch / Cartoon Das Geheimnis des dritten Planeten ).
Seine Klangqualität war für ein ungeübtes Ohr kaum zu erkennen, teilweise weil der Computer nur einen 1-Bit-manipulierten Summer hatte, aber Berichten zufolge wurde er auf Anfrage der All-Union Society of the Blind geschrieben und nahm die Mitglieder des Ziels mit Publikum ca. 10-15 Minuten, um sich daran zu gewöhnen und es produktiv zu nutzen.
Der Trick bestand darin, die Phoneme unter Verwendung eines so schmalen Frequenzbandes aufzuzeichnen, wie es für die marginale Erkennung erforderlich ist, und jedes Phonem unter Verwendung einer möglichst niedrigen Frequenz für dieses spezifische Phonem zu codieren. Durch diesen Vorgang klingen einige Phoneme wie S und F ziemlich gleich, sodass durch Falten mehr Speicherplatz gespart werden kann.
Unnötig zu erwähnen, dass es den Rechtschreibmodus für das phonetische Alphabet gab, der durch Drücken einer Taste umgeschaltet werden konnte, sowie die Tasten "Letztes Wort wiederholen" und / oder "Letzter Satz wiederholen".
Ist der 68000 eine 16-Bit-CPU? :) Für manche ist es, und deshalb Say , ab 1985, für den Commodore Amiga zählt. Es befindet sich auf der Workbench-Festplatte. Weitere Informationen finden Sie in der Oberfläche narrator.device im AmigaOS-Wiki:https://wiki.amigaos.net/wiki/Narrator_Device
Und hier ist Steamed Hams, erstellt mit Say :https://www.youtube.com/watch?v=Rx6mJ4XY0oQ
sehen:
- CZ + SK ZX SW-Archiv
Es gibt TTS-Engines für ZX Spectrum (1-Bit-Digital-Sound, kein DAC, keine FPU, keine Mul / Div-Anweisungen, ~ 3,5-MHz-8-Bit-Z80-CPU):
Kecal 1.0
Sehr einfacher ASM (portabel auf C / C ++, siehe Link unten), sehr geringe Anforderungen an die CPU. Es ist nicht sehr gute Qualität
Kecal 2.3
viel verbesserte Qualität
ZX Fone
Es ist etwas schlimmer als Kecal 2.3
Hlasovy-Programm
Dieser ist von sehr guter Qualität (viel besser als Kecal 2.3, man kann die Wörter leicht erkennen). Es sind nur 801 Bytes Assembler-Code.
siehe auch:
- SE / SO: Kann Arduino die Raumtemperatur per Sprachanruf mit sim900 ermitteln?
[Edit1] C ++ - Port des Hlasový-Programms
Ich freue mich, Ihnen mitteilen zu können , dass ich die großartige alte TTS-Engine von Voicesoft erfolgreich zerlegt und in C ++ portiert habe . Der Einfachheit halber habe ich einen Sound-API-Header hinzugefügt void sound_out(bool on);, der implementiert werden muss, um diesen zu verwenden. Es sollte einfach ein Sample zum Soundpuffer hinzugefügt werden (oder mit der Zeit synchronisiert und an den Soundport ausgegeben werden). Hier der portierte 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
//---------------------------------------------------------------------------
Es werden keine Bibliotheken, Dateien oder was auch immer verwendet ... Wenn Ihre Umgebung keine verwendet hat, BYTE,WORDverwenden Sie unsigned intstattdessen ... Ich habe es mit einer Abtastrate von 44100 Hz auf dem PC versucht und der Sound ist allen anderen TTS überlegen, die ich im Laufe der Jahre ausprobiert habe.
Der Sound ist auch bei AVR32 recht gut (benötigt jedoch einen normalen Reproduktor anstelle der kleinen Piepser).
Wenn Sie interessiert sind, wie es funktioniert, sehen Sie Folgendes:
- Einfachen (aber qualitativ hochwertigen) TTS-Motor verstehen / umkehren
Wo viel detailliertere Analyse (bis zum letzten Datenbit) und viel mehr didaktischer Code und Daten dafür gefunden werden können.
Hier eine kleine Win32 / Waveout-Demo zum Testen, vergessen Sie nicht, den Text phonetisch zu schreiben ... viel Spaß:
- win32 TTS-Port
Es reagiert auf diese Schlüssel:
[enter ]sendet Text aus dem Bearbeitungsfeld an TTS[up arrow]gibt die letzte Zeichenfolge an das Bearbeitungsfeld zurück[escape ]löscht das Bearbeitungsfeld
Natürlich gab es das Acorn Speech System für das BBC Micro.
Dies erforderte die Installation von zwei Texas Instruments-Chips unter der Tastatur und war daher keine reine Softwarelösung.
Anders als bei den meisten anderen Antworten wurde eher Phonemeingabe als reiner Text verwendet, aber das bedeutete, dass es viel klareres und verständlicheres Audio lieferte als viele seiner Konkurrenten.
Früher habe ich es verwendet, um Alarme in einer Prozessautomatisierungseinstellung bereitzustellen. Es wurde als viel sicherer angesehen, einen Anruf wie Crane A Descending oder "Crane B Ascending" zu haben, als eine Reihe verschiedener Pieptöne zu haben, die jeder vergaß, welcher welcher war.
Es wurde bekanntlich die digitalisierte Stimme von Kenneth Kendall verwendet , einem BBC-Nachrichtensprecher zu dieser Zeit. Er trat auch in dem Film 2001: A Space Odyssey auf und spielte einen BBC-Newsreader.
Ein weiteres solches Programm aus den frühen 80er Jahren war der Software Automatic Mouth . Ich hatte auch verschwommene Erinnerungen an eine Demo von The Voice von Muse Software für Apple] [e. ("Frohe Weihnachten vom Weihnachtsmann und die Stimme der Muse ...")
Der Texas Instruments TI-99 / 4A kann Text-to-Speech ausführen, wenn Sie die Terminal Emulator II-Kassette und den Solid State Speech Synthesizer verwenden. (Weitere Informationen zu letzterem finden Sie im Handbuch .)
Für den Microbee (z80) der 1980er Jahre gab es ein Hardwaremodul namens "Bee Talker", das an einen parallelen Anschluss angeschlossen wurde. Es sieht fast genauso aus wie die "Beethoven" -Einheit in diesem Bild (neben der "Tastatur"), außer dass sie mit "Beetalker" beschriftet war:
Es hatte eine einfache Text-zu-Sprache-Software-Oberfläche, die mit dem Modul geliefert wurde. Was auch immer Sie in die Konsole eingegeben haben, es würde etwas seltsam in Sprache umgewandelt. Ich erinnere mich nicht genau, was gut funktioniert hat, aber manchmal musste man das Wort phonetisch falsch schreiben, um das gewünschte Ergebnis zu erzielen.
Das Modul wurde erneut freigegeben, falls Sie es an ein Arduino oder was auch immer anschließen möchten.
EDIT: Endlich ein besseres Bild gefunden:
Sie können verschiedene Inkarnationen des Formantsynthesegerät zugrunde liegenden DECtalk finden hier
Ich bezweifle, dass Sie mit einem 8-Bit-Prozessor zufriedenstellende Ergebnisse erzielen können. 16-Bit, ja (obwohl Sie möglicherweise den Gleitkomma-Code als Festpunkt neu schreiben müssen). Ich gehe davon aus, dass der ursprüngliche Macintalk einen ziemlich ähnlichen Algorithmus verwendet hat, obwohl ich diesen Quellcode nie gesehen habe. MacinTalk 3 ("Fred" und verwandte Stimmen), das seit mehr als 30 Jahren auf Macs verfügbar ist, verwendet eine ähnliche Methode.
Klatt schrieb auch ein ziemlich lesbares Buch , das ein etwas früheres System beschreibt.
Letztendlich ist es wahrscheinlich das Gedächtnis, das den limitierenden Faktor für ein System der 1980er Jahre darstellt. Die Verarbeitungsleistung von 16-Bit-Prozessoren ist für die Formantensynthese in Ordnung, aber auf Englisch werden Sie ohne ein großes Wörterbuch oder einen enormen Regelsatz niemals eine sehr genaue Aussprache haben.
Hier ist eine Online-Version von SAM für c64. Sie können Text auf die Webseite eingeben und das Audio auf Band aufnehmen: https://discordier.github.io/sam/
Es gibt Musik-Plugins, die auch auf Mac und Atari St basieren und für Musikverbesserungen zusätzlich zum ursprünglichen Code der Sprachmaschine entwickelt wurden: https://www.youtube.com/watch?v=FmaeI5eoeH0&ab_channel=PlogueArtetTechnologie%2CInc. Es gibt Demoversionen davon irgendwo im Web.
Das IIgs verfügt über genügend Hardware, um mit SmoothTalker eine ziemlich gute Software-Sprache zu erzielen . Die Sprach-Engine von SmoothTalker wurde in einer Reihe anderer IIgs-Programme verwendet, einschließlich der Talking- Reihe zum Lesen und Rechnen . Sogar ein Schreibprogramm für die IIgs verwendete Sprache, meine Tochter verwendete sie und die Sprache ist für aktuelle Verhältnisse ziemlich gut.
War Games ... wurde eigentlich nicht computergeneriert
Sie erwähnen die Stimme der Kriegsspiele. Es war keine künstliche Stimme, sondern ein Schauspieler. Er sagte die Sätze mit Wörtern in umgekehrter Reihenfolge, die später bearbeitet wurden. Ref:
- https://www.imdb.com/title/tt0086567/trivia#tr5373943
- 8-Bit-Typ-Video, das von @RCDAWebmaster erwähnt wird, verlinkt auf den relevanten Moment
Was Sie gefragt haben: "... vor dem Vergessen gerettet und immer noch verfügbar"
Ja! Danke an den 8bit Typ für die Information. Sie können:
- Besuch https://www.simulationcorner.net/index.php?page=sam
- Quellcode abrufen https://github.com/s-macke/SAM oder https://github.com/vidarh/SAM
Dies kompiliert und funktioniert auf einer modernen Maschine.
Nur-Software-Lösungen der damaligen Zeit
Es sieht so aus, als gäbe es eine vollständige softwarebasierte Lösung (ich habe sie nicht getestet): https://cpcrulez.fr/applications_music-superior_software-speech__MANUEL__ENGLISH.htm
Zu dieser Zeit übliche Lösung: 8-Bit-Sprechmaschinen verwendeten häufig dedizierte optionale Chips
Wie in einem Kommentar erwähnt, verwendeten gängige Lösungen während der 8-Bit-Ära dedizierte Chips.
- General Instrument SP0256 auf derselben Seite und z. B. auf Roland in Space mit SSA-1-Sprachsynthesizer und GLEN HODDLE SOCCER mit SSA-1-Sprachsynthesizer . Jeder Chip war mehr oder weniger spezialisiert, der häufigste war generische englische Stimme.
- MEA8000 war flexibler und erlaubte mehrere Sprachen.
Beispiel: der SSA-1 für den Amstrad CPC
In der Regel handelte es sich um eine mehrschichtige Lösung.
Im Folgenden wird das Beispiel von SSA-1, dem Amstrad CPC, beschrieben:
- Der frühe (übergeordnete) Teil des Text-to-Speech wurde auf der CPU des Host-Computers ausgeführt und regulärer (englischer) Text in eine Reihe von Allophonen (normalerweise 64 verschiedene) umgewandelt - dies könnte mithilfe einer API umgangen werden Dies bietet eine Möglichkeit, eine Reihe von Allophonen direkt anzufordern. Auf dem Amstrad CPC standen beide Optionen zur Verfügung: Dem Benutzer wurde angeboten, bestimmte Software zu laden, zusätzliche Befehle "RSX" von Basic (und damit auch vom Assembly-Code) zur Verfügung zu stellen, obwohl die Assembly-Produktion in der Regel direkt auf den nächsten Schritt abzielt, da sie nicht ausgeführt werden Es muss kein allgemeiner englischer Satz analysiert werden (nur ausgesprochene vordefinierte Äußerungen).
- Allophoncodes wurden über reguläre E / A-Interchip-Kommunikation mit einem Byte pro Allophon an den Chip übertragen
- Auf dem Chip wandelte ein Echtzeit-Mikrocontroller Allophon-Codes in Low-Level-Vokaltrakt-Simulationsparameter um und stellte die Hardware-Register in Echtzeit ein, um den nächsten Schritt zu befehlen
- dedizierte Hardware führte die digitale Berechnung des Vokaltraktmodells durch und gab ein PCM-Signal aus
- Ein Digital-Analog-Schritt lieferte ein analoges Ausgangssignal auf Leitungsebene
- Ein Verstärker bringt das Signal auf den Lautsprecherpegel.
Alle diese Schritte (einschließlich der Lautsprecher) sind in die SSA-1-Lösung für den Amstrad CPC integriert. Im allerersten Schritt ist die Lösung Software, die auf dem Host-Computer ausgeführt wird, der Rest ist zusätzliche Hardware.
Weitere Details zum SSA-1: Amstrad SSA-1 Sprachsynthesizer - CPCWiki
In den Anfängen von Audio auf IBM PC-kompatiblen Geräten gibt es einige Beispiele für die Sprachsynthese. Diese qualifizieren sich für Ihre 16-Bit-Kategorie, da 8088 und 80286 16-Bit-CPUs waren (obwohl der 8088 durch einen 8-Bit-Datenbus verkrüppelt wurde).
Das Covox Speech Thing war ein DAC mit parallelem Port, der für die softwarebasierte Sprachsynthese verwendet werden sollte. Ich gehe davon aus, dass ein solches Programm mitgeliefert wurde, da es zwar eine anständige Anzahl von Programmen gab, die es unterstützten, ich jedoch nie auf etwas gestoßen bin, das mit Sprachsynthese zu tun hat.
Creative Labs hat ein Programm namens Dr. Sbaitso mit den originalen Sound Blaster-Karten ausgeliefert. Es war im Wesentlichen ein ELIZA-Chat-Bot, der an einen Sprachsynthesizer gekoppelt war (alles in Software). Als 8-Bit-ISA-Karte, die in einem ursprünglichen 16-Bit-IBM-PC funktioniert hat, ist dies definitiv eine Qualifikation.
Der spätere Sound Blaster 16 ASP und Sound Blaster AWE32 enthielten den Advanced Signal Processor-Chip, der hardwarebeschleunigte Sprachsynthesefunktionen bereitstellte, aber außerhalb der Creative-eigenen Software nicht viel, wenn überhaupt, nutzte. Ob sich diese beiden qualifizieren, ist umstritten, da es sich um 16-Bit-ISA-Karten handelt, die wahrscheinlich in einem 286 funktionieren würden, die jedoch herauskamen, als alle 32-Bit-386- oder 486-CPUs verwendeten.
Der OPL2 FM-Synthesizer-Chip, der die Musikfunktionen der Adlib- und frühen Sound Blaster-Karten unterstützt, enthielt einen Composite Sine Modeling-Modus, der für die hardwareunterstützte Sprachsynthese verwendet werden konnte, aber meines Wissens nie verwendet wurde. Der Programmierleitfaden von Adlib aus dem Jahr 1987 erwähnt die Funktion und lehnt sie umgehend ab, da Methoden von besserer Qualität verfügbar sind.
Es gab sicherlich einige Programme, die Sprache über den PC-Lautsprecher erzeugen konnten, aber ich habe keine Ahnung, ob sie sie synthetisierten oder nur Samples wiedergaben, und ich erinnere mich sowieso an keine Namen.
Sicher; zB veröffentlichte das Naval Research Laboratory 1976 ein Dokument (NRL-7948) mit dem Titel: "Automatische Übersetzung von englischem Text in die Phonetik mittels Letter-to-Sound-Regeln" (eine Kopie hier)
Dies lag innerhalb der Möglichkeiten von 8-Bit-Maschinen. (Ich selbst habe den Algorithmus einige Male auf Mikrocontrollern implementiert. In diesem Fall haben die Regeln etwas mehr als 8.000 Byte benötigt. Für den Code, mit dem sie ausgeführt werden, benötigen Sie etwas mehr.)
Dies führt die Text-zu-Sprache-Operation durch und konvertiert englischen Text in eine Phonemsequenz, die dann in die Synthesegerät eingespeist wird. Dieser Teil war normalerweise Hardware.
Bearbeiten: Wenn Sie neugierig auf die Ergebnisse sind, die diesen Regelsatz verwenden, finden Sie hier eine Beispielausgabe von Text-zu-Sprache-Texten an The Doors 'Hello'. Es gibt einige falsche Aussprachen, die amüsant sind; zB wird "Himmel" so ausgesprochen, als würden wir "Ski" fahren.
Wenn Sie eine anständige Geschichte der Sprachsynthese wollen, schauen Sie sich dieses Video des 8-Bit-Typen an
Der ursprüngliche Macintosh von 1984 (der auf einem Motorola 68000 lief) hatte Macintalk. Es lief ziemlich gut. Es hat eine der Figuren im Film WALL-E geäußert. Es zeigt sich in einer Vielzahl von Orten der Popkultur. Schauen Sie sich den Abschnitt In Popular Culture von anhttps://en.m.wikipedia.org/wiki/PlainTalk
Ich wette, wenn ich meinen Mac von 1984 aus dem Schrank ziehe und die richtige Diskette finde, könnte ich ihn zum Reden überreden. Es war damals ein ziemlich erstaunlicher Partytrick