src/cam_sound.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *        http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <sound_manager.h>
  19 #include <wav_player.h>
  20 #include <pthread.h>
  21 #include <vconf.h>
  22 #include <errno.h>
  23 #include <sys/time.h>
  24 #include "cam.h"
  25 #include "cam_sound.h"
  26 /*
  27 #include "cam_sound_private.h"
  28 */
  29 #include "cam_debug.h"
  30 #include "cam_ta.h"
  31 #include "cam_mm.h"
  32
  33 #define SOUND_TIMEOUT_SEC       2
  34
  35 static gchar **sound_files = NULL;
  36 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
  37 pthread_mutex_t sound_lock = PTHREAD_MUTEX_INITIALIZER;
  38 pthread_cond_t sound_cond = PTHREAD_COND_INITIALIZER;
  39 #endif
  40
  41 static void cam_sound_callback(int id, void *data);
  42
  43 gboolean cam_sound_init(GError **error)
  44 {
  45         debug_fenter(LOG_UI);
  46
  47         if (!sound_files) {
  48                 sound_files = g_new0(gchar *, CAM_SOUND_EFFECT_NUM);
  49                 g_return_val_if_fail(sound_files, FALSE);
  50
  51                 int i;
  52                 for (i = 0; i < CAM_SOUND_EFFECT_NUM; i++)
  53                         sound_files[i] = NULL;
  54 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
  55                 cam_sound_set(CAM_SOUND_EFFECT_SHUTTER1, SOUND_PATH "/Shutter_01.wav");
  56                 cam_sound_set(CAM_SOUND_EFFECT_SHUTTER2, SOUND_PATH "/Shutter_02.wav");
  57                 cam_sound_set(CAM_SOUND_EFFECT_SHUTTER3, SOUND_PATH "/Shutter_03.wav");
  58                 cam_sound_set(CAM_SOUND_EFFECT_REC_START1, SOUND_PATH "/cam_start_01.wav");
  59                 cam_sound_set(CAM_SOUND_EFFECT_REC_START2, SOUND_PATH "/cam_start_02.wav");
  60                 cam_sound_set(CAM_SOUND_EFFECT_REC_START3, SOUND_PATH "/cam_start_03.wav");
  61                 cam_sound_set(CAM_SOUND_EFFECT_REC_COMMIT1, SOUND_PATH "/cam_stop_01.wav");
  62                 cam_sound_set(CAM_SOUND_EFFECT_REC_COMMIT2, SOUND_PATH "/cam_stop_02.wav");
  63                 cam_sound_set(CAM_SOUND_EFFECT_REC_COMMIT3, SOUND_PATH "/cam_stop_03.wav");
  64 #endif
  65                 cam_sound_set(CAM_SOUND_EFFECT_TICK, SOUND_PATH "/count.wav");
  66                 cam_sound_set(CAM_SOUND_EFFECT_AF_OK, SOUND_PATH "/af_ok.wav");
  67                 cam_sound_set(CAM_SOUND_EFFECT_AF_FAIL, SOUND_PATH "/af_fail.wav");
  68
  69         }
  70 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
  71         pthread_mutex_init(&sound_lock, NULL);
  72         pthread_cond_init(&sound_cond, NULL);
  73 #endif
  74         return TRUE;
  75 }
  76
  77 void cam_sound_finalize(void)
  78 {
  79         debug_fenter(LOG_UI);
  80
  81         if (sound_files) {
  82                 int i;
  83                 for (i = 0; i < CAM_SOUND_EFFECT_NUM; i++) {
  84                         if (sound_files[i]) {
  85                                 g_free(sound_files[i]);
  86                                 sound_files[i] = NULL;
  87                         }
  88                 }
  89                 g_free(sound_files);
  90                 sound_files = NULL;
  91         }
  92 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
  93         pthread_mutex_destroy(&sound_lock);
  94         pthread_cond_destroy(&sound_cond);
  95 #endif
  96 }
  97
  98 void cam_sound_set(int index, const gchar *file)
  99 {
 100         debug_msg(LOG_UI, "%d:%s", index, file ? file : "NULL");
 101         g_return_if_fail(sound_files);
 102         if (sound_files[index]) {
 103                 g_free(sound_files[index]);
 104                 sound_files[index] = NULL;
 105         }
 106         if (file)
 107                 sound_files[index] = g_strdup(file);
 108 }
 109
 110 const gchar *cam_sound_get(int index)
 111 {
 112         debug_fenter(LOG_UI);
 113         g_return_val_if_fail(sound_files, NULL);
 114         return sound_files[index];
 115 }
 116
 117 gboolean cam_sound_is_silent_mode(void)
 118 {
 119         int sound_on = -1;
 120         if (!vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &sound_on)) {
 121                 if (sound_on == FALSE) {
 122                         cam_debug(LOG_SND, "sound off mode ");
 123                         return TRUE;
 124                 }
 125         }
 126         return FALSE;
 127 }
 128
 129 gboolean cam_sound_set_mic()
 130 {
 131         int ret = SOUND_MANAGER_ERROR_NONE;
 132         bool is_available = FALSE;
 133         sound_route_e route_to_active = SOUND_ROUTE_IN_MIC;
 134
 135         /* Check if earphone mic is available */
 136         is_available = sound_manager_is_route_available(SOUND_ROUTE_IN_WIRED_ACCESSORY);
 137
 138         /* If earphone mic is available, use earphone mic, otherwise use phone mic */
 139         route_to_active = (is_available)? SOUND_ROUTE_IN_WIRED_ACCESSORY : SOUND_ROUTE_IN_MIC;
 140         cam_debug(LOG_SND, "sound route is [%d]", route_to_active);
 141
 142         ret = sound_manager_set_active_route(route_to_active);
 143         if (ret != SOUND_MANAGER_ERROR_NONE) {
 144                 cam_critical(LOG_SND, "sound_manager_set_active_route [%d]) failed", route_to_active);
 145         }
 146
 147         return ret;
 148 }
 149
 150 static void cam_sound_callback(int id, void *data)
 151 {
 152         struct appdata *ad = (struct appdata *)data;
 153         cam_ret_if(ad == NULL);
 154
 155 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 156         cam_debug(LOG_MM, "release cond");
 157
 158         /*We can not set value to  sond_cond.
 159            Bacause it can be assigned PTHREAD_COND_INITIALIZER only.
 160            PTHREAD_COND_INITIALIZER is the MECRO of pthread.
 161            So We use the sound_files, When the sound_cond is destroied, this value set to NULL.
 162          */
 163         if (sound_files)
 164                 pthread_cond_broadcast(&sound_cond);
 165
 166         ad->play_rec_sound--;
 167         DEBUG_TRACE("ad->play_rec_sound=%d", ad->play_rec_sound);
 168 #endif
 169         return;
 170 }
 171
 172 gboolean cam_sound_play(int index, void *data)
 173 {
 174         struct appdata *ad = (struct appdata *)data;
 175         cam_retv_if(ad == NULL, FALSE);
 176
 177 #ifdef CAMERA_MACHINE_I686
 178         return TRUE;
 179 #endif
 180         int step = 0, handle = 0;
 181 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 182         gboolean sync = FALSE;
 183         struct timespec timeout;
 184         struct timeval tv;
 185 #endif
 186
 187         g_return_val_if_fail(sound_files, FALSE);
 188         g_return_val_if_fail(index >= 0 && index < CAM_SOUND_EFFECT_NUM, FALSE);
 189
 190         debug_msg(LOG_UI, "%s", sound_files[index]);
 191
 192         if (!sound_files[index]) {
 193                 return FALSE;
 194         }
 195
 196         if (cam_sound_is_silent_mode()) {
 197                 warn_msg(LOG_SND, "Silent mode now");
 198                 return FALSE;
 199         }
 200 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 201         if (index == CAM_SOUND_EFFECT_REC_START1
 202             || index == CAM_SOUND_EFFECT_REC_START2
 203             || index == CAM_SOUND_EFFECT_REC_START3 || FALSE) {
 204                 sync = TRUE;
 205         }
 206 #endif
 207
 208         cam_debug(LOG_MM, " Volume step : %d", step);
 209 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 210
 211         if (EBUSY == pthread_mutex_trylock(&sound_lock)) {
 212                 cam_critical(LOG_SND,
 213                              "another effect sound is playing, try later");
 214                 return FALSE;
 215         }
 216 #endif
 217
 218         if (WAV_PLAYER_ERROR_NONE ==
 219             wav_player_start(sound_files[index], SOUND_TYPE_MEDIA,  cam_sound_callback, ad, &handle)) {
 220 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 221                 ad->play_rec_sound++;
 222                 DEBUG_TRACE("ad->play_rec_sound=%d", ad->play_rec_sound);
 223                 if (sync) {
 224                         gettimeofday(&tv, NULL);
 225                         timeout.tv_sec = tv.tv_sec + SOUND_TIMEOUT_SEC;
 226                         timeout.tv_nsec = tv.tv_usec;
 227                         if (ETIMEDOUT ==
 228                             pthread_cond_timedwait(&sound_cond, &sound_lock,
 229                                                    &timeout)) {
 230                                 if (handle > 0) {
 231                                         if (WAV_PLAYER_ERROR_NONE != wav_player_stop(handle) {
 232                                                 cam_critical(LOG_SND, "sound play failed");
 233                                         }
 234                                 }
 235                         }
 236                 }
 237 #endif
 238         } else {
 239                 cam_critical(LOG_SND, "effect sound play failed");
 240 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 241                 pthread_mutex_unlock(&sound_lock);
 242 #endif
 243                 return FALSE;
 244         }
 245 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
 246         pthread_mutex_unlock(&sound_lock);
 247 #endif
 248         return TRUE;
 249 }