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