一个通用的IBM viavoice语音识别语音朗读的接口,适用于基于IBM viavoice开发

最新推荐文章于 2024-06-06 16:03:37 发布
最新推荐文章于 2024-06-06 16:03:37 发布
阅读量3.8k 收藏 1
点赞数
分类专栏： IBM viaVoice语音识别 语音交互开发 文章标签： ibm action null training extension delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itcastcpp/article/details/3515365
版权


//------------------------------------------------------------------------------
// sapi.cpp  -  IBM Sapi speech engine interface
//------------------------------------------------------------------------------

#include "stdafx.h"
#include "winnls.h"

#ifndef _SPEECH_
#include "objbase.h"
#include "initguid.h"
#include <objerror.h>
#include <speech.h>
#include <ibmspch.h>
#include <mmsystem.h>
#endif

#include "SRWrapEn.h"
#include "myresource.h"
#include "global.hpp"
#include "sapi.hpp"


DWORD               ListenKey;
WantNotifications tellMe;  // Notification Sink flags
const char   *pGStopPhr; // "stop dictation" phrase for various languages

//------------------------------------------------------------------------------
// Description: SapiSpeech class implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Description: constructor
//------------------------------------------------------------------------------
SapiSpeech:: SapiSpeech(CEdit *pCEdit)
{
 pGStopPhr = 0;

 m_pCEdit   = pCEdit;
 m_pSpchCentral  = 0;
 m_pSpchEngSink  = 0;
 m_pSpchDctSink  = 0;
 m_pSpchGramDict  = 0;
 m_pGramCommon  = 0;
 m_pStatusLB         = 0;
 
    m_pLtdGramCommon    = 0;   
 m_pSpchLtdSink      = 0;   

 // setup the nofification sink's notifications.
 memset(&tellMe, 0, sizeof(tellMe));
 tellMe.bDctPhraseStart  = TRUE;
 tellMe.bDctPhraseHypothesis = TRUE;
 tellMe.bDctPhraseFinish  = TRUE;

    // initialize the speech engine and grammars for Dictation
 if ( !initForDictation(SRSEQUENCE_CONTINUOUS) )
    {
  if ( !initForDictation(SRSEQUENCE_DISCRETE) )
   state = RC_SPEECH_FAILED;
  else
   state = RC_SUCCESS;
    }
 else
    {
  state = RC_SUCCESS;
    }
}

//------------------------------------------------------------------------------
// Description: destructor
//------------------------------------------------------------------------------
SapiSpeech:: ~SapiSpeech()
{
 m_pStatusLB = 0;
 
 terminate();
}

//------------------------------------------------------------------------------
// Description: terminate speech session... cleanup
//------------------------------------------------------------------------------
void SapiSpeech:: terminate()
{
 deactivate();

 if (m_pSpchCentral && m_pSpchEngSink->m_dwKey )
    m_pSpchCentral->UnRegister( m_pSpchEngSink->m_dwKey );

 if (m_pIBMAcoustics)
  m_pIBMAcoustics->Release();

 if (m_pSpchCentral)
  m_pSpchCentral->Release();

 if( m_pSpchGramDict )   m_pSpchGramDict->Release();

 if( m_pGramCommon ) m_pGramCommon->Release();
   
    if ( m_pLtdGramCommon )  m_pLtdGramCommon->Release();


    if (m_pISRListen )
    {
     if (m_dwListenKey)
       m_pISRListen->Unregister(m_dwListenKey);

  m_pISRListen->Release();
    }
 if( m_pGramActionCommon ) m_pGramActionCommon->Release();
}

//----------------------------------------------------------------------------------------------
// Description: Initializes the Speech engine via SAPI. Only the IBM dictation speech engine
//    is searched.
//----------------------------------------------------------------------------------------------
int SapiSpeech:: initForDictation(int Sequencing)
{
 HRESULT      hRes;
 SRMODEINFO     wantSRMode;
 SRMODEINFO     gotSRMode;
 PISRFIND     pFind  = 0;
 PISRENUM     pEnum  = 0;
 PIAUDIOMULTIMEDIADEVICE  pMMDev  = 0;
 int                      yes=1, no=0;
    int                      success = yes;
 

 //
 // First we create the enumerator so we can search for the IBM dictation engine
 //
 hRes = CoCreateInstance( CLSID_SREnumerator, NULL, CLSCTX_ALL, IID_ISREnum, (void**)&pEnum );
 if( FAILED(hRes) ) 
 {
  pEnum = NULL;
  Error(hRes, TEXT("Error creating SREnumerator (CoCreateInstance)."), NULL, MB_OK );
  goto initForDictation_done;
 }

 ASSERT( pEnum );

 // Get the find interface so we can search for the IBM dictation engine
 hRes = pEnum->QueryInterface(IID_ISRFind, (void**)&pFind);
 pEnum->Release(); pEnum = 0;
 if( FAILED(hRes) )
 {
  pFind = NULL;
  Error( hRes, _T("Could not create PISRFIND interface") );
  goto initForDictation_done;
 }

 //Setup the SRMODEINFO structure with the parameters we are interested in having in out speech
 // engine. Then use the enumerator to find the engine we want.
 memset( &wantSRMode, 0, sizeof(SRMODEINFO) );
 hRes = MultiByteToWideChar(CP_ACP, 0, "IBM", -1, wantSRMode.szMfgName, SRMI_NAMELEN);
 wantSRMode.dwGrammars = SRGRAM_DICTATION | SRGRAM_LIMITEDDOMAIN;

 wantSRMode.dwSequencing = Sequencing;

 hRes = pFind->Find( &wantSRMode, NULL, &gotSRMode );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Failed trying to find engine mode (Find)") );
  goto initForDictation_done;
 }

 // Did we get the IBM dictation engine???
 if (wcscmp(wantSRMode.szMfgName, gotSRMode.szMfgName) != 0)
 {
  Error(-1, TEXT("Could not find IBM dictation engine"));
        success = no;
  goto initForDictation_done;
 }

 //
 // It is preferred to not share the dictation engine. Usually, it does not make sense to do so.
 // Therefore, create a non-shared dictation engine. For a nonshared engine, we must get the
 // mmdevice
 //
 hRes = CoCreateInstance( CLSID_MMAudioSource, NULL, CLSCTX_ALL, IID_IAudioMultiMediaDevice, (void**)&pMMDev);
 if( FAILED(hRes))
 {
  Error(hRes, TEXT("CoCreateInstance for mm device failed in EngModeSelect()."));
  goto initForDictation_done;
 }

 hRes = pMMDev->DeviceNumSet( WAVE_MAPPER );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Error in IAudioMultimediaDevice::DeviceNumSet().") );
 }

 // Select now...

 // if the mode was found using the ISRFind interface then use the Find::Select()...
 hRes = pFind->Select(gotSRMode.gModeID, &m_pSpchCentral, (LPUNKNOWN)pMMDev);

 pMMDev->Release();
 pMMDev = 0;

 pFind->Release();
 pFind = 0;

 if (FAILED(hRes))
 {
  Error(hRes, TEXT("Could not select the engine"));
  m_pSpchCentral = 0;
  goto initForDictation_done;
 }

 if (0 == m_pSpchCentral)
 {
  Error(hRes, TEXT("Failed to create speech engine (m_pSpchCentral = 0)"));
        success = no;
  goto initForDictation_done;
 }


 // register the notification object to the engine
 m_pSpchEngSink = new SpchEngSink(this);
 hRes = m_pSpchCentral->Register (m_pSpchEngSink, IID_ISRNotifySink, &(m_pSpchEngSink->m_dwKey) );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Error Registering engine notification class") );
  m_pSpchEngSink = 0;
  goto initForDictation_done;
 }
                                  
    hRes = m_pSpchCentral->QueryInterface(IID_IIBM_SRListen, (void**)&m_pISRListen);
 
    if (FAILED(hRes))
 {
  Error( hRes, TEXT("Error Querying IBM Listen Extension") );
  m_pISRListen = 0;
  goto initForDictation_done;
 }

 m_pISRListen->Register(&m_dwListenKey);

 //
 // In order to work in non-US languages, the phrase to stop dictation needs to reflect the language
 // we are working in.
 //
 const char   *pGramLangSuffix;
 GUID engGuid = gotSRMode.gModeID;
 pGramLangSuffix = getGrammarLanguageSuffix(engGuid);
 pGStopPhr  = getStopPhrase(pGramLangSuffix);
 
    //
 // Create the dictation and limited-domain grammars in memory and load
    // them into the engine.
 //
    success = initGrammars( pGStopPhr );

    hRes = m_pSpchCentral->QueryInterface(IID_IIBM_SRDialogs, (void**)&m_pIBMTrainDialog);
 
    if (FAILED(hRes))
 {
  Error( hRes, TEXT("Error Querying IBM Dialogs Extension") );
  m_pIBMTrainDialog = 0;
  goto initForDictation_done;
 }
   
    hRes = m_pSpchCentral->QueryInterface(IID_IIBM_SRAcousticPronunciations, (void**)&m_pIBMAcoustics);
 
    if (FAILED(hRes))
 {
  Error( hRes, TEXT("Error Querying IBM Acoustic Pronunciations Extension") );
  m_pIBMAcoustics = 0;
  goto initForDictation_done;
 }

