sources/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/



#include "plugin.h"
#include <iostream>


void __stdcall NotifyCallbackFunction(WPARAM wParam, LPARAM lParam)
{
     Speech* pThis = (Speech*)lParam;
     pThis->callbackEvent();
}


Speech::Speech()
{
        HRESULT hr = S_OK;
        s_text = NULL;
  pVoice = NULL;
        m_bPause = FALSE; // pause audio?
  m_bStop = TRUE;  // stop audio?
        m_DefaultRate = NULL;
        m_DefaultVolume = NULL;
  
  
        hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice, (void **)&this->pVoice);   

        // 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, 0, 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_OK;


        WPARAM          nStart;
  LPARAM          nEnd;

        std::string word,text,phrase;
        cbData * cbdataWord;
        cbData * cbdataPhrase;
        cbData *cbdataPhoneme;
        char * test ;
        
  while( event.GetFrom(pVoice) == S_OK )
  {
    switch( event.eEventId )
    {
        case SPEI_START_INPUT_STREAM:
           MMechostr(MSKDEBUG,"StartStream event\n") ;
           break; 

        case SPEI_END_INPUT_STREAM:
            m_bStop = TRUE;
                                                m_bPause = FALSE;
                                                MMechostr(MSKDEBUG,"EndStream event\n");
                                                PostMessage(HScol, SPEECH_END_CB, (int)this,(LPARAM)NULL);
            MMechostr(MSKDEBUG,"EndStream event OK \n");
            break;     
            
        /*case SPEI_VOICE_CHANGE:
            MMechostr(MSKDEBUG,"Voicechange event\n");
            break;*/

        case SPEI_WORD_BOUNDARY:
            hr = pVoice->GetStatus( &Stat, NULL );
                                                text = s_text;
                                                word = text.substr(Stat.ulInputWordPos,Stat.ulInputWordLen);
                                          
                                                test = new char[word.size() + 1];
                                                strcpy(test,word.c_str());
                                                cbdataWord = new cbData(test);
                                                PostMessage(HScol, SPEECH_WORD_CB, (int)this,(LPARAM)cbdataWord);
            
            if( FAILED( hr ) )
                MMechostr(MSKDEBUG,"Voice GetStatus error\n");
            break;

        
                                case SPEI_SENTENCE_BOUNDARY:
            hr = pVoice->GetStatus( &Stat, NULL );
                                                text = s_text;
            phrase = text.substr(Stat.ulInputSentPos,Stat.ulInputSentLen);
                                        
                                                test = new char[phrase.size() + 1];
                                                strcpy(test,phrase.c_str());
            cbdataPhrase = new cbData(test);                    
                                                PostMessage(HScol, SPEECH_TEXT_CB, (int)this,(LPARAM)cbdataPhrase);
            break;

                                case SPEI_VISEME:
                                                PostMessage(HScol, SPEECH_PHONEME_CB, (int)this,(LPARAM)(event.Viseme()));
            break;

                                case SPEI_PHONEME:
            break;

                                case SPEI_TTS_PRIVATE:
                                        
            break;


        default:
            break;
    }
  }
}


Speech::~Speech()
{
                pVoice->Release();
                pVoice = NULL;
}


void Speech::SetSpeechText(char* text)
{
        this->s_text = text;
}


void Speech::play()
{
        HRESULT hr = S_OK;

        if( SUCCEEDED( hr ) )
        {
                m_bStop = FALSE;
                if( !m_bPause )
                {
      wchar_t * w_text = convertCharToLPCWSTR(s_text);          
      hr = pVoice->Speak(w_text, SPF_ASYNC|SPF_IS_XML|SPF_PURGEBEFORESPEAK, 0);
      if( FAILED( hr ))
        MMechostr(MSKDEBUG,"Error : Speak\n");

                        delete []w_text;
                }

                pVoice->Resume();
                m_bPause = FALSE;
        }
}


void Speech::pauseResume()
{
        if( !m_bStop )
        {
                if( !m_bPause )
                {
                                // Pause the voice...
                                pVoice->Pause();
                                m_bPause = TRUE;   
                }
        }
}


void Speech::stop()
{
        // Stop current rendering with a PURGEBEFORESPEAK...
        if( FAILED( pVoice->Speak( NULL, SPF_PURGEBEFORESPEAK, 0 ) ) )
                MMechostr(MSKDEBUG,">>>>>>>> Stop error\n");

        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)
{
        this->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)
{
        this->pVoice->SetRate(rateSpeech);
}


std::list <char *> Speech::getVoiceAll()
{
  ISpObjectToken* pToken;
  IEnumSpObjectTokens*  cpIEnum;
  
  // Declare local identifiers:
        HRESULT hr = S_OK;
        std::list <char *> lParamSp;
  ULONG sizel;

        hr = SpEnumTokens(SPCAT_VOICES, NULL/*L"Gender=Female;Language=409"*/, NULL/*L"Vendor=VoiceVendor1;Age=Child"*/, &cpIEnum);

  if (FAILED(hr))
  {
                MMechostr(MSKDEBUG,"getVoiceAll ->  Erreur : EnumTokens\n");
    return lParamSp;
  }
  else
        {
    cpIEnum->GetCount(&sizel);
    if (sizel <=0)
    {
                  MMechostr(MSKDEBUG,"getVoiceAll ->  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,"getVoiceAll -> SpGetDescription : ERROR\n");
      pToken->Release();
      //dstrText.~CSpDynamicString();

      //$MS
      dstrText.Clear() ;
      delete dstrText ;
                }
        }
  cpIEnum->Release();

        return lParamSp;
}


void Speech::SetSpeechVoice( char * voice)
{
  HRESULT hr = S_OK;
  IEnumSpObjectTokens*  cpIEnum;
  ISpObjectToken* pToken;
  bool testVoice = true;

        hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL, &cpIEnum);
        if (SUCCEEDED(hr))
        {       
    wchar_t * dstrTextTest ;
    char *lpszVoiceId;
 
                while ((cpIEnum->Next(1, &pToken, NULL) == S_OK) &&(testVoice == true))
                {
      hr = SpGetDescription(pToken, &dstrTextTest);
      char * textV = convertWcharToChar(dstrTextTest);
      
      MMechostr(MSKDEBUG,"hamza 111111 :::: %s\n",textV);
   
      if (SUCCEEDED(hr))
                        {
        if (strcmp(textV,voice)==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");
     
      pToken->Release();
                }
        }
  else 
    MMechostr(MSKDEBUG,"SetSpeechVoice -> Erreur EnumTokens : \n");

 cpIEnum->Release();
}


char * Speech::getSpeechVoice()
{
  ISpObjectToken* pToken;
  char * token;
  
  HRESULT hr = S_OK;
  CSpDynamicString dstrText;
        
  pVoice->GetVoice(&pToken);
  hr = SpGetDescription(pToken, &dstrText);
  token = dstrText.CopyToChar();

  dstrText.Clear() ;
  delete dstrText ;
  pToken->Release();
  
  return token;
}

---