server/ttsd_data.cpp

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <list>
  15 #include <pthread.h>
  16 #include <mutex>
  17 #include <vector>
  18 #include <atomic>
  19
  20 #include "ActivatedModes.h"
  21
  22 #include "ttsd_data.h"
  23
  24 using namespace std;
  25
  26
  27 typedef struct
  28 {
  29         char*   lang;
  30         int     vctype;
  31 }used_voice_s;
  32
  33 typedef struct
  34 {
  35         int             pid;
  36         unsigned int            uid;
  37         int             utt_id_stopped;
  38         app_tts_state_e state;
  39         tts_app_play_type_e type;
  40         ttsd_mode_e     mode;
  41         ttsd_playing_mode_e playing_mode;
  42         ttse_result_event_e result_event;
  43
  44         std::list<speak_data_s*> m_speak_data;
  45         std::list<sound_data_s*> m_wav_data;
  46         bool paused_data_existing;
  47
  48         std::list<used_voice_s> m_used_voice;
  49         tts_ipc_method_e ipc_method;
  50
  51         char* credential;
  52         int registered_event_mask;
  53 } app_data_s;
  54
  55 static vector<app_data_s> g_app_list;
  56
  57 static mutex g_app_data_mutex;
  58
  59 /* If engine is running */
  60 static atomic<ttsd_synthesis_control_e> g_synth_control;
  61
  62 static ActivatedModes g_activated_modes;
  63
  64 #ifdef DATA_DEBUG
  65 static void show_client_list()
  66 {
  67         SLOG(LOG_DEBUG, tts_tag(), "----- client list -----");
  68
  69         unsigned int i = 0;
  70         for (auto& appData : g_app_list) {
  71                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, appData.pid, appData.uid, appData.state);
  72                 i++;
  73         }
  74
  75         if (0 == i) {
  76                 SLOG(LOG_DEBUG, tts_tag(), "No Client");
  77         }
  78
  79         SLOG(LOG_DEBUG, tts_tag(), "-----------------------");
  80 }
  81
  82 static void show_sound_list(app_data_s& app_data)
  83 {
  84         SLOG(LOG_DEBUG, tts_tag(), "----- Sound list -----");
  85
  86         unsigned int i = 0;
  87         for (auto& wavData : app_data.m_wav_data) {
  88                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
  89                                 i + 1, wavData, wavData->data, wavData->data_size, wavData->utt_id, wavData->audio_type);
  90                 i++;
  91         }
  92
  93         if (0 == i) {
  94                 SLOG(LOG_DEBUG, tts_tag(), "No Sound Data");
  95         }
  96
  97         SLOG(LOG_DEBUG, tts_tag(), "----------------------");
  98 }
  99
 100 static void show_text_list(app_data_s& app_data)
 101 {
 102         SLOG(LOG_DEBUG, tts_tag(), "----- Text list -----");
 103
 104         unsigned int i = 0;
 105         for (auto& speakData : app_data.m_speak_data) {
 106                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)",
 107                                 i + 1, speakData, speakData->lang, speakData->vctype, speakData->speed, speakData->utt_id, speakData->text);
 108                 i++;
 109         }
 110
 111         if (0 == i) {
 112                 SLOG(LOG_DEBUG, tts_tag(), "No Text Data");
 113         }
 114
 115         SLOG(LOG_DEBUG, tts_tag(), "---------------------");
 116 }
 117
 118 static void show_used_voice_list(app_data_s& app_data)
 119 {
 120         SLOG(LOG_DEBUG, tts_tag(), "----- Used voice list -----");
 121
 122         unsigned int i = 0;
 123         for (auto& usedVoice : app_data.m_used_voice) {
 124                 SLOG(LOG_DEBUG, tts_tag(), "[%dth] lang(%s), vctype(%d)", i + 1, usedVoice.lang, usedVoice.vctype);
 125                 i++;
 126         }
 127
 128         if (0 == i) {
 129                 SLOG(LOG_DEBUG, tts_tag(), "No Voice Data");
 130         }
 131
 132         SLOG(LOG_DEBUG, tts_tag(), "---------------------------");
 133 }
 134 #endif
 135
 136 /*
 137 * ttsd data functions
 138 */
 139
 140 int ttsd_data_set_synth_control(ttsd_synthesis_control_e control)
 141 {
 142         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] set synth_control(%d)", control);
 143         g_synth_control = control;
 144         return 0;
 145 }
 146
 147 ttsd_synthesis_control_e ttsd_data_get_synth_control()
 148 {
 149         return g_synth_control.load();
 150 }
 151
 152 static app_data_s* get_client_app_data(unsigned int uid)
 153 {
 154         for (auto& app_data : g_app_list) {
 155                 if (app_data.uid == uid) {
 156                         return &app_data;
 157                 }
 158         }
 159
 160         return nullptr;
 161 }
 162
 163 int ttsd_data_new_client(int pid, unsigned int uid, ttsd_mode_e mode, ttsd_playing_mode_e playing_mode, int registered_event_mask, tts_ipc_method_e method)
 164 {
 165         lock_guard<mutex> lock(g_app_data_mutex);
 166         if(nullptr != get_client_app_data(uid) ) {
 167                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is already registered (%u)", uid);
 168                 return TTSD_ERROR_INVALID_PARAMETER;
 169         }
 170
 171         app_data_s app;
 172         app.pid = pid;
 173         app.uid = uid;
 174         app.utt_id_stopped = 0;
 175         app.state = APP_STATE_READY;
 176         app.type = TTS_APP_PLAY_TYPE_SYNTH;
 177         app.mode = mode;
 178         app.playing_mode = playing_mode;
 179         app.result_event = TTSE_RESULT_EVENT_FAIL;
 180         app.ipc_method = method;
 181         app.credential = nullptr;
 182         app.paused_data_existing = false;
 183         app.registered_event_mask = registered_event_mask;
 184
 185         g_app_list.push_back(app);
 186         g_activated_modes.addMode(mode);
 187
 188 #ifdef DATA_DEBUG
 189         show_client_list();
 190 #endif
 191
 192         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] New client. pid(%d), uid(%u)", app.pid, app.uid);
 193
 194         return TTSD_ERROR_NONE;
 195 }
 196
 197 static inline void destroy_speak_data(speak_data_s* speak_data)
 198 {
 199         SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] utt(%d), text(%s), lang(%s), vctype(%d) speed(%d)",
 200                 speak_data->utt_id, speak_data->text == nullptr ? "NULL" : speak_data->text, speak_data->voice.language == nullptr ? "NULL" : speak_data->voice.language, speak_data->voice.type, speak_data->synth_parameter.speed);
 201
 202         free(speak_data->text);
 203         speak_data->text = nullptr;
 204
 205         free(speak_data->voice.language);
 206         speak_data->voice.language = nullptr;
 207
 208         free(speak_data->voice.ptts_id);
 209         speak_data->voice.ptts_id = nullptr;
 210
 211         delete speak_data;
 212 }
 213
 214 static inline void destroy_sound_data(sound_data_s* sound_data)
 215 {
 216         SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] event(%d) data(%p) size(%d) rate(%d) utt(%d)",
 217                         sound_data, sound_data->event, sound_data->data, sound_data->data_size, sound_data->rate, sound_data->utt_id);
 218
 219         delete[] sound_data->data;
 220         delete sound_data;
 221 }
 222
 223 static void clean_data(app_data_s& app_data)
 224 {
 225         SLOG(LOG_ERROR, tts_tag(), "[INFO] Clean data. uid(%u)", app_data.uid);
 226
 227         int removed_last_uttid = -1;
 228         for (auto& speak_data : app_data.m_speak_data) {
 229                 if (nullptr == speak_data) {
 230                         continue;
 231                 }
 232
 233                 removed_last_uttid = speak_data->utt_id;
 234
 235                 destroy_speak_data(speak_data);
 236                 speak_data = nullptr;
 237         }
 238
 239         if (-1 != removed_last_uttid) {
 240                 app_data.utt_id_stopped = removed_last_uttid;
 241         }
 242
 243         for (auto& sound_data : app_data.m_wav_data) {
 244                 if (nullptr == sound_data) {
 245                         continue;
 246                 }
 247
 248                 destroy_sound_data(sound_data);
 249                 sound_data = nullptr;
 250         }
 251
 252         app_data.m_speak_data.clear();
 253         app_data.m_wav_data.clear();
 254
 255         free(app_data.credential);
 256         app_data.credential = nullptr;
 257 }
 258
 259 int ttsd_data_delete_client(unsigned int uid)
 260 {
 261         lock_guard<mutex> lock(g_app_data_mutex);
 262         int index = 0;
 263         for (auto& app_data : g_app_list) {
 264                 if (app_data.uid == uid) {
 265                         break;
 266                 }
 267
 268                 index++;
 269         }
 270
 271         if (index >= (int)g_app_list.size()) {
 272                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 273                 return TTSD_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         clean_data(g_app_list[index]);
 277
 278         ttsd_mode_e mode = g_app_list[index].mode;
 279         g_app_list.erase(g_app_list.begin() + index);
 280         g_activated_modes.removeMode(mode);
 281
 282 #ifdef DATA_DEBUG
 283         show_client_list();
 284 #endif
 285
 286         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Client is deleted. uid(%u), index(%d)", uid, index);
 287
 288         return TTSD_ERROR_NONE;
 289 }
 290
 291 int ttsd_data_is_client(unsigned int uid)
 292 {
 293         lock_guard<mutex> lock(g_app_data_mutex);
 294         int vsize = g_app_list.size();
 295         for (int i = 0; i < vsize; i++) {
 296                 if(g_app_list[i].uid == uid) {
 297                         return i;
 298                 }
 299         }
 300
 301         SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no corresponding client. uid(%u)", uid);
 302
 303         return -1;
 304 }
 305
 306 int ttsd_data_get_client_count()
 307 {
 308         lock_guard<mutex> lock(g_app_data_mutex);
 309         int num_client = g_app_list.size();
 310         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Number of clients(%d)", num_client);
 311
 312         return num_client;
 313 }
 314
 315 int ttsd_data_get_pid(unsigned int uid)
 316 {
 317         lock_guard<mutex> lock(g_app_data_mutex);
 318         app_data_s* app_data = get_client_app_data(uid);
 319         if (nullptr == app_data) {
 320                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 321                 return -1;
 322         }
 323
 324         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u), pid(%d)", uid, app_data->pid);
 325
 326         return app_data->pid;
 327 }
 328
 329 tts_ipc_method_e ttsd_data_get_ipc_method(unsigned int uid)
 330 {
 331         lock_guard<mutex> lock(g_app_data_mutex);
 332         app_data_s* app_data = get_client_app_data(uid);
 333         if (nullptr == app_data) {
 334                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 335                 return TTS_IPC_METHOD_UNDEFINED;
 336         }
 337
 338         return app_data->ipc_method;
 339 }
 340
 341 ttsd_mode_e ttsd_data_get_mode(unsigned int uid)
 342 {
 343         lock_guard<mutex> lock(g_app_data_mutex);
 344         app_data_s* app_data = get_client_app_data(uid);
 345         if (nullptr == app_data) {
 346                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 347                 return TTSD_MODE_DEFAULT;
 348         }
 349
 350         return app_data->mode;
 351 }
 352
 353 ttsd_playing_mode_e ttsd_data_get_playing_mode(unsigned int uid)
 354 {
 355         lock_guard<mutex> lock(g_app_data_mutex);
 356         app_data_s* app_data = get_client_app_data(uid);
 357         if (nullptr == app_data) {
 358                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 359                 return TTSD_PLAYING_MODE_BY_SERVICE;
 360         }
 361
 362         return app_data->playing_mode;
 363 }
 364
 365 int ttsd_data_set_credential(unsigned int uid, const char* credential)
 366 {
 367         lock_guard<mutex> lock(g_app_data_mutex);
 368         app_data_s* app_data = get_client_app_data(uid);
 369         if (nullptr == app_data) {
 370                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 371                 return TTSD_ERROR_INVALID_PARAMETER;
 372         }
 373
 374         free(app_data->credential);
 375         app_data->credential = nullptr;
 376
 377         if (credential) {
 378                 app_data->credential = strdup(credential);
 379         }
 380
 381         return TTSD_ERROR_NONE;
 382 }
 383
 384 char* ttsd_data_get_credential(unsigned int uid)
 385 {
 386         lock_guard<mutex> lock(g_app_data_mutex);
 387         app_data_s* app_data = get_client_app_data(uid);
 388         if (nullptr == app_data) {
 389                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 390                 return nullptr;
 391         }
 392
 393         if (nullptr == app_data->credential) {
 394                 return nullptr;
 395         }
 396
 397         return strdup(app_data->credential);
 398 }
 399
 400 int ttsd_data_get_speak_data_size(unsigned int uid)
 401 {
 402         lock_guard<mutex> lock(g_app_data_mutex);
 403         app_data_s* app_data = get_client_app_data(uid);
 404         if (nullptr == app_data) {
 405                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 406                 return TTSD_ERROR_INVALID_PARAMETER;
 407         }
 408
 409         return app_data->m_speak_data.size();
 410 }
 411
 412 int ttsd_data_set_used_voice(unsigned int uid, const char* lang, int type)
 413 {
 414         lock_guard<mutex> lock(g_app_data_mutex);
 415         app_data_s* app_data = get_client_app_data(uid);
 416         if (nullptr == app_data) {
 417                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 418                 return TTSD_ERROR_INVALID_PARAMETER;
 419         }
 420
 421         /* Find voice */
 422         list<used_voice_s>& usedVoices = app_data->m_used_voice;
 423         for (auto& voice : usedVoices) {
 424                 if (0 == strncmp(lang, voice.lang, strlen(lang)) && type == voice.vctype) {
 425                         SLOG(LOG_DEBUG, tts_tag(), "[DATA] The voice is already registered (%s)(%d)", lang, type);
 426                         return 0;
 427                 }
 428         }
 429
 430         /* Add voice */
 431         used_voice_s used_voice;
 432         used_voice.lang = strdup(lang);
 433         used_voice.vctype = type;
 434
 435         try {
 436                 usedVoices.push_back(used_voice);
 437         } catch (const std::bad_alloc&) {
 438                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_used_voice (bad_alloc)");
 439                 return -1;
 440         }
 441         SLOG(LOG_ERROR, tts_tag(), "[DATA] lang(%s), vctype(%d)", used_voice.lang, used_voice.vctype);
 442
 443 #ifdef DATA_DEBUG
 444         show_used_voice_list(*app_data);
 445 #endif
 446
 447         return -1;      /* Need to load voice*/
 448 }
 449
 450 int ttsd_data_reset_used_voice(unsigned int uid, ttsd_used_voice_cb callback)
 451 {
 452         unique_lock<mutex> lock(g_app_data_mutex);
 453         app_data_s* app_data = get_client_app_data(uid);
 454         if (nullptr == app_data) {
 455                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 456                 return TTSD_ERROR_INVALID_PARAMETER;
 457         }
 458
 459         if (nullptr == callback) {
 460                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] Used voice callback is nullptr");
 461         }
 462
 463         /* Find voice */
 464         list<used_voice_s>& usedVoices = app_data->m_used_voice;
 465         for (auto& voice : usedVoices) {
 466                 if (nullptr != callback) {
 467                         lock.unlock();
 468                         callback(voice.lang, voice.vctype);
 469                         lock.lock();
 470                 }
 471
 472                 if (nullptr != voice.lang) {
 473                         free(voice.lang);
 474                         voice.lang = nullptr;
 475                 }
 476         }
 477         usedVoices.clear();
 478
 479 #ifdef DATA_DEBUG
 480         show_used_voice_list(*app_data);
 481 #endif
 482
 483         return TTSD_ERROR_NONE;
 484 }
 485
 486 speak_data_s* ttsd_data_create_speak_data(const char* text, const char* language, int voice_type, int speed, int pitch, double volume, double background_volume_ratio, int utt_id, bool is_silent, unsigned int duration_in_msec)
 487 {
 488         speak_data_s* speak_data = new speak_data_s();
 489         if (nullptr == speak_data) {
 490                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory for speak_data_s");
 491                 return nullptr;
 492         }
 493
 494         if (text == NULL) {
 495                 speak_data->text = nullptr;
 496                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] text of speak_data for silent generation is null");
 497         } else {
 498                 speak_data->text = strdup(text);
 499         }
 500
 501         if (language == NULL) {
 502                 speak_data->voice.language = nullptr;
 503                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] lang of speak_data for silent generation is null");
 504         } else {
 505                 speak_data->voice.language = strdup(language);
 506         }
 507
 508         speak_data->voice.ptts_id = nullptr;
 509         speak_data->voice.type = voice_type;
 510
 511         speak_data->synth_parameter.speed = speed;
 512         speak_data->synth_parameter.pitch = pitch;
 513         speak_data->synth_parameter.volume = -1.0;
 514         speak_data->synth_parameter.background_volume_ratio = -1.0;
 515
 516         speak_data->utt_id = utt_id;
 517         speak_data->is_silent = is_silent;
 518         speak_data->duration_in_msec = duration_in_msec;
 519
 520         return speak_data;
 521 }
 522
 523 void ttsd_data_destroy_speak_data(speak_data_s* speak_data)
 524 {
 525         if (nullptr == speak_data) {
 526                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] data is nullptr");
 527                 return;
 528         }
 529         destroy_speak_data(speak_data);
 530 }
 531
 532 int ttsd_data_add_speak_data(unsigned int uid, speak_data_s* data)
 533 {
 534         lock_guard<mutex> lock(g_app_data_mutex);
 535         app_data_s* app_data = get_client_app_data(uid);
 536         if (nullptr == app_data) {
 537                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 538                 return TTSD_ERROR_INVALID_PARAMETER;
 539         }
 540
 541         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
 542
 543         try {
 544                 list<speak_data_s*>& speakData = app_data->m_speak_data;
 545                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] m_speak_data size(%zu)", speakData.size());
 546                 speakData.push_back(data);
 547         } catch (const std::bad_alloc&) {
 548                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_speak_data (bad_alloc)");
 549                 return TTSD_ERROR_OUT_OF_MEMORY;
 550         }
 551
 552         SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), text(%s), lang(%s), vctype(%d), speed(%d)",
 553                  data, data->utt_id, data->text, data->voice.language, data->voice.type, data->synth_parameter.speed);
 554
 555         if (1 == data->utt_id)
 556                 app_data->utt_id_stopped = 0;
 557
 558 #ifdef DATA_DEBUG
 559         show_text_list(*app_data);
 560 #endif
 561
 562         return TTSD_ERROR_NONE;
 563 }
 564
 565 static speak_data_s* get_speak_data(app_data_s* app_data)
 566 {
 567         if (app_data->m_speak_data.empty()) {
 568 #ifdef DATA_DEBUG
 569                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
 570 #endif
 571                 return nullptr;
 572         }
 573
 574 #ifdef DATA_DEBUG
 575         show_text_list(*app_data);
 576 #endif
 577
 578         return app_data->m_speak_data.front();
 579 }
 580
 581 int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data)
 582 {
 583         lock_guard<mutex> lock(g_app_data_mutex);
 584         app_data_s* app_data = get_client_app_data(uid);
 585         if (nullptr == app_data) {
 586                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 587                 return TTSD_ERROR_INVALID_PARAMETER;
 588         }
 589
 590         speak_data_s* speakData = get_speak_data(app_data);
 591         if (nullptr == speakData) {
 592                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
 593                 return TTSD_ERROR_OPERATION_FAILED;
 594         }
 595
 596         app_data->m_speak_data.pop_front();
 597         *data = speakData;
 598
 599         return TTSD_ERROR_NONE;
 600 }
 601
 602 sound_data_s* ttsd_data_create_sound_data(int utt_id, const void* data, unsigned int data_size, ttse_result_event_e event,
 603                 ttse_audio_type_e audio_type, int rate, int channels)
 604 {
 605         /* add wav data */
 606         sound_data_s* sound_data = new sound_data_s();
 607         if (nullptr == sound_data) {
 608                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory for speak_data_s");
 609                 return nullptr;
 610         }
 611
 612         sound_data->data = nullptr;
 613         sound_data->data_size = 0;
 614
 615         if (nullptr != data && 0 < data_size) {
 616                 sound_data->data = new char[data_size];
 617                 if (nullptr != sound_data->data) {
 618                         memcpy(sound_data->data, data, data_size);
 619                         sound_data->data_size = data_size;
 620                         SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] event(%d) sound_data(%p) data(%p) size(%u)",
 621                                 event, sound_data, sound_data->data, sound_data->data_size);
 622                 } else {
 623                         SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
 624                 }
 625         } else {
 626                 SLOG(LOG_ERROR, tts_tag(), "Sound data is nullptr");
 627         }
 628
 629         sound_data->utt_id = utt_id;
 630         sound_data->event = event;
 631         sound_data->audio_type = audio_type;
 632         sound_data->rate = rate;
 633         sound_data->channels = channels;
 634         sound_data->played_data_size = 0;
 635
 636         return sound_data;
 637 }
 638
 639 void ttsd_data_destroy_sound_data(sound_data_s* sound_data)
 640 {
 641         if (nullptr == sound_data) {
 642                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] data is nullptr");
 643                 return;
 644         }
 645
 646         destroy_sound_data(sound_data);
 647 }
 648
 649 int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data)
 650 {
 651         lock_guard<mutex> lock(g_app_data_mutex);
 652         app_data_s* app_data = get_client_app_data(uid);
 653         if (nullptr == app_data) {
 654                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 655                 return TTSD_ERROR_INVALID_PARAMETER;
 656         }
 657
 658         if (nullptr == data) {
 659                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] sound data is nullptr");
 660                 return TTSD_ERROR_INVALID_PARAMETER;
 661         }
 662
 663         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
 664
 665         try {
 666                 list<sound_data_s*>& wavData = app_data->m_wav_data;
 667                 SLOG(LOG_INFO, tts_tag(), "[DATA INFO] m_wav_data size(%zu)", wavData.size());
 668                 wavData.push_back(data);
 669         } catch (const std::bad_alloc&) {
 670                 SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_sound_data (bad_alloc)");
 671                 return TTSD_ERROR_OUT_OF_MEMORY;
 672         }
 673         SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), data(%p) data size(%d), type(%d)",
 674                         data, data->utt_id, data->data, data->data_size, data->audio_type);
 675
 676 #ifdef DATA_DEBUG
 677         show_sound_list(*app_data);
 678 #endif
 679
 680         return TTSD_ERROR_NONE;
 681 }
 682
 683 static sound_data_s* __get_sound_data(app_data_s* app_data)
 684 {
 685         if (app_data->m_wav_data.empty()) {
 686 #ifdef DATA_DEBUG
 687                 SLOG(LOG_DEBUG, tts_tag(), "[DATA] There is no wav data");
 688 #endif
 689                 return nullptr;
 690         }
 691
 692 #ifdef DATA_DEBUG
 693         show_sound_list(*app_data);
 694 #endif
 695
 696         return app_data->m_wav_data.front();
 697 }
 698
 699 sound_data_s* ttsd_data_get_first_sound_data(unsigned int uid)
 700 {
 701         lock_guard<mutex> lock(g_app_data_mutex);
 702         app_data_s* app_data = get_client_app_data(uid);
 703         if (nullptr == app_data) {
 704                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 705                 return nullptr;
 706         }
 707
 708         sound_data_s* soundData = __get_sound_data(app_data);
 709         if (nullptr == soundData) {
 710                 SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no sound data");
 711                 return nullptr;
 712         }
 713
 714         app_data->m_wav_data.pop_front();
 715         return soundData;
 716 }
 717
 718 int ttsd_data_get_sound_data_size(unsigned int uid)
 719 {
 720         lock_guard<mutex> lock(g_app_data_mutex);
 721         app_data_s* app_data = get_client_app_data(uid);
 722         if (nullptr == app_data) {
 723                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 724                 return -1;
 725         }
 726
 727         return app_data->m_wav_data.size();
 728 }
 729
 730 int ttsd_data_set_last_sound_result_event(unsigned int uid, ttse_result_event_e event)
 731 {
 732         lock_guard<mutex> lock(g_app_data_mutex);
 733         app_data_s* app_data = get_client_app_data(uid);
 734         if (nullptr == app_data) {
 735                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 736                 return TTSE_ERROR_INVALID_PARAMETER;
 737         }
 738
 739         app_data->result_event = event;
 740         return TTSE_ERROR_NONE;
 741 }
 742
 743 ttse_result_event_e ttsd_data_get_last_sound_result_event(unsigned int uid)
 744 {
 745         lock_guard<mutex> lock(g_app_data_mutex);
 746         app_data_s* app_data = get_client_app_data(uid);
 747         if (nullptr == app_data) {
 748                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 749                 return TTSE_RESULT_EVENT_FAIL;
 750         }
 751
 752         return app_data->result_event;
 753 }
 754
 755 int ttsd_data_clear_data(unsigned int uid)
 756 {
 757         lock_guard<mutex> lock(g_app_data_mutex);
 758         app_data_s* app_data = get_client_app_data(uid);
 759         if (nullptr == app_data) {
 760                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 761                 return TTSD_ERROR_INVALID_PARAMETER;
 762         }
 763
 764         clean_data(*app_data);
 765
 766         return TTSD_ERROR_NONE;
 767 }
 768
 769 app_tts_state_e ttsd_data_get_client_state(unsigned int uid)
 770 {
 771         lock_guard<mutex> lock(g_app_data_mutex);
 772         app_data_s* app_data = get_client_app_data(uid);
 773         if (nullptr == app_data) {
 774                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 775                 return APP_STATE_NONE;
 776         }
 777
 778         return app_data->state;
 779 }
 780
 781 static unsigned int __get_playing_app_uid()
 782 {
 783         for (auto& app : g_app_list) {
 784                 if (APP_STATE_PLAYING == app.state) {
 785                         return app.uid;
 786                 }
 787         }
 788
 789         return -1;
 790 }
 791
 792 int ttsd_data_set_client_state(unsigned int uid, app_tts_state_e state)
 793 {
 794         lock_guard<mutex> lock(g_app_data_mutex);
 795         app_data_s* app_data = get_client_app_data(uid);
 796         if (nullptr == app_data) {
 797                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 798                 return TTSD_ERROR_INVALID_PARAMETER;
 799         }
 800
 801         if (app_data->state == state) {
 802                 SLOG(LOG_ERROR, tts_tag(), "[DATA] Already current state. (%d)", state);
 803                 return TTSD_ERROR_NONE;
 804         }
 805
 806         /* The client of playing state of all clients is only one. need to check state. */
 807         int playing_uid = __get_playing_app_uid();
 808         if (APP_STATE_PLAYING == state && 0 < playing_uid) {
 809                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] A playing client has already existed. playing app uid(%u)", playing_uid);
 810                 return TTSD_ERROR_OPERATION_FAILED;
 811         }
 812
 813         app_data->state = state;
 814
 815         return TTSD_ERROR_NONE;
 816 }
 817
 818 tts_app_play_type_e ttsd_data_get_play_type(unsigned int uid)
 819 {
 820         lock_guard<mutex> lock(g_app_data_mutex);
 821         app_data_s* app_data = get_client_app_data(uid);
 822         if (nullptr == app_data) {
 823                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 824                 return TTS_APP_PLAY_TYPE_SYNTH;
 825         }
 826
 827         return app_data->type;
 828 }
 829
 830 int ttsd_data_set_play_type(unsigned int uid, tts_app_play_type_e type)
 831 {
 832         lock_guard<mutex> lock(g_app_data_mutex);
 833         app_data_s* app_data = get_client_app_data(uid);
 834         if (nullptr == app_data) {
 835                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 836                 return TTSD_ERROR_INVALID_PARAMETER;
 837         }
 838
 839         app_data->type = type;
 840
 841         return TTSD_ERROR_NONE;
 842 }
 843
 844 int ttsd_data_set_paused_data(unsigned int uid, sound_data_s* sound_data)
 845 {
 846         lock_guard<mutex> lock(g_app_data_mutex);
 847         app_data_s* app_data = get_client_app_data(uid);
 848         if (nullptr == app_data) {
 849                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 850                 return TTSD_ERROR_INVALID_PARAMETER;
 851         }
 852
 853         if (sound_data) {
 854                 app_data->m_wav_data.push_front(sound_data);
 855                 app_data->paused_data_existing = true;
 856         } else {
 857                 app_data->paused_data_existing = false;
 858         }
 859
 860         return TTSD_ERROR_NONE;
 861 }
 862
 863 bool ttsd_data_is_paused_data_existing(unsigned int uid)
 864 {
 865         lock_guard<mutex> lock(g_app_data_mutex);
 866         app_data_s* app_data = get_client_app_data(uid);
 867         if (nullptr == app_data) {
 868                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 869                 return false;
 870         }
 871
 872         return app_data->paused_data_existing;
 873 }
 874
 875 bool ttsd_data_is_service_state_changed_cb_set(unsigned int uid)
 876 {
 877         lock_guard<mutex> lock(g_app_data_mutex);
 878         app_data_s* app_data = get_client_app_data(uid);
 879         if (nullptr == app_data) {
 880                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 881                 return false;
 882         }
 883
 884         bool is_service_state_changed_cb_set = ((app_data->registered_event_mask & TTS_EVENT_MASK_SERVICE_STATE_CHANGED) != 0);
 885         return is_service_state_changed_cb_set;
 886 }
 887
 888 unsigned int ttsd_data_get_current_playing()
 889 {
 890         lock_guard<mutex> lock(g_app_data_mutex);
 891         unsigned int uid = __get_playing_app_uid();
 892
 893         SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Current playing uid(%u)", uid);
 894
 895         return uid;
 896 }
 897
 898 int ttsd_data_foreach_clients(ttsd_data_get_client_cb callback, void* user_data)
 899 {
 900         if (nullptr == callback) {
 901                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] input data is nullptr!!");
 902                 return -1;
 903         }
 904
 905 #ifdef DATA_DEBUG
 906         show_client_list();
 907 #endif
 908
 909         /* Copy app info */
 910         vector<app_data_s> temp_app_list;
 911
 912         unique_lock<mutex> lock(g_app_data_mutex);
 913         int vsize = g_app_list.size();
 914         for (int i = 0; i < vsize; i++) {
 915                 app_data_s app = {0, };
 916                 app.pid = g_app_list[i].pid;
 917                 app.uid = g_app_list[i].uid;
 918                 app.utt_id_stopped = 0;
 919                 app.state = g_app_list[i].state;
 920
 921                 temp_app_list.push_back(app);
 922         }
 923         lock.unlock();
 924
 925         for (int i = 0; i < vsize; i++) {
 926                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state);
 927                 if (false == callback(temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state, user_data)) {
 928                         break;
 929                 }
 930         }
 931
 932         return 0;
 933 }
 934
 935 unsigned int ttsd_data_get_first_client_uid()
 936 {
 937         unique_lock<mutex> lock(g_app_data_mutex);
 938         if (g_app_list.empty()) {
 939                 SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] There is no valid client");
 940                 return TTS_INVALID_UID;
 941         }
 942
 943         return g_app_list[0].uid;
 944 }
 945
 946 bool ttsd_data_is_uttid_valid(unsigned int uid, int uttid)
 947 {
 948         lock_guard<mutex> lock(g_app_data_mutex);
 949         app_data_s* app_data = get_client_app_data(uid);
 950         if (nullptr == app_data) {
 951                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
 952                 return false;
 953         }
 954
 955         if (uttid < app_data->utt_id_stopped)
 956                 return false;
 957
 958         return true;
 959 }
 960
 961 int ttsd_data_get_same_pid_client_count(int pid)
 962 {
 963         lock_guard<mutex> lock(g_app_data_mutex);
 964         int number = 0;
 965         for (auto& appData : g_app_list) {
 966                 if(appData.pid == pid) {
 967                         number++;
 968                 }
 969         }
 970
 971         return number;
 972 }
 973
 974 int ttsd_data_get_activated_mode()
 975 {
 976         lock_guard<mutex> lock(g_app_data_mutex);
 977         return g_activated_modes.getModes();
 978 }
 979
 980 int ttsd_data_save_error_log(unsigned int uid, FILE* fp)
 981 {
 982         lock_guard<mutex> lock(g_app_data_mutex);
 983         app_data_s* app_data = get_client_app_data(uid);
 984         if (nullptr == app_data) {
 985                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid client");
 986                 return -1;
 987         }
 988
 989         /* pid */
 990         fprintf(fp, "pid - %d", app_data->pid);
 991
 992         /* app state */
 993         fprintf(fp, "app state - %d", app_data->state);
 994
 995         /* get sound data */
 996         fprintf(fp, "----- Sound list -----");
 997         unsigned int i = 0;
 998         for (auto& wavData : app_data->m_wav_data) {
 999                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
1000                                 i, wavData, wavData->data, wavData->data_size, wavData->utt_id, wavData->audio_type);
1001                 i++;
1002         }
1003         fprintf(fp, "----------------------");
1004
1005         /* get speck data */
1006         fprintf(fp, "----- Text list -----");
1007
1008         i = 0;
1009         for (auto& speakData : app_data->m_speak_data) {
1010                 SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)",
1011                          i, speakData, speakData->voice.language, speakData->voice.type, speakData->synth_parameter.speed,
1012                          speakData->utt_id, speakData->text);
1013                 i++;
1014         }
1015         fprintf(fp, "---------------------");
1016
1017         return 0;
1018 }