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 /*
  25 * Internal data structure
  26 */
  27
  28 typedef enum {
  29         AUDIO_STATE_NONE = 0,
  30         AUDIO_STATE_READY,
  31         AUDIO_STATE_PLAY
  32 } audio_state_e;
  33
  34 typedef struct {
  35         int                     uid;    /** client id */
  36         app_tts_state_e         state;  /** client state */
  37
  38         /* Current utterance information */
  39         ttse_result_event_e     event;  /** event of last utterance */
  40
  41         bool                    is_paused_data;
  42         int                     idx;
  43         sound_data_s*           paused_data;
  44 } player_s;
  45
  46 #define SOUND_BUFFER_LENGTH     2048
  47 #define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
  48
  49 /** player init info */
  50 static bool g_player_init = false;
  51
  52 /** Client list */
  53 static GList *g_player_list;
  54
  55 /** current player information */
  56 static player_s* g_playing_info;
  57
  58 /* player state */
  59 static audio_state_e g_audio_state;
  60
  61 static ttse_audio_type_e g_audio_type;
  62
  63 static int g_sampling_rate;
  64
  65 static audio_out_h g_audio_h;
  66
  67 static sound_stream_info_h g_stream_info_h;
  68
  69 /*
  70 * Internal Interfaces
  71 */
  72
  73 player_s* __player_get_item(int uid)
  74 {
  75         GList *iter = NULL;
  76         player_s *data = NULL;
  77
  78         if (0 < g_list_length(g_player_list)) {
  79                 /* Get a first item */
  80                 iter = g_list_first(g_player_list);
  81
  82                 while (NULL != iter) {
  83                         /* Get handle data from list */
  84                         data = (player_s*)iter->data;
  85
  86                         /* compare uid */
  87                         if (uid == data->uid)
  88                                 return data;
  89
  90                         /* Get next item */
  91                         iter = g_list_next(iter);
  92                 }
  93         }
  94
  95         return NULL;
  96 }
  97
  98 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,
  99                                                         sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
 100 {
 101         SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
 102
 103         if (stream_info != g_stream_info_h) {
 104                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
 105                 return;
 106         }
 107         SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d)", (int)focus_state, (int)reason_for_change);
 108
 109         if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
 110                 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
 111                         g_audio_state = AUDIO_STATE_READY;
 112
 113                         if (NULL == g_playing_info) {
 114                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
 115                                 return;
 116                         }
 117
 118                         if (APP_STATE_PLAYING == g_playing_info->state) {
 119                                 int uid = g_playing_info->uid;
 120
 121                                 if (0 != ttsd_player_pause(uid)) {
 122                                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
 123                                         return;
 124                                 }
 125
 126                                 ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
 127                                 int pid = ttsd_data_get_pid(uid);
 128                                 /* send message to client about changing state */
 129                                 ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
 130                         }
 131                 } else {
 132                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
 133                 }
 134         }
 135
 136         SLOG(LOG_DEBUG, tts_tag(), "@@@");
 137
 138         return;
 139 }
 140
 141 static int __create_audio_out(ttse_audio_type_e type, int rate)
 142 {
 143         int ret = -1;
 144         audio_sample_type_e sample_type;
 145
 146         if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
 147                 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
 148         } else {
 149                 sample_type = AUDIO_SAMPLE_TYPE_U8;
 150         }
 151
 152         ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
 153         if (AUDIO_IO_ERROR_NONE != ret) {
 154                 g_audio_state = AUDIO_STATE_NONE;
 155                 g_audio_h = NULL;
 156                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
 157                 return -1;
 158         } else {
 159                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
 160         }
 161
 162         g_audio_type = type;
 163         g_sampling_rate = rate;
 164
 165         g_audio_state = AUDIO_STATE_READY;
 166
 167         return 0;
 168 }
 169
 170 static int __destroy_audio_out()
 171 {
 172         if (NULL == g_audio_h) {
 173                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
 174                 return -1;
 175         }
 176
 177         int ret = -1;
 178         ret = audio_out_destroy(g_audio_h);
 179         if (AUDIO_IO_ERROR_NONE != ret) {
 180                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
 181                 return -1;
 182         } else {
 183                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
 184         }
 185
 186         g_audio_type = 0;
 187         g_sampling_rate = 0;
 188
 189         g_audio_state = AUDIO_STATE_NONE;
 190         g_audio_h = NULL;
 191
 192         return 0;
 193 }
 194
 195 static void __end_play_thread(void *data, Ecore_Thread *thread)
 196 {
 197         SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
 198 }
 199
 200 static void __set_policy_for_playing(int volume)
 201 {
 202         /* Set stream info */
 203         int ret;
 204         if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
 205                 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
 206                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 207                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
 208                 }
 209         }
 210         ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
 211         if (AUDIO_IO_ERROR_NONE != ret) {
 212                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
 213         }
 214
 215         return;
 216 }
 217
 218 static void __unset_policy_for_playing()
 219 {
 220         int ret;
 221         /* Unset stream info */
 222         if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
 223                 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
 224                 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
 225                 if (SOUND_MANAGER_ERROR_NONE != ret) {
 226                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
 227                 }
 228
 229                 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
 230                         ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
 231                         if (SOUND_MANAGER_ERROR_NONE != ret) {
 232                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
 233                         }
 234                 }
 235         }
 236
 237         return;
 238 }
 239
 240 static void __play_thread(void *data, Ecore_Thread *thread)
 241 {
 242         SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
 243
 244         if (NULL == g_playing_info) {
 245                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
 246                 return;
 247         }
 248
 249         player_s* player = g_playing_info;
 250         sound_data_s* sound_data = NULL;
 251
 252         int ret = -1;
 253         int len = SOUND_BUFFER_LENGTH;
 254         int idx = 0;
 255
 256         /* set volume policy as 40% */
 257         __set_policy_for_playing(40);
 258         while (1) {
 259                 if (true == player->is_paused_data) {
 260                         /* Resume player */
 261                         sound_data = player->paused_data;
 262                         player->paused_data = NULL;
 263
 264                         idx = player->idx;
 265
 266                         player->is_paused_data = false;
 267                         player->idx = 0;
 268
 269                         if (NULL == sound_data) {
 270                                 /* Request unprepare */
 271                                 ret = audio_out_unprepare(g_audio_h);
 272                                 if (AUDIO_IO_ERROR_NONE != ret) {
 273                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 274                                 } else {
 275                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 276                                 }
 277
 278                                 g_audio_state = AUDIO_STATE_READY;
 279
 280                                 /* unset volume policy, volume will be 100% */
 281                                 __unset_policy_for_playing();
 282                                 return;
 283                         }
 284                         SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
 285                                 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
 286                 } else {
 287                         sound_data = NULL;
 288                         ret = ttsd_data_get_sound_data(player->uid, &sound_data);
 289                         if (0 != ret || NULL == sound_data) {
 290                                 /* empty queue */
 291                                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
 292                                 /* release audio & recover session */
 293                                 ret = audio_out_unprepare(g_audio_h);
 294                                 if (AUDIO_IO_ERROR_NONE != ret) {
 295                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 296                                 } else {
 297                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 298                                 }
 299                                 g_audio_state = AUDIO_STATE_READY;
 300
 301                                 /* unset volume policy, volume will be 100% */
 302                                 __unset_policy_for_playing();
 303
 304                                 /* wait for new audio data come */
 305                                 while (1) {
 306                                         usleep(10000);
 307                                         if (NULL == g_playing_info) {
 308                                                 /* current playing uid is replaced */
 309                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
 310                                                 return;
 311                                         } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
 312                                                 /* new audio data come */
 313                                                 SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
 314                                                 break;
 315                                         }
 316                                 }
 317
 318                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
 319
 320                                 /* set volume policy as 40%, when resume play thread*/
 321                                 __set_policy_for_playing(40);
 322
 323                                 /* resume play thread */
 324                                 player->state = APP_STATE_PLAYING;
 325                                 continue;
 326                         }
 327
 328                         /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
 329                          * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
 330                          * When previous wdata's event is 'finish' and current wdata's event is 'finish',
 331                          * the player should send utt started event.
 332                          */
 333                         if (TTSE_RESULT_EVENT_START == sound_data->event ||
 334                            (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 335                                 int pid = ttsd_data_get_pid(player->uid);
 336
 337                                 if (pid <= 0) {
 338                                         SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 339                                         /* unset volume policy, volume will be 100% */
 340                                         __unset_policy_for_playing();
 341
 342                                         if (NULL != sound_data->data) {
 343                                                 free(sound_data->data);
 344                                                 sound_data->data = NULL;
 345                                         }
 346                                         free(sound_data);
 347                                         sound_data = NULL;
 348                                         return;
 349                                 }
 350
 351                                 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
 352                                         SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
 353                                                 pid, player->uid, sound_data->utt_id);
 354                                 }
 355                                 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 356                         }
 357
 358                         /* Save last event to check utterance start */
 359                         player->event = sound_data->event;
 360                         idx = 0;
 361
 362                         if (NULL == sound_data->data || 0 >= sound_data->data_size) {
 363                                 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
 364                                         SLOG(LOG_DEBUG, tts_tag(), "No sound data");
 365                                         /* send utterence finish signal */
 366                                         int pid = ttsd_data_get_pid(player->uid);
 367
 368                                         if (pid <= 0) {
 369                                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 370                                                 /* unset volume policy, volume will be 100% */
 371                                                 __unset_policy_for_playing();
 372                                                 if (NULL != sound_data->data) {
 373                                                         free(sound_data->data);
 374                                                         sound_data->data = NULL;
 375                                                 }
 376                                                 free(sound_data);
 377                                                 sound_data = NULL;
 378                                                 return;
 379                                         }
 380                                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
 381                                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
 382                                                         pid, player->uid, sound_data->utt_id);
 383                                         }
 384                                 }
 385                                 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 386                                 if (NULL != sound_data->data) {
 387                                         free(sound_data->data);
 388                                         sound_data->data = NULL;
 389                                 }
 390                                 free(sound_data);
 391                                 sound_data = NULL;
 392                                 continue;
 393                         }
 394                 }
 395
 396                 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
 397                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
 398                         if (NULL != g_audio_h) {
 399                                 __destroy_audio_out();
 400                         }
 401
 402                         if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
 403                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
 404                                 /* unset volume policy, volume will be 100% */
 405                                 __unset_policy_for_playing();
 406
 407                                 if (NULL != sound_data->data) {
 408                                         free(sound_data->data);
 409                                         sound_data->data = NULL;
 410                                 }
 411                                 free(sound_data);
 412                                 sound_data = NULL;
 413
 414                                 return;
 415                         }
 416                         __set_policy_for_playing(40);
 417                 }
 418
 419                 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
 420                         if ((unsigned int)idx >= sound_data->data_size)
 421                                 break;
 422
 423                         if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
 424                                 len = sound_data->data_size - idx;
 425                         } else {
 426                                 len = SOUND_BUFFER_LENGTH;
 427                         }
 428
 429                         if (AUDIO_STATE_READY == g_audio_state) {
 430                                 /* Request prepare */
 431                                 ret = audio_out_prepare(g_audio_h);
 432                                 if (AUDIO_IO_ERROR_NONE != ret) {
 433                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
 434                                         g_playing_info = NULL;
 435                                         /* unset volume policy, volume will be 100% */
 436                                         __unset_policy_for_playing();
 437
 438                                         if (NULL != sound_data->data) {
 439                                                 free(sound_data->data);
 440                                                 sound_data->data = NULL;
 441                                         }
 442
 443                                         free(sound_data);
 444                                         sound_data = NULL;
 445
 446                                         return;
 447                                 }
 448                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
 449                                 g_audio_state = AUDIO_STATE_PLAY;
 450                         }
 451
 452                         char* temp_data = sound_data->data;
 453                         ret = audio_out_write(g_audio_h, &temp_data[idx], len);
 454                         if (0 > ret) {
 455                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
 456                         } else {
 457                                 idx += len;
 458                         }
 459
 460                         if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
 461                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
 462                                 g_audio_state = AUDIO_STATE_READY;
 463                                 ret = audio_out_unprepare(g_audio_h);
 464                                 if (AUDIO_IO_ERROR_NONE != ret) {
 465                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 466                                 }
 467                                 /* unset volume policy, volume will be 100% */
 468                                 __unset_policy_for_playing();
 469
 470                                 if (NULL != sound_data) {
 471                                         if (NULL != sound_data->data) {
 472                                                 free(sound_data->data);
 473                                                 sound_data->data = NULL;
 474                                         }
 475
 476                                         free(sound_data);
 477                                         sound_data = NULL;
 478                                 }
 479
 480                                 return;
 481                         }
 482
 483                         if (APP_STATE_PAUSED == player->state) {
 484                                 /* Save data */
 485                                 player->paused_data = sound_data;
 486
 487                                 player->is_paused_data = true;
 488                                 player->idx = idx;
 489
 490                                 g_audio_state = AUDIO_STATE_READY;
 491                                 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
 492
 493                                 /* Request prepare */
 494                                 ret = audio_out_unprepare(g_audio_h);
 495                                 if (AUDIO_IO_ERROR_NONE != ret) {
 496                                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 497                                 } else {
 498                                         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 499                                 }
 500                                 /* unset volume policy, volume will be 100% */
 501                                 __unset_policy_for_playing();
 502                                 return;
 503                         }
 504                 }
 505
 506                 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
 507                         /* player_stop */
 508                         g_audio_state = AUDIO_STATE_READY;
 509                         SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
 510
 511                         /* Request prepare */
 512                         ret = audio_out_unprepare(g_audio_h);
 513                         if (AUDIO_IO_ERROR_NONE != ret) {
 514                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 515                         } else {
 516                                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
 517                         }
 518
 519                         if (NULL != sound_data) {
 520                                 if (NULL != sound_data->data) {
 521                                         free(sound_data->data);
 522                                         sound_data->data = NULL;
 523                                 }
 524
 525                                 free(sound_data);
 526                                 sound_data = NULL;
 527                         }
 528                         /* unset volume policy, volume will be 100% */
 529                         __unset_policy_for_playing();
 530                         return;
 531                 }
 532
 533                 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
 534                         (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
 535                         /* send utterence finish signal */
 536                         int pid = ttsd_data_get_pid(player->uid);
 537
 538                         if (pid <= 0) {
 539                                 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 540                                 /* unset volume policy, volume will be 100% */
 541                                 __unset_policy_for_playing();
 542                                 if (NULL != sound_data->data) {
 543                                         free(sound_data->data);
 544                                         sound_data->data = NULL;
 545                                 }
 546
 547                                 free(sound_data);
 548                                 sound_data = NULL;
 549                                 return;
 550                         }
 551
 552                         if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
 553                                 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
 554                                         pid, player->uid, sound_data->utt_id);
 555                                 /* unset volume policy, volume will be 100% */
 556                                 __unset_policy_for_playing();
 557                                 if (NULL != sound_data->data) {
 558                                         free(sound_data->data);
 559                                         sound_data->data = NULL;
 560                                 }
 561
 562                                 free(sound_data);
 563                                 sound_data = NULL;
 564                                 return;
 565                         }
 566
 567                         SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
 568                 }
 569
 570                 if (NULL != sound_data) {
 571                         if (NULL != sound_data->data) {
 572                                 free(sound_data->data);
 573                                 sound_data->data = NULL;
 574                         }
 575
 576                         free(sound_data);
 577                         sound_data = NULL;
 578                 }
 579
 580                 if (NULL == g_playing_info) {
 581                         SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
 582                         g_audio_state = AUDIO_STATE_READY;
 583                         ret = audio_out_unprepare(g_audio_h);
 584                         if (AUDIO_IO_ERROR_NONE != ret) {
 585                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
 586                         }
 587                         /* unset volume policy, volume will be 100% */
 588                         __unset_policy_for_playing();
 589
 590                         return;
 591                 }
 592         }
 593 }
 594
 595 /*
 596 * Player Interfaces
 597 */
 598 int ttsd_player_init()
 599 {
 600         g_playing_info = NULL;
 601         g_audio_state = AUDIO_STATE_NONE;
 602         g_audio_h = NULL;
 603
 604         int ret;
 605
 606         ecore_thread_max_set(1);
 607
 608         int cnt = 0;
 609         while (1) {
 610                 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
 611                         SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
 612                         break;
 613                 } else {
 614                         if (0 == cnt++ % 10)
 615                                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
 616                         usleep(50000);
 617                 }
 618         }
 619
 620         ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
 621         if (SOUND_MANAGER_ERROR_NONE != ret) {
 622                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
 623                 return -1;
 624         } else {
 625                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
 626         }
 627
 628         ecore_thread_max_set(1);
 629
 630         ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
 631         if (0 != ret)
 632                 return -1;
 633
 634         g_player_init = true;
 635
 636         return 0;
 637 }
 638
 639 int ttsd_player_release(void)
 640 {
 641         if (false == g_player_init) {
 642                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 643                 return TTSD_ERROR_OPERATION_FAILED;
 644         }
 645
 646         int ret;
 647
 648         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
 649         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
 650         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
 651
 652         /* The thread should be released */
 653         int thread_count = ecore_thread_active_get();
 654         int count = 0;
 655         while (0 < thread_count) {
 656                 usleep(10000);
 657
 658                 count++;
 659                 if (20 == count) {
 660                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
 661                         break;
 662                 }
 663
 664                 thread_count = ecore_thread_active_get();
 665         }
 666
 667         SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
 668
 669         ret = __destroy_audio_out();
 670         if (0 != ret)
 671                 return -1;
 672
 673         ret = sound_manager_destroy_stream_information(g_stream_info_h);
 674         if (SOUND_MANAGER_ERROR_NONE != ret) {
 675                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
 676         } else {
 677                 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
 678         }
 679
 680         /* clear g_player_list */
 681         g_playing_info = NULL;
 682         g_player_init = false;
 683
 684         return 0;
 685 }
 686
 687 int ttsd_player_create_instance(int uid)
 688 {
 689         if (false == g_player_init) {
 690                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 691                 return -1;
 692         }
 693
 694         /* Check uid is duplicated */
 695         if (NULL != __player_get_item(uid)) {
 696                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
 697                 return -1;
 698         }
 699
 700         player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
 701         if (NULL == new_client) {
 702                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
 703                 return TTSE_ERROR_OUT_OF_MEMORY;
 704         }
 705
 706         new_client->uid = uid;
 707         new_client->event = TTSE_RESULT_EVENT_FINISH;
 708         new_client->state = APP_STATE_READY;
 709         new_client->is_paused_data = false;
 710         new_client->idx = 0;
 711         new_client->paused_data = NULL;
 712
 713         SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
 714
 715         g_player_list = g_list_append(g_player_list, new_client);
 716
 717         return 0;
 718 }
 719
 720 int ttsd_player_destroy_instance(int uid)
 721 {
 722         if (false == g_player_init) {
 723                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 724                 return -1;
 725         }
 726
 727         player_s* current;
 728         current = __player_get_item(uid);
 729         if (NULL == current) {
 730                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 731                 return -1;
 732         }
 733
 734         if (NULL != g_playing_info) {
 735                 if (uid == g_playing_info->uid) {
 736                         g_playing_info = NULL;
 737                 }
 738         }
 739
 740         GList *iter = NULL;
 741         player_s *data = NULL;
 742
 743         if (0 < g_list_length(g_player_list)) {
 744                 /* Get a first item */
 745                 iter = g_list_first(g_player_list);
 746
 747                 while (NULL != iter) {
 748                         /* Get handle data from list */
 749                         data = (player_s*)iter->data;
 750
 751                         if (NULL != data) {
 752                                 /* compare uid */
 753                                 if (uid == data->uid) {
 754                                         g_player_list = g_list_remove_link(g_player_list, iter);
 755                                         free(data);
 756                                         g_list_free(iter);
 757                                         break;
 758                                 }
 759                         }
 760
 761                         /* Get next item */
 762                         iter = g_list_next(iter);
 763                 }
 764         }
 765
 766         SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
 767
 768         return 0;
 769 }
 770
 771 int ttsd_player_play(int uid)
 772 {
 773         if (false == g_player_init) {
 774                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 775                 return -1;
 776         }
 777
 778         if (NULL != g_playing_info) {
 779                 if (uid == g_playing_info->uid) {
 780                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
 781                         return 0;
 782                 } else {
 783                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
 784                         ttsd_player_stop(g_playing_info->uid);
 785                 }
 786         }
 787
 788         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
 789
 790         /* Check sound queue size */
 791         if (0 == ttsd_data_get_sound_data_size(uid)) {
 792                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
 793                 return -1;
 794         }
 795
 796         /* Check uid */
 797         player_s* current;
 798         current = __player_get_item(uid);
 799         if (NULL == current) {
 800                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 801                 return -1;
 802         }
 803
 804         current->state = APP_STATE_PLAYING;
 805
 806         g_playing_info = current;
 807
 808         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
 809
 810         if (0 < ttsd_data_get_sound_data_size(current->uid)) {
 811                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
 812                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
 813         }
 814
 815         return 0;
 816 }
 817
 818 int ttsd_player_stop(int uid)
 819 {
 820         if (false == g_player_init) {
 821                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 822                 return -1;
 823         }
 824
 825         /* Check uid */
 826         player_s* current;
 827         current = __player_get_item(uid);
 828         if (NULL == current) {
 829                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 830                 return -1;
 831         }
 832
 833         /* check whether uid is current playing or not */
 834         if (NULL != g_playing_info) {
 835                 if (uid == g_playing_info->uid) {
 836                         /* release current playing info */
 837                         g_playing_info = NULL;
 838                 }
 839         } else {
 840                 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
 841         }
 842
 843         if (true == current->is_paused_data) {
 844                 if (NULL != current->paused_data) {
 845                         if (NULL != current->paused_data->data) {
 846                                 free(current->paused_data->data);
 847                                 current->paused_data->data = NULL;
 848                         }
 849
 850                         free(current->paused_data);
 851                         current->paused_data = NULL;
 852                 }
 853         }
 854
 855         current->event = TTSE_RESULT_EVENT_FINISH;
 856         current->state = APP_STATE_READY;
 857         current->is_paused_data = false;
 858         current->idx = 0;
 859
 860         if (NULL == g_playing_info) {
 861                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 862                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
 863                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 864
 865                 /* The thread should be released */
 866                 int thread_count = ecore_thread_active_get();
 867                 int count = 0;
 868                 while (0 < thread_count) {
 869                         usleep(10000);
 870
 871                         count++;
 872                         if (30 == count) {
 873                                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
 874                                 break;
 875                         }
 876
 877                         thread_count = ecore_thread_active_get();
 878                 }
 879
 880                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 881                 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
 882                 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 883         }
 884
 885         SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
 886
 887         return 0;
 888 }
 889
 890 int ttsd_player_clear(int uid)
 891 {
 892         if (false == g_player_init) {
 893                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 894                 return -1;
 895         }
 896
 897         /* Check uid */
 898         player_s* current;
 899         current = __player_get_item(uid);
 900         if (NULL == current) {
 901                 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 902                 return -1;
 903         }
 904
 905         if (true == current->is_paused_data) {
 906                 if (NULL != current->paused_data) {
 907                         if (NULL != current->paused_data->data) {
 908                                 free(current->paused_data->data);
 909                                 current->paused_data->data = NULL;
 910                         }
 911
 912                         free(current->paused_data);
 913                         current->paused_data = NULL;
 914                 }
 915         }
 916
 917         current->event = TTSE_RESULT_EVENT_FINISH;
 918         current->state = APP_STATE_READY;
 919         current->is_paused_data = false;
 920         current->idx = 0;
 921
 922         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
 923
 924         return 0;
 925 }
 926
 927 int ttsd_player_pause(int uid)
 928 {
 929         SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
 930
 931         if (false == g_player_init) {
 932                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 933                 return -1;
 934         }
 935
 936         /* Check uid */
 937         player_s* current;
 938         current = __player_get_item(uid);
 939         if (NULL == current) {
 940                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
 941                 return -1;
 942         }
 943
 944         /* check whether uid is current playing or not */
 945         if (NULL != g_playing_info) {
 946                 if (uid == g_playing_info->uid) {
 947                         /* release current playing info */
 948                         g_playing_info = NULL;
 949                 } else {
 950                         /* error case */
 951                 }
 952         }
 953
 954         current->state = APP_STATE_PAUSED;
 955
 956         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 957         SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
 958         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 959
 960         /* The thread should be released */
 961         int thread_count = ecore_thread_active_get();
 962         int count = 0;
 963         while (0 < thread_count) {
 964                 usleep(10000);
 965
 966                 count++;
 967                 if (30 == count) {
 968                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
 969                         break;
 970                 }
 971
 972                 thread_count = ecore_thread_active_get();
 973         }
 974
 975         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 976         SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
 977         SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
 978
 979         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
 980
 981         return 0;
 982 }
 983
 984 int ttsd_player_resume(int uid)
 985 {
 986         SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
 987
 988         if (false == g_player_init) {
 989                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
 990                 return -1;
 991         }
 992
 993         /* Check id */
 994         player_s* current;
 995         current = __player_get_item(uid);
 996         if (NULL == current) {
 997                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
 998                 return -1;
 999         }
1000
1001         /* check current player */
1002         if (NULL != g_playing_info)
1003                 g_playing_info = NULL;
1004
1005         current->state = APP_STATE_PLAYING;
1006         g_playing_info = current;
1007
1008         SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1009         ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1010
1011         return 0;
1012 }
1013
1014 int ttsd_player_all_stop()
1015 {
1016         if (false == g_player_init) {
1017                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1018                 return -1;
1019         }
1020
1021         g_playing_info = NULL;
1022
1023         GList *iter = NULL;
1024         player_s *data = NULL;
1025
1026         if (0 < g_list_length(g_player_list)) {
1027                 /* Get a first item */
1028                 iter = g_list_first(g_player_list);
1029
1030                 while (NULL != iter) {
1031                         /* Get handle data from list */
1032                         data = (player_s*)iter->data;
1033
1034                         app_tts_state_e state;
1035                         if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1036                                 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1037                                 ttsd_player_destroy_instance(data->uid);
1038                                 iter = g_list_next(iter);
1039                                 continue;
1040                         }
1041
1042                         if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1043                                 data->event = TTSE_RESULT_EVENT_FINISH;
1044                                 data->state = APP_STATE_READY;
1045
1046                                 if (true == data->is_paused_data) {
1047                                         if (NULL != data->paused_data) {
1048                                                 if (NULL != data->paused_data->data) {
1049                                                         free(data->paused_data->data);
1050                                                         data->paused_data->data = NULL;
1051                                                 }
1052
1053                                                 free(data->paused_data);
1054                                                 data->paused_data = NULL;
1055                                         }
1056                                 }
1057
1058                                 data->is_paused_data = false;
1059                                 data->idx = 0;
1060                         }
1061
1062                         /* Get next item */
1063                         iter = g_list_next(iter);
1064                 }
1065         }
1066
1067         SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
1068
1069         return 0;
1070 }
1071
1072 int ttsd_player_play_pcm(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         if (NULL != g_playing_info) {
1080                 if (uid == g_playing_info->uid) {
1081                         SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1082                         return 0;
1083                 } else {
1084                         SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1085                         ttsd_player_stop(g_playing_info->uid);
1086                 }
1087         }
1088
1089         SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1090
1091         /* Check sound queue size */
1092         if (0 == ttsd_data_get_sound_data_size(uid)) {
1093                 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1094         }
1095
1096         /* Check uid */
1097         player_s* current;
1098         current = __player_get_item(uid);
1099         if (NULL == current) {
1100                 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1101                 return -1;
1102         }
1103
1104         current->state = APP_STATE_PLAYING;
1105
1106         g_playing_info = current;
1107
1108         SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1109
1110         if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
1111                 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1112                 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1113         }
1114
1115         return 0;
1116 }
1117