src/mm_camcorder_sound.c

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23 |  INCLUDE FILES                                                                        |
  24 =======================================================================================*/
  25 #include "mm_camcorder_internal.h"
  26 #include "mm_camcorder_sound.h"
  27
  28 /*---------------------------------------------------------------------------------------
  29 |    GLOBAL VARIABLE DEFINITIONS for internal                                           |
  30 ---------------------------------------------------------------------------------------*/
  31
  32 /*---------------------------------------------------------------------------------------
  33 |    LOCAL VARIABLE DEFINITIONS for internal                                            |
  34 ---------------------------------------------------------------------------------------*/
  35
  36
  37 /*---------------------------------------------------------------------------------------
  38 |    LOCAL FUNCTION PROTOTYPES:                                                         |
  39 ---------------------------------------------------------------------------------------*/
  40
  41
  42
  43 gboolean _mmcamcorder_sound_init(MMHandleType handle)
  44 {
  45         int sound_enable = TRUE;
  46         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
  47         SOUND_INFO *info = NULL;
  48
  49         mmf_return_val_if_fail(hcamcorder, FALSE);
  50
  51         info = &(hcamcorder->snd_info);
  52
  53         g_mutex_lock(&info->open_mutex);
  54
  55         /* check sound state */
  56         if (info->state > _MMCAMCORDER_SOUND_STATE_NONE) {
  57                 _mmcam_dbg_warn("already initialized [%d]", info->state);
  58                 g_mutex_unlock(&info->open_mutex);
  59                 return TRUE;
  60         }
  61
  62         /* check sound play enable */
  63         mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
  64                 MMCAM_CAPTURE_SOUND_ENABLE, &sound_enable,
  65                 NULL);
  66         _mmcam_dbg_log("Capture sound enable %d", sound_enable);
  67         if (!sound_enable) {
  68                 _mmcam_dbg_warn("capture sound disabled");
  69                 g_mutex_unlock(&info->open_mutex);
  70                 return FALSE;
  71         }
  72
  73         /* check shutter sound policy and status of system */
  74         if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF &&
  75             hcamcorder->sub_context->info_image->sound_status == FALSE) {
  76                 _mmcam_dbg_warn("skip sound init : Sound Policy OFF and Silent status");
  77                 g_mutex_unlock(&info->open_mutex);
  78                 return FALSE;
  79         }
  80
  81         info->state = _MMCAMCORDER_SOUND_STATE_INIT;
  82
  83         _mmcam_dbg_log("init DONE");
  84
  85         g_mutex_unlock(&info->open_mutex);
  86
  87         return TRUE;
  88 }
  89
  90
  91 gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, gboolean sync_play)
  92 {
  93         int sound_enable = TRUE;
  94         const char *volume_gain = NULL;
  95
  96         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
  97         SOUND_INFO *info = NULL;
  98
  99         mmf_return_val_if_fail(hcamcorder && sample_name, FALSE);
 100
 101         /* check sound play enable */
 102         mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
 103                 MMCAM_CAPTURE_SOUND_ENABLE, &sound_enable,
 104                 NULL);
 105         _mmcam_dbg_log("Capture sound enable %d", sound_enable);
 106         if (!sound_enable) {
 107                 _mmcam_dbg_warn("capture sound disabled");
 108                 return FALSE;
 109         }
 110
 111         info = &(hcamcorder->snd_info);
 112
 113         g_mutex_lock(&info->open_mutex);
 114
 115         if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
 116                 _mmcam_dbg_log("not initialized state:[%d]", info->state);
 117                 g_mutex_unlock(&info->open_mutex);
 118                 return FALSE;
 119         }
 120
 121         if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE02))
 122                 volume_gain = "shutter2";
 123         else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP))
 124                 volume_gain = "camcording";
 125
 126         _mmcam_dbg_log("Play start - sample name [%s]", sample_name);
 127
 128         _mmcamcorder_send_sound_play_message(hcamcorder->gdbus_conn,
 129                 &hcamcorder->gdbus_info_sound, sample_name, "system", volume_gain, sync_play);
 130
 131         g_mutex_unlock(&info->open_mutex);
 132
 133         _mmcam_dbg_log("Done");
 134
 135         return TRUE;
 136 }
 137
 138
 139 gboolean _mmcamcorder_sound_finalize(MMHandleType handle)
 140 {
 141         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 142         SOUND_INFO *info = NULL;
 143
 144         mmf_return_val_if_fail(hcamcorder, FALSE);
 145
 146         info = &(hcamcorder->snd_info);
 147
 148         _mmcam_dbg_err("START");
 149
 150         g_mutex_lock(&info->open_mutex);
 151
 152         if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
 153                 _mmcam_dbg_warn("not initialized");
 154                 g_mutex_unlock(&info->open_mutex);
 155                 return TRUE;
 156         }
 157
 158         info->state = _MMCAMCORDER_SOUND_STATE_NONE;
 159
 160         _mmcam_dbg_err("DONE");
 161
 162         g_mutex_unlock(&info->open_mutex);
 163
 164         return TRUE;
 165 }
 166
 167
 168 int _mmcamcorder_sound_solo_play(MMHandleType handle, const char *sample_name, gboolean sync_play)
 169 {
 170         int sound_enable = TRUE;
 171         int current_state = MM_CAMCORDER_STATE_NONE;
 172
 173         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 174
 175         mmf_return_val_if_fail(hcamcorder && sample_name, FALSE);
 176
 177         _mmcam_dbg_log("START : [%s]", sample_name);
 178
 179         _mmcamcorder_sound_solo_play_wait(handle);
 180
 181         current_state = _mmcamcorder_get_state(handle);
 182         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
 183                 _mmcam_dbg_warn("invalid state %d", current_state);
 184                 return FALSE;
 185         }
 186
 187         /* check sound play enable */
 188         mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
 189                 MMCAM_CAPTURE_SOUND_ENABLE, &sound_enable,
 190                 NULL);
 191         _mmcam_dbg_log("Capture sound enable %d", sound_enable);
 192         if (!sound_enable) {
 193                 _mmcam_dbg_warn("capture sound disabled");
 194                 return FALSE;
 195         }
 196
 197         _mmcam_dbg_log("Play start - sample name [%s]", sample_name);
 198
 199         if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON ||
 200                 hcamcorder->sub_context->info_image->sound_status) {
 201                 _mmcamcorder_send_sound_play_message(hcamcorder->gdbus_conn,
 202                         &hcamcorder->gdbus_info_solo_sound, sample_name, "system", "shutter1", sync_play);
 203         } else {
 204                 _mmcam_dbg_warn("skip shutter sound : sound policy %d, sound status %d",
 205                         hcamcorder->shutter_sound_policy, hcamcorder->sub_context->info_image->sound_status);
 206         }
 207
 208         _mmcam_dbg_log("Done");
 209
 210         return TRUE;
 211 }
 212
 213
 214 void _mmcamcorder_sound_solo_play_wait(MMHandleType handle)
 215 {
 216         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 217
 218         mmf_return_if_fail(hcamcorder);
 219
 220         _mmcam_dbg_log("START");
 221
 222         /* check playing sound count */
 223         g_mutex_lock(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
 224
 225         if (hcamcorder->gdbus_info_solo_sound.is_playing) {
 226                 gint64 end_time = 0;
 227
 228                 _mmcam_dbg_log("Wait for signal");
 229
 230                 end_time = g_get_monotonic_time() + G_TIME_SPAN_SECOND;
 231
 232                 if (g_cond_wait_until(&hcamcorder->gdbus_info_solo_sound.sync_cond,
 233                         &hcamcorder->gdbus_info_solo_sound.sync_mutex, end_time)) {
 234                         _mmcam_dbg_log("signal received.");
 235                 } else {
 236                         _mmcam_dbg_warn("capture sound play timeout.");
 237                 }
 238         } else {
 239                 _mmcam_dbg_warn("no playing sound");
 240         }
 241
 242         g_mutex_unlock(&hcamcorder->gdbus_info_solo_sound.sync_mutex);
 243
 244         _mmcam_dbg_log("DONE");
 245
 246         return;
 247 }