Windows SAPI：语音到文本示例

我是SAPI的新手，若你们中的任何一位能为我提供一个SAPI中的“Hello World”示例，我将不胜感激。我知道微软有一些像“听写”之类的例子，但我想从一个很小的例子开始。如果你能帮上忙，我很高兴。

我用SAPI玩过一点Windows语音识别，它确实对用户不友好。下面是我用C++编写的代码示例：

#包括
#包括
#包括
#包括
const-ULONGLONG=0；
常量wchar_t*ruleName1=L“ruleName1”；
int start_监听（const std:：string和word）；
ISpRecoGrammar*init_语法（ISpRecoContext*recoContext，const std:：string&command）；
void get_text（ISpRecoContext*reco_context）；
无效检查结果（const HRESULT&result）；
int main（int argc，字符**argv）
{
开始倾听（“你好”）；
返回退出成功；
}
//当用户说出作为参数传递的单词时，此函数退出
int start_侦听（const std:：string和word）
{
//初始化COM库
if（失败（：：CoInitialize（nullptr）））{
返回退出失败；
}
std:：cout GetNotifyEventHandle（）；
if（handleEvent==无效的句柄值）{
检查结果（E_失败）；
}
龙龙利益；
利息=SPFEI（SPEI_确认）；
hr=recoContext->SetInterest（interest，interest）；
检查结果（hr）；
//激活语法
hr=recoGrammar->SetRuleState（规则名称1，0，SPRS\u处于活动状态）；
检查结果（hr）；
//启用上下文
hr=recoContext->Resume（0）；
检查结果（hr）；
//等待记录
手柄[1]；
handles[0]=handleEvent；
WaitForMultipleObjects（1，句柄，FALSE，无限）；
获取文本（上下文）；
std：：cout CreateGrammar（grammand和recoGrammar）；
检查结果（hr）；
单词langId=MAKELANGID（LANG_法语，SUBLANG_法语）；
hr=重设语法->重设语法（langId）；
检查结果（hr）；
//TODO:捕获错误并使用默认langId=>GetUserDefaultUILanguage（）
//创建规则
hr=recoGrammar->GetRule（ruleName1，0，SPRAF_顶级| SPRAF_活动，true和sate）；
检查结果（hr）；
//加一个词
const std:：wstring commandWstr=std:：wstring（command.begin（），command.end（））；
hr=recoGrammar->AddWordTransition（state，NULL，commandWstr.c_str（），L“”，SPWT_LEXICAL，1，nullptr）；
检查结果（hr）；
//提交更改
hr=recoGrammar->Commit（0）；
检查结果（hr）；
返回语法；
}
void get_text（ISpRecoContext*reco_context）
{
const ULONG maxEvents=10；
SPEVENT事件[maxEvents]；
乌龙事件计数；
HRESULT-hr；
hr=记录上下文->获取事件（maxEvents、events和eventCount）；
//如果一切正常，警告hr等于S_FALSE
//但是eventCountGetText（SP_GETWHOLEPHRASE，SP_GETWHOLEPHRASE，FALSE，&text，NULL）；
检查结果（hr）；
CoTaskMemFree（文本）；
}
无效检查结果（常量HRESULT和结果）
{
如果（结果==S_正常）{
返回；
}
std：：字符串消息；
开关（结果）{
案例E_INVALIDARG：
message=“一个或多个参数无效。”；
案例E_访问被拒绝：
message=“访问被拒绝。”；
案例E_n界面：
message=“接口不存在。”；
案例E_NOTIMPL：
message=“未实现方法。”；
案例E_OUTOFMEMORY：
message=“内存不足。”；
案例E_指针：
message=“无效指针。”；
案例E_意外：
message=“意外错误。”；
案例E_失败：
message=“失败”；
违约：
message=“Unknown:”+std:：to_字符串（结果）；
}
抛出std:：exception（message.c_str（））；
}

---

正如我所说，这有点复杂。我认为您应该将所有代码包装到一个库中，以使其更易于使用。

是的，我正在使用C++/CLI。因此，我可以使用简单的C代码：在我想用C语言进行的可怕的C++ API前面。但我太喜欢C++了；只是想让你们都意识到这个世界的某些部分。Net实现不起作用。此外，当您进入高级应用程序时，.NETAPI中不支持某些位。与其他具有相同功能的api相比，这是一个可怕的api。谢谢你的例子。

#include <sphelper.h>
#include <sapi.h>
#include <iostream>
#include <string>

const ULONGLONG grammarId = 0;
const wchar_t* ruleName1 = L"ruleName1";

int start_listening(const std::string& word);
ISpRecoGrammar* init_grammar(ISpRecoContext* recoContext, const std::string& command);
void get_text(ISpRecoContext* reco_context);
void check_result(const HRESULT& result);

