C++ SDK

#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <ctime>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include "nlsClient.h"
#include "nlsEvent.h"
#include "nlsToken.h"
#include "flowingSynthesizerRequest.h"

#define SAMPLE_RATE_16K 16000
#define DEFAULT_STRING_LEN 512
#define AUDIO_TEXT_LENGTH 2048

/**
 * Globally maintain a service authentication token and its corresponding expiration timestamp.
 * Before calling the service, first check if the token has expired.
 * If it has expired, regenerate a token using the AccessKey ID and AccessKey
 * Secret, and update this global token and its expiration timestamp.
 *
 * Note: Do not regenerate a new token every time you call the service. Only regenerate it when the token is about to expire. All concurrent services can share one token.
 */
// Custom thread parameters
struct ParamStruct {
  char text[AUDIO_TEXT_LENGTH];
  char token[DEFAULT_STRING_LEN];
  char appkey[DEFAULT_STRING_LEN];
  char url[DEFAULT_STRING_LEN];

  pthread_mutex_t mtx;
};

// Custom event callback parameters
struct ParamCallBack {
 public:
  explicit ParamCallBack(ParamStruct* param) {
    tParam = param;
    pthread_mutex_init(&mtxWord, NULL);
    pthread_cond_init(&cvWord, NULL);
  };
  ~ParamCallBack() {
    tParam = NULL;
    pthread_mutex_destroy(&mtxWord);
    pthread_cond_destroy(&cvWord);
  };

  pthread_mutex_t mtxWord;
  pthread_cond_t cvWord;

  ParamStruct* tParam;
};

std::string g_appkey = "";
std::string g_akId = "";
std::string g_akSecret = "";
std::string g_token = "";
std::string g_url = "";
std::string g_voice = "xiaoyun";
int g_threads = 1;
bool g_save_audio = true;
std::string g_text = "";
std::string g_format = "wav";
long g_expireTime = -1;
static int sample_rate = SAMPLE_RATE_16K;
static bool enableSubtitle = false;

std::vector<std::string> splitString(
    const std::string& str, const std::vector<std::string>& delimiters) {
  std::vector<std::string> result;
  size_t startPos = 0;

  // Find each separator in the string
  while (startPos < str.length()) {
    size_t minPos = std::string::npos;
    size_t delimiterLength = 0;

    for (std::vector<std::string>::const_iterator it = delimiters.begin();
         it != delimiters.end(); ++it) {
      std::size_t position = str.find(*it, startPos);
      // Find the nearest separator
      if (position != std::string::npos &&
          (minPos == std::string::npos || position < minPos)) {
        minPos = position;
        delimiterLength = it->size();
      }
    }

    // If a separator is found, extract the preceding string
    if (minPos != std::string::npos) {
      result.push_back(str.substr(startPos, minPos - startPos));
      startPos = minPos + delimiterLength;
    } else {
      // No more separators, the rest is one part
      result.push_back(str.substr(startPos));
      break;
    }
  }

  return result;
}

/**
 * Regenerate a token using the AccessKey ID and AccessKey Secret, and get its expiration timestamp.
 */
int generateToken(std::string akId, std::string akSecret, std::string* token,
                  long* expireTime) {
  AlibabaNlsCommon::NlsToken nlsTokenRequest;
  nlsTokenRequest.setAccessKeyId(akId);
  nlsTokenRequest.setKeySecret(akSecret);

  int retCode = nlsTokenRequest.applyNlsToken();
  /*Get the failure cause*/
  if (retCode < 0) {
    std::cout << "Failed error code: " << retCode
              << "  error msg: " << nlsTokenRequest.getErrorMsg() << std::endl;
    return retCode;
  }

  *token = nlsTokenRequest.getToken();
  *expireTime = nlsTokenRequest.getExpireTime();

  return 0;
}

void OnSynthesisStarted(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout << "OnSynthesisStarted:"
            << "  status code: " << cbEvent->getStatusCode()
            << "  task id: " << cbEvent->getTaskId()
            << "  all response:" << cbEvent->getAllResponse() << std::endl;
}

/**
 * @brief When the SDK receives a synthesis completion message from the cloud, the SDK's internal thread reports a Completed event.
 * @note After the Completed event is reported, the SDK will close the recognition connection channel internally.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 */