initForDictation_done:
 if (pMMDev) pMMDev->Release();
 if (pFind) pFind->Release();

 if (FAILED(hRes))
 {
        success = no;
    }

 if ( success == no && Sequencing == SRSEQUENCE_CONTINUOUS )
 {
  AfxMessageBox(TEXT("Now, trying for discrete engine"));
 }

    return success;
}

//----------------------------------------------------------------------------------------------
// Description: Initializes the Dictation and Limite-domain Grammars for SAPI speech.
//----------------------------------------------------------------------------------------------
int SapiSpeech:: initGrammars( const char * const stopPhrase )
{
 int       Actionlen,wordlen;
 HRESULT      hRes;
 SDATA      dictGram, ltdGram, actionGram;
 PSRCHUNK     pSRChunk = 0;
 PSRHEADER     pSRHeader = 0;
 PSRACTIONVERB            pSRActionVerb = 0;
 LPUNKNOWN     lpUnkDict  = 0;
 LPUNKNOWN     lpUnkLtd   = 0;
 LPUNKNOWN     lpUnkAction= 0;
    int                      yes=1, no=0;
    int                      success = yes;
 
   
    dictGram.pData = 0;

 //
 // Create the dictation grammar in memory and load it into the engine.
 
 //

    wordlen = strlen(stopPhrase) * 2 + 2;  // +2 for ending null

 dictGram.dwSize = sizeof(SRHEADER) + sizeof(SRCHUNK) + wordlen;
 dictGram.pData = (void*) new unsigned int[dictGram.dwSize];

 pSRHeader = (SRHEADER *)dictGram.pData;
    pSRHeader->dwType = SRHDRTYPE_DICTATION;
    pSRHeader->dwFlags = SRHDRFLAG_UNICODE;
   
   
    pSRChunk = (SRCHUNK *) ((PBYTE)dictGram.pData + sizeof(SRHEADER));
 pSRChunk->dwChunkID = SRCKD_SUBTOPIC;
 pSRChunk->dwChunkSize = wordlen;
 MultiByteToWideChar(CP_ACP, 0, "dummy", -1, (unsigned short *)&pSRChunk->avInfo[0], wordlen);


 m_pSpchDctSink = new SpchDctSink(this);
 hRes = m_pSpchCentral->GrammarLoad( SRGRMFMT_DICTATION,
          dictGram,
          (PVOID)m_pSpchDctSink,
          IID_ISRGramNotifySink,
          &lpUnkDict );
 if( FAILED(hRes))
 {
  Error(hRes, TEXT("Could not load the dictation grammar"));
  goto initGrammars_done;
 }


 /*------------------------------------------------------------------------------------*/
 /* Now that we have the Unknown to the grammer object, lets get the common interface. */
 /*------------------------------------------------------------------------------------*/
 hRes = lpUnkDict->QueryInterface( IID_ISRGramCommon, (void**)&m_pGramCommon );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get ISRGramCommon interface."));
  goto initGrammars_done;
 }
 
 hRes = lpUnkDict->QueryInterface( IID_ISRGramDictation, (void**)&m_pSpchGramDict );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get the ISRGramDictation interface."));
  goto initGrammars_done;
 }

    hRes = lpUnkDict->QueryInterface( IID_IIBM_SRGramDictation, (void**)&m_pIBMGramDict );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get the IBM SRGramDictation interface."));
  goto initGrammars_done;
 }
   

 //
 // Create the limited-domain grammar in memory and load it into the engine.
 //
    ltdGram.pData = 0;

 wordlen = strlen(stopPhrase) * 2 + 2;  // +2 for ending null

 ltdGram.dwSize = sizeof(SRHEADER) + sizeof(SRCHUNK) + wordlen;
 ltdGram.pData = (void*) new unsigned int[ltdGram.dwSize];

 pSRHeader = (SRHEADER *)ltdGram.pData;
    pSRHeader->dwType = SRHDRTYPE_LIMITEDDOMAIN;
    pSRHeader->dwFlags = SRHDRFLAG_UNICODE;

 pSRChunk = (SRCHUNK *) ((PBYTE)ltdGram.pData + sizeof(SRHEADER));
 pSRChunk->dwChunkID = SRCKLD_WORDS;
 pSRChunk->dwChunkSize = wordlen;
 MultiByteToWideChar(CP_ACP, 0, stopPhrase, -1, (unsigned short *)&pSRChunk->avInfo[0], wordlen);


 m_pSpchLtdSink = new SpchLtdSink(this);
 hRes = m_pSpchCentral->GrammarLoad( SRGRMFMT_LIMITEDDOMAIN,
          ltdGram,
          (PVOID)m_pSpchLtdSink,
          IID_ISRGramNotifySink,
          &lpUnkLtd );
 if( FAILED(hRes))
 {
  Error(hRes, TEXT("Could not load the dictation grammar"));
  goto initGrammars_done;
 }


    /*------------------------------------------------------------------------------------*/
 /* Now that we have the Unknown to the grammer object, lets get the Action interface. */
 /*------------------------------------------------------------------------------------*/
 hRes = lpUnkLtd->QueryInterface( IID_IIBM_SRUpdateWords, (void**)&m_pIBMUpdateWords );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get IBM SRUpdateWords interface."));
  goto initGrammars_done;
 }


 /*------------------------------------------------------------------------------------*/
 /* Now that we have the Unknown to the grammer object, lets get the common interface. */
 /*------------------------------------------------------------------------------------*/
 hRes = lpUnkLtd->QueryInterface( IID_ISRGramCommon, (void**)&m_pLtdGramCommon );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get ISRGramCommon interface."));
  goto initGrammars_done;
 }

 

    actionGram.pData = 0;

   
 Actionlen = strlen("sel") * 2 + 2;
 wordlen = strlen("dummy") * 2 + 2;


 actionGram.dwSize = sizeof(SRHEADER) + (sizeof(SRCHUNK) *2) + sizeof(SRACTIONVERB) + Actionlen + wordlen;
 actionGram.pData = (void*) new unsigned int[actionGram.dwSize];

 // Set Header Data
 pSRHeader = (SRHEADER *)actionGram.pData;
    pSRHeader->dwType = IBM_SRHDRTYPE_ACTION;
    pSRHeader->dwFlags = SRHDRFLAG_UNICODE;
   

    // Fill in Chunk Data
    pSRChunk = (SRCHUNK *) ((PBYTE)actionGram.pData + sizeof(SRHEADER));
 pSRChunk->dwChunkID = SRCKACTION_ACTIONVERB;
 pSRChunk->dwChunkSize = sizeof(SRACTIONVERB) + Actionlen;
   
 // Fill In Action Verb Data

    pSRActionVerb = (PSRACTIONVERB)((PBYTE)actionGram.pData + sizeof(SRHEADER)+ sizeof(SRCHUNK));
 pSRActionVerb->dwSize = sizeof(SRACTIONVERB) + Actionlen;
    pSRActionVerb->dwActionNum = 1;
 MultiByteToWideChar(CP_ACP, 0, "sel", -1, (unsigned short *)&pSRActionVerb->szString[0], Actionlen);

 // Fill in Word  Data
    pSRChunk = (SRCHUNK *) ((PBYTE)pSRActionVerb + sizeof(SRACTIONVERB) + Actionlen);
 pSRChunk->dwChunkID = SRCKACTION_WORDSSEQUENCE;
 pSRChunk->dwChunkSize = wordlen;
    MultiByteToWideChar(CP_ACP, 0, "dummy", -1, (unsigned short *)&pSRChunk->avInfo[0], wordlen);

    m_pSpchActionSink = new SpchActionSink(this);
 hRes = m_pSpchCentral->GrammarLoad( (SRGRMFMT) IBM_SRGRMFMT_ACTION,
          actionGram,
          (PVOID)m_pSpchActionSink,
          IID_ISRGramNotifySink,
          &lpUnkAction );
 if( FAILED(hRes))
 {
  Error(hRes, TEXT("Could not load the IBM Action grammar"));
  goto initGrammars_done;
 }


    /*------------------------------------------------------------------------------------*/
 /* Now that we have the Unknown to the grammer object, lets get the Action interface. */
 /*------------------------------------------------------------------------------------*/
 hRes = lpUnkAction->QueryInterface( IID_IIBM_SRGramAction, (void**)&m_pGramAction );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get IBM SRGramAction interface."));
  goto initGrammars_done;
 }

    hRes = lpUnkAction->QueryInterface( IID_ISRGramCommon, (void**)&m_pGramActionCommon );
 if (FAILED(hRes))
 {
  Error( hRes, TEXT("Could not get ISRGramCommon interface."));
  goto initGrammars_done;
 }


   


