speech.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 "speech.h"
 
void __stdcall NotifyCallbackFunction(WPARAM wParam, LPARAM lParam)
{
  Speech* speech = (Speech*)lParam;
  speech->callbackEvent();
}
 
 
Speech::Speech()
{
  HRESULT hr = S_FALSE;
  m_bPause = FALSE;
  m_bStop = TRUE;
  m_DefaultRate = 0;
  m_DefaultVolume = 0;
 
  hr = pVoice.CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL);
 
  // We're interested in all TTS events
  if (SUCCEEDED(hr))
    hr = pVoice->SetInterest(SPFEI_ALL_TTS_EVENTS, SPFEI_ALL_TTS_EVENTS);
  else
    MMechostr(MSKDEBUG, "Error CoCreateInstance\n");
 
  if (SUCCEEDED(hr))
    hr = pVoice->SetNotifyCallbackFunction(NotifyCallbackFunction, NULL, LPARAM(this));
  else
    MMechostr(MSKDEBUG, "Error SetInterest\n");
 
  // Get default rate and volume
  if (SUCCEEDED(hr))
    hr = pVoice->GetRate(&m_DefaultRate);
  else
    MMechostr(MSKDEBUG, "Error SetNotifyCallbackFunction\n");
 
  if (SUCCEEDED(hr))
    hr = pVoice->GetVolume(&m_DefaultVolume);
  else
    MMechostr(MSKDEBUG, "Error GetRate\n");
}
 
 
void Speech::callbackEvent()
{
  CSpEvent event;
 
  SPVOICESTATUS Stat;
  HRESULT hr = S_FALSE;
  std::string* param;
  std::string word;
  while (event.GetFrom(pVoice) == S_OK)
  {
    switch (event.eEventId)
    {
    case SPEI_START_INPUT_STREAM:
      OBJpostEvent(SPEECH_START_CB, SCOL_PTR this, 0);
      m_bStop = FALSE;
      m_bPause = FALSE;
      break;
 
    case SPEI_END_INPUT_STREAM:
      if (!m_bStop)
      {
        m_bStop = TRUE;
        m_bPause = FALSE;
 
        // send neutral viseme and phoneme
        OBJpostEvent(SPEECH_VISEME_CB, SCOL_PTR this, 0);
        OBJpostEvent(SPEECH_PHONEME_CB, SCOL_PTR this, 0);
        OBJpostEvent(SPEECH_END_CB, SCOL_PTR this, 0);
        break;
      }
    case SPEI_WORD_BOUNDARY:
      hr = pVoice->GetStatus(&Stat, NULL);
      if (FAILED(hr))
        break;
 
      if ((Stat.ulInputWordPos + Stat.ulInputWordLen) <= m_buffer.length())
        word = m_buffer.substr(Stat.ulInputWordPos, Stat.ulInputWordLen);
      param = new std::string(word);
 
      if (!param->empty())
        OBJpostEvent(SPEECH_WORD_CB, SCOL_PTR this, SCOL_PTR param);
      else
        SAFE_DELETE(param);
      break;
 
    case SPEI_SENTENCE_BOUNDARY:
      hr = pVoice->GetStatus(&Stat, NULL);
      if (FAILED(hr))
        break;
 
      if ((Stat.ulInputSentPos + Stat.ulInputSentLen) <= m_buffer.length())
        word = m_buffer.substr(Stat.ulInputSentPos, Stat.ulInputSentLen);
      param = new std::string(word);
 
      if (!param->empty())
        OBJpostEvent(SPEECH_TEXT_CB, SCOL_PTR this, SCOL_PTR param);
      else
        SAFE_DELETE(param);
      break;
 
    case SPEI_VISEME:
      OBJpostEvent(SPEECH_VISEME_CB, SCOL_PTR this, SCOL_PTR (event.Viseme()));
      break;
 
    case SPEI_PHONEME:
      OBJpostEvent(SPEECH_PHONEME_CB, SCOL_PTR this, SCOL_PTR (event.Phoneme()));
      break;
 
    case SPEI_TTS_PRIVATE:
      break;
 
    default:
      break;
    }
  }
}
 
 
Speech::~Speech()
{
  this->stop();
  pVoice.Release();
  pVoice = NULL;
}
 
 
void Speech::SetSpeechText(std::string text)
{
  s_text = text;
}
 
 
void Speech::play()
{
  HRESULT hr = S_OK;
  SPVOICESTATUS Stat;
  bool haveBuffer = false;
 
  if (!SUCCEEDED(pVoice->SetOutput(NULL, TRUE)))
    return;
 
  //do not reset the buffer if paused
  if (!SUCCEEDED(pVoice->GetStatus(&Stat, NULL)))
    haveBuffer = (Stat.ulCurrentStream == 0) ? false : true;
 
  if (!m_bPause || !haveBuffer)
  {
    // copy the text associated with the play for callbacks
    m_buffer = s_text;
 
    m_bStop = TRUE;
    if (!m_buffer.empty())
    {
      wchar_t* wc = convertCharToLPCWSTR((char*)m_buffer.c_str());
      hr = pVoice->Speak(wc, SPF_ASYNC | SPF_IS_XML | SPF_PURGEBEFORESPEAK, 0);
      SAFE_DELETE(wc);
    }
    else
    {
      hr = pVoice->Speak(NULL, SPF_PURGEBEFORESPEAK, 0);
    }
    if (FAILED(hr))
      MMechostr(MSKDEBUG, "Error : Speak\n");
  }
 
  m_bPause = FALSE;
  pVoice->Resume();
}
 
 
void Speech::pause(bool state)
{
  if (!m_bStop)
  {
    if ((m_bPause == FALSE) && state)
    {
      // Pause the voice...
      m_bPause = TRUE;
      pVoice->Pause();
 
      // send neutral viseme and phoneme
      OBJpostEvent(SPEECH_VISEME_CB, SCOL_PTR this, 0);
      OBJpostEvent(SPEECH_PHONEME_CB, SCOL_PTR this, 0);
    }
    else if (!state)
    {
      m_bPause = FALSE;
      pVoice->Resume();
    }
  }
}
 
 
void Speech::stop()
{
  SPVOICESTATUS Stat;
  bool haveBuffer = false;
 
  if (!FAILED(pVoice->GetStatus(&Stat, NULL)))
  {
    haveBuffer = (Stat.ulCurrentStream == 0) ? false : true;
  }
 
  // Stop current rendering with a PURGEBEFORESPEAK...
  if (haveBuffer)
  {
    pVoice->Resume();
    if (FAILED(pVoice->Speak(NULL, SPF_PURGEBEFORESPEAK, 0)))
      MMechostr(MSKDEBUG, ">>>>>>>> Stop error\n");
    pVoice->Pause();
  }
 
  // send neutral viseme and phoneme
  if (haveBuffer)
  {
    OBJpostEvent(SPEECH_VISEME_CB, SCOL_PTR this, 0);
    OBJpostEvent(SPEECH_PHONEME_CB, SCOL_PTR this, 0);
    OBJpostEvent(SPEECH_END_CB, SCOL_PTR this, 0);
  }
 
  m_bPause = FALSE;
  m_bStop = TRUE;
}
 
 
int Speech::getVolumeSpeech()
{
  // Declare local identifiers:
  HRESULT hr = S_OK;
  int volumeSpeech = 0;
  hr = pVoice->GetVolume((USHORT*)&volumeSpeech);
  if (FAILED(hr))
    return -1;
  else
    return volumeSpeech;
}
 
 
void Speech::setVolumeSpeech(int volumeSpeech)
{
  pVoice->SetVolume((USHORT)volumeSpeech);
}
 
 
int Speech::getRateSpeech()
{
  // Declare local identifiers:
  HRESULT hr = S_OK;
  int rateSpeech = 0;
  hr = pVoice->GetRate((long*)&rateSpeech);
  if (FAILED(hr))
    return -1;
  else
    return rateSpeech;
}
 
 
void Speech::setRateSpeech(int rateSpeech)
{
  pVoice->SetRate(rateSpeech);
}
 
 
std::list <char *> Speech::getVoices(int voiceType)
{
  CComPtr<ISpObjectToken> pToken;
  CComPtr<IEnumSpObjectTokens> cpIEnum;
 
  // Declare local identifiers:
  HRESULT hr = S_OK;
  std::list <char *> lParamSp;
  ULONG sizel;
 
  if (voiceType == 0)
    hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL/*L"Vendor=VoiceVendor1;Age=Child"*/, &cpIEnum);
  else if (voiceType == 1)
    hr = SpEnumTokens(SPCAT_VOICES, L"Gender=Male", NULL, &cpIEnum);
  else if (voiceType == 2)
    hr = SpEnumTokens(SPCAT_VOICES, L"Gender=Female", NULL, &cpIEnum);
 
  if (FAILED(hr))
  {
    MMechostr(MSKDEBUG, "getVoices ->  Erreur : EnumTokens\n");
    return lParamSp;
  }
  else
  {
    cpIEnum->GetCount(&sizel);
    if (sizel <= 0)
    {
      MMechostr(MSKDEBUG, "getVoices ->  Erreur : EnumTokens\n");
      return lParamSp;
    }
    else
      while (cpIEnum->Next(1, &pToken, NULL) == S_OK)
      {
        CSpDynamicString dstrText;
        hr = SpGetDescription(pToken, &dstrText);
        if (SUCCEEDED(hr))
          lParamSp.push_back(dstrText.CopyToChar());
        else
          MMechostr(MSKDEBUG, "getVoices -> SpGetDescription : ERROR\n");
        pToken.Release();
 
        //$MS
        dstrText.Clear();
        delete dstrText;
      }
  }
  cpIEnum.Release();
 
  return lParamSp;
}
 
 
void Speech::SetSpeechVoice(std::string voice)
{
  HRESULT hr = S_FALSE;
  CComPtr<IEnumSpObjectTokens> cpIEnum;
  CComPtr<ISpObjectToken> pToken;
  bool testVoice = true;
 
  hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL, &cpIEnum);
  if (SUCCEEDED(hr))
  {
    wchar_t* dstrTextTest;
    while ((cpIEnum->Next(1, &pToken, NULL) == S_OK) && (testVoice == true))
    {
      hr = SpGetDescription(pToken, &dstrTextTest);
      char* textV = convertWcharToChar(dstrTextTest);
 
      if (SUCCEEDED(hr))
      {
        if (strcmp(textV, voice.c_str()) == 0)
        {
          hr = pVoice->SetVoice(pToken);
          if (SUCCEEDED(hr))
            MMechostr(MSKDEBUG, "SetSpeechVoice -> SetVoice : OK \n");
          else
            MMechostr(MSKDEBUG, "SetSpeechVoice -> SetVoice : ERROR\n");
          testVoice = false;
        }
        else
          MMechostr(MSKDEBUG, "SetSpeechVoice -> lpszVoiceId <> voice\n");
      }
      else
        MMechostr(MSKDEBUG, "SetSpeechVoice -> SpGetDescription : ERROR\n");
 
      SAFE_DELETE(textV);
      pToken.Release();
    }
  }
  else
    MMechostr(MSKDEBUG, "SetSpeechVoice -> Erreur EnumTokens : \n");
 
  cpIEnum.Release();
}
 
 
std::string Speech::getSpeechVoice()
{
  CComPtr<ISpObjectToken> pToken;
  std::string token;
 
  if (SUCCEEDED(pVoice->GetVoice(&pToken)))
  {
    CSpDynamicString dstrText;
 
    if (SUCCEEDED(SpGetDescription(pToken, &dstrText)))
    {
      token = dstrText.CopyToChar();
      dstrText.Clear();
    }
    delete dstrText;
    pToken.Release();
  }
 
  return token;
}