void OnSynthesisCompleted(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSynthesisCompleted: "
      << ", status code: "
      << cbEvent
             ->getStatusCode()  // Gets the status code of the message. Success is 0 or 20000000. Failure corresponds to a specific error code.
      << ", task id: "
      << cbEvent->getTaskId()  // The task ID of the current task. It is recommended to output this for troubleshooting.
      << std::endl;
  std::cout << "OnSynthesisCompleted: All response:"
            << cbEvent->getAllResponse()
            << std::endl;  // Gets all information returned by the server.
}

/**
 * @brief If an exception occurs during the synthesis process, the SDK's internal thread reports a TaskFailed event.
 * @note After the TaskFailed event is reported, the SDK will close the recognition connection channel internally.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 */
void OnSynthesisTaskFailed(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  FILE* failed_stream = fopen("synthesisTaskFailed.log", "a+");
  if (failed_stream) {
    char outbuf[1024] = {0};
    snprintf(outbuf, sizeof(outbuf),
             "OnSynthesisTaskFailed status code:%d task id:%s error mesg:%s\n",
             cbEvent->getStatusCode(), cbEvent->getTaskId(),
             cbEvent->getErrorMessage());
    std::cout << outbuf << std::endl;
    fwrite(outbuf, strlen(outbuf), 1, failed_stream);
    fclose(failed_stream);
  }
}

/**
 * @brief When recognition ends or an exception occurs, the connection channel is closed.
 * The SDK's internal thread reports a ChannelClosed event.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 */
void OnSynthesisChannelClosed(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  ParamCallBack* tmpParam = static_cast<ParamCallBack*>(cbParam);
  if (tmpParam) {
    std::cout << "OnSynthesisChannelClosed: "
              << ", All response: " << cbEvent->getAllResponse()
              << std::endl;  // Gets all information returned by the server.
  }
}

/**
 * @brief After the text is reported to the server, binary audio data is received from the server.
 * The SDK's internal thread reports this to the user through a BinaryDataRecved event.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 * @notice Do not perform blocking operations here. Only transfer and store the audio data. If too many operations are performed in this callback,
 *         it will block subsequent data callbacks and the completed event callback.
 */
void OnBinaryDataRecved(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::vector<unsigned char> data =
      cbEvent->getBinaryData();  // getBinaryData() gets the binary audio data of the text synthesis.
  std::cout
      << "  OnBinaryDataRecved: status code: "
      << cbEvent
             ->getStatusCode()  // Gets the status code of the message. Success is 0 or 20000000. Failure corresponds to a specific error code.
      << ", taskId: "
      << cbEvent->getTaskId()  // The task ID of the current task. It is recommended to output this for troubleshooting.
      << ", data size: " << data.size()  // The size of the data.
      << std::endl;

  if (g_save_audio && data.size() > 0) {
    // Append the binary audio data to the file.
    std::string dir = "./tts_audio";
    if (access(dir.c_str(), 0) == -1) {
      mkdir(dir.c_str(), S_IRWXU);
    }
    char file_name[256] = {0};
    snprintf(file_name, 256, "%s/%s.%s", dir.c_str(), cbEvent->getTaskId(),
             g_format.c_str());
    FILE* tts_stream = fopen(file_name, "a+");
    if (tts_stream) {
      fwrite((char*)&data[0], data.size(), 1, tts_stream);
      fclose(tts_stream);
    }
  }
}

void OnSentenceBegin(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceBegin "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // Gets the status code of the message. Success is 0 or 20000000. Failure corresponds to a specific error code.
      << std::endl;
}

void OnSentenceEnd(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceEnd "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // Gets the status code of the message. Success is 0 or 20000000. Failure corresponds to a specific error code.
      << std::endl;
}

/**
 * @brief Returns log information corresponding to the TTS text, and incrementally returns corresponding caption information.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 */
void OnSentenceSynthesis(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceSynthesis "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // Gets the status code of the message. Success is 0 or 20000000. Failure corresponds to a specific error code.
      << std::endl;
}

/**
 * @brief All information returned by the server is fed back through this callback.
 * @param cbEvent Callback event structure. For more information, see nlsEvent.h.
 * @param cbParam Custom callback parameter, default is NULL. You can customize parameters as needed.
 * @return
 */