initGrammars_done:
 if (lpUnkDict) lpUnkDict->Release();
 if (dictGram.pData) delete dictGram.pData;
 if (lpUnkLtd) lpUnkLtd->Release();
 if (ltdGram.pData) delete ltdGram.pData;

 if (lpUnkAction) lpUnkAction->Release();
 if (actionGram.pData) delete actionGram.pData;

 if (FAILED(hRes))
 {
        success = no;
    }

    return success;
}

//--------------------------------------------------------------------------
// Description: returns the "stop dictation" phrase that is appropriate for
//    the current language.
//--------------------------------------------------------------------------
const char *SapiSpeech:: getStopPhrase(const char *pCountryCode)
{
 if (0 == strcmp(pCountryCode, "US")) return "stop dictation"; // United States
 if (0 == strcmp(pCountryCode, "UK")) return "stop dictation"; // United Kingdom
 if (0 == strcmp(pCountryCode, "FR")) return "stop dictation"; // French
 if (0 == strcmp(pCountryCode, "GR")) return "stop dictation"; // German
 if (0 == strcmp(pCountryCode, "IT")) return "stop dictation"; // Italian
 if (0 == strcmp(pCountryCode, "ES")) return "stop dictation"; // Spanish

 return "unknown language";
}

//--------------------------------------------------------------------------
// Description: returns the prefix for the grammars based upon which language
//              we are in.                                         
//--------------------------------------------------------------------------
const char * SapiSpeech:: getGrammarLanguageSuffix(GUID &engGuid)
{
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeUS ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeUS)  // US english
  return "US";
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeUK ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeUK)  // UK english
  return "UK";
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeFR ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeFR)  // french
  return "FR";
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeGR ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeGR)  // german
  return "GR";
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeIT ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeIT)  // italian
  return "IT";
 if (engGuid == CLSID_SREngineEnumIBMDiscreteDictationModeES ||
  engGuid == CLSID_SREngineEnumIBMContinuousDictationModeES)  // spanish
  return "ES";

 return "";
}
 
