server/ttsd_player.c

   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 <audio_io.h>
  15 #include <Ecore.h>
  16 #include <sound_manager.h>
  17 #include <sound_manager_internal.h>
  18
  19 #include "ttsd_main.h"
  20 #include "ttsd_player.h"
  21 #include "ttsd_data.h"
  22 #include "ttsd_dbus.h"
  23
  24 #include "tts_internal.h"
  25 #include "ttsd_server.h"
  26
  27 /*
  28 * Internal data structure
  29 */
  30
  31 typedef enum {
  32         AUDIO_STATE_NONE = 0,
  33         AUDIO_STATE_READY,
  34         AUDIO_STATE_PLAY
  35 } audio_state_e;
  36
  37 typedef struct {
  38         int                     uid;    /** client id */
  39         app_tts_state_e         state;  /** client state */
  40
  41         /* Current utterance information */
  42         ttse_result_event_e     event;  /** event of last utterance */
  43
  44         bool                    is_paused_data;
  45         int                     idx;
  46         sound_data_s*           paused_data;
  47 } player_s;
  48
  49 #define SOUND_BUFFER_LENGTH     2048
  50 #define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
  51
  52 /* Sound buf save for test */
  53 /*
  54 #define BUF_SAVE_MODE
  55 */
  56 #ifdef BUF_SAVE_MODE
  57 static char g_temp_file_name[128] = {'\0',};
  58
  59 static FILE* g_pFile;
  60
  61 static int g_count = 1;
  62 #endif
  63
  64 /** player init info */
  65 static bool g_player_init = false;
  66
  67 /** Client list */
  68 static GList *g_player_list;
  69
  70 /** current player information */
  71 static player_s* g_playing_info;
  72
  73 /* player state */
  74 static audio_state_e g_audio_state;
  75
  76 static ttse_audio_type_e g_audio_type;
  77
  78 static int g_sampling_rate;
  79
  80 static audio_out_h g_audio_h;
  81
  82 static sound_stream_info_h g_stream_info_h;
  83
  84 static sound_stream_ducking_h g_media_stream_ducking;
  85 static sound_stream_ducking_h g_system_stream_ducking;
  86 static sound_stream_ducking_h g_notification_stream_ducking;
  87 static sound_stream_ducking_h g_alarm_stream_ducking;
  88
  89 // static bool ducking_flag;
  90
  91 #define SND_MGR_DUCKING_DURATION 500
  92
  93 static int g_focus_watch_id;
  94
  95 static double g_bg_volume_ratio;
  96
  97 /*
  98 * Internal Interfaces
  99 */
 100
 101 player_s* __player_get_item(int uid)
 102 {
 103         GList *iter = NULL;
 104         player_s *data = NULL;
 105
 106         if (0 < g_list_length(g_player_list)) {
 107                 /* Get a first item */
 108                 iter = g_list_first(g_player_list);
 109
 110                 while (NULL != iter) {
 111                         /* Get handle data from list */
 112                         data = (player_s*)iter->data;
 113
 114                         /* compare uid */
 115                         if (uid == data->uid)
 116                                 return data;
 117
 118                         /* Get next item */
 119                         iter = g_list_next(iter);
 120                 }
 121         }
 122
 123         return NULL;
 124 }
 125
 126 void __player_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
 127                                                         sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
 128 {
 129         SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
 130
 131         if (stream_info != g_stream_info_h) {
 132                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
 133                 return;
 134         }
 135         SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d) and extra info(%s)", (int)focus_state, (int)reason_for_change, extra_info);
 136
 137         if (NULL == g_playing_info) {
 138                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
 139                 return;
 140         }
 141
 142         if (APP_STATE_PLAYING == g_playing_info->state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
 143                 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
 144                         g_audio_state = AUDIO_STATE_READY;
 145
 146                         int uid = g_playing_info->uid;
 147
 148                         if (0 != ttsd_player_pause(uid)) {
 149                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
 150                                 return;
 151                         }
 152
 153                         ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
 154                         int pid = ttsd_data_get_pid(uid);
 155                         /* send message to client about changing state */
 156                         ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
 157                 } else {
 158                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
 159                 }
 160         }
 161
 162 /*      if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
 163                 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
 164                         g_audio_state = AUDIO_STATE_PLAY;
 165
 166                         if (NULL == g_playing_info) {
 167                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
 168                                 return;
 169                         }
 170
 171                         if (APP_STATE_PAUSED == g_playing_info->state) {
 172                                 int uid = g_playing_info->uid;
 173
 174                                 g_audio_state = AUDIO_STATE_PLAY;
 175                                 if (0 != ttsd_player_resume(uid)) {
 176                                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
 177                                         g_audio_state = AUDIO_STATE_READY;
 178                                         return;
 179                                 }
 180
 181                                 ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
 182                                 int pid = ttsd_data_get_pid(uid);
 183                                 ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
 184                         }
 185
 186                 } else {
 187                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
 188                 }
 189         }
 190 */
 191         SLOG(LOG_DEBUG, tts_tag(), "@@@");
 192
 193         return;
 194 }
 195
 196 void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason,
 197                                                                 const char *extra_info, void *user_data)
 198 {
 199         SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
 200
 201         ttsd_mode_e mode = ttsd_get_mode();
 202
 203         if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
 204                 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
 205                 return;
 206         }
 207
 208         if (NULL == g_playing_info) {
 209                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
 210                 return;
 211         }
 212
 213         if (APP_STATE_PLAYING == g_playing_info->state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason &&
 214                         NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
 215                 /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
 216                 g_audio_state = AUDIO_STATE_READY;
 217
 218                 int uid = g_playing_info->uid;
 219
 220                 if (0 != ttsd_server_stop(uid)) {
 221                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
 222                         return;
 223                 }
 224                 if (0 != ttsd_player_stop(uid)) {
 225                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
 226                         return;
 227                 }
 228
 229                 ttsd_data_set_client_state(uid, APP_STATE_READY);
 230                 int pid = ttsd_data_get_pid(uid);
 231                 /* send message to client about changing state */
 232                 ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
 233         } else {
 234                 SLOG(LOG_DEBUG, tts_tag(), "[Player] Extra info is not Interrupt mode(%s) or not playing state(%d).", extra_info, g_playing_info->state);
 235         }
 236
 237         return;
 238 }
 239
 240 void __sound_stream_ducking_state_changed_cb(sound_stream_ducking_h stream_ducking, bool is_ducked, void *user_data)
 241 {
 242         SLOG(LOG_DEBUG, tts_tag(), "@@@ ducking state changed cb");
 243         SLOG(LOG_DEBUG, tts_tag(), "[Player] is ducked : %d", is_ducked);
 244         // ducking_flag = true;
 245         return;
 246 }
 247
 248 static char* __get_ducking_stream(sound_stream_type_e stream_type)
 249 {
 250         if (SOUND_STREAM_TYPE_MEDIA == stream_type)
 251                 return "Media stream";
 252         else if (SOUND_STREAM_TYPE_SYSTEM == stream_type)
 253                 return "System stream";
 254         else if (SOUND_STREAM_TYPE_NOTIFICATION == stream_type)
 255                 return "Notification stream";
 256         else if (SOUND_STREAM_TYPE_ALARM == stream_type)
 257                 return "Alarm stream";
 258         return "Non matched stream";
 259 }
 260
 261 static int __activate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
 262 {
 263         bool is_ducked = false;
 264         int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
 265         if (is_ducked) {
 266                 SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already ducked", __get_ducking_stream(stream_type));
 267         } else {
 268                 ret = sound_manager_activate_ducking(stream_ducking_h, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio);
 269                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 270                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking for %s", __get_ducking_stream(stream_type));
 271                 } else {
 272                         SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Activate ducking for %s", __get_ducking_stream(stream_type));
 273                 }
 274         }
 275         return ret;
 276 }
 277
 278 static void __change_background_volume()
 279 {
 280         SLOG(LOG_INFO, tts_tag(), "[Player] volume ratio(%lf)", g_bg_volume_ratio);
 281         if (1.0 > g_bg_volume_ratio) {
 282                 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
 283                 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
 284                 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
 285                 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
 286         }
 287 }
 288
 289 static int __deactivate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
 290 {
 291         bool is_ducked = false;
 292         int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
 293         if (!is_ducked) {
 294                 SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already recovered from ducking", __get_ducking_stream(stream_type));
 295         } else {
 296                 ret = sound_manager_deactivate_ducking(stream_ducking_h);
 297                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 298                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking for %s", __get_ducking_stream(stream_type));
 299                 } else {
 300                         SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Deactivate ducking for %s", __get_ducking_stream(stream_type));
 301                 }
 302         }
 303         return ret;
 304 }
 305
 306 static void __recover_background_volume()
 307 {
 308         __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
 309         __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
 310         __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
 311         __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
 312 }
 313
 314 static int __create_audio_out(ttse_audio_type_e type, int rate)
 315 {
 316         int ret = -1;
 317         audio_sample_type_e sample_type;
 318
 319         if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
 320                 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
 321         } else {
 322                 sample_type = AUDIO_SAMPLE_TYPE_U8;
 323         }
 324
 325         ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
 326         if (AUDIO_IO_ERROR_NONE != ret) {
 327                 g_audio_state = AUDIO_STATE_NONE;
 328                 g_audio_h = NULL;
 329                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
 330                 return -1;
 331         } else {
 332                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
 333         }
 334
 335         g_audio_type = type;
 336         g_sampling_rate = rate;
 337
 338         g_audio_state = AUDIO_STATE_READY;
 339
 340         return 0;
 341 }
 342
 343 static int __destroy_audio_out()
 344 {
 345         if (NULL == g_audio_h) {
 346                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
 347                 return -1;
 348         }
 349
 350         int ret = -1;
 351         ret = audio_out_destroy(g_audio_h);
 352         if (AUDIO_IO_ERROR_NONE != ret) {
 353                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
 354                 return -1;
 355         } else {
 356                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
 357         }
 358
 359         g_audio_type = 0;
 360         g_sampling_rate = 0;
 361
 362         g_audio_state = AUDIO_STATE_NONE;
 363         g_audio_h = NULL;
 364
 365         return 0;
 366 }
 367
 368 static void __end_play_thread(void *data, Ecore_Thread *thread)
 369 {
 370         SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
 371
 372 #ifdef BUF_SAVE_MODE
 373         fclose(g_pFile);
 374 #endif
 375 }
 376
 377 static void __set_policy_for_playing(int volume)
 378 {
 379
 380         __change_background_volume();
 381
 382         /* Set stream info */
 383         int ret;
 384         ttsd_mode_e mode = ttsd_get_mode();
 385         if (TTSD_MODE_DEFAULT == mode) {
 386                 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
 387                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 388                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
 389                 } else {
 390                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
 391                 }
 392         } else if (TTSD_MODE_INTERRUPT == mode) {
 393                 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
 394                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 395                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
 396                 } else {
 397                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
 398                 }
 399         }
 400
 401         ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
 402         if (AUDIO_IO_ERROR_NONE != ret) {
 403                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
 404         }
 405
 406         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
 407
 408         return;
 409 }
 410
 411 static void __unset_policy_for_playing()
 412 {
 413         int ret;
 414         ttsd_mode_e mode = ttsd_get_mode();
 415         /* Unset stream info */
 416         if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
 417                 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
 418                 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
 419                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 420                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
 421                 }
 422
 423                 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
 424                         if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
 425                                 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
 426                                 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
 427                         }
 428
 429                         if (SOUND_MANAGER_ERROR_NONE != ret) {
 430                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
 431                         }
 432                 }
 433         }
 434
 435         __recover_background_volume();
 436
 437         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
 438
 439         return;
 440 }
 441
 442 int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
 443 {
 444         int ret;
 445         ttsd_mode_e mode = ttsd_get_mode();
 446
 447         if (TTSD_MODE_INTERRUPT != mode) {
 448                 /* check the current playback focus */
 449                 sound_stream_focus_change_reason_e reason;
 450                 int sound_behavior = 0;
 451                 char *extra_info = NULL;
 452
 453                 ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
 454
 455                 SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior);
 456
 457                 if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) {
 458                         if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
 459                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
 460                                 *is_current_interrupt = true;
 461
 462                                 free(extra_info);
 463                                 extra_info = NULL;
 464
 465                                 return TTSD_ERROR_NONE;
 466                         }
 467                 }
 468
 469                 if (NULL != extra_info) {
 470                         free(extra_info);
 471                         extra_info = NULL;
 472                 }
 473         }
 474
 475         *is_current_interrupt = false;
 476
 477         return TTSD_ERROR_NONE;
 478 }
 479
 480 static void __play_thread(void *data, Ecore_Thread *thread)
 481 {
 482         SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
 483
 484 #ifdef BUF_SAVE_MODE
 485         g_count++;
 486
 487         while (1) {
 488                 snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/tts_temp_%d_%d", getpid(), g_count);
 489                 int ret = access(g_temp_file_name, 0);
 490
 491                 if (0 == ret) {
 492                         SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File is already exist");
 493                         if (0 == remove(g_temp_file_name)) {
 494                                 SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Remove file");
 495                                 break;
 496                         } else {
 497                                 g_count++;
 498                         }
 499                 } else {
 500                         break;
 501                 }
 502         }
 503
 504         SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Temp file name=[%s]", g_temp_file_name);
 505
 506         /* open test file */
 507         g_pFile = fopen(g_temp_file_name, "wb+x");
 508         if (!g_pFile) {
 509                 SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File not found!");
 510                 return;
 511         }
 512 #endif
 513
 514         if (NULL == g_playing_info) {
 515                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
 516                 return;
 517         }
 518
 519         player_s* player = g_playing_info;
 520         sound_data_s* sound_data = NULL;
 521
 522         int ret = -1;
 523         int len = SOUND_BUFFER_LENGTH;
 524         int idx = 0;
 525
 526         /* set volume policy as 40% */
 527         __set_policy_for_playing(40);
 528         while (1) {
 529                 if (true == player->is_paused_data) {
 530                         /* Resume player */
 531                         sound_data = player->paused_data;
 532                         player->paused_data = NULL;
 533
 534                         idx = player->idx;
 535
 536                         player->is_paused_data = false;
 537                         player->idx = 0;
 538
 539                         if (NULL == sound_data) {
 540                                 /* Request unprepare */
 541                                 ret = audio_out_unprepare(g_audio_h);
 542                                 if (AUDIO_IO_ERROR_NONE != ret) {
 543                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 544                                 } else {
 545                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 546                                 }
 547
 548                                 g_audio_state = AUDIO_STATE_READY;
 549
 550                                 /* unset volume policy, volume will be 100% */
 551                                 __unset_policy_for_playing();
 552                                 return;
 553                         }
 554                         SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
 555                                 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
 556                 } else {
 557                         sound_data = NULL;
 558                         ret = ttsd_data_get_sound_data(player->uid, &sound_data);
 559                         if (0 != ret || NULL == sound_data) {
 560                                 /* empty queue */
 561                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
 562
 563                                 /* wait for new audio data come */
 564                                 while (1) {
 565                                         usleep(10000);
 566                                         if (NULL == g_playing_info) {
 567                                                 /* current playing uid is replaced */
 568                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
 569                                                 if (AUDIO_STATE_PLAY == g_audio_state) {
 570                                                         /* release audio & recover session */
 571                                                         ret = audio_out_unprepare(g_audio_h);
 572                                                         if (AUDIO_IO_ERROR_NONE != ret) {
 573                                                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 574                                                         } else {
 575                                                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 576                                                         }
 577                                                         g_audio_state = AUDIO_STATE_READY;
 578                                                 }
 579                                                 /* unset volume policy, volume will be 100% */
 580                                                 __unset_policy_for_playing();
 581                                                 return;
 582                                         } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
 583                                                 /* new audio data come */
 584                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
 585                                                 break;
 586                                         }
 587
 588                                         /* If engine is not on processing */
 589                                         if (TTSD_SYNTHESIS_CONTROL_DOING != ttsd_get_synth_control()) {
 590                                                 if (AUDIO_STATE_PLAY == g_audio_state) {
 591                                                         /* release audio & recover session */
 592                                                         ret = audio_out_unprepare(g_audio_h);
 593                                                         if (AUDIO_IO_ERROR_NONE != ret) {
 594                                                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 595                                                         } else {
 596                                                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 597                                                         }
 598                                                         g_audio_state = AUDIO_STATE_READY;
 599
 600                                                         /* unset volume policy, volume will be 100% */
 601                                                         __unset_policy_for_playing();
 602                                                 }
 603                                         }
 604                                 }
 605
 606                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
 607
 608                                 if (AUDIO_STATE_READY == g_audio_state) {
 609                                         /* set volume policy as 40%, when resume play thread*/
 610                                         __set_policy_for_playing(40);
 611                                 }
 612
 613                                 /* resume play thread */
 614                                 player->state = APP_STATE_PLAYING;
 615                                 continue;
 616                         }
 617
 618                         /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
 619                          * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
 620                          * When previous wdata's event is 'finish' and current wdata's event is 'finish',
 621                          * the player should send utt started event.
 622                          */
 623                         if (TTSE_RESULT_EVENT_START == sound_data->event ||
 624                            (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 625                                 int pid = ttsd_data_get_pid(player->uid);
 626
 627                                 if (pid <= 0) {
 628                                         SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 629                                         /* unset volume policy, volume will be 100% */
 630                                         __unset_policy_for_playing();
 631                                         ttsd_data_clear_sound_data(&sound_data);
 632                                         return;
 633                                 }
 634
 635                                 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
 636                                         SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
 637                                                 pid, player->uid, sound_data->utt_id);
 638                                 }
 639                                 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 640                         }
 641
 642                         /* Save last event to check utterance start */
 643                         player->event = sound_data->event;
 644                         idx = 0;
 645
 646                         if (NULL == sound_data->data || 0 >= sound_data->data_size) {
 647                                 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
 648                                         SLOG(LOG_DEBUG, tts_tag(), "No sound data");
 649                                         /* send utterence finish signal */
 650                                         int pid = ttsd_data_get_pid(player->uid);
 651
 652                                         if (pid <= 0) {
 653                                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 654                                                 /* unset volume policy, volume will be 100% */
 655                                                 __unset_policy_for_playing();
 656                                                 ttsd_data_clear_sound_data(&sound_data);
 657                                                 return;
 658                                         }
 659
 660                                         __unset_policy_for_playing();
 661
 662                                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
 663                                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
 664                                                         pid, player->uid, sound_data->utt_id);
 665                                         } else {
 666                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 667                                         }
 668                                 }
 669                                 SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%d), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
 670                                 ttsd_data_clear_sound_data(&sound_data);
 671                                 continue;
 672                         }
 673                 }
 674
 675                 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
 676                         SLOG(LOG_INFO, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
 677                         if (NULL != g_audio_h) {
 678                                 __destroy_audio_out();
 679                         }
 680
 681                         if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
 682                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
 683                                 /* unset volume policy, volume will be 100% */
 684                                 __unset_policy_for_playing();
 685
 686                                 ttsd_data_clear_sound_data(&sound_data);
 687
 688                                 return;
 689                         }
 690
 691                         SLOG(LOG_INFO, tts_tag(), "[Player INFO] Success to destroy and recreate audio out");
 692                         __set_policy_for_playing(40);
 693                 }
 694
 695                 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
 696                         if ((unsigned int)idx >= sound_data->data_size)
 697                                 break;
 698
 699                         if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
 700                                 len = sound_data->data_size - idx;
 701                         } else {
 702                                 len = SOUND_BUFFER_LENGTH;
 703                         }
 704
 705                         if (AUDIO_STATE_READY == g_audio_state) {
 706                                 /* Request prepare */
 707                                 ret = audio_out_prepare(g_audio_h);
 708                                 if (AUDIO_IO_ERROR_NONE != ret) {
 709                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
 710                                         g_playing_info = NULL;
 711                                         /* unset volume policy, volume will be 100% */
 712                                         __unset_policy_for_playing();
 713
 714                                         ttsd_data_clear_sound_data(&sound_data);
 715
 716                                         return;
 717                                 }
 718                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
 719                                 g_audio_state = AUDIO_STATE_PLAY;
 720                         }
 721
 722                         char* temp_data = sound_data->data;
 723                         SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)",
 724                                         temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len);
 725 #ifdef BUF_SAVE_MODE
 726                         /* write pcm buffer */
 727                         fwrite(&temp_data[idx], 1, len, g_pFile);
 728 #endif
 729                         ret = audio_out_write(g_audio_h, &temp_data[idx], len);
 730                         if (0 > ret) {
 731                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
 732                         } else {
 733                                 idx += len;
 734                                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] After audio_out_write");
 735                         }
 736
 737                         if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
 738                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
 739                                 g_audio_state = AUDIO_STATE_READY;
 740                                 ret = audio_out_unprepare(g_audio_h);
 741                                 if (AUDIO_IO_ERROR_NONE != ret) {
 742                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 743                                 }
 744                                 /* unset volume policy, volume will be 100% */
 745                                 __unset_policy_for_playing();
 746
 747                                 ttsd_data_clear_sound_data(&sound_data);
 748
 749                                 return;
 750                         }
 751
 752                         if (APP_STATE_PAUSED == player->state) {
 753                                 /* Save data */
 754                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] player(%p)", player);
 755                                 player->paused_data = sound_data;
 756
 757                                 player->is_paused_data = true;
 758                                 player->idx = idx;
 759
 760                                 g_audio_state = AUDIO_STATE_READY;
 761
 762                                 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
 763
 764                                 /* Request prepare */
 765                                 ret = audio_out_unprepare(g_audio_h);
 766                                 if (AUDIO_IO_ERROR_NONE != ret) {
 767                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 768                                 } else {
 769                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 770                                 }
 771                                 /* unset volume policy, volume will be 100% */
 772                                 __unset_policy_for_playing();
 773                                 return;
 774                         }
 775                 }
 776
 777                 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
 778                         /* player_stop */
 779                         g_audio_state = AUDIO_STATE_READY;
 780                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
 781
 782                         /* Request prepare */
 783                         ret = audio_out_unprepare(g_audio_h);
 784                         if (AUDIO_IO_ERROR_NONE != ret) {
 785                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 786                         } else {
 787                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 788                         }
 789
 790                         /* unset volume policy, volume will be 100% */
 791                         __unset_policy_for_playing();
 792                         ttsd_data_clear_sound_data(&sound_data);
 793                         return;
 794                 }
 795
 796                 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
 797                         (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 798                         /* send utterence finish signal */
 799                         int pid = ttsd_data_get_pid(player->uid);
 800
 801                         if (pid <= 0) {
 802                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 803                                 /* unset volume policy, volume will be 100% */
 804                                 __unset_policy_for_playing();
 805                                 ttsd_data_clear_sound_data(&sound_data);
 806                                 return;
 807                         }
 808
 809                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
 810                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
 811                                         pid, player->uid, sound_data->utt_id);
 812                                 /* unset volume policy, volume will be 100% */
 813                                 __unset_policy_for_playing();
 814                                 ttsd_data_clear_sound_data(&sound_data);
 815                                 return;
 816                         }
 817
 818                         SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 819                 }
 820
 821                 ttsd_data_clear_sound_data(&sound_data);
 822
 823                 if (NULL == g_playing_info) {
 824                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
 825                         g_audio_state = AUDIO_STATE_READY;
 826                         ret = audio_out_unprepare(g_audio_h);
 827                         if (AUDIO_IO_ERROR_NONE != ret) {
 828                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 829                         }
 830                         /* unset volume policy, volume will be 100% */
 831                         __unset_policy_for_playing();
 832                         ttsd_data_clear_sound_data(&sound_data);
 833                         return;
 834                 }
 835         }
 836 }
 837
 838 int __create_ducking_handle(void)
 839 {
 840         int ret = -1;
 841         if (NULL == g_media_stream_ducking) {
 842                 ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_media_stream_ducking);
 843                 if (SOUND_MANAGER_ERROR_NONE != ret)
 844                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for type media, ret(%d)", ret);
 845         } else {
 846                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
 847         }
 848         if (NULL == g_system_stream_ducking) {
 849                 ret = sound_manager_create_stream_ducking(SOUND_TYPE_SYSTEM, __sound_stream_ducking_state_changed_cb, NULL, &g_system_stream_ducking);
 850                 if (SOUND_MANAGER_ERROR_NONE != ret)
 851                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for system type, ret(%d)", ret);
 852         } else {
 853                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
 854         }
 855
 856         if (NULL == g_notification_stream_ducking) {
 857                 ret = sound_manager_create_stream_ducking(SOUND_TYPE_NOTIFICATION, __sound_stream_ducking_state_changed_cb, NULL, &g_notification_stream_ducking);
 858                 if (SOUND_MANAGER_ERROR_NONE != ret)
 859                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for notification type, ret(%d)", ret);
 860         } else {
 861                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
 862         }
 863
 864         if (NULL == g_alarm_stream_ducking) {
 865                 ret = sound_manager_create_stream_ducking(SOUND_TYPE_ALARM, __sound_stream_ducking_state_changed_cb, NULL, &g_alarm_stream_ducking);
 866                 if (SOUND_MANAGER_ERROR_NONE != ret)
 867                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for alarm type, ret(%d)", ret);
 868         } else {
 869                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
 870         }
 871
 872         return ret;
 873 }
 874
 875 /*
 876 * Player Interfaces
 877 */
 878 int ttsd_player_init()
 879 {
 880         g_playing_info = NULL;
 881         g_audio_state = AUDIO_STATE_NONE;
 882         g_audio_h = NULL;
 883
 884         int ret;
 885
 886         ecore_thread_max_set(1);
 887
 888         int cnt = 0;
 889         while (1) {
 890                 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
 891                         SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
 892                         break;
 893                 } else {
 894                         if (0 == cnt++ % 10)
 895                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
 896                         usleep(50000);
 897                 }
 898         }
 899
 900         ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
 901         if (SOUND_MANAGER_ERROR_NONE != ret) {
 902                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
 903                 return -1;
 904         } else {
 905                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
 906         }
 907
 908         /* add sound focus state watch callback */
 909         ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
 910         if (SOUND_MANAGER_ERROR_NONE != ret) {
 911                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
 912                 sound_manager_destroy_stream_information(g_stream_info_h);
 913                 return -1;
 914         } else {
 915                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
 916         }
 917
 918         ret = __create_ducking_handle();
 919         if (SOUND_MANAGER_ERROR_NONE != ret) {
 920                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create ducking handle, ret(%d)", ret);
 921         } else {
 922                 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Create ducking handle");
 923         }
 924
 925         ecore_thread_max_set(1);
 926
 927         ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
 928         if (0 != ret) {
 929                 sound_manager_destroy_stream_information(g_stream_info_h);
 930                 sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
 931                 return -1;
 932         }
 933
 934         g_player_init = true;
 935
 936         return 0;
 937 }
 938
 939 int __destroy_ducking_handle(void)
 940 {
 941         int ret = -1;
 942         if (g_media_stream_ducking) {
 943                 ret = sound_manager_destroy_stream_ducking(g_media_stream_ducking);
 944                 if (SOUND_MANAGER_ERROR_NONE != ret)
 945                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy media stream ducking, ret(%d)", ret);
 946                 g_media_stream_ducking = NULL;
 947         } else {
 948                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
 949         }
 950
 951         if (g_system_stream_ducking) {
 952                 ret = sound_manager_destroy_stream_ducking(g_system_stream_ducking);
 953                 if (SOUND_MANAGER_ERROR_NONE != ret)
 954                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy system stream ducking, ret(%d)", ret);
 955                 g_system_stream_ducking = NULL;
 956         } else {
 957                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
 958         }
 959
 960         if (g_notification_stream_ducking) {
 961                 ret = sound_manager_destroy_stream_ducking(g_notification_stream_ducking);
 962                 if (SOUND_MANAGER_ERROR_NONE != ret)
 963                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy notification stream ducking, ret(%d)", ret);
 964                 g_notification_stream_ducking = NULL;
 965         } else {
 966                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
 967         }
 968
 969         if (g_alarm_stream_ducking) {
 970                 ret = sound_manager_destroy_stream_ducking(g_alarm_stream_ducking);
 971                 if (SOUND_MANAGER_ERROR_NONE != ret)
 972                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy alarm stream ducking, ret(%d)", ret);
 973                 g_alarm_stream_ducking = NULL;
 974         } else {
 975                 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
 976         }
 977         return ret;
 978 }
 979
 980 int ttsd_player_release(void)
 981 {
 982         if (false == g_player_init) {
 983                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 984                 return TTSD_ERROR_OPERATION_FAILED;
 985         }
 986
 987         int ret;
 988
 989         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
 990         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
 991         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
 992
 993         /* The thread should be released */
 994         int thread_count = ecore_thread_active_get();
 995         int count = 0;
 996         while (0 < thread_count) {
 997                 usleep(10000);
 998
 999                 count++;
1000                 if (20 == count) {
1001                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1002                         break;
1003                 }
1004
1005                 thread_count = ecore_thread_active_get();
1006         }
1007
1008         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
1009
1010         ret = __destroy_audio_out();
1011         if (0 != ret)
1012                 return -1;
1013
1014         ret = sound_manager_destroy_stream_information(g_stream_info_h);
1015         if (SOUND_MANAGER_ERROR_NONE != ret) {
1016                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
1017         } else {
1018                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
1019         }
1020
1021         /* remove focus state watch callback */
1022         ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
1023         if (SOUND_MANAGER_ERROR_NONE != ret) {
1024                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
1025         } else {
1026                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
1027         }
1028
1029         ret = __destroy_ducking_handle();
1030         if (SOUND_MANAGER_ERROR_NONE != ret)
1031                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking, ret(%d)", ret);
1032         else
1033                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking");
1034
1035         /* clear g_player_list */
1036         g_playing_info = NULL;
1037         g_player_init = false;
1038
1039         return 0;
1040 }
1041
1042 int ttsd_player_create_instance(int uid)
1043 {
1044         if (false == g_player_init) {
1045                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1046                 return -1;
1047         }
1048
1049         /* Check uid is duplicated */
1050         if (NULL != __player_get_item(uid)) {
1051                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
1052                 return -1;
1053         }
1054
1055         player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
1056         if (NULL == new_client) {
1057                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
1058                 return TTSE_ERROR_OUT_OF_MEMORY;
1059         }
1060
1061         new_client->uid = uid;
1062         new_client->event = TTSE_RESULT_EVENT_FINISH;
1063         new_client->state = APP_STATE_READY;
1064         new_client->is_paused_data = false;
1065         new_client->idx = 0;
1066         new_client->paused_data = NULL;
1067
1068         SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
1069
1070         g_player_list = g_list_append(g_player_list, new_client);
1071
1072         return 0;
1073 }
1074
1075 int ttsd_player_destroy_instance(int uid)
1076 {
1077         if (false == g_player_init) {
1078                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1079                 return -1;
1080         }
1081
1082         player_s* current;
1083         current = __player_get_item(uid);
1084         if (NULL == current) {
1085                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1086                 return -1;
1087         }
1088
1089         if (NULL != g_playing_info) {
1090                 if (uid == g_playing_info->uid) {
1091                         g_playing_info = NULL;
1092                 }
1093         }
1094
1095         GList *iter = NULL;
1096         player_s *data = NULL;
1097
1098         if (0 < g_list_length(g_player_list)) {
1099                 /* Get a first item */
1100                 iter = g_list_first(g_player_list);
1101
1102                 while (NULL != iter) {
1103                         /* Get handle data from list */
1104                         data = (player_s*)iter->data;
1105
1106                         if (NULL != data) {
1107                                 /* compare uid */
1108                                 if (uid == data->uid) {
1109                                         g_player_list = g_list_remove_link(g_player_list, iter);
1110                                         free(data);
1111                                         g_list_free(iter);
1112                                         break;
1113                                 }
1114                         }
1115
1116                         /* Get next item */
1117                         iter = g_list_next(iter);
1118                 }
1119         }
1120
1121         SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
1122
1123         return 0;
1124 }
1125
1126 int ttsd_player_play(int uid)
1127 {
1128         if (false == g_player_init) {
1129                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1130                 return -1;
1131         }
1132
1133         if (NULL != g_playing_info) {
1134                 if (uid == g_playing_info->uid) {
1135                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1136                         return 0;
1137                 } else {
1138                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1139                         ttsd_player_stop(g_playing_info->uid);
1140                 }
1141         }
1142
1143         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1144
1145         /* Check sound queue size */
1146         if (0 == ttsd_data_get_sound_data_size(uid)) {
1147                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1148                 return -1;
1149         }
1150
1151         /* Check uid */
1152         player_s* current;
1153         current = __player_get_item(uid);
1154         if (NULL == current) {
1155                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1156                 return -1;
1157         }
1158
1159         current->state = APP_STATE_PLAYING;
1160
1161         g_playing_info = current;
1162
1163         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1164
1165         if (0 < ttsd_data_get_sound_data_size(current->uid)) {
1166                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1167                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1168         }
1169
1170         return 0;
1171 }
1172
1173 int ttsd_player_stop(int uid)
1174 {
1175         int ret = ttsd_player_clear(uid);
1176         if (0 != ret) {
1177                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to stop player, ret(%d)", ret);
1178                 return ret;
1179         }
1180
1181         /* check whether uid is current playing or not */
1182         if (NULL != g_playing_info) {
1183                 if (uid == g_playing_info->uid) {
1184                         /* release current playing info */
1185                         g_playing_info = NULL;
1186                 }
1187         } else {
1188                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
1189         }
1190
1191         if (NULL == g_playing_info) {
1192                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1193                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1194                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1195
1196                 /* The thread should be released */
1197                 int thread_count = ecore_thread_active_get();
1198                 int count = 0;
1199                 while (0 < thread_count) {
1200                         usleep(10000);
1201
1202                         count++;
1203                         if (30 == count) {
1204                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1205                                 break;
1206                         }
1207
1208                         thread_count = ecore_thread_active_get();
1209                 }
1210
1211                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1212                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1213                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1214         }
1215
1216         SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
1217
1218         return 0;
1219 }
1220
1221 int ttsd_player_clear(int uid)
1222 {
1223         if (false == g_player_init) {
1224                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1225                 return -1;
1226         }
1227
1228         /* Check uid */
1229         player_s* current;
1230         current = __player_get_item(uid);
1231         if (NULL == current) {
1232                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1233                 return -1;
1234         }
1235
1236         if (true == current->is_paused_data) {
1237                 if (NULL != current->paused_data) {
1238                         if (NULL != current->paused_data->data) {
1239                                 free(current->paused_data->data);
1240                                 current->paused_data->data = NULL;
1241                         }
1242
1243                         free(current->paused_data);
1244                         current->paused_data = NULL;
1245                 }
1246         }
1247
1248         current->event = TTSE_RESULT_EVENT_FINISH;
1249         current->state = APP_STATE_READY;
1250         current->is_paused_data = false;
1251         current->idx = 0;
1252
1253         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
1254
1255         return 0;
1256 }
1257
1258 int ttsd_player_pause(int uid)
1259 {
1260         SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
1261
1262         if (false == g_player_init) {
1263                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1264                 return -1;
1265         }
1266
1267         /* Check uid */
1268         player_s* current;
1269         current = __player_get_item(uid);
1270         if (NULL == current) {
1271                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
1272                 return -1;
1273         }
1274
1275         /* check whether uid is current playing or not */
1276         if (NULL != g_playing_info) {
1277                 if (uid == g_playing_info->uid) {
1278                         /* release current playing info */
1279                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%d)", uid);
1280                         g_playing_info = NULL;
1281                 } else {
1282                         /* error case */
1283                 }
1284         }
1285
1286         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current player (%p), g_playing_info(%p)", current, g_playing_info);
1287
1288         current->state = APP_STATE_PAUSED;
1289
1290         if (NULL == g_playing_info) {
1291                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1292                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1293                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1294
1295                 /* The thread should be released */
1296                 int thread_count = ecore_thread_active_get();
1297                 int count = 0;
1298                 while (0 < thread_count) {
1299                         usleep(10000);
1300
1301                         count++;
1302                         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current(%p), state(%d)", current, current->state);
1303
1304                         if (30 == count) {
1305                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue. current(%p) current state(%d)", current, current->state);
1306                                 break;
1307                         }
1308
1309                         thread_count = ecore_thread_active_get();
1310                 }
1311
1312                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1313                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1314                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1315         }
1316
1317
1318         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
1319
1320         return 0;
1321 }
1322
1323 int ttsd_player_resume(int uid)
1324 {
1325         SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
1326
1327         if (false == g_player_init) {
1328                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1329                 return -1;
1330         }
1331
1332         /* Check id */
1333         player_s* current;
1334         current = __player_get_item(uid);
1335         if (NULL == current) {
1336                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1337                 return -1;
1338         }
1339
1340         /* check current player */
1341         if (NULL != g_playing_info)
1342                 g_playing_info = NULL;
1343
1344         current->state = APP_STATE_PLAYING;
1345         g_playing_info = current;
1346
1347         SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1348         ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1349
1350         return 0;
1351 }
1352
1353 int ttsd_player_all_stop()
1354 {
1355         if (false == g_player_init) {
1356                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1357                 return -1;
1358         }
1359
1360         g_playing_info = NULL;
1361
1362         GList *iter = NULL;
1363         player_s *data = NULL;
1364
1365         if (0 < g_list_length(g_player_list)) {
1366                 /* Get a first item */
1367                 iter = g_list_first(g_player_list);
1368
1369                 while (NULL != iter) {
1370                         /* Get handle data from list */
1371                         data = (player_s*)iter->data;
1372
1373                         app_tts_state_e state;
1374                         if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1375                                 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1376                                 ttsd_player_destroy_instance(data->uid);
1377                                 iter = g_list_next(iter);
1378                                 continue;
1379                         }
1380
1381                         if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1382                                 data->event = TTSE_RESULT_EVENT_FINISH;
1383                                 data->state = APP_STATE_READY;
1384
1385                                 if (true == data->is_paused_data) {
1386                                         if (NULL != data->paused_data) {
1387                                                 if (NULL != data->paused_data->data) {
1388                                                         free(data->paused_data->data);
1389                                                         data->paused_data->data = NULL;
1390                                                 }
1391
1392                                                 free(data->paused_data);
1393                                                 data->paused_data = NULL;
1394                                         }
1395                                 }
1396
1397                                 data->is_paused_data = false;
1398                                 data->idx = 0;
1399                         }
1400
1401                         /* Get next item */
1402                         iter = g_list_next(iter);
1403                 }
1404         }
1405
1406         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
1407
1408         return 0;
1409 }
1410
1411 int ttsd_player_play_pcm(int uid)
1412 {
1413         if (false == g_player_init) {
1414                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1415                 return -1;
1416         }
1417
1418         if (NULL != g_playing_info) {
1419                 if (uid == g_playing_info->uid) {
1420                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1421                         return 0;
1422                 } else {
1423                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1424                         ttsd_player_stop(g_playing_info->uid);
1425                 }
1426         }
1427
1428         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1429
1430         /* Check sound queue size */
1431         if (0 == ttsd_data_get_sound_data_size(uid)) {
1432                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1433         }
1434
1435         /* Check uid */
1436         player_s* current;
1437         current = __player_get_item(uid);
1438         if (NULL == current) {
1439                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1440                 return -1;
1441         }
1442
1443         current->state = APP_STATE_PLAYING;
1444
1445         g_playing_info = current;
1446
1447         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1448
1449         if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
1450                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1451                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1452         }
1453
1454         return 0;
1455 }
1456
1457 int ttsd_player_get_background_volume_ratio(double* ratio)
1458 {
1459         if (NULL == ratio)
1460                 return -1;
1461         else
1462                 *ratio = g_bg_volume_ratio;
1463
1464         return TTSD_ERROR_NONE;
1465 }
1466
1467 int ttsd_player_set_background_volume_ratio(double ratio)
1468 {
1469         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] ttsd_player_set_background_volume_ratio : %lf", ratio);
1470
1471         g_bg_volume_ratio = ratio;
1472         return TTSD_ERROR_NONE;
1473 }