void onMessage(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout << "onMessage: All response:" << cbEvent->getAllResponse()
            << std::endl;
}

/**
 * @brief Worker thread in short-connection mode.
 *        It loops as follows:
 *        createFlowingSynthesizerRequest   <----|
 *                   |                              |
 *           request->start()                       |
 *                   |                              |
 *           request->sendText()                    |
 *                   |                              |
 *           request->stop()                        |
 *                   |                              |
 *           Receive OnSynthesisChannelClosed callback |
 *                   |                              |
 *      releaseFlowingSynthesizerRequest(request) --|
 */
void* pthreadFunc(void* arg) {
  int testCount = 0;  // Run count, used to exit after exceeding the set loop count.
  bool timedwait_flag = false;

  // Get token, configuration files, and other parameters from the custom thread parameters.
  ParamStruct* tst = static_cast<ParamStruct*>(arg);
  if (tst == NULL) {
    std::cout << "arg is not valid." << std::endl;
    return NULL;
  }

  pthread_mutex_init(&(tst->mtx), NULL);

  // Initialize custom callback parameters.
  ParamCallBack cbParam(tst);

  /*
   * 1. Create a FlowingSynthesizerRequest object for streaming text-to-speech synthesis.
   *
   * For more information about streaming text-to-speech synthesis, see:
   * https://help.aliyun.com/document_detail/423223.html
   */

  AlibabaNls::FlowingSynthesizerRequest* request =
      AlibabaNls::NlsClient::getInstance()->createFlowingSynthesizerRequest();
  if (request == NULL) {
    std::cout << "createFlowingSynthesizerRequest failed." << std::endl;
    return NULL;
  }

  /*
   * 2. Set the callback for receiving results.
   */
  // Set the callback function for when audio synthesis can start.
  request->setOnSynthesisStarted(OnSynthesisStarted, &cbParam);
  // Set the callback function for when audio synthesis is completed.
  request->setOnSynthesisCompleted(OnSynthesisCompleted, &cbParam);
  // Set the callback function for when the audio synthesis channel is closed.
  request->setOnChannelClosed(OnSynthesisChannelClosed, &cbParam);
  // Set the callback function for exception failures.
  request->setOnTaskFailed(OnSynthesisTaskFailed, &cbParam);
  // Set the callback function for receiving text-to-audio data.
  request->setOnBinaryDataReceived(OnBinaryDataRecved, &cbParam);
  // Set caption information.
  request->setOnSentenceSynthesis(OnSentenceSynthesis, &cbParam);
  // A sentence begins.
  request->setOnSentenceBegin(OnSentenceBegin, &cbParam);
  // A sentence ends.
  request->setOnSentenceEnd(OnSentenceEnd, &cbParam);
  // Set the callback function for all server return messages.
  // request->setOnMessage(onMessage, &cbParam);
  // Enable the callback function for all server return messages. Other callbacks (except OnBinaryDataRecved) will become invalid.
  // request->setEnableOnMessage(true);

  /*
   * 3. Set the relevant parameters for the request.
   */
  // The voice, such as "xiaoyun", "ruoxi", and "xiaogang". This is an optional parameter. The default value is xiaoyun.
  request->setVoice(g_voice.c_str());
  // The volume. The range is 0 to 100. This is an optional parameter. The default value is 50.
  request->setVolume(50);
  // The audio encoding format. This is an optional parameter. The default value is wav. Supported formats are pcm, wav, and mp3.
  request->setFormat("wav");
  // The audio sampling rate, such as 8000 and 16000. This is an optional parameter. The default value is 16000.
  request->setSampleRate(sample_rate);
  // The speech rate. The range is -500 to 500. This is an optional parameter. The default value is 0.
  request->setSpeechRate(0);
  // The pitch rate. The range is -500 to 500. This is an optional parameter. The default value is 0.
  request->setPitchRate(0);
  // Enable captions.
  request->setEnableSubtitle(enableSubtitle);

  // Set the AppKey. This is a required parameter. For more information, see the official website to apply for one.
  if (strlen(tst->appkey) > 0) {
    request->setAppKey(tst->appkey);
  }
  // Set the account verification token. This is a required parameter.
  if (strlen(tst->token) > 0) {
    request->setToken(tst->token);
  }

  if (strlen(tst->url) > 0) {
    request->setUrl(tst->url);
  }

  // Set the connection timeout to 500 ms.
  // request->setTimeout(500);
  // Get the encoding format of the returned text.
  // const char* output_format = request->getOutputFormat();
  // std::cout << "text format: " << output_format << std::endl;

  /*
   * 4.
   * start() is an asynchronous operation. If it succeeds, the system starts to return BinaryRecv events. If it fails, it returns a TaskFailed event.
   */
  std::cout << "start -> pid " << pthread_self() << std::endl;
  struct timespec outtime;
  struct timeval now;
  int ret = request->start();
  testCount++;
  if (ret < 0) {
    std::cout << "start failed. pid:" << pthread_self() << std::endl;
    const char* request_info = request->dumpAllInfo();
    if (request_info) {
      std::cout << "  all info: " << request_info << std::endl;
    }
    AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
        request);  // start() failed, release the request object.
    return NULL;
  } else {
    std::cout << "start success. pid " << pthread_self() << std::endl;
    /*
     * Wait for the started event to be returned, which indicates that start() is successful. Then, send the audio data.
     * The voice server may not be able to process the current request in time and does not return any callbacks within 10 seconds.
     * After 10 seconds, it returns a TaskFailed callback. Therefore, you must set a timeout mechanism.
     */
    std::cout << "wait started callback." << std::endl;
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + 10;
    outtime.tv_nsec = now.tv_usec * 1000;
    pthread_mutex_lock(&(cbParam.mtxWord));
    if (ETIMEDOUT == pthread_cond_timedwait(&(cbParam.cvWord),
                                            &(cbParam.mtxWord), &outtime)) {
      std::cout << "start timeout" << std::endl;
      timedwait_flag = true;
      pthread_mutex_unlock(&(cbParam.mtxWord));
      // start() call timed out. cancel() cancels the current request.
      request->cancel();
      return NULL;
    }
    pthread_mutex_unlock(&(cbParam.mtxWord));
  }

  /*
   * 5. Simulate the streaming return of text results from a large model and perform speech synthesis one by one.
   */
  std::string text_str(tst->text);
  if (!text_str.empty()) {
    const char* delims[] = {".", "!", ";", "?", "\n"};
    std::vector<std::string> delimiters(
        delims, delims + sizeof(delims) / sizeof(delims[0]));
    std::vector<std::string> sentences = splitString(text_str, delimiters);
    for (std::vector<std::string>::const_iterator it = sentences.begin();
         it != sentences.end(); ++it) {
      std::cout << "sendText: " << *it << std::endl;
      ret = request->sendText(it->c_str());
      if (ret < 0) {
        break;
      }
      usleep(500 * 1000);
    }  // for
    if (ret < 0) {
      std::cout << "sendText failed. pid:" << pthread_self() << std::endl;
      const char* request_info = request->dumpAllInfo();
      if (request_info) {
        std::cout << "  all info: " << request_info << std::endl;
      }
      AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
          request);  // start() failed, release the request object.
      return NULL;
    }
  }

  /*
   * 6. start() succeeded. Start waiting to receive all synthesized data.
   *    stop() is a meaningless interface. The entire process runs regardless of whether it is called.
   *    cancel() stops the task immediately and no callback is returned. If it fails, a TaskFailed event is returned.
   */
  //    ret = request->cancel();
  ret = request->stop();

  /*
   * Start waiting to receive all synthesized data.
   */
  if (ret == 0) {
    /*
     * Wait for the started event to be returned, which indicates that start() is successful. Then, send the audio data.
     * The voice server may not be able to process the current request in time and does not return any callbacks within 10 seconds.
     * After 10 seconds, it returns a TaskFailed callback. Therefore, you must set a timeout mechanism.
     */
    // Release after the closed event is returned. Otherwise, a crash may occur.
    std::cout << "wait closed callback." << std::endl;
    /*
     * The voice server may not be able to process the current request in time and does not return any callbacks within 10 seconds.
     * After 10 seconds, it returns a TaskFailed callback with the error message:
     * "Gateway:IDLE_TIMEOUT:Websocket session is idle for too long time,
     * the last directive is 'XXXX'!" Therefore, you must set a timeout mechanism.
     */
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + 30;
    outtime.tv_nsec = now.tv_usec * 1000;
    // Release after the closed event is returned. Otherwise, a crash may occur.
    pthread_mutex_lock(&(cbParam.mtxWord));
    if (ETIMEDOUT == pthread_cond_timedwait(&(cbParam.cvWord),
                                            &(cbParam.mtxWord), &outtime)) {
      std::cout << "stop timeout" << std::endl;
      pthread_mutex_unlock(&(cbParam.mtxWord));
      return NULL;
    }
    pthread_mutex_unlock(&(cbParam.mtxWord));
  } else {
    std::cout << "ret is " << ret << ", pid " << pthread_self() << std::endl;
  }
  gettimeofday(&now, NULL);
  std::cout << "current request task_id:" << request->getTaskId() << std::endl;
  std::cout << "stop finished. pid " << pthread_self() << " tv: " << now.tv_sec
            << std::endl;

  /*
   * 7. Release the current request after all tasks are complete.
   *    Release the request after the closed event is returned to confirm that all tasks are complete. Otherwise, the internal state machine may be damaged
   * and the running request will be forcibly uninstalled.
   */
  const char* request_info = request->dumpAllInfo();
  if (request_info) {
    std::cout << "  all info: " << request_info << std::endl;
  }
  AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
      request);
  std::cout << "release Synthesizer success. pid " << pthread_self()
            << std::endl;

  pthread_mutex_destroy(&(tst->mtx));

  return NULL;
}

