X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=server%2Fttsd_player.c;h=08b2c55bb3e8b79dc25afd7b1cf67b82dc89c455;hb=0f8703fbeb38dbf26dc2184c2d4b538b956954b3;hp=502da431c7e43993c5ea6bad6ac704d047d5051b;hpb=16baa5f59fcbf595ba4d6db1e8fbc901786607e0;p=platform%2Fcore%2Fuifw%2Ftts.git diff --git a/server/ttsd_player.c b/server/ttsd_player.c old mode 100755 new mode 100644 index 502da43..08b2c55 --- a/server/ttsd_player.c +++ b/server/ttsd_player.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -21,6 +21,9 @@ #include "ttsd_data.h" #include "ttsd_dbus.h" +#include "tts_internal.h" +#include "ttsd_server.h" + /* * Internal data structure */ @@ -33,10 +36,10 @@ typedef enum { typedef struct { int uid; /** client id */ - app_state_e state; /** client state */ + app_tts_state_e state; /** client state */ /* Current utterance information */ - ttsp_result_event_e event; /** event of last utterance */ + ttse_result_event_e event; /** event of last utterance */ bool is_paused_data; int idx; @@ -44,6 +47,19 @@ typedef struct { } player_s; #define SOUND_BUFFER_LENGTH 2048 +#define FOCUS_SERVER_READY "/tmp/.sound_server_ready" + +/* Sound buf save for test */ +/* +#define BUF_SAVE_MODE +*/ +#ifdef BUF_SAVE_MODE +static char g_temp_file_name[128] = {'\0',}; + +static FILE* g_pFile; + +static int g_count = 1; +#endif /** player init info */ static bool g_player_init = false; @@ -57,7 +73,7 @@ static player_s* g_playing_info; /* player state */ static audio_state_e g_audio_state; -static ttsp_audio_type_e g_audio_type; +static ttse_audio_type_e g_audio_type; static int g_sampling_rate; @@ -65,6 +81,19 @@ static audio_out_h g_audio_h; static sound_stream_info_h g_stream_info_h; +static sound_stream_ducking_h g_media_stream_ducking; +static sound_stream_ducking_h g_system_stream_ducking; +static sound_stream_ducking_h g_notification_stream_ducking; +static sound_stream_ducking_h g_alarm_stream_ducking; + +// static bool ducking_flag; + +#define SND_MGR_DUCKING_DURATION 500 + +static int g_focus_watch_id; + +static double g_bg_volume_ratio; + /* * Internal Interfaces */ @@ -94,61 +123,200 @@ player_s* __player_get_item(int uid) return NULL; } -void __player_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_change_reason_e reason_for_change, const char *extra_info, void *user_data) +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, + sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data) { - SLOG(LOG_DEBUG, get_tag(), "===== Focus state changed cb"); + SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb"); if (stream_info != g_stream_info_h) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Invalid stream info handle"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle"); return; } + SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d) and extra info(%s)", (int)focus_state, (int)reason_for_change, extra_info); - int ret; - sound_stream_focus_state_e state_for_playback ; - ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playback, NULL); - if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to get focus state"); + if (NULL == g_playing_info) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player"); return; } - SLOG(LOG_WARN, get_tag(), "[Player] focus state changed to (%d) with reason(%d)", (int)state_for_playback, (int)reason_for_change); - - if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_STATE_RELEASED == state_for_playback) { + if (APP_STATE_PLAYING == g_playing_info->state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) { if (TTSD_MODE_DEFAULT == ttsd_get_mode()) { g_audio_state = AUDIO_STATE_READY; - + + int uid = g_playing_info->uid; + + if (0 != ttsd_player_pause(uid)) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player"); + return; + } + + ttsd_data_set_client_state(uid, APP_STATE_PAUSED); + int pid = ttsd_data_get_pid(uid); + /* send message to client about changing state */ + ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode()); + } + } + +/* if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) { + if (TTSD_MODE_DEFAULT == ttsd_get_mode()) { + g_audio_state = AUDIO_STATE_PLAY; + if (NULL == g_playing_info) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] No current player"); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player"); return; } - if (APP_STATE_PLAYING == g_playing_info->state) { - g_playing_info->state = APP_STATE_PAUSED; - - ttsd_data_set_client_state(g_playing_info->uid, APP_STATE_PAUSED); + if (APP_STATE_PAUSED == g_playing_info->state) { + int uid = g_playing_info->uid; - int pid = ttsd_data_get_pid(g_playing_info->uid); + g_audio_state = AUDIO_STATE_PLAY; + if (0 != ttsd_player_resume(uid)) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player"); + g_audio_state = AUDIO_STATE_READY; + return; + } - /* send message to client about changing state */ - ttsdc_send_set_state_message(pid, g_playing_info->uid, APP_STATE_PAUSED); + ttsd_data_set_client_state(uid, APP_STATE_PLAYING); + int pid = ttsd_data_get_pid(uid); + ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING); } + } else { - SLOG(LOG_DEBUG, get_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode()); + SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode()); + } + } +*/ + SLOG(LOG_DEBUG, tts_tag(), "@@@"); + + return; +} + +void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason, + const char *extra_info, void *user_data) +{ + SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb"); + + ttsd_mode_e mode = ttsd_get_mode(); + + if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) { + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode."); + return; + } + + if (NULL == g_playing_info) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player"); + return; + } + + if (APP_STATE_PLAYING == g_playing_info->state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && + NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) { + /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */ + g_audio_state = AUDIO_STATE_READY; + + int uid = g_playing_info->uid; + + if (0 != ttsd_server_stop(uid)) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server"); + return; } + if (0 != ttsd_player_stop(uid)) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player"); + return; + } + + ttsd_data_set_client_state(uid, APP_STATE_READY); + int pid = ttsd_data_get_pid(uid); + /* send message to client about changing state */ + ttsdc_send_set_state_message(pid, uid, APP_STATE_READY); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player] Extra info is not Interrupt mode(%s) or not playing state(%d).", extra_info, g_playing_info->state); } - SLOG(LOG_DEBUG, get_tag(), "====="); - SLOG(LOG_DEBUG, get_tag(), ""); + return; +} +void __sound_stream_ducking_state_changed_cb(sound_stream_ducking_h stream_ducking, bool is_ducked, void *user_data) +{ + SLOG(LOG_DEBUG, tts_tag(), "@@@ ducking state changed cb"); + SLOG(LOG_DEBUG, tts_tag(), "[Player] is ducked : %d", is_ducked); + // ducking_flag = true; return; } -static int __create_audio_out(ttsp_audio_type_e type, int rate) +static char* __get_ducking_stream(sound_stream_type_e stream_type) +{ + if (SOUND_STREAM_TYPE_MEDIA == stream_type) + return "Media stream"; + else if (SOUND_STREAM_TYPE_SYSTEM == stream_type) + return "System stream"; + else if (SOUND_STREAM_TYPE_NOTIFICATION == stream_type) + return "Notification stream"; + else if (SOUND_STREAM_TYPE_ALARM == stream_type) + return "Alarm stream"; + return "Non matched stream"; +} + +static int __activate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h) +{ + bool is_ducked = false; + int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked); + if (is_ducked) { + SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already ducked", __get_ducking_stream(stream_type)); + } else { + ret = sound_manager_activate_ducking(stream_ducking_h, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking for %s", __get_ducking_stream(stream_type)); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Activate ducking for %s", __get_ducking_stream(stream_type)); + } + } + return ret; +} + +static void __change_background_volume() +{ + SLOG(LOG_INFO, tts_tag(), "[Player] current ducking stream(%s), volume ratio(%d)", __get_ducking_stream(stream_type), g_bg_volume_ratio); + if (1.0 > g_bg_volume_ratio) { + __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking); + __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking); + __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking); + __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking); + } +} + +static int __deactivate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h) +{ + bool is_ducked = false; + int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked); + if (!is_ducked) { + SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already recovered from ducking", __get_ducking_stream(stream_type)); + } else { + ret = sound_manager_deactivate_ducking(stream_ducking_h); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking for %s", __get_ducking_stream(stream_type)); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Deactivate ducking for %s", __get_ducking_stream(stream_type)); + } + } + return ret; +} + +static void __recover_background_volume() +{ + __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking); + __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking); + __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking); + __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking); +} + +static int __create_audio_out(ttse_audio_type_e type, int rate) { int ret = -1; audio_sample_type_e sample_type; - if (TTSP_AUDIO_TYPE_RAW_S16 == type) { + if (TTSE_AUDIO_TYPE_RAW_S16 == type) { sample_type = AUDIO_SAMPLE_TYPE_S16_LE; } else { sample_type = AUDIO_SAMPLE_TYPE_U8; @@ -158,10 +326,10 @@ static int __create_audio_out(ttsp_audio_type_e type, int rate) if (AUDIO_IO_ERROR_NONE != ret) { g_audio_state = AUDIO_STATE_NONE; g_audio_h = NULL; - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to create audio"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio"); return -1; } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Create audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio"); } g_audio_type = type; @@ -175,17 +343,17 @@ static int __create_audio_out(ttsp_audio_type_e type, int rate) static int __destroy_audio_out() { if (NULL == g_audio_h) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Current handle is not valid"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid"); return -1; } int ret = -1; ret = audio_out_destroy(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to destroy audio"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio"); return -1; } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Destroy audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio"); } g_audio_type = 0; @@ -199,63 +367,152 @@ static int __destroy_audio_out() static void __end_play_thread(void *data, Ecore_Thread *thread) { - SLOG(LOG_ERROR, get_tag(), "===== End thread"); + SLOG(LOG_ERROR, tts_tag(), "@@@ End thread"); + +#ifdef BUF_SAVE_MODE + fclose(g_pFile); +#endif } static void __set_policy_for_playing(int volume) { + + __change_background_volume(); + /* Set stream info */ int ret; - if (TTSD_MODE_DEFAULT == ttsd_get_mode()) { - ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, NULL); + ttsd_mode_e mode = ttsd_get_mode(); + if (TTSD_MODE_DEFAULT == mode) { + ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL); if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to acquire focus"); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus"); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)"); } - ret = audio_out_set_stream_info(g_audio_h, g_stream_info_h); - if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to set stream info"); + } else if (TTSD_MODE_INTERRUPT == mode) { + ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT"); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus"); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)"); } } - /* Set volume policy */ -/* - SLOG(LOG_WARN, get_tag(), "[Player WARNING] set volume policy"); - ret = sound_manager_set_volume_voice_policy(volume); - if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to set volume policy"); + ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h); + if (AUDIO_IO_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info"); } -*/ + + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing"); + return; } static void __unset_policy_for_playing() { int ret; - /* Unset volume policy */ -/* - SLOG(LOG_WARN, get_tag(), "[Player WARNING] unset volume policy"); - ret = sound_manager_unset_volume_voice_policy(); - if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to unset volume policy"); - } -*/ + ttsd_mode_e mode = ttsd_get_mode(); /* Unset stream info */ - if (TTSD_MODE_DEFAULT == ttsd_get_mode()) { - ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, NULL); + if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) { + sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED; + ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL); if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to release focus"); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret); + } + + if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) { + if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) { + ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL); + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode); + } + + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus"); + } } } + __recover_background_volume(); + + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing"); + return; } +int ttsd_player_check_current_playback_focus(bool *is_current_interrupt) +{ + int ret; + ttsd_mode_e mode = ttsd_get_mode(); + + if (TTSD_MODE_INTERRUPT != mode) { + /* check the current playback focus */ + sound_stream_focus_change_reason_e reason; + int sound_behavior = 0; + char *extra_info = NULL; + + ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info); + + SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior); + + if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) { + if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) { + SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data"); + *is_current_interrupt = true; + + free(extra_info); + extra_info = NULL; + + return TTSD_ERROR_NONE; + } + } + + if (NULL != extra_info) { + free(extra_info); + extra_info = NULL; + } + } + + *is_current_interrupt = false; + + return TTSD_ERROR_NONE; +} + static void __play_thread(void *data, Ecore_Thread *thread) { - SLOG(LOG_DEBUG, get_tag(), "===== Start thread"); + SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread"); + +#ifdef BUF_SAVE_MODE + g_count++; + + while (1) { + snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/tts_temp_%d_%d", getpid(), g_count); + int ret = access(g_temp_file_name, 0); + + if (0 == ret) { + SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File is already exist"); + if (0 == remove(g_temp_file_name)) { + SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Remove file"); + break; + } else { + g_count++; + } + } else { + break; + } + } + + SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Temp file name=[%s]", g_temp_file_name); + + /* open test file */ + g_pFile = fopen(g_temp_file_name, "wb+x"); + if (!g_pFile) { + SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File not found!"); + return; + } +#endif if (NULL == g_playing_info) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] No current player"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player"); return; } @@ -283,9 +540,9 @@ static void __play_thread(void *data, Ecore_Thread *thread) /* Request unprepare */ ret = audio_out_unprepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio"); } g_audio_state = AUDIO_STATE_READY; @@ -294,42 +551,64 @@ static void __play_thread(void *data, Ecore_Thread *thread) __unset_policy_for_playing(); return; } - SLOG(LOG_INFO, get_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)", + SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)", sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event); } else { sound_data = NULL; ret = ttsd_data_get_sound_data(player->uid, &sound_data); if (0 != ret || NULL == sound_data) { /* empty queue */ - SLOG(LOG_DEBUG, get_tag(), "[Player] No sound data. Waiting mode"); - /* release audio & recover session */ - ret = audio_out_unprepare(g_audio_h); - if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); - } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio"); - } - g_audio_state = AUDIO_STATE_READY; - - /* unset volume policy, volume will be 100% */ - __unset_policy_for_playing(); + SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode"); /* wait for new audio data come */ while (1) { usleep(10000); if (NULL == g_playing_info) { /* current playing uid is replaced */ - SLOG(LOG_DEBUG, get_tag(), "[Player] Finish thread"); + SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread"); + if (AUDIO_STATE_PLAY == g_audio_state) { + /* release audio & recover session */ + ret = audio_out_unprepare(g_audio_h); + if (AUDIO_IO_ERROR_NONE != ret) { + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio"); + } + g_audio_state = AUDIO_STATE_READY; + } + /* unset volume policy, volume will be 100% */ + __unset_policy_for_playing(); return; } else if (0 < ttsd_data_get_sound_data_size(player->uid)) { /* new audio data come */ - SLOG(LOG_DEBUG, get_tag(), "[Player] Resume thread"); + SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread"); break; } + + /* If engine is not on processing */ + if (TTSD_SYNTHESIS_CONTROL_DOING != ttsd_get_synth_control()) { + if (AUDIO_STATE_PLAY == g_audio_state) { + /* release audio & recover session */ + ret = audio_out_unprepare(g_audio_h); + if (AUDIO_IO_ERROR_NONE != ret) { + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio"); + } + g_audio_state = AUDIO_STATE_READY; + + /* unset volume policy, volume will be 100% */ + __unset_policy_for_playing(); + } + } } - /* set volume policy as 40%, when resume play thread*/ - __set_policy_for_playing(40); + SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come"); + + if (AUDIO_STATE_READY == g_audio_state) { + /* set volume policy as 40%, when resume play thread*/ + __set_policy_for_playing(40); + } /* resume play thread */ player->state = APP_STATE_PLAYING; @@ -341,22 +620,23 @@ static void __play_thread(void *data, Ecore_Thread *thread) * When previous wdata's event is 'finish' and current wdata's event is 'finish', * the player should send utt started event. */ - if (TTSP_RESULT_EVENT_START == sound_data->event || - (TTSP_RESULT_EVENT_FINISH == player->event && TTSP_RESULT_EVENT_FINISH == sound_data->event)) { + if (TTSE_RESULT_EVENT_START == sound_data->event || + (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) { int pid = ttsd_data_get_pid(player->uid); if (pid <= 0) { - SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid"); + SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid"); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); + return; } if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) { - SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)", + SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)", pid, player->uid, sound_data->utt_id); } - SLOG(LOG_DEBUG, get_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); + SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); } /* Save last event to check utterance start */ @@ -364,39 +644,51 @@ static void __play_thread(void *data, Ecore_Thread *thread) idx = 0; if (NULL == sound_data->data || 0 >= sound_data->data_size) { - if (TTSP_RESULT_EVENT_FINISH == sound_data->event) { - SLOG(LOG_DEBUG, get_tag(), "No sound data"); + if (TTSE_RESULT_EVENT_FINISH == sound_data->event) { + SLOG(LOG_DEBUG, tts_tag(), "No sound data"); /* send utterence finish signal */ int pid = ttsd_data_get_pid(player->uid); if (pid <= 0) { - SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid"); + SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid"); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); return; } + + __unset_policy_for_playing(); + if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) { - SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", + SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", pid, player->uid, sound_data->utt_id); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); } } - SLOG(LOG_DEBUG, get_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); + SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%d), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id); + ttsd_data_clear_sound_data(player->uid, &sound_data); continue; } } if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) { - SLOG(LOG_DEBUG, get_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate); + SLOG(LOG_INFO, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate); if (NULL != g_audio_h) { __destroy_audio_out(); } if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to create audio out"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out"); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); + + ttsd_data_clear_sound_data(player->uid, &sound_data); + return; } + + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Success to destroy and recreate audio out"); + __set_policy_for_playing(40); } while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) { @@ -413,63 +705,67 @@ static void __play_thread(void *data, Ecore_Thread *thread) /* Request prepare */ ret = audio_out_prepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to prepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret); g_playing_info = NULL; /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); + + ttsd_data_clear_sound_data(player->uid, &sound_data); + return; } - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Prepare audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio"); g_audio_state = AUDIO_STATE_PLAY; } char* temp_data = sound_data->data; + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)", + temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len); +#ifdef BUF_SAVE_MODE + /* write pcm buffer */ + fwrite(&temp_data[idx], 1, len, g_pFile); +#endif ret = audio_out_write(g_audio_h, &temp_data[idx], len); if (0 > ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to audio write - %d", ret); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret); } else { idx += len; + SLOG(LOG_INFO, tts_tag(), "[Player INFO] After audio_out_write"); } if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Current player is NULL"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL"); g_audio_state = AUDIO_STATE_READY; ret = audio_out_unprepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); } /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); - if (NULL != sound_data) { - if (NULL != sound_data->data) { - free(sound_data->data); - sound_data->data = NULL; - } - - free(sound_data); - sound_data = NULL; - } + ttsd_data_clear_sound_data(player->uid, &sound_data); return; } if (APP_STATE_PAUSED == player->state) { /* Save data */ + SLOG(LOG_DEBUG, tts_tag(), "[Player] player(%p)", player); player->paused_data = sound_data; player->is_paused_data = true; player->idx = idx; g_audio_state = AUDIO_STATE_READY; - SLOG(LOG_DEBUG, get_tag(), "[Player] Stop player thread by pause"); + + SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause"); /* Request prepare */ ret = audio_out_unprepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio"); } /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); @@ -480,69 +776,56 @@ static void __play_thread(void *data, Ecore_Thread *thread) if (NULL == g_playing_info && APP_STATE_READY == player->state) { /* player_stop */ g_audio_state = AUDIO_STATE_READY; - SLOG(LOG_DEBUG, get_tag(), "[Player] Stop player thread"); + SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread"); /* Request prepare */ ret = audio_out_unprepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Unprepare audio"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio"); } - if (NULL != sound_data) { - if (NULL != sound_data->data) { - free(sound_data->data); - sound_data->data = NULL; - } - - free(sound_data); - sound_data = NULL; - } + ttsd_data_clear_sound_data(player->uid, &sound_data); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); return; } if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) && - (TTSP_RESULT_EVENT_FINISH == sound_data->event)) { + (TTSE_RESULT_EVENT_FINISH == sound_data->event)) { /* send utterence finish signal */ int pid = ttsd_data_get_pid(player->uid); if (pid <= 0) { - SLOG(LOG_WARN, get_tag(), "[Send WARNIING] Current player is not valid"); + SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid"); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); + return; } if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) { - SLOG(LOG_ERROR, get_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", + SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", pid, player->uid, sound_data->utt_id); /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); + + ttsd_data_clear_sound_data(player->uid, &sound_data); return; } - SLOG(LOG_DEBUG, get_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); + SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id); } - if (NULL != sound_data) { - if (NULL != sound_data->data) { - free(sound_data->data); - sound_data->data = NULL; - } - - free(sound_data); - sound_data = NULL; - } + ttsd_data_clear_sound_data(player->uid, &sound_data); if (NULL == g_playing_info) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Current player is NULL"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL"); g_audio_state = AUDIO_STATE_READY; ret = audio_out_unprepare(g_audio_h); if (AUDIO_IO_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret); } /* unset volume policy, volume will be 100% */ __unset_policy_for_playing(); @@ -552,6 +835,43 @@ static void __play_thread(void *data, Ecore_Thread *thread) } } +int __create_ducking_handle(void) +{ + int ret = -1; + if (NULL == g_media_stream_ducking) { + ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_media_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for type media, ret(%d)", ret); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created"); + } + if (NULL == g_system_stream_ducking) { + ret = sound_manager_create_stream_ducking(SOUND_TYPE_SYSTEM, __sound_stream_ducking_state_changed_cb, NULL, &g_system_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for system type, ret(%d)", ret); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created"); + } + + if (NULL == g_notification_stream_ducking) { + ret = sound_manager_create_stream_ducking(SOUND_TYPE_NOTIFICATION, __sound_stream_ducking_state_changed_cb, NULL, &g_notification_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for notification type, ret(%d)", ret); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created"); + } + + if (NULL == g_alarm_stream_ducking) { + ret = sound_manager_create_stream_ducking(SOUND_TYPE_ALARM, __sound_stream_ducking_state_changed_cb, NULL, &g_alarm_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for alarm type, ret(%d)", ret); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created"); + } + + return ret; +} + /* * Player Interfaces */ @@ -565,35 +885,110 @@ int ttsd_player_init() ecore_thread_max_set(1); + int cnt = 0; + while (1) { + if (0 == access(FOCUS_SERVER_READY, F_OK)) { + SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available"); + break; + } else { + if (0 == cnt++ % 10) + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available"); + usleep(50000); + } + } + ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h); if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to create stream info"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info"); return -1; } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Create stream info"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info"); } - ret = __create_audio_out(TTSP_AUDIO_TYPE_RAW_S16, 16000); - if (0 != ret) + /* add sound focus state watch callback */ + ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback"); + sound_manager_destroy_stream_information(g_stream_info_h); return -1; + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback"); + } + + ret = __create_ducking_handle(); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create ducking handle, ret(%d)", ret); + } else { + SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Create ducking handle"); + } + + ecore_thread_max_set(1); + + ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000); + if (0 != ret) { + sound_manager_destroy_stream_information(g_stream_info_h); + sound_manager_remove_focus_state_watch_cb(g_focus_watch_id); + return -1; + } g_player_init = true; return 0; } +int __destroy_ducking_handle(void) +{ + int ret = -1; + if (g_media_stream_ducking) { + ret = sound_manager_destroy_stream_ducking(g_media_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy media stream ducking, ret(%d)", ret); + g_media_stream_ducking = NULL; + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created"); + } + + if (g_system_stream_ducking) { + ret = sound_manager_destroy_stream_ducking(g_system_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy system stream ducking, ret(%d)", ret); + g_system_stream_ducking = NULL; + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created"); + } + + if (g_notification_stream_ducking) { + ret = sound_manager_destroy_stream_ducking(g_notification_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy notification stream ducking, ret(%d)", ret); + g_notification_stream_ducking = NULL; + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created"); + } + + if (g_alarm_stream_ducking) { + ret = sound_manager_destroy_stream_ducking(g_alarm_stream_ducking); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy alarm stream ducking, ret(%d)", ret); + g_alarm_stream_ducking = NULL; + } else { + SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created"); + } + return ret; +} + int ttsd_player_release(void) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return TTSD_ERROR_OPERATION_FAILED; } int ret; - SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] =========================="); - SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get()); - SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] =========================="); + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@"); + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@"); /* The thread should be released */ int thread_count = ecore_thread_active_get(); @@ -603,14 +998,14 @@ int ttsd_player_release(void) count++; if (20 == count) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING!!] Thread is blocked. Player release continue."); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue."); break; } thread_count = ecore_thread_active_get(); } - SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Thread is released"); + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released"); ret = __destroy_audio_out(); if (0 != ret) @@ -618,11 +1013,25 @@ int ttsd_player_release(void) ret = sound_manager_destroy_stream_information(g_stream_info_h); if (SOUND_MANAGER_ERROR_NONE != ret) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] Fail to destroy stream info"); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info"); + } else { + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info"); + } + + /* remove focus state watch callback */ + ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id); + if (SOUND_MANAGER_ERROR_NONE != ret) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb"); } else { - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Destroy stream info"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb"); } + ret = __destroy_ducking_handle(); + if (SOUND_MANAGER_ERROR_NONE != ret) + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking, ret(%d)", ret); + else + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking"); + /* clear g_player_list */ g_playing_info = NULL; g_player_init = false; @@ -633,30 +1042,30 @@ int ttsd_player_release(void) int ttsd_player_create_instance(int uid) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } /* Check uid is duplicated */ if (NULL != __player_get_item(uid)) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is already registered", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid); return -1; } player_s* new_client = (player_s*)calloc(1, sizeof(player_s)); if (NULL == new_client) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Fail to allocate memory"); - return TTSP_ERROR_OUT_OF_MEMORY; + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory"); + return TTSE_ERROR_OUT_OF_MEMORY; } new_client->uid = uid; - new_client->event = TTSP_RESULT_EVENT_FINISH; + new_client->event = TTSE_RESULT_EVENT_FINISH; new_client->state = APP_STATE_READY; new_client->is_paused_data = false; new_client->idx = 0; new_client->paused_data = NULL; - SECURE_SLOG(LOG_DEBUG, get_tag(), "[Player] Create player : uid(%d)", uid); + SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid); g_player_list = g_list_append(g_player_list, new_client); @@ -666,14 +1075,14 @@ int ttsd_player_create_instance(int uid) int ttsd_player_destroy_instance(int uid) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } player_s* current; current = __player_get_item(uid); if (NULL == current) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); return -1; } @@ -709,7 +1118,7 @@ int ttsd_player_destroy_instance(int uid) } } - SLOG(LOG_DEBUG, get_tag(), "[PLAYER Success] Destroy instance"); + SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance"); return 0; } @@ -717,25 +1126,25 @@ int ttsd_player_destroy_instance(int uid) int ttsd_player_play(int uid) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } if (NULL != g_playing_info) { if (uid == g_playing_info->uid) { - SLOG(LOG_DEBUG, get_tag(), "[Player] uid(%d) has already played", g_playing_info->uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid); return 0; } else { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid); ttsd_player_stop(g_playing_info->uid); } } - SLOG(LOG_DEBUG, get_tag(), "[Player] start play : uid(%d)", uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid); /* Check sound queue size */ if (0 == ttsd_data_get_sound_data_size(uid)) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid); return -1; } @@ -743,7 +1152,7 @@ int ttsd_player_play(int uid) player_s* current; current = __player_get_item(uid); if (NULL == current) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); return -1; } @@ -751,10 +1160,10 @@ int ttsd_player_play(int uid) g_playing_info = current; - SLOG(LOG_DEBUG, get_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get()); if (0 < ttsd_data_get_sound_data_size(current->uid)) { - SLOG(LOG_DEBUG, get_tag(), "[Player] Run thread"); + SLOG(LOG_INFO, tts_tag(), "[Player] Run thread"); ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL); } @@ -764,7 +1173,7 @@ int ttsd_player_play(int uid) int ttsd_player_stop(int uid) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } @@ -772,7 +1181,7 @@ int ttsd_player_stop(int uid) player_s* current; current = __player_get_item(uid); if (NULL == current) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); return -1; } @@ -783,7 +1192,7 @@ int ttsd_player_stop(int uid) g_playing_info = NULL; } } else { - SLOG(LOG_DEBUG, get_tag(), "[Player] No current playing"); + SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing"); } if (true == current->is_paused_data) { @@ -798,15 +1207,15 @@ int ttsd_player_stop(int uid) } } - current->event = TTSP_RESULT_EVENT_FINISH; + current->event = TTSE_RESULT_EVENT_FINISH; current->state = APP_STATE_READY; current->is_paused_data = false; current->idx = 0; if (NULL == g_playing_info) { - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - SLOG(LOG_ERROR, get_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); + SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); /* The thread should be released */ int thread_count = ecore_thread_active_get(); @@ -816,19 +1225,19 @@ int ttsd_player_stop(int uid) count++; if (30 == count) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING!!] Thread is blocked. Player release continue."); + SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue."); break; } thread_count = ecore_thread_active_get(); } - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - SLOG(LOG_ERROR, get_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); + SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); } - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid); + SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid); return 0; } @@ -836,7 +1245,7 @@ int ttsd_player_stop(int uid) int ttsd_player_clear(int uid) { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } @@ -844,7 +1253,7 @@ int ttsd_player_clear(int uid) player_s* current; current = __player_get_item(uid); if (NULL == current) { - SECURE_SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); + SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); return -1; } @@ -860,22 +1269,22 @@ int ttsd_player_clear(int uid) } } - current->event = TTSP_RESULT_EVENT_FINISH; + current->event = TTSE_RESULT_EVENT_FINISH; current->state = APP_STATE_READY; current->is_paused_data = false; current->idx = 0; - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid); return 0; } int ttsd_player_pause(int uid) { - SLOG(LOG_DEBUG, get_tag(), "[Player] pause player : uid(%d)", uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid); if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } @@ -883,7 +1292,7 @@ int ttsd_player_pause(int uid) player_s* current; current = __player_get_item(uid); if (NULL == current) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid); return -1; } @@ -891,48 +1300,56 @@ int ttsd_player_pause(int uid) if (NULL != g_playing_info) { if (uid == g_playing_info->uid) { /* release current playing info */ + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%d)", uid); g_playing_info = NULL; } else { /* error case */ } } + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current player (%p), g_playing_info(%p)", current, g_playing_info); + current->state = APP_STATE_PAUSED; - - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - SLOG(LOG_ERROR, get_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - /* The thread should be released */ - int thread_count = ecore_thread_active_get(); - int count = 0; - while (0 < thread_count) { - usleep(10000); + if (NULL == g_playing_info) { + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); + SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); - count++; - if (30 == count) { - SLOG(LOG_WARN, get_tag(), "[Player WARNING!!] Thread is blocked. Player release continue."); - break; + /* The thread should be released */ + int thread_count = ecore_thread_active_get(); + int count = 0; + while (0 < thread_count) { + usleep(10000); + + count++; + SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current(%p), state(%d)", current, current->state); + + if (30 == count) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue. current(%p) current state(%d)", current, current->state); + break; + } + + thread_count = ecore_thread_active_get(); } - thread_count = ecore_thread_active_get(); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); + SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); + SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@"); } - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - SLOG(LOG_ERROR, get_tag(), "[Player] Active thread count : %d", ecore_thread_active_get()); - SLOG(LOG_DEBUG, get_tag(), "[Player] =========================="); - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid); return 0; } int ttsd_player_resume(int uid) { - SLOG(LOG_DEBUG, get_tag(), "[Player] Resume player : uid(%d)", uid); + SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid); if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } @@ -940,7 +1357,7 @@ int ttsd_player_resume(int uid) player_s* current; current = __player_get_item(uid); if (NULL == current) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] uid(%d) is not valid", uid); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); return -1; } @@ -951,7 +1368,7 @@ int ttsd_player_resume(int uid) current->state = APP_STATE_PLAYING; g_playing_info = current; - SLOG(LOG_DEBUG, get_tag(), "[Player] Run thread"); + SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread"); ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL); return 0; @@ -960,7 +1377,7 @@ int ttsd_player_resume(int uid) int ttsd_player_all_stop() { if (false == g_player_init) { - SLOG(LOG_ERROR, get_tag(), "[Player ERROR] Not Initialized"); + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); return -1; } @@ -977,16 +1394,16 @@ int ttsd_player_all_stop() /* Get handle data from list */ data = (player_s*)iter->data; - app_state_e state; + app_tts_state_e state; if (0 > ttsd_data_get_client_state(data->uid, &state)) { - SLOG(LOG_ERROR, get_tag(), "[player ERROR] uid(%d) is not valid", data->uid); + SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid); ttsd_player_destroy_instance(data->uid); iter = g_list_next(iter); continue; } if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) { - data->event = TTSP_RESULT_EVENT_FINISH; + data->event = TTSE_RESULT_EVENT_FINISH; data->state = APP_STATE_READY; if (true == data->is_paused_data) { @@ -1010,7 +1427,71 @@ int ttsd_player_all_stop() } } - SLOG(LOG_DEBUG, get_tag(), "[Player SUCCESS] player all stop!!"); + SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!"); return 0; } + +int ttsd_player_play_pcm(int uid) +{ + if (false == g_player_init) { + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized"); + return -1; + } + + if (NULL != g_playing_info) { + if (uid == g_playing_info->uid) { + SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid); + return 0; + } else { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid); + ttsd_player_stop(g_playing_info->uid); + } + } + + SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid); + + /* Check sound queue size */ + if (0 == ttsd_data_get_sound_data_size(uid)) { + SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid); + } + + /* Check uid */ + player_s* current; + current = __player_get_item(uid); + if (NULL == current) { + SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid); + return -1; + } + + current->state = APP_STATE_PLAYING; + + g_playing_info = current; + + SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get()); + + if (0 <= ttsd_data_get_sound_data_size(current->uid)) { + SLOG(LOG_INFO, tts_tag(), "[Player] Run thread"); + ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL); + } + + return 0; +} + +int ttsd_player_get_background_volume_ratio(double* ratio) +{ + if (NULL == ratio) + return -1; + else + *ratio = g_bg_volume_ratio; + + return TTSD_ERROR_NONE; +} + +int ttsd_player_set_background_volume_ratio(double ratio) +{ + SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] ttsd_player_set_background_volume_ratio : %lf", ratio); + + g_bg_volume_ratio = ratio; + return TTSD_ERROR_NONE; +}