//--------------------------------------------------------------------------
// Description: Activates the Grammar
//--------------------------------------------------------------------------
int SapiSpeech:: activate(BOOL pause)
{
 HRESULT hres;

    m_pCEdit->SetFocus();

 hres = m_pISRListen->StartListening(m_dwListenKey);
 if ( FAILED(hres) )
    {
        return( hres );
    }

    hres = m_pGramCommon->Activate( m_pCEdit->GetParent()->m_hWnd, pause, NULL );
    if ( FAILED(hres) )
    {
     return( hres );
    }

 

 return m_pLtdGramCommon->Activate( m_pCEdit->GetParent()->m_hWnd, pause, NULL );
 
}

//--------------------------------------------------------------------------
// Description: Deactivates the Grammar
//--------------------------------------------------------------------------
int SapiSpeech:: deactivate()
{
 HRESULT hres;

    if (0 != m_pISRListen)
    {
      hres = m_pISRListen->StopListening(m_dwListenKey);
   if ( FAILED(hres) )
   {
        return( hres );
   }
    }

    if (0 != m_pGramCommon)
    {
        hres = m_pGramCommon->Deactivate(NULL);
        if ( FAILED(hres) )
        {
            return hres;
        }
    }

    if (0 != m_pLtdGramCommon)
    {
        hres = m_pLtdGramCommon->Deactivate(NULL);
        if ( FAILED(hres) )
        {
            return hres;
        }
    }

    return RC_SUCCESS;
}

//--------------------------------------------------------------------------
// Description: Activates an Action in an action Grammar
//--------------------------------------------------------------------------
int SapiSpeech:: ActivateAction(char * szAction)
{
 HRESULT hres;
 WCHAR   wszAction[100];

   
// Activate Action Specified

    hres = MultiByteToWideChar(CP_ACP, 0, szAction, -1, wszAction, 100);
    hres = m_pGramActionCommon->Activate( m_pCEdit->GetParent()->m_hWnd, false, wszAction );
   

 return hres;
 
}

//--------------------------------------------------------------------------
// Description: Activates an Action in an action Grammar
//--------------------------------------------------------------------------
int SapiSpeech:: DeActivateAction(char * szAction)
{
 HRESULT hres;
    WCHAR   wszAction[100];
   
// Activate Action Specified

    hres = MultiByteToWideChar(CP_ACP, 0, szAction, -1, wszAction, 100);
    hres = m_pGramActionCommon->Deactivate(wszAction );
   

 return hres;
 
}

 


//--------------------------------------------------------------------------
// Description: This logs the events from the grammar sink and the engine sink.
//--------------------------------------------------------------------------
void SapiSpeech::logEventSink(SPCHEVENTID id, char *fmt, ...)
{
    static char buf[1000];
    va_list args;
    va_start(args, fmt);
    vsprintf(buf, fmt, args);
    va_end(args);

 if (m_pStatusLB)
  m_pStatusLB->AddString(buf);
 else
 {
  TRACE(buf);
  TRACE("/n");
 }
}

//----------------------------------------------------------------------------------------------
// Description: reset the context for word(s) that are to be corrected.
//----------------------------------------------------------------------------------------------
int  SapiSpeech:: resetContext( void )
{

 PWSTR  pszPrior = NULL;
 PWSTR  pszAfter = NULL;

 // reset the context... prior and after words are null
 HRESULT hres = m_pSpchGramDict->Context( pszPrior, pszAfter );
 if ( hres != NOERROR )
    {
        return 0;
    }

 return 1;
}

void SapiSpeech::DisplayTopics(CListBox *pLB)
{
 HRESULT      hRes;
    PIIBM_SRSUBTOPIC         pISRTopic  = 0;
 PCWSTR                   pTopicList = NULL;
 DWORD                    dwTopicSize;
 char                     szTopic[256];


 hRes = m_pSpchCentral->QueryInterface(IID_IIBM_SRSubTopic, (void**)&pISRTopic);

 if (FAILED(hRes))
 {
   Error( hRes, TEXT("Error Querying IBM Topics Extension") );
   return;
 }
 else
 {
 pISRTopic->EnumSubTopics(&dwTopicSize,&pTopicList);

 // loop through all of the Topics and display them...

    if (dwTopicSize > 0)
 { 
  WCHAR *  pSRWord= (WCHAR *) pTopicList;
  WCHAR *  pSRMax = (WCHAR *) ((BYTE*)pTopicList + (dwTopicSize-2));
  while( pSRWord < pSRMax)
  {
  int count = WideCharToMultiByte(CP_ACP, NULL, (unsigned short *)pSRWord, -1, szTopic, dwTopicSize, NULL, NULL);
  if (count == 0)
  {
   Error( -1000, TEXT("WideCharToMultiByte failed") );
   continue;
  }
  else
  {
   if (pLB)
     pLB->AddString(szTopic);
  }

        pSRWord = (WCHAR *) pSRWord + count;
  
  }
 }

 pISRTopic->Release();
 if (pTopicList)
   CoTaskMemFree((VOID*)pTopicList);
 }
 return;
}


//------------------------------------------------------------------------------
// Description: Speech engine notification sink implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Description: constructor
//------------------------------------------------------------------------------
SpchEngSink::SpchEngSink( SapiSpeech *pSpchObj )
{
 m_pSpchObj = pSpchObj;
 m_dwRefCnt = 0;
}