/**
 * Synthesize multiple text data.
 * Multi-threading in the SDK means one thread for one text data, not multiple threads for one text data.
 * The sample code starts four threads to synthesize four files at the same time.
 * Free users cannot have more than two concurrent connections.
 */
#define AUDIO_TEXT_NUMS 4
#define AUDIO_FILE_NAME_LENGTH 32
int flowingSynthesizerMultFile(const char* appkey, int threads) {
  /**
   * Get the current system timestamp to check whether the token has expired.
   */
  std::time_t curTime = std::time(0);
  if (g_token.empty()) {
    if (g_expireTime - curTime < 10) {
      std::cout << "the token will be expired, please generate new token by "
                   "AccessKey-ID and AccessKey-Secret."
                << std::endl;
      int ret = generateToken(g_akId, g_akSecret, &g_token, &g_expireTime);
      if (ret < 0) {
        std::cout << "generate token failed" << std::endl;
        return -1;
      } else {
        if (g_token.empty() || g_expireTime < 0) {
          std::cout << "generate empty token" << std::endl;
          return -2;
        }
        std::cout << "token: " << g_token << std::endl;
      }
    }
  }

  /* Do not exceed AUDIO_TEXT_LENGTH */
  const char texts[AUDIO_TEXT_LENGTH] = {
      "Chirp, chirp, and again, chirp, chirp, Mulan weaves at the door. The sound of the shuttle is not heard, only the girl's sighs. They ask the girl what she is thinking, they ask the girl what she is remembering."
      "The girl is not thinking of anything, the girl is not remembering anything. Last night I saw the draft papers, the Khan is calling up a great army. The army list is in twelve scrolls, and on every scroll is my father's name."
      "Father has no grown-up son, Mulan has no elder brother. I want to buy a saddle and horse, and serve in the army in my father's place. In the East Market she buys a fine horse, in the West Market a saddle and cloth,"
      "in the South Market a bridle, in the North Market a long whip. At dawn she bids farewell to her parents, at dusk she camps by the Yellow River. She doesn't hear her parents' call, only the splashing water of the Yellow River. At dawn she leaves the Yellow River, at dusk she reaches the Black Mountain. She doesn't hear her parents' call, only the neighing of the nomad horses on Mount Yan."
      " She travels thousands of miles to the war, crossing mountains as if flying. The northern air carries the watchman's clapper, the cold light shines on her iron armor. Generals die in a hundred battles, and the bravest soldiers return after ten years"
      ". "
      "On her return she sees the Son of Heaven, the Son of Heaven sits in the Splendid Hall. He records her merits in twelve ranks, and bestows rewards of a hundred thousand and more. The Khan asks what she desires, Mulan has no use for a minister's post"
      ", I want to ride a swift horse for a thousand miles, to take me back to my old home. "
      "When her parents hear their daughter is coming, they go out to the city wall to welcome her; When her elder sister hears her sister is coming, she puts on her red makeup at the door; When her younger brother hears his sister is coming, he sharpens his knife, whirring, for the pig and sheep"
      ". I open my east chamber door, and sit on my west chamber bed. I take off my wartime robe, and put on my old-time clothes. By the window I arrange my cloud-like hair, before the mirror I put on the yellow flower. I go out to see my comrades, my comrades are all amazed and bewildered: 'We traveled together for twelve years, and didn't know Mulan was a girl.' "
      "The male rabbit's feet hop and skip, the female rabbit's eyes are blurred and dim; But when the two rabbits run side by side, how can you tell which is the male and which is the female?"};

  ParamStruct pa[threads];

  for (int i = 0; i < threads; i++) {
    memset(pa[i].token, 0, DEFAULT_STRING_LEN);
    memcpy(pa[i].token, g_token.c_str(), g_token.length());

    memset(pa[i].appkey, 0, DEFAULT_STRING_LEN);
    memcpy(pa[i].appkey, appkey, strlen(appkey));

    memset(pa[i].text, 0, AUDIO_TEXT_LENGTH);
    if (g_text.empty()) {
      memcpy(pa[i].text, texts, strlen(texts));
    } else {
      memcpy(pa[i].text, g_text.data(), strlen(g_text.data()));
    }

    memset(pa[i].url, 0, DEFAULT_STRING_LEN);
    if (!g_url.empty()) {
      memcpy(pa[i].url, g_url.c_str(), g_url.length());
    }
  }

  std::vector<pthread_t> pthreadId(threads);
  // Start four worker threads to recognize four audio files at the same time.
  for (int j = 0; j < threads; j++) {
    pthread_create(&pthreadId[j], NULL, &pthreadFunc, (void*)&(pa[j]));
  }

  std::cout << "start pthread_join..." << std::endl;

  for (int j = 0; j < threads; j++) {
    pthread_join(pthreadId[j], NULL);
  }

  std::cout << "flowingSynthesizerMultFile exit..." << std::endl;
  return 0;
}

