server/ttsd_player.c

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