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