int main(int argc, char** argv)
{
    start_listening("Hello");
    return EXIT_SUCCESS;
}

// This function exits when the word passed as parameter is said by the user
int start_listening(const std::string& word)
{
    // Initialize COM library
    if (FAILED(::CoInitialize(nullptr))) {
        return EXIT_FAILURE;
    }

    std::cout << "You should start Windows Recognition" << std::endl;
    std::cout << "Just say \""<< word << "\"" << std::endl;

    HRESULT hr;

    ISpRecognizer* recognizer;
    hr = CoCreateInstance(CLSID_SpSharedRecognizer,
        nullptr, CLSCTX_ALL, IID_ISpRecognizer,
        reinterpret_cast<void**>(&recognizer));
    check_result(hr);

    ISpRecoContext* recoContext;
    hr = recognizer->CreateRecoContext(&recoContext);
    check_result(hr);

    // Disable context
    hr = recoContext->Pause(0);
    check_result(hr);

    ISpRecoGrammar* recoGrammar = init_grammar(recoContext, word);

    hr = recoContext->SetNotifyWin32Event();
    check_result(hr);

    HANDLE handleEvent;
    handleEvent = recoContext->GetNotifyEventHandle();
    if(handleEvent == INVALID_HANDLE_VALUE) {
        check_result(E_FAIL);
    }

    ULONGLONG interest;
    interest = SPFEI(SPEI_RECOGNITION);
    hr = recoContext->SetInterest(interest, interest);
    check_result(hr);

    // Activate Grammar
    hr = recoGrammar->SetRuleState(ruleName1, 0, SPRS_ACTIVE);
    check_result(hr);

    // Enable context
    hr = recoContext->Resume(0);
    check_result(hr);

    // Wait for reco
    HANDLE handles[1];
    handles[0] = handleEvent;
    WaitForMultipleObjects(1, handles, FALSE, INFINITE);
    get_text(recoContext);

    std::cout << "Hello user" << std::endl;

    recoGrammar->Release();
    ::CoUninitialize();

    system("PAUSE");
    return EXIT_SUCCESS;
}

/**
* Create and initialize the Grammar.
* Create a rule for the grammar.
* Add word to the grammar.
*/
ISpRecoGrammar* init_grammar(ISpRecoContext* recoContext, const std::string& command)
{
    HRESULT hr;
    SPSTATEHANDLE sate;

    ISpRecoGrammar* recoGrammar;
    hr = recoContext->CreateGrammar(grammarId, &recoGrammar);
    check_result(hr);

    WORD langId = MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH);
    hr = recoGrammar->ResetGrammar(langId);
    check_result(hr);
    // TODO: Catch error and use default langId => GetUserDefaultUILanguage()

    // Create rules
    hr = recoGrammar->GetRule(ruleName1, 0, SPRAF_TopLevel | SPRAF_Active, true, &sate);
    check_result(hr);

    // Add a word
    const std::wstring commandWstr = std::wstring(command.begin(), command.end());
    hr = recoGrammar->AddWordTransition(sate, NULL, commandWstr.c_str(), L" ", SPWT_LEXICAL, 1, nullptr);
    check_result(hr);

    // Commit changes
    hr = recoGrammar->Commit(0);
    check_result(hr);

    return recoGrammar;
}

void get_text(ISpRecoContext* reco_context)
{
    const ULONG maxEvents = 10;
    SPEVENT events[maxEvents];

    ULONG eventCount;
    HRESULT hr;
    hr = reco_context->GetEvents(maxEvents, events, &eventCount);

    // Warning hr equal S_FALSE if everything is OK 
    // but eventCount < requestedEventCount
    if(!(hr == S_OK || hr == S_FALSE)) {
        check_result(hr);
    }

    ISpRecoResult* recoResult;
    recoResult = reinterpret_cast<ISpRecoResult*>(events[0].lParam);

    wchar_t* text;
    hr = recoResult->GetText(SP_GETWHOLEPHRASE, SP_GETWHOLEPHRASE, FALSE, &text, NULL);
    check_result(hr);

    CoTaskMemFree(text);
}

void check_result(const HRESULT& result)
{
    if (result == S_OK) {
        return;
    }

    std::string message;

    switch(result) {

    case E_INVALIDARG:
        message = "One or more arguments are invalids.";

    case E_ACCESSDENIED:
        message = "Acces Denied.";

    case E_NOINTERFACE:
        message = "Interface does not exist.";

    case E_NOTIMPL:
        message = "Not implemented method.";

    case E_OUTOFMEMORY:
        message = "Out of memory.";

    case E_POINTER:
        message = "Invalid pointer.";

    case E_UNEXPECTED:
        message = "Unexpecter error.";

    case E_FAIL:
        message = "Failure";

    default:
        message = "Unknown : " + std::to_string(result);
    }

    throw std::exception(message.c_str());
}