reco_sphinx.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "reco_sphinx.h"
 
#define MAX_BUFFER 262144
 
#include <iostream>
#include <sstream>
#include <algorithm>
 
#ifdef _WIN32
#include <windows.h>
 
#define P_SLASH "\\"
 
bool fileExists(const std::string& filePath)
{
  DWORD fileAttributes = GetFileAttributes(filePath.c_str());
  return (fileAttributes != INVALID_FILE_ATTRIBUTES);
}
#else
#include <iostream>
#include <sys/stat.h>
 
#define P_SLASH "/"
 
bool fileExists(const std::string& filePath)
{
  struct stat buffer;
  return (stat(filePath.c_str(), &buffer) == 0);
}
#endif
 
std::string getDirectoryFromFilePath(const std::string& filePath)
{
  size_t found = filePath.find_last_of("/\\");
 
  if (found != std::string::npos)
    return filePath.substr(0, found);
 
  return "";
}
 
std::string getFileNameWithoutExtension(const std::string& filePath)
{
  size_t lastSlash = filePath.find_last_of("/\\");
  size_t lastDot = filePath.find_last_of(".");
  if (lastDot != std::string::npos && (lastSlash == std::string::npos || lastDot > lastSlash))
    return filePath.substr(lastSlash + 1, lastDot - lastSlash - 1);
 
  return filePath.substr(lastSlash + 1);
}
 
int countWords(const std::string& text)
{
  std::istringstream iss(text);
  int wordCount = 0;
  std::string word;
 
  while (iss >> word)
    ++wordCount;
 
  return wordCount;
}
 
Recognition::Recognition()
{
  mValid = false;
  mBuffer = 0;
  mEndPointer = NULL;
  mDecoder = NULL;
  mConfig = NULL;
}
 
Recognition::Recognition(std::string pathtobin, std::string lang)
{
  mValid = false;
  mBuffer = NULL;
  mEndPointer = NULL;
  mDecoder = NULL;
  mKeySearch = false;
 
  mConfig = ps_config_init(NULL);
 
  std::string pathDir = getDirectoryFromFilePath(pathtobin);
  std::string pathToDict = pathDir + P_SLASH + getFileNameWithoutExtension(pathtobin) + ".dict";
 
  if (fileExists(pathtobin) && fileExists(pathToDict) && fileExists(pathDir + P_SLASH + lang))
  {
    ps_config_set_int(mConfig, "samprate", 16000);
    //ps_config_set_int(mConfig, "maxwpf", 5);
    ps_config_set_int(mConfig, "pl_window", 3);
    ps_config_set_int(mConfig, "topn", 3);
    ps_config_set_str(mConfig, "hmm", (pathDir + P_SLASH + lang).c_str()); // path to lang
    ps_config_set_str(mConfig, "lm", pathtobin.c_str());
    ps_config_set_str(mConfig, "dict", pathToDict.c_str());
 
    mDecoder = ps_init(mConfig);
    mEndPointer = ps_endpointer_init(0, 0.0, PS_VAD_MEDIUM_LOOSE, 0, 0);
    if ((mDecoder != NULL) && (mEndPointer != NULL))
    {
      mFrameSize = ps_endpointer_frame_size(mEndPointer);
      mValid = true;
    }
  }
  
  if (!mValid)
  {
    if (mEndPointer != NULL)
      ps_endpointer_free(mEndPointer);
    mEndPointer = NULL;
 
    if (mDecoder != NULL)
      ps_free(mDecoder);
    mDecoder = NULL;
 
    if (mConfig != NULL)
      ps_config_free(mConfig);
    mConfig = NULL;
  }
  else
  {
    mBuffer = new Buffer(MAX_BUFFER);
    mThread = std::thread(std::bind(&Recognition::cbThread, this));
  }
}
 