//----------------------------------------------------------------------------------------------
// Description: destructor
//----------------------------------------------------------------------------------------------
SpchEngSink::~SpchEngSink()
{
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::QueryInterface( REFIID riid, LPVOID *ppv )
{
 *ppv = NULL;

 // always return our IUnkown for IID_IUnknown...
 if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ISRNotifySink))
 {
  AddRef();
  *ppv = (LPVOID)this;
  return S_OK;
 }

 // otherwise, cant find...
 return ResultFromScode (E_NOINTERFACE);
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_ (ULONG) SpchEngSink::AddRef()
{
 return ++m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) SpchEngSink::Release()
{
 if( --m_dwRefCnt == 0 )
 {
  delete this;
  return 0;
 }
 return m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::AttribChanged( DWORD dwAttribID )
{
 if (tellMe.bEngAttribChanged)
  m_pSpchObj->logEventSink(ENG_ATTRIBCHANGED, TEXT("Attrib Id: 0x%x"), dwAttribID);

 return NOERROR;
}


//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::Interference( QWORD qTimeStampBegin,QWORD qTimeStampEnd, DWORD dwType )
{
 if (tellMe.bEngInterference)
  m_pSpchObj->logEventSink(ENG_INTERFERENCE, TEXT("Interference Beg: %I64x End: %I64x Type: 0x%04x"),
        qTimeStampBegin, qTimeStampEnd, dwType);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::Sound( QWORD qTimeStampBegin, QWORD qTimeStampEnd )
{
 if (tellMe.bEngSound)
  m_pSpchObj->logEventSink(ENG_SOUND, TEXT("Sound: Beg: %I64x, end %I64x"), qTimeStampBegin, qTimeStampEnd);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::UtteranceBegin( QWORD qTimeStampBegin )
{
 if (tellMe.bEngUtteranceBegin)
  m_pSpchObj->logEventSink(ENG_UTTERANCEBEGIN, TEXT("UtteranceBeg Beg: %I64x"), qTimeStampBegin);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::UtteranceEnd( QWORD qTimeStampBegin,QWORD qTimeStampEnd )
{
 if (tellMe.bEngUtteranceEnd)
  m_pSpchObj->logEventSink(ENG_UTTERANCEEND, TEXT("UtteranceEnd      Beg: %I64x End: %I64x"), qTimeStampBegin, qTimeStampEnd);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchEngSink::VUMeter( QWORD qTimeStampBegin, WORD wLevel )
{
 if (tellMe.bEngVUMeter)
  m_pSpchObj->logEventSink(ENG_VUMETER, TEXT("VUMeter Beg: %I64x Level: 0x%04x"), qTimeStampBegin, wLevel);

 return NOERROR;
}


//------------------------------------------------------------------------------
// Description: Dictation Grammar notification sink implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Description: constructor
//------------------------------------------------------------------------------
SpchDctSink::SpchDctSink( SapiSpeech *pSpch)
:m_ResList(pSpch)
{
 m_pSpchObj = pSpch;
 m_dwRefCnt = 0;
}

//----------------------------------------------------------------------------------------------
// Description: destructor
//----------------------------------------------------------------------------------------------
SpchDctSink::~SpchDctSink()
{
}


//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::QueryInterface( REFIID riid, LPVOID *ppv )
{
 *ppv = NULL;

 // always return our IUnknown for IID_IUnknown...
 if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ISRGramNotifySink))
 {
  AddRef();
  *ppv = (LPVOID)this;
  return S_OK;
 }

 // otherwise, cant find...
 return ResultFromScode (E_NOINTERFACE);
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_ (ULONG) SpchDctSink::AddRef()
{
 return ++m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) SpchDctSink::Release()
{
 if( --m_dwRefCnt == 0 )
 {
  delete this;
  return 0;
 }
 return m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::BookMark( DWORD dwID )
{
 if (tellMe.bDctBookmark)
        m_pSpchObj->logEventSink(DCT_BOOKMARK, TEXT("Dict:BookMark id: 0x%lx"), dwID);
 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::Paused()
{
 if (tellMe.bDctPaused)
        m_pSpchObj->logEventSink(DCT_PAUSED, TEXT("Dict:Paused..."));

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::PhraseStart( QWORD qTimeStampBegin )
{
 if (tellMe.bDctPhraseStart)
        m_pSpchObj->logEventSink(DCT_PHRASESTART, TEXT("Dict:PhraseStart Beg: %I64x"), qTimeStampBegin );

 m_ResList.dctPhStart(qTimeStampBegin);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::PhraseHypothesis( DWORD dwFlags, QWORD qTimeStampBegin,
   QWORD qTimeStampEnd, PSRPHRASE pSRPhrase, LPUNKNOWN lpResults )
{
 if (tellMe.bDctPhraseHypothesis)
        m_pSpchObj->logEventSink(DCT_PHRASEHYPOTHESIS, TEXT("Dict:PhraseHypothesis Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );

 char  buf[MAX_PHRASELEN];
 CString  phrase;

    // Make sure that the reco is for us
    if ( !(dwFlags & ISRNOTEFIN_THISGRAMMAR)) return NOERROR;
 if ( !(dwFlags & ISRNOTEFIN_RECOGNIZED )) return NOERROR;

    // unrecognized utterance
 if( !pSRPhrase )
  return NOERROR;

 // loop through all of the words and display them...
 PSRWORD  pSRWord = (PSRWORD) (pSRPhrase->abWords);
 PSRWORD  pSRMax = (PSRWORD) ((BYTE*)pSRPhrase + pSRPhrase->dwSize);
 while( pSRWord < pSRMax )
 {
  int count = WideCharToMultiByte(CP_ACP, NULL, pSRWord->szWord, -1, buf, MAX_PHRASELEN, NULL, NULL);
  if (count = 0)
  {
   Error( -1000, TEXT("Dct PhraseHypothesis: WideCharToMultiByte failed") );
   continue;
  }
  if (phrase.GetLength() > 0)
         phrase += " ";
  phrase += buf;
  pSRWord = (PSRWORD) ((BYTE*) pSRWord + pSRWord->dwSize);
 }

 m_ResList.dctPhHypothesis(phrase);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::PhraseFinish( DWORD     dwFlags,
                                          QWORD     qTimeStampBegin,
                                          QWORD     qTimeStampEnd,
                                          PSRPHRASE pSRPhrase,
                                          LPUNKNOWN lpResults )
{
 char buf[MAX_PHRASELEN];


    // Make sure that the reco is for us
    if ( !(dwFlags & ISRNOTEFIN_THISGRAMMAR)) return NOERROR;
 if ( !(dwFlags & ISRNOTEFIN_RECOGNIZED )) return NOERROR;

 if (tellMe.bDctPhraseFinish)
        m_pSpchObj->logEventSink(DCT_PHRASEFINISH, TEXT("Dict:PhraseFinish Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );

 PSRWORD  pSRWord, pSRMax;
 CString  phrase;

    // unrecognized utterance
 if( !pSRPhrase )
  return NOERROR;

 // loop through all of the words and display them...
 pSRMax  = (PSRWORD) ((BYTE*)pSRPhrase + pSRPhrase->dwSize);
 pSRWord = (PSRWORD) (pSRPhrase->abWords);
 while( pSRWord < pSRMax )
 {
  int count = WideCharToMultiByte(CP_ACP, NULL, pSRWord->szWord, -1, buf, MAX_PHRASELEN, NULL, NULL);
  if (count = 0)
  {
   Error( -1000, TEXT("Dct PhraseHypothesis: WideCharToMultiByte failed") );
   continue;
  }

  // store the phrase to display in the results list box...
  if( lpResults )
  {
   if (phrase.GetLength() > 0)
             phrase += " ";
   phrase += buf;
  }
  pSRWord = (PSRWORD) ((BYTE*) pSRWord + pSRWord->dwSize);
 }

 if ("" == phrase)         // new phrase is empty
  return NOERROR;

 return m_ResList.dctText(lpResults, phrase);

   
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::ReEvaluate( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctReevaluate)
        m_pSpchObj->logEventSink(DCT_REEVALUATE, TEXT("Dict:Reevaluate lpUnk: %08x"), lpUnk);

 if ( 0 == lpUnk ) return NOERROR;

// Let the ResultList do its thing for correction.
 m_ResList.dctReevaluate(lpUnk);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::Training( DWORD dwTrain )
{
 if (tellMe.bDctTraining)
        m_pSpchObj->logEventSink(DCT_TRAINING, TEXT("Dict:TrainingRequest Flag: 0x%lx."), dwTrain );

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchDctSink::UnArchive( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctUnarchive)
        m_pSpchObj->logEventSink(DCT_UNARCHIVE, TEXT("Dict:Unarchive lpUnk: %08x"), lpUnk);

 return NOERROR;
}

 


//------------------------------------------------------------------------------
// Description: Limited-domain Grammar notification sink implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Description: constructor
//------------------------------------------------------------------------------
SpchLtdSink::SpchLtdSink( SapiSpeech *pSpch)
:m_ResList(pSpch)
{
 m_pSpchObj = pSpch;
 m_dwRefCnt = 0;
}

//----------------------------------------------------------------------------------------------
// Description: destructor
//----------------------------------------------------------------------------------------------
SpchLtdSink::~SpchLtdSink()
{
}


//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::QueryInterface( REFIID riid, LPVOID *ppv )
{
 *ppv = NULL;

 // always return our IUnknown for IID_IUnknown...
 if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ISRGramNotifySink))
 {
  AddRef();
  *ppv = (LPVOID)this;
  return S_OK;
 }

 // otherwise, cant find...
 return ResultFromScode (E_NOINTERFACE);
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_ (ULONG) SpchLtdSink::AddRef()
{
 return ++m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) SpchLtdSink::Release()
{
 if( --m_dwRefCnt == 0 )
 {
  delete this;
  return 0;
 }
 return m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::BookMark( DWORD dwID )
{
 if (tellMe.bDctBookmark)
        m_pSpchObj->logEventSink(DCT_BOOKMARK, TEXT("Ltd:BookMark id: 0x%lx"), dwID);
 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::Paused()
{
 if (tellMe.bDctPaused)
        m_pSpchObj->logEventSink(DCT_PAUSED, TEXT("Ltd:Paused..."));

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::PhraseStart( QWORD qTimeStampBegin )
{
 if (tellMe.bDctPhraseStart)
        m_pSpchObj->logEventSink(DCT_PHRASESTART, TEXT("Ltd:PhraseStart Beg: %I64x"), qTimeStampBegin );

 m_ResList.dctPhStart(qTimeStampBegin);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::PhraseHypothesis( DWORD dwFlags, QWORD qTimeStampBegin,
   QWORD qTimeStampEnd, PSRPHRASE pSRPhrase, LPUNKNOWN lpResults )
{
 if (tellMe.bDctPhraseHypothesis)
        m_pSpchObj->logEventSink(DCT_PHRASEHYPOTHESIS, TEXT("Ltd:PhraseHypothesis Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec...
//              The "stop dictation" phrase is searched for here. If it is found, then dictaiton
//    is deactivated. Note that additional PhraseFinish invocation will still come
//    since the speech engine will firm up all remaining word
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::PhraseFinish( DWORD     dwFlags,
                                          QWORD     qTimeStampBegin,
                                          QWORD     qTimeStampEnd,
                                          PSRPHRASE pSRPhrase,
                                          LPUNKNOWN lpResults )
{
 char buf[MAX_PHRASELEN];


    // Make sure that the reco is for us
    if ( !(dwFlags & ISRNOTEFIN_THISGRAMMAR)) return NOERROR;
    if ( !(dwFlags & ISRNOTEFIN_RECOGNIZED )) return NOERROR;

 if (tellMe.bDctPhraseFinish)
        m_pSpchObj->logEventSink(DCT_PHRASEFINISH, TEXT("Ltd:PhraseFinish Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );

 PSRWORD  pSRWord, pSRMax;
 CString  phrase;

    // unrecognized utterance
 if( !pSRPhrase )
  return NOERROR;

 // loop through all of the words and display them...
 pSRMax  = (PSRWORD) ((BYTE*)pSRPhrase + pSRPhrase->dwSize);
 pSRWord = (PSRWORD) (pSRPhrase->abWords);
 while( pSRWord < pSRMax )
 {
  int count = WideCharToMultiByte(CP_ACP, NULL, pSRWord->szWord, -1, buf, MAX_PHRASELEN, NULL, NULL);
  if (count = 0)
  {
   Error( -1000, TEXT("Ltd PhraseHypothesis: WideCharToMultiByte failed") );
   continue;
  }

  // store the phrase to display in the results list box...
  if (phrase.GetLength() > 0)
         phrase += " ";
  phrase += buf;

        pSRWord = (PSRWORD) ((BYTE*) pSRWord + pSRWord->dwSize);
 }

 if ("" == phrase)         // new phrase is empty
  return NOERROR;

    // did we recognize the stop dictation phrase for this language
 if ( phrase.Compare(pGStopPhr) == 0 )
 {
  m_pSpchObj->m_pCEdit->GetParent()->PostMessage(WM_DICT_STOPPING, 0, 0);
 }


  
    return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::ReEvaluate( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctReevaluate)
        m_pSpchObj->logEventSink(DCT_REEVALUATE, TEXT("Ltd:Reevaluate lpUnk: %08x"), lpUnk);

 if ( 0 == lpUnk ) return NOERROR;

 // Let the ResultList do its thing for correction.
 m_ResList.dctReevaluate(lpUnk);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::Training( DWORD dwTrain )
{
 if (tellMe.bDctTraining)
        m_pSpchObj->logEventSink(DCT_TRAINING, TEXT("Ltd:TrainingRequest Flag: 0x%lx."), dwTrain );

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchLtdSink::UnArchive( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctUnarchive)
        m_pSpchObj->logEventSink(DCT_UNARCHIVE, TEXT("Ltd:Unarchive lpUnk: %08x"), lpUnk);

 return NOERROR;
}

 


//------------------------------------------------------------------------------
// Description: Action Grammar notification sink implementation
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Description: constructor
//------------------------------------------------------------------------------
SpchActionSink::SpchActionSink( SapiSpeech *pSpch)
:m_ResList(pSpch)
{
 m_pSpchObj = pSpch;
 m_dwRefCnt = 0;
}

//----------------------------------------------------------------------------------------------
// Description: destructor
//----------------------------------------------------------------------------------------------
SpchActionSink::~SpchActionSink()
{
}


//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::QueryInterface( REFIID riid, LPVOID *ppv )
{
 *ppv = NULL;

 // always return our IUnknown for IID_IUnknown...
 if (IsEqualIID (riid, IID_IUnknown) || IsEqualIID(riid,IID_ISRGramNotifySink))
 {
  AddRef();
  *ppv = (LPVOID)this;
  return S_OK;
 }

 // otherwise, cant find...
 return ResultFromScode (E_NOINTERFACE);
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_ (ULONG) SpchActionSink::AddRef()
{
 return ++m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) SpchActionSink::Release()
{
 if( --m_dwRefCnt == 0 )
 {
  delete this;
  return 0;
 }
 return m_dwRefCnt;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::BookMark( DWORD dwID )
{
 if (tellMe.bDctBookmark)
        m_pSpchObj->logEventSink(DCT_BOOKMARK, TEXT("Action:BookMark id: 0x%lx"), dwID);
 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::Paused()
{
 if (tellMe.bDctPaused)
        m_pSpchObj->logEventSink(DCT_PAUSED, TEXT("Action:Paused..."));

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::PhraseStart( QWORD qTimeStampBegin )
{
 if (tellMe.bDctPhraseStart)
        m_pSpchObj->logEventSink(DCT_PHRASESTART, TEXT("Action:PhraseStart Beg: %I64x"), qTimeStampBegin );

 m_ResList.dctPhStart(qTimeStampBegin);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::PhraseHypothesis( DWORD dwFlags, QWORD qTimeStampBegin,
   QWORD qTimeStampEnd, PSRPHRASE pSRPhrase, LPUNKNOWN lpResults )
{
 if (tellMe.bDctPhraseHypothesis)
        m_pSpchObj->logEventSink(DCT_PHRASEHYPOTHESIS, TEXT("Action:PhraseHypothesis Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec...
//              The "stop dictation" phrase is searched for here. If it is found, then dictaiton
//    is deactivated. Note that additional PhraseFinish invocation will still come
//    since the speech engine will firm up all remaining word
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::PhraseFinish( DWORD     dwFlags,
                                           QWORD     qTimeStampBegin,
                                           QWORD     qTimeStampEnd,
                                           PSRPHRASE pSRPhrase,
                                           LPUNKNOWN lpResults )
{
 char buf[MAX_PHRASELEN];
 DWORD   dwActionID = 0; 


    // Make sure that the reco is for us
    if ( !(dwFlags & ISRNOTEFIN_THISGRAMMAR)) return NOERROR;
    if ( !(dwFlags & ISRNOTEFIN_RECOGNIZED )) return NOERROR;

    if (tellMe.bDctPhraseFinish)
       m_pSpchObj->logEventSink(DCT_PHRASEFINISH, TEXT("Action:PhraseFinish Beg: %I64x End: %I64x Flags: 0x%lx"), qTimeStampBegin, qTimeStampEnd, dwFlags );


 PSRWORD  pSRWord, pSRMax;
 CString  phrase;

    // unrecognized utterance
 if( !pSRPhrase )
  return NOERROR;

 // loop through all of the words
 pSRMax  = (PSRWORD) ((BYTE*)pSRPhrase + pSRPhrase->dwSize);
 pSRWord = (PSRWORD) (pSRPhrase->abWords);
 while( pSRWord < pSRMax )
 {
  int count = WideCharToMultiByte(CP_ACP, NULL, pSRWord->szWord, -1, buf, MAX_PHRASELEN, NULL, NULL);
  if (count = 0)
  {
   Error( -1000, TEXT("Ltd PhraseHypothesis: WideCharToMultiByte failed") );
   continue;
  }

  // store the phrase to display in the results list box...
  if (phrase.GetLength() > 0)
         phrase += " ";
  phrase += buf;

  if (dwActionID == 0)
    dwActionID = pSRWord->dwWordNum;

        pSRWord = (PSRWORD) ((BYTE*) pSRWord + pSRWord->dwSize);
 }

 if ("" == phrase)         // new phrase is empty
  return NOERROR;

    m_pSpchObj->logEventSink(DCT_PHRASEFINISH, TEXT("Action Recognized: %s Action ID = %d"), (LPCSTR)phrase , dwActionID);

   
  
    return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::ReEvaluate( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctReevaluate)
        m_pSpchObj->logEventSink(DCT_REEVALUATE, TEXT("Action:Reevaluate lpUnk: %08x"), lpUnk);

 if ( 0 == lpUnk ) return NOERROR;

 // Let the ResultList do its thing for correction.
 m_ResList.dctReevaluate(lpUnk);

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::Training( DWORD dwTrain )
{
 if (tellMe.bDctTraining)
        m_pSpchObj->logEventSink(DCT_TRAINING, TEXT("Action:TrainingRequest Flag: 0x%lx."), dwTrain );

 return NOERROR;
}

//----------------------------------------------------------------------------------------------
// Description: Defined in SAPI Spec
//----------------------------------------------------------------------------------------------
STDMETHODIMP SpchActionSink::UnArchive( LPUNKNOWN lpUnk )
{
 if (tellMe.bDctUnarchive)
        m_pSpchObj->logEventSink(DCT_UNARCHIVE, TEXT("Action:Unarchive lpUnk: %08x"), lpUnk);

 return NOERROR;
}

尹成
关注
专栏目录
html5 | 通过js实现对网页文本内容语音朗读 | 教程
洛阳泰山的博客
02-17 9380
网页文字语音阅读功能实现的核心是通过网页语音 API的SpeechSynthesis接口是语音服务的控制接口；它可以用于获取设备上关于可用的合成声音的信息，开始、暂停语音，或除此之外的其他命令。 在定义了一些必要的变量后，我们用SpeechSynthesis.getVoices()获取了一列可用的声音并且用它们生成一列可选表单，这样用户能够选择他们想要的声音。 inputForm.onsubmit的内部操作中，我们用preventDefault()阻止了表单的提交，创建了一个从&lt...
语音识别系统 基于IBM viavoice 源码
08-18
//all rights reserved for the original author //PROHIBIT to use it for commercial purpose 语音识别系统 基于IBM viavoice
免费的文字转语音朗读 -API接口
优派编程
11-10 8587
接口地址（中文）：https://api.oick.cn/txt/apiz.php 接口地址（英文）：https://api.oick.cn/txt/apie.php 返回格式：MP3 请求方式：GET 请求示例：https://api.oick.cn/txt/apiz.php?text=方包博客&spd=1 请求参数说明： 名称 必填 类型 说明 text 是 String 输入要转换的文字或英文 spd 是 Strin...
文本转语音的接口（开放免费）
leaf的博客
04-01 2万+
“http://tts.baidu.com/text2audio?lan=zh&ie=UTF-8&spd=4&text=你好啊，听起来好憨啊” lan 语言类型 lan=en 英文 lan = zh 中文 ie 文字编码方式 spd 语速 1-9的数字，数字越大，语速越快。 text 要转换的文本 ...
|ViaVoice(IBM语音识别输入系统)下载v9.1官方版 - 欧普软件下载
q6q6q的专栏
10-27 726
ViaVoice是一款专业的IBM语音识别输入系统，拥有先进的语音识别技术，完整的语音数据库，可以快速识别语音内容，输入速度甚至可以达到150字/秒,正确率高达95%以上，自带常用命令集，可满足对电脑的基本操作。需要的朋友可以下载！软件功能1、软件可用于声控打字和语音导航。2、可提高打字速度，每分钟可输入150个汉字。3、语音识别功能强大，可达到95%的准确率。4、即使您不会打字，也可迅速准备好文...
viaVoice开发，怎样设置IBM viavoice的语言
尹成的技术博客
12-14 3593
#include #include #include "reslist.hpp"#define MAX_PHRASELEN 128class SapiSpeech;class Result;class ResultsList;typedef enum SpeechEventEnum{ ENG_ATTRIBCHANGED,  ENG_INTERFERENCE,  ENG_SOUND,  
IBM ViaVoice语音识别系统简介.
07-27
IBM ViaVoice是一款由IBM公司推出的中文语音识别系统软件，旨在解决汉字输入难题。它不仅适用于个人用户，也广泛应用于商业环境中。本文将详细介绍IBM ViaVoice的主要功能、使用方法、性能特点以及如何提高语音识别...
嵌入式系统/ARM技术中的IBM嵌入式语音识别技术无需预先存储特殊指令
12-01
通过对声学模型的优化、增强声学模型训练技术的应用以及改进的语音静默检测方法，该系统能够在嘈杂环境中，如车辆行驶时遇到的道路噪音、喇叭声或铁路道口的警告声中，更准确地识别语音指令。这对于车载应用尤其关键...
基于语音识别的声控鼠标的设计方法
01-19
摘要： 实现了一种基于语音识别技术的声控鼠标光标应用程序， 可以用语音控制鼠标光标移动到屏幕的任意位置， 能用来帮助伤残人士只用声音而不用鼠标和键盘就能操作电脑。分析了语音控制鼠标光标使用过程中的延时...
消费电子中的基于语音识别的声控鼠标的设计方法
10-21
摘要： 实现了一种基于语音识别技术的声控鼠标光标应用程序， 可以用语音控制鼠标光标移动到屏幕的任意位置， 能用来帮助伤残人士只用声音而不用鼠标和键盘就能操作电脑。分析了语音控制鼠标光标使用过程中的延时...
讯飞开放接口实现了语音合成，识别，录音，以及语音朗读功能的源码
03-19
本案例调用科大讯飞开放接口实现了语音合成，识别，录音，以及语音朗读功能。有界面，可运行。windows应用程序
文本朗诵语音的API
11-27
请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业请勿用于商业
百度语音合成接口的调用以及根据语音时长播放语音
08-06
百度语音合成接口的调用以及根据语音时长播放语音,文中接口请自行申请。
jacob语音朗读（包含API）
05-04
jacob-1.17-M2 语音朗读jar 包和开发文档 jacob-1.17-M2 语音朗读jar 包和开发文档
百度和有道还有bing的语音播报发音url接口，有女声也有男声
q616804668的专栏
07-25 2万+
http://tts.baidu.com/text2audio?lan=zh&ie=UTF-8&text=百度翻译女声语音播报apihttp://api.microsofttranslator.com/v2/http.svc/speak?appId=TJnIprF8gfKIzzWSJUYbWZBxOdX4nQDJK4o5BoiI42GE*&language=zh-TW&format=audio/mp
微信小程序调用讯飞语音听写（流式版）API接口-js
最新发布
qq_63479260的博客
06-06 2374
需要的参数分别为‘api_key’、‘algorithm’、‘headers’、‘signature’，其中‘headers’和‘algorithm’为固定参数，文档中已经给出（algorithm为加密算法，目前仅支持hmac-sha256，所以也为固定参数），分别为algorithm="hmac-sha256"、headers="host date request-line"，获取自己公网ip可以百度搜索ip，有专门的网站可以查询（图1-6、图1-7），将查到的ip填入白名单即可。
几个常见的语音交互平台的简介和比较
qinglongzhan的博客
07-12 9658
1.概述最近做了两个与语音识别相关的项目，两个项目的主要任务虽然都是语音识别，或者更确切的说是关键字识别，但开发的平台不同， 一个是windows下的，另一个是android平台的，于是也就选用了不同的语音识别平台，前者选的是微软的Speech API开发的，后者则选用 的是CMU的pocketsphinx，本文主要将一些常见的语音交互平台进行简单的介绍和对比。这里所说的语音交互包含语音识别（Sp...
js语音播报android浏览器,JS 简单调用百度TTS接口实现语音朗读
weixin_32312081的博客
05-27 2559
TTS简介TTS是Text To Speech的缩写，即“从文本到语音”，是人机对话的一部分，让机器能够说话。网页作为世界之窗，自然是向所有人开放的，所以也就包括视力不好的人群了，而网页语音化并不是什么新技术，HTML语义化在某种层次上也是为了让网页语音化更好的实现。正文简单实现语音朗读，要说多简单，直接用别人的接口算不算简单？我们要做的就是借用百度TTS接口，通过audio标签进行朗读。实现核心...
在网页上通过JS实现文本的语音朗读
热门推荐
mixi9760的博客
07-27 3万+
摘要: 语音合成：也被称为文本转换技术（TTS），它是将计算机自己产生的、或外部输入的文字信息转变为可以听得懂的、流利的口语输出的技术。 1、接口定义 http://tts.baidu.com/text2audio?lan=zh&ie=UTF-8&spd=2&text=你要转换的文字 参数说明： lan=zh：语言是中文，如果改为lan=en，则语言是英文。 ie=UTF-8：文
IBM ViaVoice98：语音识别技术的里程碑与计算智能的飞跃
语音识别技术在1998年取得了重大突破，IBM公司的ViaVoice98技术展现了显著的进步。这款产品的词库容量相较于早期版本扩大了三倍，不仅支持普通话，还能够适应广东、四川、上海等不同地区的口音，显著提升了识别率。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

尹成

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值