Partager via

Specifying parameters for an inproc Recognizer

  • Article

I’ve seen a couple of questions come by the listen alias about using an in-process speech recognizer.  When you use an in-process recognizer, you have to specify a lot more than you need to specify with the shared recognizer.

In particular, you need to specify an audio source and a recognition engine.  The shared recognizer uses the defaults for both of these.

Most people figure out that they need to specify an audio source; more commonly (and I’ve tripped over this myself) they forget to specify a recognition engine.

And while there’s a nifty helper for the audio input in sphelper.h (namely, SpGetDefaultTokenFromCategoryId(SPCAT_AUDIOIN, &cpToken)), there isn’t a helper for the recognition engine.

So, here’s a helper function that returns the object token for the default shared recognizer:

  1. // Get the object token for the default shared recognizer engine.
  2. HRESULT SpGetDefaultSharedRecognizerToken(ISpObjectToken **ppSharedRecognizerToken)
  3. {
  4.     HRESULT hr = S_OK;
  5.     const WCHAR pszWindowsCompatAtt[] = L"windowsV6compatible";
  6.     LANGID UIlangID = GetUserDefaultUILanguage();
  7.     
  8.     // Find recognizers that match windowsV6compatible and the primary language id of the UI.
  9.     // Use primary language because there may be several recognizers available for different sub-languages,
  10.     // and there is generally only one UI language per primary language.
  11.     // e.g. US and UK English recognizers on a US English system.
  12.     // If so, to distinguish these the locale is used below.
  13.  
  14.     CComPtr<IEnumSpObjectTokens> cpEnum;
  15.     hr = SpEnumTokensMatchingPrimaryLangID(SPCAT_RECOGNIZERS, PRIMARYLANGID(UIlangID), pszWindowsCompatAtt, &cpEnum);
  16.  
  17.     ULONG ulRecognizers(0);
  18.     if (SUCCEEDED(hr))
  19.     {
  20.         hr = cpEnum->GetCount(&ulRecognizers);
  21.     }
  22.  
  23.     if (SUCCEEDED(hr))
  24.     {
  25.         if (ulRecognizers == 0)
  26.         {
  27.             // If zero - error.
  28.             hr = SPERR_RECOGNIZER_NOT_FOUND;
  29.         }
  30.         else if (ulRecognizers == 1)
  31.         {
  32.             // If one - we are done.
  33.             hr = cpEnum->Item(0, ppSharedRecognizerToken);
  34.         }
  35.         else
  36.         {
  37.             // More than one recognizer matches - we must pick the best default:
  38.             BOOL fFoundDefault = FALSE;
  39.  
  40.             // If there's no language-specific default then use the locale.
  41.             LANGID localeID = GetUserDefaultLangID();
  42.             if (!fFoundDefault && SUCCEEDED(hr) &&
  43.                 PRIMARYLANGID(UIlangID) == PRIMARYLANGID(localeID))
  44.             {
  45.                 // First see if there's an engine whose language exactly matches the locale.
  46.                 // For example if the langid is U.S English, but the locale is U.K. English
  47.                 // and there's a U.K. recognizer then use that.
  48.  
  49.                 hr = S_OK;
  50.                 WCHAR pszLocaleString[] = L"Language=XXXXXXXX";
  51.                 SpHexFromUlong(pszLocaleString + wcslen(pszLocaleString) - 8, localeID);
  52.                 for (ULONG ul = 0; SUCCEEDED(hr) && ul < ulRecognizers; ul++)
  53.                 {
  54.                     CComPtr<ISpObjectToken> cpToken;
  55.                     hr = cpEnum->Item(ul, &cpToken);
  56.                     if (SUCCEEDED(hr))
  57.                     {
  58.                         hr = cpToken->MatchesAttributes(pszLocaleString, &fFoundDefault);
  59.                     }
  60.  
  61.                     if (SUCCEEDED(hr) && fFoundDefault)
  62.                     {
  63.                         *ppSharedRecognizerToken = cpToken.Detach();
  64.                         break;
  65.                     }
  66.                 }
  67.             }
  68.  
  69.             // If there's no engine that directly matches the locale see if the backup list of SupportedLocales is matched.
  70.             if (!fFoundDefault && (SUCCEEDED(hr) || hr == SPERR_NOT_FOUND) &&
  71.                 PRIMARYLANGID(UIlangID) == PRIMARYLANGID(localeID))
  72.             {
  73.                 // See if there's an engine which has a supported Locale matches the current locale.
  74.                 // For example if the langid is U.S English, but the locale is Australian English
  75.                 // there may be no recognizer that directly supports Australian English,
  76.                 // but a U.K. recognizer might specify it can be used in the Australian English locale with this attribute.
  77.  
  78.                 hr = S_OK;
  79.                 WCHAR pszSupportedLocalesString[] = L"SupportedLocales=XXXXXXXX";
  80.                 SpHexFromUlong(pszSupportedLocalesString + wcslen(pszSupportedLocalesString) - 8, localeID);
  81.                 for (ULONG ul = 0; SUCCEEDED(hr) && ul < ulRecognizers; ul++)
  82.                 {
  83.                     CComPtr<ISpObjectToken> cpToken;
  84.                     hr = cpEnum->Item(ul, &cpToken);
  85.                     if (SUCCEEDED(hr))
  86.                     {
  87.                         hr = cpToken->MatchesAttributes(pszSupportedLocalesString, &fFoundDefault);
  88.                     }
  89.  
  90.                     if (SUCCEEDED(hr) && fFoundDefault)
  91.                     {
  92.                         *ppSharedRecognizerToken = cpToken.Detach();
  93.                         break;
  94.                     }
  95.                 }
  96.             }
  97.  
  98.             // We still haven't found a match - just pick the first recognizer.
  99.             if (!fFoundDefault && (SUCCEEDED(hr) || hr == SPERR_NOT_FOUND))
  100.             {
  101.                 CComPtr<ISpObjectToken> cpToken;
  102.                 hr = cpEnum->Item(0, ppSharedRecognizerToken);
  103.             }
  104.         }
  105.     }
  106.  
  107.     return hr;
  108. }
  109.  
  110.  
  111. // Return a token enumerator containing all tokens that match the primary language
  112. // of a particular language id. pszRequiredAttributes can be used to specify additional attributes all tokens must have.
  113. HRESULT SpEnumTokensMatchingPrimaryLangID(const LPCWSTR pszCategoryId, LANGID priLangID, LPCWSTR pszRequiredAtts,
  114.                                                  IEnumSpObjectTokens **ppEnum)
  115. {
  116.     HRESULT hr = S_OK;
  117.  
  118.     // First enumerate the tokens using pszRequiredAtts.
  119.     CComPtr<ISpObjectTokenCategory> cpCategory;
  120.     hr = SpGetCategoryFromId(pszCategoryId, &cpCategory);
  121.     
  122.     CComPtr<IEnumSpObjectTokens> cpEnum;
  123.     if (SUCCEEDED(hr))
  124.     {
  125.         hr = cpCategory->EnumTokens(pszRequiredAtts, NULL, &cpEnum);
  126.     }
  127.  
  128.     ULONG ulTokens(0);
  129.     if (SUCCEEDED(hr))
  130.     {
  131.         hr = cpEnum->GetCount(&ulTokens);
  132.     }
  133.  
  134.     // Create enumerator to store new tokens.
  135.     CComPtr<ISpObjectTokenEnumBuilder> cpBuilder;
  136.     if (SUCCEEDED(hr))
  137.     {
  138.         hr = cpBuilder.CoCreateInstance(CLSID_SpObjectTokenEnum);
  139.     }
  140.     if (SUCCEEDED(hr))
  141.     {
  142.         hr = cpBuilder->SetAttribs(NULL, NULL);
  143.     }
  144.  
  145.     // Now, for each token, check language string to see if it matches.
  146.     for (ULONG ul = 0; SUCCEEDED(hr) && ul < ulTokens; ul++)
  147.     {
  148.         LANGID tokenLangID(0);
  149.         CComPtr<ISpObjectToken> cpToken;
  150.         hr = cpEnum->Item(ul, &cpToken);
  151.         if (SUCCEEDED(hr))
  152.         {
  153.             // Just look at the first language id
  154.             hr = SpGetLanguageFromToken(cpToken, &tokenLangID);
  155.         }
  156.  
  157.         if (SUCCEEDED(hr) && PRIMARYLANGID(tokenLangID) == PRIMARYLANGID(priLangID))
  158.         {
  159.             // Add to builder
  160.             hr = cpBuilder->AddTokens(1, &(cpToken.p));
  161.         }
  162.     }
  163.  
  164.     if (SUCCEEDED(hr))
  165.     {
  166.         hr = cpBuilder->Reset();
  167.     }
  168.     if (SUCCEEDED(hr))
  169.     {
  170.         *ppEnum = cpBuilder.Detach();
  171.     }
  172.  
  173.     return hr;
  174. }