int main(int argc, char* argv[]) {
  std::string g_appkey = getenv("NLS_APPKEY_ENV");
  g_akId = getenv("NLS_AK_ENV");
  g_akSecret = getenv("NLS_SK_ENV");

  std::cout << " appKey: " << g_appkey << std::endl;
  std::cout << " akId: " << g_akId << std::endl;
  std::cout << " akSecret: " << g_akSecret << std::endl;
  std::cout << " voice: " << g_voice << std::endl;
  std::cout << "\n" << std::endl;

  int ret = AlibabaNls::NlsClient::getInstance()->setLogConfig(
      "log-flowingSynthesizer", AlibabaNls::LogDebug, 400, 50, NULL);
  if (ret < 0) {
    std::cout << "set log failed." << std::endl;
    return -1;
  }

  // Set the socket address type required by the running environment. The default value is AF_INET.
  // This must be called before startWorkThread().
  // AlibabaNls::NlsClient::getInstance()->setAddrInFamily("AF_INET");

  // Set the direct connection IP for private cloud deployments.
  // This must be called before startWorkThread().
  // AlibabaNls::NlsClient::getInstance()->setDirectHost("xxx.xxx.xxx.xxx");

  std::cout << "startWorkThread begin... " << std::endl;

  // Start the worker thread. This function must be called before creating and starting a request.
  // If the input parameter is negative, the number of available cores in the current system is started.
  // For high concurrency, 4 is recommended. For a single request, 1 is recommended.
  // If the CPU usage is high in a high-concurrency scenario, you can set it to -1 to enable all CPU cores.
  AlibabaNls::NlsClient::getInstance()->startWorkThread(1);

  std::cout << "startWorkThread finish" << std::endl;

  // Synthesize multiple texts.
  ret = flowingSynthesizerMultFile(g_appkey.c_str(), g_threads);
  if (ret) {
    std::cout << "flowingSynthesizerMultFile failed." << std::endl;
    AlibabaNls::NlsClient::releaseInstance();
    return -2;
  }

  // After all tasks are complete, release nlsClient before the process exits.
  // Note that releaseInstance() is not thread-safe.
  std::cout << "releaseInstance -> " << std::endl;
  AlibabaNls::NlsClient::releaseInstance();
  std::cout << "releaseInstance done." << std::endl;

  return 0;
}