4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jeongmo Yang <jm80.yang@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 /*=======================================================================================
24 =======================================================================================*/
26 #include <mm_sound_private.h>
27 #include "mm_camcorder_internal.h"
28 #include "mm_camcorder_sound.h"
30 /*---------------------------------------------------------------------------------------
31 | GLOBAL VARIABLE DEFINITIONS for internal |
32 ---------------------------------------------------------------------------------------*/
34 /*---------------------------------------------------------------------------------------
35 | LOCAL VARIABLE DEFINITIONS for internal |
36 ---------------------------------------------------------------------------------------*/
37 #define SAMPLE_SOUND_RATE 44100
38 #define DEFAULT_ACTIVE_DEVICE 0xffffffff
40 /*---------------------------------------------------------------------------------------
41 | LOCAL FUNCTION PROTOTYPES: |
42 ---------------------------------------------------------------------------------------*/
43 static void __solo_sound_callback(void *data);
45 static void __pulseaudio_play_sample_cb(pa_context *pulse_context, uint32_t stream_index, void *user_data)
47 SOUND_INFO *info = NULL;
49 mmf_return_if_fail(user_data);
51 info = (SOUND_INFO *)user_data;
53 _mmcam_dbg_log("START - idx : %d", stream_index);
55 pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
57 _mmcam_dbg_log("DONE");
62 static void __pulseaudio_context_state_cb(pa_context *pulse_context, void *user_data)
65 SOUND_INFO *info = NULL;
67 mmf_return_if_fail(user_data);
69 info = (SOUND_INFO *)user_data;
71 state = pa_context_get_state(pulse_context);
73 case PA_CONTEXT_READY:
74 _mmcam_dbg_log("pulseaudio context READY");
75 if (info->pulse_context == pulse_context) {
77 _mmcam_dbg_log("pulseaudio send signal");
78 pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
81 case PA_CONTEXT_TERMINATED:
82 if (info->pulse_context == pulse_context) {
84 _mmcam_dbg_log("Context terminated : pulseaudio send signal");
85 pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
88 case PA_CONTEXT_UNCONNECTED:
89 case PA_CONTEXT_CONNECTING:
90 case PA_CONTEXT_AUTHORIZING:
91 case PA_CONTEXT_SETTING_NAME:
92 case PA_CONTEXT_FAILED:
94 _mmcam_dbg_log("pulseaudio context %p, state %d",
95 pulse_context, state);
102 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
103 static void __pulseaudio_stream_write_cb(pa_stream *stream, size_t length, void *user_data)
105 sf_count_t read_length;
107 SOUND_INFO *info = NULL;
109 mmf_return_if_fail(user_data);
111 info = (SOUND_INFO *)user_data;
113 _mmcam_dbg_log("START");
115 data = pa_xmalloc(length);
117 read_length = (sf_count_t)(length/pa_frame_size(&(info->sample_spec)));
119 if ((sf_readf_short(info->infile, data, read_length)) != read_length) {
124 pa_stream_write(stream, data, length, pa_xfree, 0, PA_SEEK_RELATIVE);
126 info->sample_length -= length;
128 if (info->sample_length <= 0) {
129 pa_stream_set_write_callback(info->sample_stream, NULL, NULL);
130 pa_stream_finish_upload(info->sample_stream);
132 pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
133 _mmcam_dbg_log("send signal DONE");
136 _mmcam_dbg_log("DONE read_length %d", read_length);
142 static void __pulseaudio_remove_sample_finish_cb(pa_context *pulse_context, int success, void *user_data)
144 SOUND_INFO *info = NULL;
146 mmf_return_if_fail(user_data);
148 info = (SOUND_INFO *)user_data;
150 _mmcam_dbg_log("START");
152 pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
154 _mmcam_dbg_log("DONE");
158 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
160 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
161 gboolean _mmcamcorder_sound_init(MMHandleType handle, char *filename)
162 #else /* _MMCAMCORDER_UPLOAD_SAMPLE */
163 gboolean _mmcamcorder_sound_init(MMHandleType handle)
164 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
167 int sound_enable = TRUE;
168 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
169 SOUND_INFO *info = NULL;
170 pa_mainloop_api *api = NULL;
171 int error = PA_ERR_INTERNAL;
173 mmf_return_val_if_fail(hcamcorder, FALSE);
175 /* check sound play enable */
176 ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
177 "capture-sound-enable", &sound_enable,
179 _mmcam_dbg_log("Capture sound enable %d", sound_enable);
181 _mmcam_dbg_warn("capture sound disabled");
185 info = &(hcamcorder->snd_info);
187 pthread_mutex_lock(&(info->open_mutex));
189 if (info->state > _MMCAMCORDER_SOUND_STATE_NONE) {
190 _mmcam_dbg_warn("already initialized [%d]", info->state);
191 pthread_mutex_unlock(&(info->open_mutex));
195 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
196 if (info->filename) {
197 free(info->filename);
198 info->filename = NULL;
201 info->filename = strdup(filename);
202 if (info->filename == NULL) {
203 _mmcam_dbg_err("strdup failed");
206 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
208 pthread_mutex_init(&(info->play_mutex), NULL);
209 pthread_cond_init(&(info->play_cond), NULL);
211 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
213 memset (&(info->sfinfo), 0, sizeof(SF_INFO));
214 info->infile = sf_open(info->filename, SFM_READ, &(info->sfinfo));
215 if (!(info->infile)) {
216 _mmcam_dbg_err("Failed to open sound file");
217 goto SOUND_INIT_ERROR;
219 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
222 * Init Pulseaudio thread
224 /* create pulseaudio mainloop */
225 info->pulse_mainloop = pa_threaded_mainloop_new();
226 if (info->pulse_mainloop == NULL) {
227 _mmcam_dbg_err("pa_threaded_mainloop_new failed");
228 goto SOUND_INIT_ERROR;
231 /* start PA mainloop */
232 ret = pa_threaded_mainloop_start(info->pulse_mainloop);
234 _mmcam_dbg_err("pa_threaded_mainloop_start failed");
235 goto SOUND_INIT_ERROR;
238 /* lock pulseaudio thread */
239 pa_threaded_mainloop_lock(info->pulse_mainloop);
241 /* get pulseaudio api */
242 api = pa_threaded_mainloop_get_api(info->pulse_mainloop);
244 _mmcam_dbg_err("pa_threaded_mainloop_get_api failed");
245 pa_threaded_mainloop_unlock(info->pulse_mainloop);
246 goto SOUND_INIT_ERROR;
249 /* create pulseaudio context */
250 info->pulse_context = pa_context_new(api, NULL);
251 if (info->pulse_context == NULL) {
252 _mmcam_dbg_err("pa_context_new failed");
253 pa_threaded_mainloop_unlock(info->pulse_mainloop);
254 goto SOUND_INIT_ERROR;
257 /* set pulseaudio context callback */
258 pa_context_set_state_callback(info->pulse_context, __pulseaudio_context_state_cb, info);
260 if (pa_context_connect(info->pulse_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) {
261 _mmcam_dbg_err("pa_context_connect error");
264 /* wait READY state of pulse context */
266 pa_context_state_t state = pa_context_get_state(info->pulse_context);
268 _mmcam_dbg_log("pa context state is now %d", state);
270 if (!PA_CONTEXT_IS_GOOD (state)) {
271 _mmcam_dbg_log("connection failed");
275 if (state == PA_CONTEXT_READY) {
276 _mmcam_dbg_log("pa context READY");
280 /* Wait until the context is ready */
281 _mmcam_dbg_log("waiting..................");
282 pa_threaded_mainloop_wait(info->pulse_mainloop);
283 _mmcam_dbg_log("waiting DONE. check again...");
286 /* unlock pulseaudio thread */
287 pa_threaded_mainloop_unlock(info->pulse_mainloop);
289 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
293 if (pa_sndfile_read_sample_spec(info->infile, &(info->sample_spec)) < 0) {
294 _mmcam_dbg_err("Failed to determine sample specification from file");
295 goto SOUND_INIT_ERROR;
298 info->sample_spec.format = PA_SAMPLE_S16LE;
300 if (pa_sndfile_read_channel_map(info->infile, &(info->channel_map)) < 0) {
301 pa_channel_map_init_extend(&(info->channel_map), info->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
303 if (info->sample_spec.channels > 2) {
304 _mmcam_dbg_warn("Failed to determine sample specification from file");
308 info->sample_length = (size_t)info->sfinfo.frames * pa_frame_size(&(info->sample_spec));
310 pa_threaded_mainloop_lock(info->pulse_mainloop);
312 /* prepare uploading */
313 info->sample_stream = pa_stream_new(info->pulse_context, SAMPLE_SOUND_NAME, &(info->sample_spec), NULL);
314 /* set stream write callback */
315 pa_stream_set_write_callback(info->sample_stream, __pulseaudio_stream_write_cb, info);
316 /* upload sample (ASYNC) */
317 pa_stream_connect_upload(info->sample_stream, info->sample_length);
318 /* wait for upload completion */
319 pa_threaded_mainloop_wait(info->pulse_mainloop);
321 pa_threaded_mainloop_unlock(info->pulse_mainloop);
324 sf_close(info->infile);
326 #else /* _MMCAMCORDER_UPLOAD_SAMPLE */
327 if (info->sample_stream) {
328 pa_stream_connect_playback(info->sample_stream, NULL, NULL, 0, NULL, NULL);
331 pa_stream_state_t state = pa_stream_get_state(info->sample_stream);
333 if (state == PA_STREAM_READY) {
334 _mmcam_dbg_warn("device READY done");
338 if (!PA_STREAM_IS_GOOD(state)) {
339 error = pa_context_errno(info->pulse_context);
340 _mmcam_dbg_err("pa context state is not good, %d", error);
344 /* Wait until the stream is ready */
345 pa_threaded_mainloop_wait(info->pulse_mainloop);
348 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
350 //info->volume_type = PA_TIZEN_AUDIO_VOLUME_TYPE_FIXED;
351 info->volume_level = 0;
353 info->state = _MMCAMCORDER_SOUND_STATE_INIT;
355 _mmcam_dbg_log("init DONE");
357 pthread_mutex_unlock(&(info->open_mutex));
363 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
365 * Release allocated resources
367 if (info->filename) {
368 free(info->filename);
369 info->filename = NULL;
371 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
373 /* remove pulse mainloop */
374 if (info->pulse_mainloop) {
375 pa_threaded_mainloop_lock(info->pulse_mainloop);
377 /* remove pulse context */
378 if (info->pulse_context) {
379 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
380 /* remove uploaded sample */
381 if (info->sample_stream) {
382 pa_threaded_mainloop_lock(info->pulse_mainloop);
384 /* Remove sample (ASYNC) */
385 pa_operation_unref(pa_context_remove_sample(info->pulse_context, SAMPLE_SOUND_NAME, __pulseaudio_remove_sample_finish_cb, info));
387 /* Wait for async operation */
388 pa_threaded_mainloop_wait(info->pulse_mainloop);
390 #else /* _MMCAMCORDER_UPLOAD_SAMPLE */
391 /* release sample stream */
392 if (info->sample_stream) {
393 pa_stream_disconnect(info->sample_stream);
394 pa_stream_unref(info->sample_stream);
395 info->sample_stream = NULL;
397 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
399 /* Make sure we don't get any further callbacks */
400 pa_context_set_state_callback(info->pulse_context, NULL, NULL);
402 pa_context_disconnect(info->pulse_context);
403 pa_context_unref(info->pulse_context);
404 info->pulse_context = NULL;
407 pa_threaded_mainloop_unlock(info->pulse_mainloop);
409 pa_threaded_mainloop_stop(info->pulse_mainloop);
410 pa_threaded_mainloop_free(info->pulse_mainloop);
411 info->pulse_mainloop = NULL;
414 /* remove mutex and cond */
415 pthread_mutex_destroy(&(info->play_mutex));
416 pthread_cond_destroy(&(info->play_cond));
418 pthread_mutex_unlock(&(info->open_mutex));
424 gboolean _mmcamcorder_sound_play(MMHandleType handle, const char *sample_name, gboolean sync_play)
426 int sound_enable = TRUE;
427 int gain_type = VOLUME_GAIN_SHUTTER1;
429 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
430 SOUND_INFO *info = NULL;
432 pa_operation *pulse_op = NULL;
435 mmf_return_val_if_fail(hcamcorder && sample_name, FALSE);
437 /* check sound play enable */
438 mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
439 "capture-sound-enable", &sound_enable,
441 _mmcam_dbg_log("Capture sound enable %d", sound_enable);
443 _mmcam_dbg_warn("capture sound disabled");
447 info = &(hcamcorder->snd_info);
449 pthread_mutex_lock(&(info->open_mutex));
451 if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
452 _mmcam_dbg_log("not initialized state:[%d]", info->state);
453 pthread_mutex_unlock(&(info->open_mutex));
457 if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_CAPTURE)) {
458 gain_type = VOLUME_GAIN_SHUTTER2;
459 } else if (!strcmp(sample_name, _MMCAMCORDER_SAMPLE_SOUND_NAME_REC_STOP)) {
460 gain_type = VOLUME_GAIN_CAMCORDING;
463 _mmcam_dbg_log("Play start - sample name [%s]", sample_name);
466 pa_threaded_mainloop_lock(info->pulse_mainloop);
468 pulse_op = pa_ext_policy_play_sample(info->pulse_context,
473 __pulseaudio_play_sample_cb,
476 _mmcam_dbg_log("wait for signal");
477 pa_threaded_mainloop_wait(info->pulse_mainloop);
478 _mmcam_dbg_log("received signal");
480 pa_threaded_mainloop_unlock(info->pulse_mainloop);
483 pulse_op = pa_ext_policy_play_sample(info->pulse_context,
495 pa_operation_unref(pulse_op);
500 pthread_mutex_unlock(&(info->open_mutex));
502 _mmcam_dbg_log("Done");
508 gboolean _mmcamcorder_sound_finalize(MMHandleType handle)
510 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
511 SOUND_INFO *info = NULL;
513 mmf_return_val_if_fail(hcamcorder, FALSE);
515 info = &(hcamcorder->snd_info);
517 _mmcam_dbg_err("START");
519 pthread_mutex_lock(&(info->open_mutex));
521 if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
522 _mmcam_dbg_warn("not initialized");
523 pthread_mutex_unlock(&(info->open_mutex));
527 pa_threaded_mainloop_lock(info->pulse_mainloop);
529 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
533 _mmcam_dbg_log("remove sample");
535 /* Remove sample (ASYNC) */
536 pa_operation_unref(pa_context_remove_sample(info->pulse_context, SAMPLE_SOUND_NAME, __pulseaudio_remove_sample_finish_cb, info));
538 /* Wait for async operation */
539 pa_threaded_mainloop_wait(info->pulse_mainloop);
540 #else /* _MMCAMCORDER_UPLOAD_SAMPLE */
541 if (info->sample_stream) {
542 pa_stream_disconnect(info->sample_stream);
543 pa_stream_unref(info->sample_stream);
544 info->sample_stream = NULL;
546 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
549 * Release pulseaudio thread
551 _mmcam_dbg_log("release pulseaudio thread");
553 pa_context_disconnect(info->pulse_context);
555 /* Make sure we don't get any further callbacks */
556 pa_context_set_state_callback(info->pulse_context, NULL, NULL);
558 pa_context_unref(info->pulse_context);
559 info->pulse_context = NULL;
561 pa_threaded_mainloop_unlock(info->pulse_mainloop);
563 pa_threaded_mainloop_stop(info->pulse_mainloop);
564 pa_threaded_mainloop_free(info->pulse_mainloop);
565 info->pulse_mainloop = NULL;
567 #ifdef _MMCAMCORDER_UPLOAD_SAMPLE
568 if (info->filename) {
569 free(info->filename);
570 info->filename = NULL;
572 #endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
574 info->state = _MMCAMCORDER_SOUND_STATE_NONE;
576 /* release mutex and cond */
577 _mmcam_dbg_log("release play_mutex/cond");
578 pthread_mutex_destroy(&(info->play_mutex));
579 pthread_cond_destroy(&(info->play_cond));
581 pthread_mutex_unlock(&(info->open_mutex));
583 _mmcam_dbg_err("DONE");
589 void _mmcamcorder_sound_solo_play(MMHandleType handle, const char* filepath, gboolean sync_play)
591 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
593 int sound_handle = 0;
594 int ret = MM_ERROR_NONE;
595 int sound_enable = TRUE;
596 int sound_played = FALSE;
597 int gain_type = VOLUME_GAIN_SHUTTER1;
599 mmf_return_if_fail(filepath && hcamcorder);
601 _mmcam_dbg_log("START : %s", filepath);
603 _mmcamcorder_sound_solo_play_wait(handle);
605 ret = pthread_mutex_trylock(&(hcamcorder->sound_lock));
607 _mmcam_dbg_warn("g_mutex_trylock failed.[%s]", strerror(ret));
611 /* check filename to set gain_type */
612 if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE_SND) ||
613 !strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_START_SND)) {
614 if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_START_SND)) {
615 gain_type = VOLUME_GAIN_CAMCORDING;
617 gain_type = VOLUME_GAIN_SHUTTER1;
619 } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE2_SND)) {
620 gain_type = VOLUME_GAIN_SHUTTER2;
621 } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_STOP_SND)) {
622 gain_type = VOLUME_GAIN_CAMCORDING;
625 _mmcam_dbg_log("gain type 0x%x", gain_type);
627 ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
628 "capture-sound-enable", &sound_enable,
630 _mmcam_dbg_log("Capture sound enable %d", sound_enable);
633 /* send capture sound completed message */
634 pthread_mutex_unlock(&(hcamcorder->sound_lock));
639 if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON ||
640 hcamcorder->sub_context->info_image->sound_status) {
641 ret = mm_sound_play_sound(filepath, VOLUME_TYPE_FIXED | gain_type,
642 (mm_sound_stop_callback_func)__solo_sound_callback, (void*)hcamcorder, &sound_handle);
645 _mmcam_dbg_warn("skip shutter sound");
648 _mmcam_dbg_log("sync_play %d, sound_played %d, ret 0x%x", sync_play, sound_played, ret);
650 if (ret != MM_ERROR_NONE) {
651 _mmcam_dbg_err( "Capture sound play FAILED.[%x]", ret );
654 /* increase capture sound count */
655 hcamcorder->capture_sound_count++;
658 /* wait for sound completed signal */
659 if (sync_play && sound_played) {
660 struct timespec timeout;
663 gettimeofday( &tv, NULL );
664 timeout.tv_sec = tv.tv_sec + 2;
665 timeout.tv_nsec = tv.tv_usec * 1000;
667 _mmcam_dbg_log("Wait for signal");
669 if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) {
670 _mmcam_dbg_log("signal received.");
672 _mmcam_dbg_warn("capture sound play timeout.");
673 if (sound_handle > 0) {
674 mm_sound_stop_sound(sound_handle);
680 pthread_mutex_unlock(&(hcamcorder->sound_lock));
682 _mmcam_dbg_log("DONE");
687 static void __solo_sound_callback(void *data)
689 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
691 mmf_return_if_fail(hcamcorder);
693 _mmcam_dbg_log("START");
695 /* decrease capture sound count */
696 pthread_mutex_lock(&(hcamcorder->sound_lock));
697 if (hcamcorder->capture_sound_count > 0) {
698 hcamcorder->capture_sound_count--;
700 _mmcam_dbg_warn("invalid capture_sound_count %d, reset count", hcamcorder->capture_sound_count);
701 hcamcorder->capture_sound_count = 0;
703 pthread_mutex_unlock(&(hcamcorder->sound_lock));
705 _mmcam_dbg_log("Signal SEND");
706 pthread_cond_broadcast(&(hcamcorder->sound_cond));
708 _mmcam_dbg_log("DONE");
714 void _mmcamcorder_sound_solo_play_wait(MMHandleType handle)
716 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
718 mmf_return_if_fail(hcamcorder);
720 _mmcam_dbg_log("START");
722 /* check playing sound count */
723 pthread_mutex_lock(&(hcamcorder->sound_lock));
724 if (hcamcorder->capture_sound_count > 0) {
725 struct timespec timeout;
728 gettimeofday( &tv, NULL );
729 timeout.tv_sec = tv.tv_sec + 2;
730 timeout.tv_nsec = tv.tv_usec * 1000;
732 _mmcam_dbg_log("Wait for signal");
734 if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) {
735 _mmcam_dbg_log("signal received.");
737 _mmcam_dbg_warn("capture sound play timeout.");
740 _mmcam_dbg_warn("no playing sound - count %d", hcamcorder->capture_sound_count);
742 pthread_mutex_unlock(&(hcamcorder->sound_lock));
744 _mmcam_dbg_log("DONE");