wuhanhenglong/容器最新语音sdk/Container/RecognitionCppDll/online_tts_demo.cc

//
// Copyright 2018 Mobvoi Inc. All Rights Reserved.
// Author: ybtang@mobvoi.com (Yanbin Tang)
#include <tchar.h>
#include "online_tts_demo.h"

extern std::string gTtsStrGlobal;
extern std::string gSdkConfigBasePath;
extern "C" int playPcmFile(const char * cFileName);

extern std::string GBKToUTF8(const std::string& strGBK);
extern std::string UTF8ToGBK(const char* strUTF8);


namespace mobvoi {
	namespace sds {

OnlineTtsDemo* OnlineTtsDemo::GetInstance() {
  static OnlineTtsDemo instance;
  
  instance.ttsContent_ = "";
  instance.language_ = "";
  instance.speaker_ = "";
  instance.speed_ = "";
  
  return &instance;
}

void OnlineTtsDemo::setTtsParas(std::string ttsContent, std::string language, std::string speaker, std::string speed){
	ttsContent_ = ttsContent;
	language_ = language;
	speaker_ = speaker;
	speed_ = speed;
}

bool OnlineTtsDemo::Run(int argc, char* argv[]) {
  if (!ParseCmdArgs(argc, argv)) {
    std::cerr << "OnlineTtsDemo Error: ParseCmdArgs failed." << std::endl;
    return false;
  }

  if (!InitEnv()) {
    std::cerr << "OnlineTtsDemo Error: InitEnv failed." << std::endl;
    return false;
  }

  if (!GetService()) {
    std::cerr << "OnlineTtsDemo Error: GetService failed." << std::endl;
    ReleaseEnv();
    return false;
  }

  if (!InvokeSetParams()) {
    std::cerr << "OnlineTtsDemo Error: InvokeSetParams failed." << std::endl;
    ReleaseService();
    ReleaseEnv();
    return false;
  }

  if (!InvokeStart()) {
    std::cerr << "OnlineTtsDemo Error: InvokeStartService failed." << std::endl;
    ReleaseService();
    ReleaseEnv();
    return false;
  }
  std::string text;
   
  if (ttsContent_ !="") {
	  text = GBKToUTF8(ttsContent_);
	  std::cerr << "ttsContent_:" << ttsContent_ << std::endl;
  }
  else {
	  if (gTtsStrGlobal == "") {
		  //text = u8"1234567890";
		  //text = "¼��������ʶ�������쳣.";
		  std::string temp = "�Բ�����û��������Ŷ";//��.����
		  text = GBKToUTF8(temp);
	  }
	  else {
		  text = gTtsStrGlobal;
	  }
  }

  if (!InvokeFeedText(text)) {
    std::cerr << "Error: InvokeFeedText failed." << std::endl;
    ReleaseService();
    ReleaseEnv();
    return false;
  }

  //text = "����������ô��";
  //if (!InvokeFeedText(text)) {
  //  std::cerr << "Error: InvokeFeedText failed." << std::endl;
  //  ReleaseService();
  //  ReleaseEnv();
  //  return false;
  //}

  if (!InvokeReadTtsData()) {
    std::cerr << "Error: InvokeReadTtsData failed." << std::endl;
    ReleaseService();
    ReleaseEnv();
    return false;
  }

  if (!InvokeStop()) {
    std::cerr << "Error: InvokeStop failed." << std::endl;
    ReleaseService();
    ReleaseEnv();
    return false;
  }

  if (!ReleaseService()) {
    std::cerr << "Error: ReleaseService failed." << std::endl;
    ReleaseEnv();
    return false;
  }

  if (!ReleaseEnv()) {
    std::cerr << "Error: ReleaseEnv failed." << std::endl;
    return false;
  }

  std::string filename = gSdkConfigBasePath + "\\ttsTest.pcm";

#ifndef AUTO_SDK_TEST
  PlayTts(filename);
#endif

  return true;
}

bool OnlineTtsDemo::ParseCmdArgs(int argc, char* argv[]) {
  //if (argc < 2) {
  //  std::cerr << "Usage: " << argv[0]
  //            << " <base dir>" << std::endl;
  //  return false;
  //}

  //const char* path = argv[1];
  //const char* path = "D:\\sdktest\\config";
  const char* path = gSdkConfigBasePath.c_str();
  struct stat info;
  if (stat(path, &info) != 0) {
    std::cerr << "Error: Cannot access " << path << std::endl;
    return false;
  } else if (!(info.st_mode & S_IFDIR)) {
    std::cerr << "Error: " << path << " is not a directory" << std::endl;
    return false;
  }

  base_dir_ = path;
  return true;
}

bool OnlineTtsDemo::InitEnv() {
  speech_sds_ = SpeechSDS::MakeInstance();
  if (NULL == speech_sds_) {
    std::cerr << "Error: Failed obtaining SpeechSDS instance" << std::endl;
    return false;
  }

  Parameter params(MOBVOI_SDS_INIT);
  params[MOBVOI_SDS_BASE_DIR]    = base_dir_;
  params[MOBVOI_SDS_USER_HANDLE] = (Handle)this;  // NOLINT

  params[MOBVOI_SDS_LOG_LEVEL] = 0;
  params[MOBVOI_SDS_VLOG_LEVEL] = 4;

  std::string filename = gSdkConfigBasePath + "\\tts_log.txt";
  params[MOBVOI_SDS_LOG_FILE] = filename.c_str();

  return speech_sds_->Init(params);
}

bool OnlineTtsDemo::GetService() {
  service_ = speech_sds_->GetService(MOBVOI_SDS_ONLINE_TTS);
  return (service_ != NULL);
}

bool OnlineTtsDemo::ReleaseService() {
  if (speech_sds_->ReleaseService(service_)) {
    service_ = NULL;
    return true;
  } else {
    std::cerr << "Failed releasing service " << MOBVOI_SDS_ONLINE_TTS
              << std::endl;
  }
  return false;
}

void OnlineTtsDemo::PlayTts(std::string fullName) {
	/*
	MCI_OPEN_PARMS OpenParms; //�����豸  
	OpenParms.lpstrDeviceType = NULL; // "mpegvideo";  
	OpenParms.lpstrElementName = (LPCWSTR)fullName.c_str();
	OpenParms.wDeviceID = NULL;
	mciSendCommand(NULL, MCI_OPEN, MCI_OPEN_ELEMENT, (DWORD)&OpenParms);

	MCI_PLAY_PARMS PlayParms; //�����ļ�  
	PlayParms.dwFrom = 0;
	mciSendCommand(OpenParms.wDeviceID, MCI_PLAY, MCI_FROM, (DWORD)&PlayParms);
	*/

	//PlaySound((LPCWSTR)fullName.c_str(), NULL, SND_FILENAME | SND_SYNC);//ֻ�ܲ���wav


	//PlaySound(TEXT("D:\\sdktest\\config\\recordTest1.wav"), NULL,  SND_FILENAME );//����wav��SND_ASYNC���˳���

	//playPcmFile(_T("D:\\sdktest\\config\\ttsTest1.pcm"));

	//TCHAR wc[MAX_PATH];
	//_stprintf_s(wc, MAX_PATH, _T("%S"), fullName.c_str());
	//playPcmFile(wc);

	playPcmFile(fullName.c_str());
	
}

bool OnlineTtsDemo::ReleaseEnv() {
  speech_sds_->CleanUp();
  SpeechSDS::DestroyInstance(speech_sds_);
  return true;
}

bool OnlineTtsDemo::InvokeSetParams() {

  Parameter params(MOBVOI_SDS_SET_PARAM);

  params[MOBVOI_SDS_LANGUAGE] = "Mandarin";
  if (language_ != "") {
	  params[MOBVOI_SDS_LANGUAGE] = language_;
  }

  params[MOBVOI_SDS_SPEAKER] = "lucy";
  if (speaker_!="") {
	  params[MOBVOI_SDS_SPEAKER] = speaker_;
  }

  if (speed_ != "") {
	  params[MOBVOI_SDS_SPEED] = speed_;
  }

  Parameter ret = service_->Invoke(params);
  return (MOBVOI_SDS_SUCCESS == ret[MOBVOI_SDS_ERROR_CODE].AsInt());
}

bool OnlineTtsDemo::InvokeStart() {
  Parameter params(MOBVOI_SDS_START);
  Parameter ret = service_->Invoke(params);
  return (MOBVOI_SDS_SUCCESS == ret[MOBVOI_SDS_ERROR_CODE].AsInt());
}

bool OnlineTtsDemo::InvokeFeedText(std::string text) {
  Parameter params(MOBVOI_SDS_FEED_TEXT);
  params[MOBVOI_SDS_TEXT] = text;
  Parameter ret = service_->Invoke(params);
  return (MOBVOI_SDS_SUCCESS == ret[MOBVOI_SDS_ERROR_CODE].AsInt());
}

bool OnlineTtsDemo::InvokeReadTtsData() {
	std::string filename = gSdkConfigBasePath + "\\ttsTest.pcm";
	std::FILE* fp = std::fopen(filename.c_str(), "wb");
	if (nullptr == fp) {
    std::cerr << "Can't dump pcm: " << strerror(errno);
    return false;
  }
  Buf audio_buf;
  Parameter params(MOBVOI_SDS_READ);
  const int BUF_SIZE = 640;
  char* addr = new char[BUF_SIZE];
  audio_buf.SetAddr(addr);
  audio_buf.SetSize(BUF_SIZE);
  params[MOBVOI_SDS_AUDIO_BUF] = audio_buf;
  while (true) {
    Parameter ret = service_->Invoke(params);
    if (MOBVOI_SDS_SUCCESS != ret[MOBVOI_SDS_ERROR_CODE].AsInt()) {
      std::cout << " Invoke read tts data failed." << std::endl;
      delete[] addr;
      std::fclose(fp);
      return false;
    }
    int read_bytes = ret[MOBVOI_SDS_TTS_READ_SIZE].AsInt();
    if (read_bytes != -1) {
      std::fwrite(audio_buf.GetAddr(), 1, read_bytes, fp);
    } else {
      break;
    }
  }
  std::fclose(fp);
  delete[] addr;
  return true;
}

bool OnlineTtsDemo::InvokeStop() {
  Parameter params(MOBVOI_SDS_STOP);
  Parameter ret = service_->Invoke(params);
  return (MOBVOI_SDS_SUCCESS == ret[MOBVOI_SDS_ERROR_CODE].AsInt());
}

}  // namespace sds
}  // namespace mobvoi