src/ptclib/ptts.cxx

   1 /*
   2  * ptts.cxx
   3  *
   4  * Text To Speech classes
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 2002 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.11  2004/06/19 09:02:32  csoutheren
  28  * Added rate and volume to keep Festival happy
  29  *
  30  * Revision 1.10  2004/06/19 07:18:59  csoutheren
  31  * Change TTS engine registration to use abstract factory code
  32  *
  33  * Revision 1.9  2004/04/09 06:52:17  rjongbloed
  34  * Removed #pargma linker command for /delayload of DLL as documentations sais that
  35  *   you cannot do this.
  36  *
  37  * Revision 1.8  2004/02/23 23:52:20  csoutheren
  38  * Added pragmas to avoid every Windows application needing to include libs explicitly
  39  *
  40  * Revision 1.7  2003/10/30 11:28:25  rjongbloed
  41  * Added dircetory name for Speech API under Windows.
  42  *
  43  * Revision 1.6  2003/09/17 06:02:13  csoutheren
  44  * Fixed windows header file problem caused by removing recursive headers
  45  *
  46  * Revision 1.5  2003/04/17 01:21:33  craigs
  47  * Added import of pybuildopts to correctly detect if P_SAPI is set
  48  *
  49  * Revision 1.4  2003/04/16 08:00:19  robertj
  50  * Windoes psuedo autoconf support
  51  *
  52  * Revision 1.3  2002/11/06 22:47:25  robertj
  53  * Fixed header comment (copyright etc)
  54  *
  55  * Revision 1.2  2002/08/14 15:18:25  craigs
  56  * Fixed Festval implementation
  57  *
  58  * Revision 1.1  2002/08/06 04:45:58  craigs
  59  * Initial version
  60  *
  61  */
  62
  63 #ifdef __GNUC__
  64 #pragma implementation "ptts.h"
  65 #endif
  66
  67 #include "ptbuildopts.h"
  68
  69
  70 ////////////////////////////////////////////////////////////
  71
  72 // WIN32 COM stuff must be first in file to compile properly
  73
  74 #if P_SAPI
  75
  76 #if defined(P_SAPI_LIBRARY)
  77 #pragma comment(lib, P_SAPI_LIBRARY)
  78 #endif
  79
  80 #ifndef _WIN32_DCOM
  81 #define _WIN32_DCOM 1
  82 #endif
  83
  84 #include <objbase.h>
  85 #include <atlbase.h>
  86 #include <objbase.h>
  87 #include <windows.h>
  88 #include <windowsx.h>
  89 #include <sphelper.h>
  90
  91 #endif
  92
  93 ////////////////////////////////////////////////////////////
  94
  95 // this disables the winsock2 stuff in the Windows contain.h, to avoid header file problems
  96 #define P_KNOCKOUT_WINSOCK2
  97
  98 #include <ptlib.h>
  99 #include <ptlib/pipechan.h>
 100 #include <ptclib/ptts.h>
 101
 102 ////////////////////////////////////////////////////////////
 103 //
 104 // Text to speech using Microsoft's Speech API (SAPI)
 105 // Can be downloaded from http://www.microsoft.com/speech/download/sdk51
 106 //
 107
 108 #if P_SAPI
 109
 110 #define MAX_FN_SIZE 1024
 111
 112 class PTextToSpeech_SAPI : public PTextToSpeech
 113 {
 114   PCLASSINFO(PTextToSpeech_SAPI, PTextToSpeech);
 115   public:
 116     PTextToSpeech_SAPI();
 117     ~PTextToSpeech_SAPI();
 118
 119     // overrides
 120     PStringArray GetVoiceList();
 121     BOOL SetVoice(const PString & voice);
 122
 123     BOOL SetRate(unsigned rate);
 124     unsigned GetRate();
 125
 126     BOOL SetVolume(unsigned volume);
 127     unsigned GetVolume();
 128
 129     BOOL OpenFile   (const PFilePath & fn);
 130     BOOL OpenChannel(PChannel * channel);
 131     BOOL IsOpen()     { return opened; }
 132
 133     BOOL Close      ();
 134     BOOL Speak      (const PString & str, TextType hint);
 135
 136   protected:
 137     BOOL OpenVoice();
 138
 139     static PMutex refMutex;
 140     static int * refCount;
 141
 142     PMutex mutex;
 143     CComPtr<ISpVoice> m_cpVoice;
 144     CComPtr<ISpStream> cpWavStream;
 145     BOOL opened;
 146     BOOL usingFile;
 147     unsigned rate, volume;
 148     PString voice;
 149 };
 150
 151 static PAbstractFactory<PTextToSpeech, PTextToSpeech_SAPI> sapiTTSFactory("Microsoft SAPI");
 152
 153 int * PTextToSpeech_SAPI::refCount;
 154 PMutex PTextToSpeech_SAPI::refMutex;
 155
 156
 157 PTextToSpeech_SAPI::PTextToSpeech_SAPI()
 158 {
 159   PWaitAndSignal m(refMutex);
 160
 161   if (refCount == NULL) {
 162     refCount = new int;
 163     *refCount = 1;
 164     ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
 165   } else {
 166     (*refCount)++;
 167   }
 168
 169   usingFile = opened = FALSE;
 170 }
 171
 172
 173 PTextToSpeech_SAPI::~PTextToSpeech_SAPI()
 174 {
 175   PWaitAndSignal m(refMutex);
 176
 177   if ((--(*refCount)) == 0) {
 178     ::CoUninitialize();
 179     delete refCount;
 180     refCount = NULL;
 181   }
 182 }
 183
 184 BOOL PTextToSpeech_SAPI::OpenVoice()
 185 {
 186   PWaitAndSignal m(mutex);
 187
 188   HRESULT hr = m_cpVoice.CoCreateInstance(CLSID_SpVoice);
 189   return (opened = SUCCEEDED(hr));
 190 }
 191
 192 BOOL PTextToSpeech_SAPI::OpenChannel(PChannel *)
 193 {
 194   PWaitAndSignal m(mutex);
 195
 196   Close();
 197   usingFile = FALSE;
 198   return (opened = FALSE);
 199 }
 200
 201
 202 BOOL PTextToSpeech_SAPI::OpenFile(const PFilePath & fn)
 203 {
 204   PWaitAndSignal m(mutex);
 205
 206   Close();
 207   usingFile = TRUE;
 208
 209   if (!OpenVoice())
 210     return FALSE;
 211
 212   CSpStreamFormat wavFormat;
 213   wavFormat.AssignFormat(SPSF_8kHz16BitMono);
 214
 215   WCHAR szwWavFileName[MAX_FN_SIZE] = L"";;
 216
 217   USES_CONVERSION;
 218   wcscpy(szwWavFileName, T2W((const char *)fn));
 219   HRESULT hr = SPBindToFile(szwWavFileName, SPFM_CREATE_ALWAYS, &cpWavStream, &wavFormat.FormatId(), wavFormat.WaveFormatExPtr());
 220
 221   if (!SUCCEEDED(hr)) {
 222     cpWavStream.Release();
 223     return FALSE;
 224   }
 225
 226         hr = m_cpVoice->SetOutput(cpWavStream, TRUE);
 227
 228   return (opened = SUCCEEDED(hr));
 229 }
 230
 231 BOOL PTextToSpeech_SAPI::Close()
 232 {
 233   PWaitAndSignal m(mutex);
 234
 235   if (!opened)
 236     return TRUE;
 237
 238   if (usingFile) {
 239     if (opened)
 240       m_cpVoice->WaitUntilDone(INFINITE);
 241     cpWavStream.Release();
 242   }
 243
 244   if (opened)
 245     m_cpVoice.Release();
 246
 247   opened = FALSE;
 248
 249   return TRUE;
 250 }
 251
 252
 253 BOOL PTextToSpeech_SAPI::Speak(const PString & otext, TextType hint)
 254 {
 255   PWaitAndSignal m(mutex);
 256
 257   if (!IsOpen())
 258     return FALSE;
 259
 260   PString text = otext;
 261
 262   // do various things to the string, depending upon the hint
 263   switch (hint) {
 264     case Digits:
 265       {
 266       }
 267       break;
 268
 269     default:
 270     ;
 271   };
 272
 273   // quick hack to calculate length of Unicode string
 274   unsigned short * uStr = new unsigned short[text.GetLength()+1];
 275
 276   USES_CONVERSION;
 277   wcscpy(uStr, T2W((const char *)text));
 278
 279   HRESULT hr = m_cpVoice->Speak(uStr, SPF_DEFAULT, NULL);
 280
 281   delete[] uStr;
 282
 283   return SUCCEEDED(hr);
 284 }
 285
 286 PStringArray PTextToSpeech_SAPI::GetVoiceList()
 287 {
 288   PWaitAndSignal m(mutex);
 289
 290   PStringArray voiceList;
 291
 292   CComPtr<ISpObjectToken> cpVoiceToken;
 293   CComPtr<IEnumSpObjectTokens> cpEnum;
 294   ULONG ulCount = 0;
 295
 296   //Enumerate the available voices
 297   HRESULT hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL, &cpEnum);
 298
 299   // Get the number of voices
 300   if (SUCCEEDED(hr))
 301     hr = cpEnum->GetCount(&ulCount);
 302
 303   // Obtain a list of available voice tokens, set the voice to the token, and call Speak
 304   while (SUCCEEDED(hr) && ulCount--) {
 305
 306     cpVoiceToken.Release();
 307
 308     if (SUCCEEDED(hr))
 309       hr = cpEnum->Next(1, &cpVoiceToken, NULL );
 310
 311     if (SUCCEEDED(hr)) {
 312       voiceList.AppendString("voice");
 313     }
 314   }
 315
 316   return voiceList;
 317 }
 318
 319 BOOL PTextToSpeech_SAPI::SetVoice(const PString & v)
 320 {
 321   PWaitAndSignal m(mutex);
 322   voice = v;
 323   return TRUE;
 324 }
 325
 326 BOOL PTextToSpeech_SAPI::SetRate(unsigned v)
 327 {
 328   rate = v;
 329   return TRUE;
 330 }
 331
 332 unsigned PTextToSpeech_SAPI::GetRate()
 333 {
 334   return rate;
 335 }
 336
 337 BOOL PTextToSpeech_SAPI::SetVolume(unsigned v)
 338 {
 339   volume = v;
 340   return TRUE;
 341 }
 342
 343 unsigned PTextToSpeech_SAPI::GetVolume()
 344 {
 345   return volume;
 346 }
 347
 348 #endif
 349 // P_SAPI
 350
 351 ////////////////////////////////////////////////////////////
 352 //
 353 //  Generic text to speech using Festival
 354 //
 355
 356 class PTextToSpeech_Festival : public PTextToSpeech
 357 {
 358   PCLASSINFO(PTextToSpeech_Festival, PTextToSpeech);
 359   public:
 360     PTextToSpeech_Festival();
 361     ~PTextToSpeech_Festival();
 362
 363     // overrides
 364     PStringArray GetVoiceList();
 365     BOOL SetVoice(const PString & voice);
 366
 367     BOOL SetRate(unsigned rate);
 368     unsigned GetRate();
 369
 370     BOOL SetVolume(unsigned volume);
 371     unsigned GetVolume();
 372
 373     BOOL OpenFile   (const PFilePath & fn);
 374     BOOL OpenChannel(PChannel * channel);
 375     BOOL IsOpen()    { return opened; }
 376
 377     BOOL Close      ();
 378     BOOL Speak      (const PString & str, TextType hint);
 379
 380   protected:
 381     BOOL Invoke(const PString & str, const PFilePath & fn);
 382
 383     PMutex mutex;
 384     BOOL opened;
 385     BOOL usingFile;
 386     PString text;
 387     PFilePath path;
 388     unsigned volume, rate;
 389     PString voice;
 390 };
 391
 392 static PAbstractFactory<PTextToSpeech, PTextToSpeech_Festival> festivalTTSFactory("Festival");
 393
 394 PTextToSpeech_Festival::PTextToSpeech_Festival()
 395 {
 396   PWaitAndSignal m(mutex);
 397   usingFile = opened = FALSE;
 398   rate = 8000;
 399   volume = 100;
 400 }
 401
 402
 403 PTextToSpeech_Festival::~PTextToSpeech_Festival()
 404 {
 405   PWaitAndSignal m(mutex);
 406 }
 407
 408 BOOL PTextToSpeech_Festival::OpenChannel(PChannel *)
 409 {
 410   PWaitAndSignal m(mutex);
 411
 412   Close();
 413   usingFile = FALSE;
 414   opened = FALSE;
 415
 416   return TRUE;
 417 }
 418
 419
 420 BOOL PTextToSpeech_Festival::OpenFile(const PFilePath & fn)
 421 {
 422   PWaitAndSignal m(mutex);
 423
 424   Close();
 425   usingFile = TRUE;
 426   path = fn;
 427   opened = TRUE;
 428
 429   PTRACE(3, "TTS\tWriting speech to " << fn);
 430
 431   return TRUE;
 432 }
 433
 434 BOOL PTextToSpeech_Festival::Close()
 435 {
 436   PWaitAndSignal m(mutex);
 437
 438   if (!opened)
 439     return TRUE;
 440
 441   BOOL stat = FALSE;
 442
 443   if (usingFile)
 444     stat = Invoke(text, path);
 445
 446   text = PString();
 447
 448   opened = FALSE;
 449
 450   return stat;
 451 }
 452
 453
 454 BOOL PTextToSpeech_Festival::Speak(const PString & ostr, TextType hint)
 455 {
 456   PWaitAndSignal m(mutex);
 457
 458   if (!IsOpen()) {
 459     PTRACE(3, "TTS\tAttempt to speak whilst engine not open");
 460     return FALSE;
 461   }
 462
 463   PString str = ostr;
 464
 465   // do various things to the string, depending upon the hint
 466   switch (hint) {
 467     case Digits:
 468     default:
 469     ;
 470   };
 471
 472   if (usingFile) {
 473     PTRACE(3, "TTS\tSpeaking " << ostr);
 474     text = text & str;
 475     return TRUE;
 476   }
 477
 478   PTRACE(3, "TTS\tStream mode not supported for Festival");
 479
 480   return FALSE;
 481 }
 482
 483 PStringArray PTextToSpeech_Festival::GetVoiceList()
 484 {
 485   PWaitAndSignal m(mutex);
 486
 487   PStringArray voiceList;
 488
 489   voiceList.AppendString("default");
 490
 491   return voiceList;
 492 }
 493
 494 BOOL PTextToSpeech_Festival::SetVoice(const PString & v)
 495 {
 496   PWaitAndSignal m(mutex);
 497   voice = v;
 498   return TRUE;
 499 }
 500
 501 BOOL PTextToSpeech_Festival::SetRate(unsigned v)
 502 {
 503   rate = v;
 504   return TRUE;
 505 }
 506
 507 unsigned PTextToSpeech_Festival::GetRate()
 508 {
 509   return rate;
 510 }
 511
 512 BOOL PTextToSpeech_Festival::SetVolume(unsigned v)
 513 {
 514   volume = v;
 515   return TRUE;
 516 }
 517
 518 unsigned PTextToSpeech_Festival::GetVolume()
 519 {
 520   return volume;
 521 }
 522
 523 BOOL PTextToSpeech_Festival::Invoke(const PString & otext, const PFilePath & fname)
 524 {
 525   PString text = otext;
 526   text.Replace('\n', ' ', TRUE);
 527   text.Replace('\"', '\'', TRUE);
 528   text.Replace('\\', ' ', TRUE);
 529   text = "\"" + text + "\"";
 530
 531   PString cmdLine = "echo " + text + " | ./text2wave -F " + PString(PString::Unsigned, rate) + " -otype riff > " + fname;
 532
 533 #if 1
 534
 535   system(cmdLine);
 536   return TRUE;
 537
 538 #else
 539
 540   PPipeChannel cmd;
 541   int code = -1;
 542   if (!cmd.Open(cmdLine, PPipeChannel::ReadWriteStd)) {
 543     PTRACE(2, "TTS\tCannot execute command " << cmd);
 544   } else {
 545     PTRACE(2, "TTS\tCreating " << fname << " using " << cmdLine);
 546     cmd.Execute();
 547     code = cmd.WaitForTermination();
 548     if (code >= 0) {
 549       PTRACE(2, "TTS\tdata generated");
 550     } else {
 551       PTRACE(2, "TTS\tgeneration failed");
 552     }
 553   }
 554
 555   return code == 0;
 556
 557 #endif
 558 }
 559
 560 PINSTANTIATE_FACTORY(PTextToSpeech)
 561
 562 // End Of File ///////////////////////////////////////////////////////////////