开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 语音合成与识别 > 查看源码
cspeech.cpp
资源名称：cspeech.zip　[点击查看]
上传用户：zhaopin
上传日期：2007-01-07
资源大小：79k
文件大小：21k
源码类别：

语音合成与识别

开发平台：

Visual C++

cspeech.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        cspeech.cpp
  3. // Purpose: Text to speech class
  4. // Author: Julian Smart
  5. // Modified by:
  6. // Created: 07/02/98
  7. // RCS-ID: $Id$
  8. // Copyright: (c) Julian Smart
  9. // Licence: wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  12. #include "cspeech.h"
  13. #include "cspeechp.h"
  15. #include <mmsystem.h>
  17. CSpeech::CSpeech()
  18. {
  19. m_speechImpl = new CSpeechImpl(this);
  20. }
  22. CSpeech::~CSpeech()
  23. {
  24. delete m_speechImpl;
  26. // This can cause crashes, so don't do it from the destructor.
  27. // Terminate();
  28. }
  30. BOOL CSpeech::Init()
  31. {
  32. if (!m_speechImpl->InitTTS())
  33. return FALSE;
  35.     if (EnumerateModes())
  36.     {
  37. // Set the mode to the first one found.
  38.         SetMode(0);
  39.     }
  40.     else {
  41. //       CSpeechError("You don't have any text-to-speech engines installed.");
  42.        return FALSE;
  43.     }
  44. // m_speechImpl->m_pITTSCentral->Register((void*)m_speechImpl->m_pTestNotify, IID_ITTSNotifySink,
  45. //                                 &m_speechImpl->m_dwRegKey);
  47. return TRUE;
  48. }
  50. BOOL CSpeech::Terminate()
  51. {
  52. return m_speechImpl->TerminateTTS();
  53. }
  55. BOOL CSpeech::SetMode(int mode)
  56. {
  57. HRESULT hRes;
  58. #ifdef __MFC__
  59. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_WAIT));
  60. #endif
  62. if(m_speechImpl->m_pITTSAttributes) {
  63.        m_speechImpl->m_pITTSAttributes->Release();
  64.        m_speechImpl->m_pITTSAttributes= NULL;
  65.     }
  66. if(m_speechImpl->m_pITTSDialogs) {
  67.        m_speechImpl->m_pITTSDialogs->Release();
  68.        m_speechImpl->m_pITTSDialogs= NULL;
  69.     }
  70. if(m_speechImpl->m_pITTSCentral) {
  71.        m_speechImpl->m_pITTSCentral->UnRegister(m_speechImpl->m_dwRegKey);
  72.        m_speechImpl->m_pITTSCentral->Release();
  74.        m_speechImpl->m_pITTSCentral= NULL;
  75.     }
  76. #ifdef DIRECTSOUND
  77.     if (m_speechImpl->m_pIAD) {
  78. while (m_speechImpl->m_pIAD->Release());
  79. m_speechImpl->m_pIAD= NULL;
  80. }
  81. #else // DIRECTSOUND
  82.     if (m_speechImpl->m_pIMMD) {
  83.       // some engines will leak an audio destination object
  84.       // but if release they crash
  85. //while (
  86.       //   m_speechImpl->m_pIMMD->Release();
  87.       //   );
  88. m_speechImpl->m_pIMMD= NULL;
  89. }
  90. #endif
  92. #ifdef DIRECTSOUND
  93. hRes = CoCreateInstance (CLSID_AudioDestDirect, NULL, CLSCTX_ALL, IID_IAudioDirect, (void**)&(m_speechImpl->m_pIAD));
  94. if (FAILED(hRes))
  95. {
  96. CSpeechMessage("Can't find CLSID_AudioDestDirect");
  97.    return FALSE;
  98. }
  100.    // crreate direct sound stuff
  101.    LPDIRECTSOUND lpDirectSound;
  102.    hRes = CoCreateInstance (CLSID_DirectSound, NULL,
  103.       CLSCTX_ALL, IID_IDirectSound, (LPVOID*) &lpDirectSound);
  104.    if (hRes) {
  105. CSpeechMessage( "Can't find IID_IDirectSound" );
  106.    return FALSE;
  107.    }
  108.    hRes = lpDirectSound->Initialize(NULL);
  109.    if (hRes) {
  110. CSpeechMessage( "Can't initialize DirectSound" );
  111.    return FALSE;
  112.    }
  114. #ifdef __MFC__
  115.    hRes = lpDirectSound->SetCooperativeLevel (AfxGetApp()->m_pMainWnd, DSSCL_NORMAL);
  116. #endif
  118.    // tell the audio object about our stuff
  119.    m_speechImpl->m_pIAD->Init ((PVOID) lpDirectSound,IID_IDirectSound);
  121.     m_speechImpl->m_pIAD->AddRef();
  122.     m_speechImpl->m_pITTSEnum->Select(m_speechImpl->m_GUIDModes[mode], &m_speechImpl->m_pITTSCentral, m_speechImpl->m_pIAD);
  123. #else // DIRECTSOUND
  124. hRes = CoCreateInstance (CLSID_MMAudioDest, NULL, CLSCTX_ALL, IID_IAudioMultiMediaDevice, (void**)&(m_speechImpl->m_pIMMD));
  125. if (FAILED(hRes))
  126. {
  127. CSpeechMessage( "Error creating AudioDest Object(CoCreateInstance)." );
  128. }
  130.     hRes = m_speechImpl->m_pIMMD->DeviceNumSet( 0XFFFFFFFF);
  132.    // some engines will leak an audio destination object
  133.    // but if release they crash
  134.     // m_pIMMD->AddRef();
  135.     m_speechImpl->m_pITTSEnum->Select(m_speechImpl->m_GUIDModes[mode], &m_speechImpl->m_pITTSCentral, m_speechImpl->m_pIMMD);
  136. #endif // DIRECTSOUND
  137.     
  138.     m_speechImpl->m_pITTSCentral->QueryInterface (IID_ITTSAttributes, (void**)&m_speechImpl->m_pITTSAttributes);
  139.     m_speechImpl->m_pITTSCentral->QueryInterface (IID_ITTSDialogs, (void**)&m_speechImpl->m_pITTSDialogs);
  140. m_speechImpl->m_pITTSCentral->Register((void*)m_speechImpl->m_pTestNotify, IID_ITTSNotifySink,
  141.                                  &m_speechImpl->m_dwRegKey);
  143. return TRUE;
  144. }
  146. BOOL CSpeech::Pause(BOOL pause)
  147. {
  148. if (pause) {
  149. return (m_speechImpl->m_pITTSCentral->AudioPause() == NOERROR);
  150. } else {
  151. return (m_speechImpl->m_pITTSCentral->AudioResume() == NOERROR);
  152. }
  153. }
  155. BOOL CSpeech::EnumerateModes(void)
  156. {
  157. HRESULT hRes;
  158.     PITTSENUM pClone1;
  159.     TTSMODEINFO TTSModeInfo;
  160.     DWORD dwNumTimes;
  161.     int index = 0;
  163. hRes = m_speechImpl->m_pITTSEnum->Clone(&pClone1);
  164.     if( FAILED(hRes) )
  165.     {
  166.         CSpeechMessage ( "Couldn't clone ITTSEnum state, aborting enumeration test" );
  167.        return 0;
  168.     }
  170.     hRes = pClone1->Next (1, &TTSModeInfo, &dwNumTimes);
  171.     if( dwNumTimes == 0 ) return FALSE;
  173.     while (dwNumTimes) {
  174. m_speechImpl->m_modeFeatures[index] = TTSModeInfo.dwFeatures ;
  175.         m_speechImpl->m_modeNames[index] = TTSModeInfo.szModeName ;
  176.         m_speechImpl->m_GUIDModes[index] = TTSModeInfo.gModeID;
  178. //        if (TTSModeInfo.dwFeatures & TTSFEATURE_ANYWORD)
  180. hRes = pClone1->Next (1, &TTSModeInfo, &dwNumTimes);
  181. index ++;
  182.     }
  184. pClone1->Release();
  185. pClone1=NULL;
  186.    return index ? TRUE : FALSE;
  187. }
  189. int CSpeech::FindMode(const CString modeName)
  190. {
  191. int i;
  192. for (i = 0; i < GetModeCount() ; i++)
  193. {
  194. if (m_speechImpl->m_modeNames[i] == modeName)
  195. return i;
  196. }
  197. return -1;
  198. }
  200. // Set the pitch
  201. BOOL CSpeech::SetPitch(int pitch)
  202. {
  203. return (m_speechImpl->m_pITTSAttributes->PitchSet(pitch) == NOERROR);
  204. }
  206. // Get the pitch
  207. int CSpeech::GetPitch(void) const
  208. {
  209. WORD pitch = 0;
  210. if (m_speechImpl->m_pITTSAttributes->PitchGet(& pitch) == NOERROR)
  211. return pitch;
  212. else
  213. return -1;
  214. }
  216. // Get the min pitch
  217. int CSpeech::GetMinPitch(void) const
  218. {
  219. CSpeech *This = (CSpeech*) this;
  221. int currPitch = This->GetPitch();
  222. This->SetPitch(TTSATTR_MINPITCH);
  223. int minPitch = This->GetPitch();
  224. This->SetPitch(currPitch);
  226. return minPitch;
  227. }
  229. // Get the max pitch
  230. int CSpeech::GetMaxPitch(void) const
  231. {
  232. CSpeech *This = (CSpeech*) this;
  234. int currPitch = This->GetPitch();
  235. This->SetPitch(TTSATTR_MAXPITCH);
  236. int maxPitch = This->GetPitch();
  237. This->SetPitch(currPitch);
  239. return maxPitch;
  240. }
  242. // Set the speed
  243. BOOL CSpeech::SetSpeed(long speed)
  244. {
  245. return (m_speechImpl->m_pITTSAttributes->SpeedSet(speed) == NOERROR);
  246. }
  248. // Get the speed
  249. long CSpeech::GetSpeed(void) const
  250. {
  251. DWORD speed = 0;
  252. if (m_speechImpl->m_pITTSAttributes->SpeedGet(& speed) == NOERROR)
  253. return speed;
  254. else
  255. return -1;
  256. }
  258. // Get the min speed
  259. long CSpeech::GetMinSpeed(void) const
  260. {
  261. CSpeech *This = (CSpeech*) this;
  263. long currSpeed = This->GetSpeed();
  264. This->SetSpeed(TTSATTR_MINSPEED);
  265. long minSpeed = This->GetSpeed();
  266. This->SetSpeed(currSpeed);
  268. return minSpeed;
  269. }
  271. // Get the max speed
  272. long CSpeech::GetMaxSpeed(void) const
  273. {
  274. CSpeech *This = (CSpeech*) this;
  276. long currSpeed = This->GetSpeed();
  277. This->SetSpeed(TTSATTR_MAXSPEED);
  278. long maxSpeed = This->GetSpeed();
  279. This->SetSpeed(currSpeed);
  281. return maxSpeed;
  282. }
  284. // Set the volume
  285. BOOL CSpeech::SetVolume(long volume)
  286. {
  287. return (m_speechImpl->m_pITTSAttributes->VolumeSet(volume) == NOERROR);
  288. }
  290. // Get the volume
  291. long CSpeech::GetVolume(void) const
  292. {
  293. DWORD vol = 0;
  294. if (m_speechImpl->m_pITTSAttributes->VolumeGet(& vol) == NOERROR)
  295. return vol;
  296. else
  297. return -1;
  298. }
  300. // Get the min volume
  301. long CSpeech::GetMinVolume(void) const
  302. {
  303. return 0;
  304. }
  306. // Get the max volume
  307. long CSpeech::GetMaxVolume(void) const
  308. {
  309. return 65535;
  310. }
  312. BOOL CSpeech::Say(const CString& textStr, BOOL tagged)
  313. {
  314.     SDATA text;
  315.     text.dwSize = strlen(textStr) + 1;
  316.     text.pData = (CHAR *) malloc( text.dwSize);
  317.     strcpy((CHAR*)text.pData, textStr);
  318.     HRESULT res = m_speechImpl->m_pITTSCentral->TextData(CHARSET_TEXT, tagged, text, NULL, IID_ITTSBufNotifySink);
  319. free(text.pData);
  320. return (res == NOERROR);
  321. }
  323. BOOL CSpeech::Reset()
  324. {
  325. return (m_speechImpl->m_pITTSCentral->AudioReset() == NOERROR);
  326. }
  328. BOOL CSpeech::Default()
  329. {
  330.     return (m_speechImpl->m_pITTSCentral->Inject("\rst\") == NOERROR);
  331. }
  333. BOOL CSpeech::Inject(const CString& text)
  334. {
  335.     return (m_speechImpl->m_pITTSCentral->Inject(text) == NOERROR);
  336. }
  338. // Get the mode name by index
  339. CString CSpeech::GetModeName(int mode) const
  340. {
  341.      return m_speechImpl->m_modeNames[mode] ;
  342. }
  344. // Get the mode features by index
  345. long CSpeech::GetModeFeatures(int mode) const
  346. {
  347.     return m_speechImpl->m_modeFeatures[mode] ;
  348. }
  350. // Get the number of modes
  351. int CSpeech::GetModeCount(void) const
  352. {
  353.     return m_speechImpl->m_noModes;
  354. }
  356. // Overridables
  357. // ITTSNotifySink
  358. BOOL CSpeech::OnAttribChanged(long attribId)
  359. {
  360. return TRUE;
  361. }
  363. BOOL CSpeech::OnAudioStart(timestamp_t timeStamp)
  364. {
  365. return TRUE;
  366. }
  368. BOOL CSpeech::OnAudioStop(timestamp_t timeStamp)
  369. {
  370. return TRUE;
  371. }
  373. BOOL CSpeech::OnVisual(timestamp_t timeStamp, char cIPAPhoneme,
  374. char cEnginePhoneme, long dwHints, const CSpeechMouth& mouth)
  375. {
  376. return TRUE;
  377. }
  379. // ITTSBufNotifySink
  380. BOOL CSpeech::OnBookMark(timestamp_t qTimeStamp, long dwMarkNum)
  381. {
  382. return TRUE;
  383. }
  385. BOOL CSpeech::OnTextDataStarted (timestamp_t qTimeStamp)
  386. {
  387. return TRUE;
  388. }
  390. BOOL CSpeech::OnTextDataDone (timestamp_t qTimeStamp, long dwFlags)
  391. {
  392. return TRUE;
  393. }
  395. BOOL CSpeech::OnWordPosition (timestamp_t qTimeStamp, long dwByteOffset)
  396. {
  397. return TRUE;
  398. }
  400. // Shows an engine-specific About dialog.
  401. // Returns FALSE if not supported or there is some other error.
  402. BOOL CSpeech::AboutDialog(window_t parentWindow, const CString& title)
  403. {
  404. // I don't know how to convert to PWSTR (Unicode) so
  405. // pass NULL for now.
  406. return (m_speechImpl->m_pITTSDialogs->AboutDlg((HWND) parentWindow, NULL) == NOERROR);
  407. }
  409. // Shows an engine-specific general settings dialog.
  410. // Returns FALSE if not supported or there is some other error.
  411. BOOL CSpeech::GeneralDialog(window_t parentWindow, const CString& title)
  412. {
  413. // I don't know how to convert to PWSTR (Unicode) so
  414. // pass NULL for now.
  415. return (m_speechImpl->m_pITTSDialogs->GeneralDlg((HWND) parentWindow, NULL) == NOERROR);
  416. }
  418. // Shows an engine-specific lexicon dialog.
  419. // Returns FALSE if not supported or there is some other error.
  420. BOOL CSpeech::LexiconDialog(window_t parentWindow, const CString& title)
  421. {
  422. // I don't know how to convert to PWSTR (Unicode) so
  423. // pass NULL for now.
  424. return (m_speechImpl->m_pITTSDialogs->LexiconDlg((HWND) parentWindow, NULL) == NOERROR);
  425. }
  427. // Shows an engine-specific translation dialog.
  428. // Returns FALSE if not supported or there is some other error.
  429. BOOL CSpeech::TranslateDialog(window_t parentWindow, const CString& title)
  430. {
  431. // I don't know how to convert to PWSTR (Unicode) so
  432. // pass NULL for now.
  433. return (m_speechImpl->m_pITTSDialogs->TranslateDlg((HWND) parentWindow, NULL) == NOERROR);
  434. }
  436. // CSpeechImpl
  438. CSpeechImpl::CSpeechImpl(CSpeech* speech)
  439. {
  440.     m_pITTSEnum = 0;
  441.     m_pITTSCentral = 0;
  442.     m_pITTSAttributes = 0;
  443.     m_pITTSDialogs = 0;
  444.     m_pTestNotify = 0;
  445.     m_pTestBufNotify = 0;
  446. #ifdef DIRECTSOUND
  447.     m_pIAD = 0;
  448. #else
  449.     m_pIMMD;
  450. #endif
  451.     m_dwRegKey = 0;
  452. m_noModes = 0;
  453. m_speech = speech;
  454. }
  456. CSpeechImpl::~CSpeechImpl()
  457. {
  458. }
  460. BOOL CSpeechImpl::InitTTS(void)
  461. {
  462. HRESULT hRes;
  464.     m_pITTSCentral = NULL;
  465.     m_pITTSEnum = NULL;
  466.     m_pITTSAttributes = NULL;
  467.     m_pITTSDialogs = NULL;
  468.     m_dwRegKey = 0xFFFFFFFF;
  469.     m_pTestNotify = NULL;
  470.     m_pTestBufNotify = NULL;
  471. #ifdef DIRECTSOUND
  472.     m_pIAD = NULL;
  473. #else
  474.     m_pIMMD = NULL;
  475. #endif
  477. hRes = CoCreateInstance (CLSID_TTSEnumerator, NULL, CLSCTX_ALL, IID_ITTSEnum, (void**)&m_pITTSEnum);
  479. if (FAILED(hRes))
  480. {
  481. CSpeechMessage( "Error creating TTSEnumerator (CoCreateInstance)." );
  482.     return FALSE;
  483. }
  485. if( (m_pTestNotify = new CTestNotify(m_speech)) == NULL )
  486. CSpeechMessage( "Error creating notify pointer." );
  488. if( (m_pTestBufNotify = new CTestBufNotify(m_speech)) == NULL )
  489. CSpeechMessage( "Error creating buf notify pointer." );
  491. return TRUE;
  492. }
  494. BOOL CSpeechImpl::TerminateTTS(void)
  495. {
  496. if ( m_pITTSEnum ) {
  497.         m_pITTSEnum->Release();
  498.         m_pITTSEnum = NULL;
  499.     }
  500. if ( m_pITTSAttributes ) {
  501.         m_pITTSAttributes->Release();
  502.         m_pITTSAttributes = NULL;
  503.     }
  504. if ( m_pITTSDialogs ) {
  505.         m_pITTSDialogs->Release();
  506.         m_pITTSDialogs = NULL;
  507.     }
  508. if ( m_pITTSCentral ) {
  509.     m_pITTSCentral->UnRegister(m_dwRegKey);
  510.         m_pITTSCentral->Release();
  511.         m_pITTSCentral = NULL;
  512.     }
  514. #ifdef DIRECTSOUND
  515. if ( m_pIAD ) {
  516.         while (m_pIAD->Release());
  517.         m_pIAD = NULL;
  518.     }
  519. #else
  520. if ( m_pIMMD ) {
  521.       // some engines will leak an audio destination object
  522.       // but if release they crash
  523. //while (
  524.       //   m_pIMMD->Release();
  525.       //   );
  526.     }
  527. #endif
  529. if (m_pTestNotify ) {
  530.         delete(m_pTestNotify);
  531.         m_pTestNotify = NULL;
  532.     }
  533. if (m_pTestBufNotify) {
  534.         delete(m_pTestBufNotify);
  535.         m_pTestBufNotify = NULL;
  536.     }
  537. return TRUE;
  538. }
  541. /*************************************************************************
  542. CTestNotify - Notification object.
  543. */
  544. CTestNotify::CTestNotify (CSpeech *pCSpeech)
  545. {
  546.     m_speech = pCSpeech;
  547. }
  549. CTestNotify::~CTestNotify (void)
  550. {
  551. // this space intentionally left blank
  552. }
  554. STDMETHODIMP CTestNotify::QueryInterface (REFIID riid, LPVOID *ppv)
  555. {
  556. *ppv = NULL;
  558. /* always return our IUnknown for IID_IUnknown */
  559. if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ITTSNotifySink))
  560. {
  561. *ppv = (LPVOID) this;
  562. return S_OK;
  563. }
  565. // otherwise, cant find
  566. return ResultFromScode (E_NOINTERFACE);
  567. }
  569. STDMETHODIMP_ (ULONG) CTestNotify::AddRef (void)
  570. {
  571. // normally this increases a reference count, but this object
  572. // is going to be freed as soon as the app is freed, so it doesn't
  573. // matter
  574. return 1;
  575. }
  577. STDMETHODIMP_(ULONG) CTestNotify::Release (void)
  578. {
  579. // normally this releases a reference count, but this object
  580. // is going to be freed when the application is freed so it doesnt
  581. // matter
  582. return 1;
  583. }
  585. STDMETHODIMP CTestNotify::AttribChanged (DWORD dwAttribID)
  586. {
  587. if (m_speech->OnAttribChanged(dwAttribID))
  588.     return NOERROR;
  589. else
  590. return E_FAIL;
  591. }
  593. STDMETHODIMP CTestNotify::AudioStart (QWORD qTimeStamp)
  594. {
  595. if (m_speech->OnAudioStart(qTimeStamp))
  596.     return NOERROR;
  597. else
  598. return E_FAIL;
  599. }
  601. STDMETHODIMP CTestNotify::AudioStop (QWORD qTimeStamp)
  602. {
  603. if (m_speech->OnAudioStop(qTimeStamp))
  604.     return NOERROR;
  605. else
  606. return E_FAIL;
  607. }
  609. STDMETHODIMP CTestNotify::Visual (QWORD qTimeStamp, CHAR cIPAPhoneme,
  610. CHAR cEnginePhoneme, DWORD dwHints, PTTSMOUTH pTTSMouth)
  611. {
  612. CSpeechMouth mouth;
  613. mouth.m_mouthHeight = pTTSMouth->bMouthHeight;
  614. mouth.m_mouthWidth = pTTSMouth->bMouthWidth;
  615. mouth.m_mouthUpturn = pTTSMouth->bMouthUpturn;
  616. mouth.m_jawOpen = pTTSMouth->bJawOpen;
  617. mouth.m_teethUpperVisible = pTTSMouth->bTeethUpperVisible;
  618. mouth.m_teethLowerVisible = pTTSMouth->bTeethLowerVisible;
  619. mouth.m_tonguePosn = pTTSMouth->bTonguePosn;
  620. mouth.m_lipTension = pTTSMouth->bLipTension;
  622. if (m_speech->OnVisual(qTimeStamp, cIPAPhoneme, cEnginePhoneme, dwHints, mouth))
  623.     return NOERROR;
  624. else
  625. return E_FAIL;
  627. #if 0
  628.     CDC* pdc = m_pCSpeech->GetDC();
  629.     CRect r,r1;
  630.     POINT pPoints[6];
  631.     m_pCSpeech->GetClientRect(&r);
  632.     CBrush bkBrush(COLORREF(pdc->GetBkColor()));
  633. CBrush redBrush(COLORREF(RGB(0xff,0x00,0x00))); //a solid red brush
  634. CBrush whiteBrush(COLORREF(RGB(0xff,0xff,0xff))); //a solid white brush
  635. CBrush blackBrush(COLORREF(RGB(0x00,0x00,0x00))); //a solid black brush
  636.     
  637.     CBrush *oldBrush = pdc->SelectObject(&bkBrush);
  638.     int nTeethUpperHeight, nTeethLowerHeight, nMouthHeight;
  639.     int nCenterX, nCenterY, nLeft, nLeft2, nRight, nRight2;
  641.     static BOOL fKnowMouth = FALSE;
  642.     if (!fKnowMouth) {
  643.        fKnowMouth = TRUE;
  645.        // remember the mouth position
  646.       HWND hWndMouth;
  647.       hWndMouth = ::GetDlgItem (ghWndMain, IDC_MOUTHBOX);
  648.       ::GetWindowRect(hWndMouth, &gRectMouth);
  649.       POINT  pDlg;
  650.       pDlg.x = gRectMouth.left;
  651.       pDlg.y = gRectMouth.top;
  652.       ::ScreenToClient(ghWndMain, &pDlg);
  653.       gRectMouth.left = pDlg.x;
  654.       gRectMouth.top = pDlg.y;
  655.       pDlg.x = gRectMouth.right;
  656.       pDlg.y = gRectMouth.bottom;
  657.       ::ScreenToClient(ghWndMain, &pDlg);
  658.       gRectMouth.right = pDlg.x;
  659.       gRectMouth.bottom = pDlg.y;
  660.     }
  663.     r1 = gRectMouth;
  664.     pdc->FillRect(r1,oldBrush);
  666.     nCenterX = (gRectMouth.left + gRectMouth.right) / 2;
  667.     nCenterY = (gRectMouth.top * 2 + gRectMouth.bottom) / 3;
  668.     
  669.     pdc->SelectObject(redBrush);
  670.     if (pTTSMouth) {
  671.     
  672.         nLeft2 = (LONG) (nCenterX - pTTSMouth->bMouthWidth * 20.0f / 256.0f);
  673.         nLeft = (LONG) (nCenterX - pTTSMouth->bMouthWidth * 40.0f / 256.0f);
  674.         nRight2 = (LONG) (nCenterX + pTTSMouth->bMouthWidth * 20.0f / 256.0f);
  675.         nRight = (LONG) (nCenterX + pTTSMouth->bMouthWidth * 40.0f / 256.0f);
  676.         nTeethUpperHeight = (LONG) (pTTSMouth->bTeethUpperVisible * 8.0f / 256.0f);
  677.         nTeethLowerHeight = (LONG) (pTTSMouth->bTeethLowerVisible * 8.0f / 256.0f);
  678.         nMouthHeight = (LONG) (pTTSMouth->bMouthHeight * 80.0f / 256.0f);
  679.         pPoints[0].x = pPoints[2].x = nLeft2;
  680.         pPoints[1].x = nLeft;
  681.         pPoints[3].x = pPoints[5].x = nRight2;
  682.         pPoints[4].x = nRight;
  683.         pPoints[0].y = pPoints[5].y = nCenterY - nTeethUpperHeight - 5;
  684.         pPoints[1].y = pPoints[4].y = nCenterY;
  685.         pPoints[2].y = pPoints[3].y = nCenterY - nTeethUpperHeight + nMouthHeight + 5;
  686.         pdc->Polygon(pPoints, 6);
  688.         pdc->SelectObject(whiteBrush);
  689.         pPoints[0].y = pPoints[5].y = nCenterY - nTeethUpperHeight;
  690.         pPoints[1].y = pPoints[4].y = nCenterY;
  691.         pPoints[2].y = pPoints[3].y = nCenterY - nTeethUpperHeight + nMouthHeight;
  692.         pdc->Polygon(pPoints, 6);
  694.         pdc->SelectObject(blackBrush);
  695.         pPoints[0].y = pPoints[5].y = nCenterY;
  696.         pPoints[1].y = pPoints[4].y = nCenterY;
  697.         pPoints[2].y = pPoints[3].y = nCenterY - nTeethUpperHeight + nMouthHeight - nTeethLowerHeight;
  698.         pdc->Polygon(pPoints, 6);
  699. } else {
  700.         nLeft2 = (LONG) (nCenterX - 10);
  701.         nLeft = (LONG) (nCenterX - 20);
  702.         nRight2 = (LONG) (nCenterX + 10);
  703.         nRight = (LONG) (nCenterX + 20);
  704.         pPoints[0].x = pPoints[2].x = nLeft2;
  705.         pPoints[1].x = nLeft;
  706.         pPoints[3].x = pPoints[5].x = nRight2;
  707.         pPoints[4].x = nRight;
  708.         pPoints[0].y = pPoints[5].y = nCenterY - 5;
  709.         pPoints[1].y = pPoints[4].y = nCenterY;
  710.         pPoints[2].y = pPoints[3].y = nCenterY + 5;
  711.         
  712.         pdc->Polygon(pPoints, 6);
  713. }
  714.     
  715.     pdc->SelectObject(oldBrush);
  716.     m_speech->ReleaseDC(pdc);
  717. #endif
  719.    return NOERROR;
  720. }
  722. /*************************************************************************
  723. CTestBufNotify - Notification object.
  724. */
  725. CTestBufNotify::CTestBufNotify (CSpeech* speech)
  726. {
  727. m_speech = speech;
  728. }
  730. CTestBufNotify::~CTestBufNotify (void)
  731. {
  732. // this space intentionally left blank
  733. }
  735. STDMETHODIMP CTestBufNotify::QueryInterface (REFIID riid, LPVOID *ppv)
  736. {
  737. *ppv = NULL;
  739. /* always return our IUnknown for IID_IUnknown */
  740. if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ITTSBufNotifySink))
  741. {
  742. *ppv = (LPVOID) this;
  743. return S_OK;
  744. }
  746. // otherwise, cant find
  747. return ResultFromScode (E_NOINTERFACE);
  748. }
  750. STDMETHODIMP_ (ULONG) CTestBufNotify::AddRef (void)
  751. {
  752. // normally this increases a reference count, but this object
  753. // is going to be freed as soon as the app is freed, so it doesn't
  754. // matter
  755. return 1;
  756. }
  758. STDMETHODIMP_(ULONG) CTestBufNotify::Release (void)
  759. {
  760. // normally this releases a reference count, but this object
  761. // is going to be freed when the application is freed so it doesnt
  762. // matter
  763. return 1;
  764. }
  766. STDMETHODIMP CTestBufNotify::BookMark (QWORD qTimeStamp, DWORD dwMarkNum)
  767. {
  768. if (m_speech->OnBookMark(qTimeStamp, dwMarkNum))
  769.     return NOERROR;
  770. else
  771. return E_FAIL;
  772. }
  774. STDMETHODIMP CTestBufNotify::TextDataDone (QWORD qTimeStamp, DWORD dwFlags)
  775. {
  776. if (m_speech->OnTextDataDone(qTimeStamp, dwFlags))
  777.     return NOERROR;
  778. else
  779. return E_FAIL;
  780. }
  782. STDMETHODIMP CTestBufNotify::TextDataStarted (QWORD qTimeStamp)
  783. {
  784. if (m_speech->OnTextDataStarted(qTimeStamp))
  785.     return NOERROR;
  786. else
  787. return E_FAIL;
  788. }
  790. STDMETHODIMP CTestBufNotify::WordPosition (QWORD qTimeStamp, DWORD dwByteOffset)
  791. {
  792. if (m_speech->OnWordPosition(qTimeStamp, dwByteOffset))
  793.     return NOERROR;
  794. else
  795. return E_FAIL;
  796. }
  798. void CSpeechMessage(const CString& msg, const CString& label)
  799. {
  800.         MessageBox (NULL, TEXT(msg), TEXT(label), MB_OK );
  801. }