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