Recognition::~Recognition()
{
  mValid = false;
  if (mThread.joinable())
    mThread.join();
 
  if (mEndPointer != NULL)
    ps_endpointer_free(mEndPointer);
 
  if (mDecoder != NULL)
    ps_free(mDecoder);
 
  if (mConfig != NULL)
    ps_config_free(mConfig);
 
  SAFE_DELETE(mBuffer);
}
 
 
void Recognition::fillAudioBuffer(const char* data, size_t lenght)
{
  if (mBuffer == NULL)
    return;
 
  const std::lock_guard<std::mutex> lock(mMutex);
  mBuffer->fill(data, lenght);
}
 
void Recognition::cbThread()
{
  //consume buffer and send callbacks
  const int16 *speech;
  int16 buffer[MAX_BUFFER];
 
  while (mValid)
  {
    const std::lock_guard<std::mutex> lock(mMutexConfig);
    int prev_in_speech = ps_endpointer_in_speech(mEndPointer);
 
    //nothing to consume
    if (mBuffer->getCount() < mFrameSize)
    {
      std::this_thread::sleep_for(std::chrono::milliseconds(10));
      continue;
    }
 
    //todo fill buffer from char * with convertCharToInt16
    {
      const std::lock_guard<std::mutex> lock(mMutex);
      mBuffer->getInt16(buffer, mFrameSize);
    }
    speech = ps_endpointer_process(mEndPointer, buffer);
 
    if (speech != NULL)
    {
      const char *hyp;
      if (!prev_in_speech)
      {
        OBJpostEvent(RECOGNITION_START_CB, SCOL_PTR this, 0);
        ps_start_utt(mDecoder);
      }
 
      if (ps_process_raw(mDecoder, speech, mFrameSize, FALSE, FALSE) < 0)
      {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        continue;
      }
 
      if (!ps_endpointer_in_speech(mEndPointer))
      {
        ps_end_utt(mDecoder);
 
        if ((hyp = ps_get_hyp(mDecoder, NULL)) != NULL)
        {
          if (hyp == NULL)
            continue;
 
          cbData* cbdataText = new cbData(from_utf8(hyp));
          OBJpostEvent(RECOGNITION_TEXT_CB, SCOL_PTR this, SCOL_PTR cbdataText);
        }
 
        // to get the best 10 results if there are engough
        std::list<pTextRec*> lPhraseRec;
        ps_nbest_t* nbest = ps_nbest(mDecoder);
        int32 score;
        for (int n = 0; nbest && n < 10; nbest = ps_nbest_next(nbest), n++)
        {
          hyp = ps_nbest_hyp(nbest, &score);
          if (hyp == NULL)
            continue;
 
          pTextRec* paramTextRec = new pTextRec();
          paramTextRec->altText = from_utf8(hyp);
          paramTextRec->altConfidence = (float)score * 0.01; // ?? what is score value range ?
          lPhraseRec.push_back(paramTextRec);
        }
 
        if (!lPhraseRec.empty())
        {
          cbData* cbdataTextAlt = new cbData(lPhraseRec);
          OBJpostEvent(RECOGNITION_TEXTS_ALT_CB, SCOL_PTR this, SCOL_PTR cbdataTextAlt);
        }
 
        OBJpostEvent(RECOGNITION_END_CB, SCOL_PTR this, 0);
      }
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
}
 
 
void Recognition::AddWord(std::string s_Rule, std::string s_Word)
{
  const std::lock_guard<std::mutex> lock(mMutexConfig);
  mKeyWords.push_back(s_Word);
 
  std::string wlist;
  for (unsigned int i = 0; i < mKeyWords.size(); i++)
  {
    std::string w = mKeyWords[i];
    std::transform(w.begin(), w.end(), w.begin(), ::tolower);
    int wcnt = countWords(w);
    wlist = wlist + to_utf8(w) + " /1e-" + std::to_string(std::min(wcnt * 10, 60)) + "/\n";
  }
 
  ps_add_keyphrase(mDecoder, "keyword", wlist.c_str());
  ps_activate_search(mDecoder, "keyword");
 
  mKeySearch = true;
}
 
bool Recognition::initializeObjects()
{
  return mValid;
}
 
int Recognition::getVolume()
{
  return -1;
}
 
 
void Recognition::setVolume(int volume)
{
}