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 ========================================================================================*/
28 #include <gst/gstutils.h>
29 #include <gst/gstpad.h>
32 #include "mm_camcorder_internal.h"
35 #include <gst/interfaces/colorbalance.h>
36 #include <gst/interfaces/cameracontrol.h>
37 #include <asm/types.h>
39 #include <mm_session.h>
40 #include <mm_session_private.h>
41 #include <audio-session-manager.h>
43 /*---------------------------------------------------------------------------------------
44 | GLOBAL VARIABLE DEFINITIONS for internal |
45 ---------------------------------------------------------------------------------------*/
47 /*---------------------------------------------------------------------------------------
48 | LOCAL VARIABLE DEFINITIONS for internal |
49 ---------------------------------------------------------------------------------------*/
50 #define __MMCAMCORDER_CMD_ITERATE_MAX 3
51 #define __MMCAMCORDER_SECURITY_HANDLE_DEFAULT -1
52 #define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 5
54 /*---------------------------------------------------------------------------------------
55 | LOCAL FUNCTION PROTOTYPES: |
56 ---------------------------------------------------------------------------------------*/
57 /* STATIC INTERNAL FUNCTION */
58 static gboolean __mmcamcorder_gstreamer_init(camera_conf * conf);
60 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error);
61 static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message);
62 static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message);
63 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message);
64 static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message);
65 static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
66 static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
68 static int __mmcamcorder_asm_get_event_type(int sessionType);
69 static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder);
70 static void __mmcamcorder_force_resume(mmf_camcorder_t *hcamcorder);
71 ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src,
72 ASM_sound_commands_t command,
73 unsigned int sound_status, void *cb_data);
74 ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src,
75 ASM_sound_commands_t command,
76 unsigned int sound_status, void *cb_data);
78 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
79 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
80 #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
82 /*=======================================================================================
83 | FUNCTION DEFINITIONS |
84 =======================================================================================*/
85 /*---------------------------------------------------------------------------------------
86 | GLOBAL FUNCTION DEFINITIONS: |
87 ---------------------------------------------------------------------------------------*/
89 /* Internal command functions {*/
90 int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
92 int ret = MM_ERROR_NONE;
94 int sessionType = MM_SESSION_TYPE_SHARE;
95 int errorcode = MM_ERROR_NONE;
96 int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
97 int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
98 int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
99 int play_capture_sound = TRUE;
100 int camera_device_count = MM_VIDEO_DEVICE_NUM;
101 int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
102 char *err_attr_name = NULL;
103 char *ConfCtrlFile = NULL;
104 mmf_camcorder_t *hcamcorder = NULL;
105 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
106 type_element *EvasSurfaceElement = NULL;
108 _mmcam_dbg_log("Entered");
110 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
111 mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
113 /* Create mmf_camcorder_t handle and initialize every variable */
114 hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
115 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY);
116 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
119 hcamcorder->type = 0;
120 hcamcorder->state = MM_CAMCORDER_STATE_NONE;
121 hcamcorder->sub_context = NULL;
122 hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
124 /* thread - for g_mutex_new() */
125 if (!g_thread_supported()) {
129 (hcamcorder->mtsafe).lock = g_mutex_new();
130 (hcamcorder->mtsafe).cond = g_cond_new();
132 (hcamcorder->mtsafe).cmd_lock = g_mutex_new();
133 (hcamcorder->mtsafe).state_lock = g_mutex_new();
134 (hcamcorder->mtsafe).gst_state_lock = g_mutex_new();
135 (hcamcorder->mtsafe).message_cb_lock = g_mutex_new();
136 (hcamcorder->mtsafe).vcapture_cb_lock = g_mutex_new();
137 (hcamcorder->mtsafe).vstream_cb_lock = g_mutex_new();
138 (hcamcorder->mtsafe).astream_cb_lock = g_mutex_new();
140 pthread_mutex_init(&(hcamcorder->sound_lock), NULL);
141 pthread_cond_init(&(hcamcorder->sound_cond), NULL);
143 /* Sound mutex/cond init */
144 pthread_mutex_init(&(hcamcorder->snd_info.open_mutex), NULL);
145 pthread_cond_init(&(hcamcorder->snd_info.open_cond), NULL);
147 if (info->videodev_type < MM_VIDEO_DEVICE_NONE ||
148 info->videodev_type >= MM_VIDEO_DEVICE_NUM) {
149 _mmcam_dbg_err("_mmcamcorder_create::video device type is out of range.");
150 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
151 goto _ERR_DEFAULT_VALUE_INIT;
154 /* Check and register ASM */
155 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
156 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
157 sessionType = MM_SESSION_TYPE_SHARE;
160 /* Call will not be interrupted. so does not need callback function */
161 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
162 int pid = -1; /* process id of itself */
164 /* set SHARE session */
165 if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_sh), ASM_EVENT_SHARE_MMCAMCORDER, ASM_STATE_NONE,
166 (ASM_sound_cb_t)_mmcamcorder_asm_callback_sh,
167 (void*)hcamcorder, mm_resource, &errorcode)) {
168 _mmcam_dbg_err("SHARE ASM_register_sound() failed[%x]", errorcode);
169 ret = MM_ERROR_POLICY_INTERNAL;
170 goto _ERR_DEFAULT_VALUE_INIT;
173 /* set EXCLUSIVE session */
174 if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_ex), ASM_EVENT_EXCLUSIVE_MMCAMCORDER, ASM_STATE_NONE,
175 (ASM_sound_cb_t)_mmcamcorder_asm_callback_ex,
176 (void*)hcamcorder, mm_resource, &errorcode)) {
177 _mmcam_dbg_err("EXCLUSIVE ASM_register_sound() failed[%x]", errorcode);
178 ret = MM_ERROR_POLICY_INTERNAL;
179 goto _ERR_DEFAULT_VALUE_INIT;
182 _mmcam_dbg_log("ASM handle - SHARE %d, EXCLUSIVE %d",
183 hcamcorder->asm_handle_sh, hcamcorder->asm_handle_ex);
186 /* Get Camera Configure information from Camcorder INI file */
187 __ta__( " _mmcamcorder_conf_get_info main",
188 _mmcamcorder_conf_get_info(CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
191 if (!(hcamcorder->conf_main)) {
192 _mmcam_dbg_err( "Failed to get configure(main) info." );
194 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
195 goto _ERR_AUDIO_BLOCKED;
198 __ta__(" _mmcamcorder_alloc_attribute",
199 hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
201 if (!(hcamcorder->attributes)) {
202 _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
204 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
205 goto _ERR_AUDIO_BLOCKED;
208 if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
209 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
210 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
211 "UseConfCtrl", &UseConfCtrl);
214 _mmcam_dbg_log( "Enable Configure Control system." );
216 switch (info->videodev_type) {
217 case MM_VIDEO_DEVICE_CAMERA0:
218 _mmcamcorder_conf_get_value_string(hcamcorder->conf_main,
219 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
220 "ConfCtrlFile0", &ConfCtrlFile);
222 case MM_VIDEO_DEVICE_CAMERA1:
223 _mmcamcorder_conf_get_value_string(hcamcorder->conf_main,
224 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
225 "ConfCtrlFile1", &ConfCtrlFile);
228 _mmcam_dbg_err( "Not supported camera type." );
229 ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
230 goto _ERR_ALLOC_ATTRIBUTE;
233 _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile);
235 __ta__( " _mmcamcorder_conf_get_info ctrl",
236 _mmcamcorder_conf_get_info(CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl);
239 _mmcamcorder_conf_print_info(&hcamcorder->conf_main);
240 _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
243 _mmcamcorder_conf_query_info(CONFIGURE_TYPE_CTRL, info->videodev_type, &hcamcorder->conf_ctrl);
245 if (!(hcamcorder->conf_ctrl)) {
246 _mmcam_dbg_err( "Failed to get configure(control) info." );
247 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
248 goto _ERR_ALLOC_ATTRIBUTE;
251 __ta__( " _mmcamcorder_init_convert_table",
252 ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
254 if (ret != MM_ERROR_NONE) {
255 _mmcam_dbg_warn("converting table initialize error!!");
258 __ta__( " _mmcamcorder_init_attr_from_configure",
259 ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder);
261 if (ret != MM_ERROR_NONE) {
262 _mmcam_dbg_warn("converting table initialize error!!");
265 /* Get device info, recommend preview fmt and display rotation from INI */
266 _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
267 CONFIGURE_CATEGORY_CTRL_CAMERA,
268 "RecommendPreviewFormatCapture",
271 _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
272 CONFIGURE_CATEGORY_CTRL_CAMERA,
273 "RecommendPreviewFormatRecord",
274 &rcmd_fmt_recording);
276 _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
277 CONFIGURE_CATEGORY_CTRL_CAMERA,
278 "RecommendDisplayRotation",
281 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
282 CONFIGURE_CATEGORY_MAIN_CAPTURE,
284 &play_capture_sound);
286 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
287 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
289 &camera_device_count);
291 _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
292 CONFIGURE_CATEGORY_CTRL_CAMERA,
294 &camera_facing_direction);
296 _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot[%d], cap snd[%d], dev cnt[%d], cam facing dir[%d]",
297 rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
298 play_capture_sound, camera_device_count, camera_facing_direction);
300 mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
301 MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
302 MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
303 MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
304 MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
305 MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
306 "capture-sound-enable", play_capture_sound,
309 _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
311 err_attr_name = NULL;
314 /* Get UseZeroCopyFormat value from INI */
315 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
316 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
318 &(hcamcorder->use_zero_copy_format));
319 _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
323 _mmcam_dbg_log( "Disable Configure Control system." );
324 hcamcorder->conf_ctrl = NULL;
328 __ta__( " __mmcamcorder_gstreamer_init",
329 ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
332 _mmcam_dbg_err( "Failed to initialize gstreamer!!" );
333 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
334 goto _ERR_ALLOC_ATTRIBUTE;
337 /* Make some attributes as read-only type */
338 __ta__( " _mmcamcorder_lock_readonly_attributes",
339 _mmcamcorder_lock_readonly_attributes((MMHandleType)hcamcorder);
342 /* Disable attributes in each model */
343 __ta__( " _mmcamcorder_set_disabled_attributes",
344 _mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder);
347 /* Determine state change as sync or async */
348 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
349 CONFIGURE_CATEGORY_MAIN_GENERAL,
351 &hcamcorder->sync_state_change );
352 if (!(hcamcorder->sync_state_change)) {
353 _mmcamcorder_create_command_loop((MMHandleType)hcamcorder);
356 /* Get videosink name for evas surface */
357 _mmcamcorder_conf_get_element(hcamcorder->conf_main,
358 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
359 "VideosinkElementEvas",
360 &EvasSurfaceElement);
361 if (EvasSurfaceElement) {
363 char *evassink_name = NULL;
364 mmf_attribute_t *item_evassink_name = NULL;
365 mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
367 _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name);
368 mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index);
369 item_evassink_name = &attrs->items[attr_index];
370 mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name));
371 mmf_attribute_commit(item_evassink_name);
373 _mmcam_dbg_log("Evassink name : %s", evassink_name);
376 /* get shutter sound policy */
377 vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
378 _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
380 /* Set initial state */
381 _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
382 _mmcam_dbg_log("_mmcamcorder_set_state");
384 *handle = (MMHandleType)hcamcorder;
386 return MM_ERROR_NONE;
388 _ERR_ALLOC_ATTRIBUTE:
390 /* unregister audio session manager */
392 errorcode = MM_ERROR_NONE;
393 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
394 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
395 sessionType = MM_SESSION_TYPE_SHARE;
398 if((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
399 /* unregister SHARE session */
400 if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) {
401 _mmcam_dbg_err("ASM_unregister_sound() SHARE failed(hdl:%p, stype:%d, err:%x)",
402 (void*)hcamcorder->asm_handle_sh, sessionType, errorcode);
404 /* unregister EXCLUSIVE session */
405 if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) {
406 _mmcam_dbg_err("ASM_unregister_sound() EXCLUSIVE failed(hdl:%p, stype:%d, err:%x)",
407 (void*)hcamcorder->asm_handle_ex, sessionType, errorcode);
412 _ERR_DEFAULT_VALUE_INIT:
413 g_mutex_free ((hcamcorder->mtsafe).lock);
414 g_cond_free ((hcamcorder->mtsafe).cond);
415 g_mutex_free ((hcamcorder->mtsafe).cmd_lock);
416 g_mutex_free ((hcamcorder->mtsafe).state_lock);
417 g_mutex_free ((hcamcorder->mtsafe).gst_state_lock);
419 if (hcamcorder->conf_ctrl) {
420 _mmcamcorder_conf_release_info( &hcamcorder->conf_ctrl );
423 if (hcamcorder->conf_main) {
424 _mmcamcorder_conf_release_info( &hcamcorder->conf_main );
431 int _mmcamcorder_destroy(MMHandleType handle)
433 int ret = MM_ERROR_NONE;
434 int state = MM_CAMCORDER_STATE_NONE;
435 int state_FROM = MM_CAMCORDER_STATE_NULL;
436 int state_TO = MM_CAMCORDER_STATE_NONE;
437 int sessionType = MM_SESSION_TYPE_SHARE;
438 int errorcode = MM_ERROR_NONE;
440 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
445 _mmcam_dbg_err("Not initialized");
446 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
447 goto _ERR_CAMCORDER_CMD_PRECON;
450 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
451 _mmcam_dbg_err("Another command is running.");
452 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
453 goto _ERR_CAMCORDER_CMD_PRECON;
456 state = _mmcamcorder_get_state(handle);
457 if (state != state_FROM) {
458 _mmcam_dbg_err("Wrong state(%d)", state);
459 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
460 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
463 /* Set async state */
464 ret = _mmcamcorder_set_async_state(handle, state_TO);
466 _mmcam_dbg_err("Can't set async state");
467 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
470 /* Release SubContext and pipeline */
471 if (hcamcorder->sub_context) {
472 if (hcamcorder->sub_context->element) {
473 __ta__(" _mmcamcorder_destroy_pipeline",
474 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
478 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
479 hcamcorder->sub_context = NULL;
482 /* Remove idle function which is not called yet */
483 if (hcamcorder->setting_event_id) {
484 _mmcam_dbg_log("Remove remaining idle function");
485 g_source_remove(hcamcorder->setting_event_id);
486 hcamcorder->setting_event_id = 0;
489 /* Remove attributes */
490 if (hcamcorder->attributes) {
491 _mmcamcorder_dealloc_attribute(hcamcorder->attributes);
492 hcamcorder->attributes = 0;
495 /* Remove exif info */
496 if (hcamcorder->exif_info) {
497 mm_exif_destory_exif_info(hcamcorder->exif_info);
498 hcamcorder->exif_info=NULL;
502 /* Remove command loop when async state change mode */
503 if (!hcamcorder->sync_state_change) {
504 _mmcamcorder_destroy_command_loop(handle);
507 /* Release configure info */
508 if (hcamcorder->conf_ctrl) {
509 _mmcamcorder_conf_release_info( &hcamcorder->conf_ctrl );
511 if (hcamcorder->conf_main) {
512 _mmcamcorder_conf_release_info( &hcamcorder->conf_main );
515 /* Remove messages which are not called yet */
516 _mmcamcroder_remove_message_all(handle);
519 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
520 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
521 sessionType = MM_SESSION_TYPE_SHARE;
523 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
524 /* unregister SHARE session */
525 if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) {
526 _mmcam_dbg_err("SHARE ASM_unregister_sound() failed(hdl:%p, err:%x)",
527 (void*)hcamcorder->asm_handle_sh, errorcode);
530 /* unregister EXCLUSIVE session */
531 if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) {
532 _mmcam_dbg_err("EXCLUSIVE ASM_unregister_sound() failed(hdl:%p, err:%x)",
533 (void*)hcamcorder->asm_handle_ex, errorcode);
537 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
539 /* Release lock, cond */
540 if ((hcamcorder->mtsafe).lock) {
541 g_mutex_free ((hcamcorder->mtsafe).lock);
542 (hcamcorder->mtsafe).lock = NULL;
544 if ((hcamcorder->mtsafe).cond) {
545 g_cond_free ((hcamcorder->mtsafe).cond);
546 (hcamcorder->mtsafe).cond = NULL;
548 if ((hcamcorder->mtsafe).cmd_lock) {
549 g_mutex_free ((hcamcorder->mtsafe).cmd_lock);
550 (hcamcorder->mtsafe).cmd_lock = NULL;
552 if ((hcamcorder->mtsafe).state_lock) {
553 g_mutex_free ((hcamcorder->mtsafe).state_lock);
554 (hcamcorder->mtsafe).state_lock = NULL;
556 if ((hcamcorder->mtsafe).gst_state_lock) {
557 g_mutex_free ((hcamcorder->mtsafe).gst_state_lock);
558 (hcamcorder->mtsafe).gst_state_lock = NULL;
560 if ((hcamcorder->mtsafe).message_cb_lock) {
561 g_mutex_free ((hcamcorder->mtsafe).message_cb_lock);
562 (hcamcorder->mtsafe).message_cb_lock = NULL;
564 if ((hcamcorder->mtsafe).vcapture_cb_lock) {
565 g_mutex_free ((hcamcorder->mtsafe).vcapture_cb_lock);
566 (hcamcorder->mtsafe).vcapture_cb_lock = NULL;
568 if ((hcamcorder->mtsafe).vstream_cb_lock) {
569 g_mutex_free ((hcamcorder->mtsafe).vstream_cb_lock);
570 (hcamcorder->mtsafe).vstream_cb_lock = NULL;
572 if ((hcamcorder->mtsafe).astream_cb_lock) {
573 g_mutex_free ((hcamcorder->mtsafe).astream_cb_lock);
574 (hcamcorder->mtsafe).astream_cb_lock = NULL;
577 pthread_mutex_destroy(&(hcamcorder->sound_lock));
578 pthread_cond_destroy(&(hcamcorder->sound_cond));
579 pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex));
580 pthread_cond_destroy(&(hcamcorder->snd_info.open_cond));
583 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
586 return MM_ERROR_NONE;
588 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
589 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
591 _ERR_CAMCORDER_CMD_PRECON:
593 _mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
596 _mmcam_dbg_err("Destroy fail (ret %x)", ret);
602 int _mmcamcorder_realize(MMHandleType handle)
604 int ret = MM_ERROR_NONE;
605 int state = MM_CAMCORDER_STATE_NONE;
606 int state_FROM = MM_CAMCORDER_STATE_NULL;
607 int state_TO = MM_CAMCORDER_STATE_READY;
608 int sessionType = MM_SESSION_TYPE_SHARE;
609 int errorcode = MM_ERROR_NONE;
610 int display_surface_type = MM_DISPLAY_SURFACE_X;
611 double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
612 char *videosink_element_type = NULL;
613 char *videosink_name = NULL;
615 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
620 _mmcam_dbg_err("Not initialized");
621 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
625 /* Check quick-device-close for emergency */
626 if (hcamcorder->quick_device_close) {
627 _mmcam_dbg_err("_mmcamcorder_realize can't be called!!!!");
628 ret = MM_ERROR_CAMCORDER_DEVICE;
629 goto _ERR_CAMCORDER_CMD_PRECON;
632 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
633 _mmcam_dbg_err("Another command is running.");
634 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
635 goto _ERR_CAMCORDER_CMD_PRECON;
638 state = _mmcamcorder_get_state(handle);
639 if (state != state_FROM) {
640 _mmcam_dbg_err("Wrong state(%d)", state);
641 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
642 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
645 /* set camera state to vconf key */
646 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
647 int vconf_camera_state = 0;
649 /* get current camera state of vconf key */
650 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
651 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
653 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
654 vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
657 /* Set async state */
658 ret = _mmcamcorder_set_async_state(handle, state_TO);
660 _mmcam_dbg_err("Can't set async state");
661 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
664 mm_camcorder_get_attributes(handle, NULL,
665 MMCAM_MODE, &hcamcorder->type,
666 MMCAM_DISPLAY_SURFACE, &display_surface_type,
667 MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
670 /* Get profile mode */
671 _mmcam_dbg_log("Profile mode set is (%d)", hcamcorder->type);
673 /* Check and make SHARE session as PLAYING */
674 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
675 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
676 sessionType = MM_SESSION_TYPE_SHARE;
678 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
679 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
681 switch (hcamcorder->type) {
682 case MM_CAMCORDER_MODE_AUDIO:
683 mm_resource = ASM_RESOURCE_NONE;
685 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
687 mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
691 if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER,
692 ASM_STATE_PLAYING, mm_resource, &errorcode)) {
693 _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode);
694 ret = MM_ERROR_POLICY_BLOCKED;
695 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
699 /* alloc sub context */
700 hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
701 if(!hcamcorder->sub_context) {
702 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
703 goto _ERR_CAMCORDER_CMD;
706 /* Set basic configure information */
707 if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
708 hcamcorder->sub_context->is_modified_rate = TRUE;
711 _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
712 CONFIGURE_CATEGORY_MAIN_CAPTURE,
714 &(hcamcorder->sub_context->bencbin_capture));
716 switch (display_surface_type) {
717 case MM_DISPLAY_SURFACE_X:
718 videosink_element_type = strdup("VideosinkElementX");
720 case MM_DISPLAY_SURFACE_EVAS:
721 videosink_element_type = strdup("VideosinkElementEvas");
723 case MM_DISPLAY_SURFACE_GL:
724 videosink_element_type = strdup("VideosinkElementGL");
726 case MM_DISPLAY_SURFACE_NULL:
727 videosink_element_type = strdup("VideosinkElementNull");
730 videosink_element_type = strdup("VideosinkElementX");
734 /* check string of videosink element */
735 if (videosink_element_type) {
736 _mmcamcorder_conf_get_element(hcamcorder->conf_main,
737 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
738 videosink_element_type,
739 &hcamcorder->sub_context->VideosinkElement);
740 free(videosink_element_type);
741 videosink_element_type = NULL;
743 _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
744 display_surface_type);
746 _mmcamcorder_conf_get_element(hcamcorder->conf_main,
747 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
748 _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
749 &hcamcorder->sub_context->VideosinkElement );
752 _mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
753 _mmcam_dbg_log("Videosink name : %s", videosink_name);
755 _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
756 CONFIGURE_CATEGORY_CTRL_CAPTURE,
757 "SensorEncodedCapture",
758 &(hcamcorder->sub_context->SensorEncodedCapture));
759 _mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture);
761 /* create pipeline */
762 __ta__(" _mmcamcorder_create_pipeline",
763 ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type);
765 if (ret != MM_ERROR_NONE) {
766 /* check internal error of gstreamer */
767 if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
768 ret = hcamcorder->sub_context->error_code;
769 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
772 /* release sub context */
773 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
774 hcamcorder->sub_context = NULL;
775 goto _ERR_CAMCORDER_CMD;
778 /* set command function */
779 ret = _mmcamcorder_set_functions(handle, hcamcorder->type);
780 if (ret != MM_ERROR_NONE) {
781 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
782 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
783 hcamcorder->sub_context = NULL;
784 goto _ERR_CAMCORDER_CMD;
787 _mmcamcorder_set_state(handle, state_TO);
789 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
791 return MM_ERROR_NONE;
794 /* set async state and (set async cancel or set state) are pair. */
795 _mmcamcorder_set_async_cancel(handle);
797 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
798 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
800 _ERR_CAMCORDER_CMD_PRECON:
801 _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
802 hcamcorder->type, state, ret);
804 /* rollback camera state to vconf key */
805 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
806 int vconf_camera_state = 0;
808 /* get current camera state of vconf key */
809 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
810 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
812 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
813 vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
820 int _mmcamcorder_unrealize(MMHandleType handle)
822 int ret = MM_ERROR_NONE;
823 int state = MM_CAMCORDER_STATE_NONE;
824 int state_FROM = MM_CAMCORDER_STATE_READY;
825 int state_TO = MM_CAMCORDER_STATE_NULL;
826 int sessionType = MM_SESSION_TYPE_SHARE;
827 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
829 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
834 _mmcam_dbg_err("Not initialized");
835 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
839 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
840 _mmcam_dbg_err("Another command is running.");
841 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
842 goto _ERR_CAMCORDER_CMD_PRECON;
845 state = _mmcamcorder_get_state(handle);
846 if (state != state_FROM) {
847 _mmcam_dbg_err("Wrong state(%d)", state);
848 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
849 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
852 /* set async state */
853 ret = _mmcamcorder_set_async_state(handle, state_TO);
854 if (ret != MM_ERROR_NONE) {
855 _mmcam_dbg_err("Can't set async state");
856 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
859 /* Release SubContext */
860 if (hcamcorder->sub_context) {
861 /* destroy pipeline */
862 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
863 /* Deallocate SubContext */
864 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
865 hcamcorder->sub_context = NULL;
868 /* Deinitialize main context member */
870 hcamcorder->command = NULL;
872 /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
873 if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
874 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
875 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
876 sessionType = MM_SESSION_TYPE_SHARE;
879 /* Call session is not ended here */
880 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
881 mm_resource = ASM_RESOURCE_NONE;
883 switch (hcamcorder->type) {
884 case MM_CAMCORDER_MODE_AUDIO:
885 mm_resource = ASM_RESOURCE_NONE;
887 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
889 mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
893 /* STOP SHARE session */
894 if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER,
895 ASM_STATE_STOP, mm_resource, &ret)) {
896 _mmcam_dbg_err("SHARE Set state to STOP failed 0x%x", ret);
901 _mmcamcorder_set_state(handle, state_TO);
903 /* set camera state to vconf key */
904 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
905 int vconf_camera_state = 0;
907 /* get current camera state of vconf key */
908 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
909 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
911 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
912 vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
915 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
917 return MM_ERROR_NONE;
919 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
920 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
922 _ERR_CAMCORDER_CMD_PRECON:
924 _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
925 hcamcorder->type, state, ret);
930 int _mmcamcorder_start(MMHandleType handle)
932 int ret = MM_ERROR_NONE;
933 int state = MM_CAMCORDER_STATE_NONE;
934 int state_FROM = MM_CAMCORDER_STATE_READY;
935 int state_TO =MM_CAMCORDER_STATE_PREPARE;
937 _MMCamcorderSubContext *sc = NULL;
938 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
943 _mmcam_dbg_err("Not initialized");
944 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
948 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
949 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
951 /* check quick-device-close for emergency */
952 if (hcamcorder->quick_device_close) {
953 _mmcam_dbg_err("_mmcamcorder_start can't be called!!!!");
954 ret = MM_ERROR_CAMCORDER_DEVICE;
955 goto _ERR_CAMCORDER_CMD_PRECON;
958 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
959 _mmcam_dbg_err("Another command is running.");
960 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
961 goto _ERR_CAMCORDER_CMD_PRECON;
964 state = _mmcamcorder_get_state(handle);
965 if (state != state_FROM) {
966 _mmcam_dbg_err("Wrong state(%d)", state);
967 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
968 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
971 /* initialize error code */
972 hcamcorder->sub_context->error_code = MM_ERROR_NONE;
974 /* set async state */
975 ret = _mmcamcorder_set_async_state(handle, state_TO);
976 if (ret != MM_ERROR_NONE) {
977 _mmcam_dbg_err("Can't set async state");
978 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
981 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
982 if (ret != MM_ERROR_NONE) {
983 goto _ERR_CAMCORDER_CMD;
986 _mmcamcorder_set_state(handle, state_TO);
988 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
989 int vconf_camera_state = 0;
991 _mmcamcorder_set_attribute_to_camsensor(handle);
993 /* check camera state of vconf key */
994 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
996 /* set camera state to vconf key */
997 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
999 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1000 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1003 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1005 return MM_ERROR_NONE;
1008 /* set async state and (set async cancel or set state) are pair. */
1009 _mmcamcorder_set_async_cancel(handle);
1011 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1012 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1014 _ERR_CAMCORDER_CMD_PRECON:
1015 /* check internal error of gstreamer */
1016 if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
1017 ret = hcamcorder->sub_context->error_code;
1018 hcamcorder->sub_context->error_code = MM_ERROR_NONE;
1020 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1023 _mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
1024 hcamcorder->type, state, ret);
1029 int _mmcamcorder_stop(MMHandleType handle)
1031 int ret = MM_ERROR_NONE;
1032 int state = MM_CAMCORDER_STATE_NONE;
1033 int state_FROM = MM_CAMCORDER_STATE_PREPARE;
1034 int state_TO = MM_CAMCORDER_STATE_READY;
1037 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1042 _mmcam_dbg_err("Not initialized");
1043 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1047 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1048 _mmcam_dbg_err("Another command is running.");
1049 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1050 goto _ERR_CAMCORDER_CMD_PRECON;
1053 state = _mmcamcorder_get_state(handle);
1054 if (state != state_FROM) {
1055 _mmcam_dbg_err("Wrong state(%d)", state);
1056 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1057 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1060 /* set async state */
1061 ret = _mmcamcorder_set_async_state(handle, state_TO);
1062 if (ret != MM_ERROR_NONE) {
1063 _mmcam_dbg_err("Can't set async state");
1064 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1067 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP);
1068 if (ret != MM_ERROR_NONE) {
1069 goto _ERR_CAMCORDER_CMD;
1072 /* KPI : frame rate */
1073 frame_rate=_mmcamcorder_video_average_framerate(handle);
1074 __ta__(__tafmt__("MM_CAM_006:: Frame per sec : %d", frame_rate), ;);
1076 _mmcamcorder_set_state(handle, state_TO);
1078 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1079 int vconf_camera_state = 0;
1081 /* check camera state of vconf key */
1082 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1084 /* set camera state to vconf key */
1085 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
1087 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1088 vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
1091 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1093 return MM_ERROR_NONE;
1096 /* set async state and (set async cancel or set state) are pair. */
1097 _mmcamcorder_set_async_cancel(handle);
1099 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1100 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1102 _ERR_CAMCORDER_CMD_PRECON:
1104 _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
1105 hcamcorder->type, state, ret);
1111 int _mmcamcorder_capture_start(MMHandleType handle)
1113 int ret = MM_ERROR_NONE;
1114 int state = MM_CAMCORDER_STATE_NONE;
1115 int state_FROM_0 = MM_CAMCORDER_STATE_PREPARE;
1116 int state_FROM_1 = MM_CAMCORDER_STATE_RECORDING;
1117 int state_FROM_2 = MM_CAMCORDER_STATE_PAUSED;
1118 int state_TO = MM_CAMCORDER_STATE_CAPTURING;
1119 char *err_name = NULL;
1121 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1126 _mmcam_dbg_err("Not initialized");
1127 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1131 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1132 _mmcam_dbg_err("Another command is running.");
1133 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1134 goto _ERR_CAMCORDER_CMD_PRECON;
1137 state = _mmcamcorder_get_state(handle);
1138 if (state != state_FROM_0 &&
1139 state != state_FROM_1 &&
1140 state != state_FROM_2) {
1141 _mmcam_dbg_err("Wrong state(%d)", state);
1142 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1143 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1146 /* set async state */
1147 ret = _mmcamcorder_set_async_state(handle, state_TO);
1148 if (ret != MM_ERROR_NONE) {
1149 _mmcam_dbg_err("Can't set async state");
1150 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1153 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE);
1154 if (ret != MM_ERROR_NONE) {
1155 goto _ERR_CAMCORDER_CMD;
1158 /* Do not change state when recording snapshot capture */
1159 if (state == state_FROM_0) {
1160 _mmcamcorder_set_state(handle, state_TO);
1163 /* Init break continuous shot attr */
1164 mm_camcorder_set_attributes(handle, &err_name, "capture-break-cont-shot", 0, NULL);
1166 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1168 return MM_ERROR_NONE;
1171 /* set async state and (set async cancel or set state) are pair. */
1172 _mmcamcorder_set_async_cancel(handle);
1174 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1175 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1177 _ERR_CAMCORDER_CMD_PRECON:
1179 _mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
1180 hcamcorder->type, state, ret);
1185 int _mmcamcorder_capture_stop(MMHandleType handle)
1187 int ret = MM_ERROR_NONE;
1188 int state = MM_CAMCORDER_STATE_NONE;
1189 int state_FROM = MM_CAMCORDER_STATE_CAPTURING;
1190 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1191 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1196 _mmcam_dbg_err("Not initialized");
1197 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1201 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1202 _mmcam_dbg_err("Another command is running.");
1203 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1204 goto _ERR_CAMCORDER_CMD_PRECON;
1207 state = _mmcamcorder_get_state(handle);
1208 if (state != state_FROM) {
1209 _mmcam_dbg_err("Wrong state(%d)", state);
1210 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1211 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1214 /* set async state */
1215 ret = _mmcamcorder_set_async_state(handle, state_TO);
1216 if (ret != MM_ERROR_NONE) {
1217 _mmcam_dbg_err("Can't set async state");
1218 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1221 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
1222 if (ret != MM_ERROR_NONE) {
1223 goto _ERR_CAMCORDER_CMD;
1226 _mmcamcorder_set_state(handle, state_TO);
1228 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1230 MMTA_ACUM_ITEM_END("Real First Capture Start", FALSE);
1232 return MM_ERROR_NONE;
1235 /* set async state and (set async cancel or set state) are pair. */
1236 _mmcamcorder_set_async_cancel(handle);
1238 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1239 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1241 _ERR_CAMCORDER_CMD_PRECON:
1243 _mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
1244 hcamcorder->type, state, ret);
1249 int _mmcamcorder_record(MMHandleType handle)
1251 int ret = MM_ERROR_NONE;
1252 int state = MM_CAMCORDER_STATE_NONE;
1253 int state_FROM1 = MM_CAMCORDER_STATE_PREPARE;
1254 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1255 int state_TO = MM_CAMCORDER_STATE_RECORDING;
1256 int sessionType = MM_SESSION_TYPE_SHARE;
1258 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1263 _mmcam_dbg_err("Not initialized");
1264 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1268 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1269 _mmcam_dbg_err("Another command is running.");
1270 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1271 goto _ERR_CAMCORDER_CMD_PRECON;
1274 state = _mmcamcorder_get_state(handle);
1275 if (state != state_FROM1 && state != state_FROM2) {
1276 _mmcam_dbg_err("Wrong state(%d)", state);
1277 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1278 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1281 /* initialize error code */
1282 hcamcorder->sub_context->error_code = MM_ERROR_NONE;
1284 /* Check and register EXCLUSIVE ASM */
1285 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
1286 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
1287 sessionType = MM_SESSION_TYPE_SHARE;
1289 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
1291 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
1293 switch (hcamcorder->type) {
1294 case MM_CAMCORDER_MODE_AUDIO:
1295 mm_resource = ASM_RESOURCE_NONE;
1297 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
1299 mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
1303 if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
1304 ASM_STATE_PLAYING, mm_resource, &errorcode)) {
1305 _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode);
1306 ret = MM_ERROR_POLICY_BLOCKED;
1307 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1311 /* set async state */
1312 ret = _mmcamcorder_set_async_state(handle, state_TO);
1313 if (ret != MM_ERROR_NONE) {
1314 _mmcam_dbg_err("Can't set async state");
1315 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1318 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
1319 if (ret != MM_ERROR_NONE) {
1320 goto _ERR_CAMCORDER_CMD;
1323 _mmcamcorder_set_state(handle, state_TO);
1325 /* set camera state to vconf key */
1326 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1327 int vconf_camera_state = 0;
1329 /* get current camera state of vconf key */
1330 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1331 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING);
1333 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1334 vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING);
1337 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1339 return MM_ERROR_NONE;
1342 /* set async state and (set async cancel or set state) are pair. */
1343 _mmcamcorder_set_async_cancel(handle);
1345 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1346 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1348 _ERR_CAMCORDER_CMD_PRECON:
1349 /* check internal error of gstreamer */
1350 if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
1351 ret = hcamcorder->sub_context->error_code;
1352 hcamcorder->sub_context->error_code = MM_ERROR_NONE;
1354 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1357 _mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
1358 hcamcorder->type, state, ret);
1364 int _mmcamcorder_pause(MMHandleType handle)
1366 int ret = MM_ERROR_NONE;
1367 int state = MM_CAMCORDER_STATE_NONE;
1368 int state_FROM = MM_CAMCORDER_STATE_RECORDING;
1369 int state_TO = MM_CAMCORDER_STATE_PAUSED;
1371 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1376 _mmcam_dbg_err("Not initialized");
1377 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1381 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1382 _mmcam_dbg_err("Another command is running.");
1383 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1384 goto _ERR_CAMCORDER_CMD_PRECON;
1387 state = _mmcamcorder_get_state(handle);
1388 if (state != state_FROM) {
1389 _mmcam_dbg_err("Wrong state(%d)", state);
1390 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1391 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1394 /* set async state */
1395 ret = _mmcamcorder_set_async_state(handle, state_TO);
1396 if (ret != MM_ERROR_NONE) {
1397 _mmcam_dbg_err("Can't set async state");
1398 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1401 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE);
1402 if (ret != MM_ERROR_NONE) {
1403 goto _ERR_CAMCORDER_CMD;
1406 _mmcamcorder_set_state(handle, state_TO);
1408 /* set camera state to vconf key */
1409 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1410 int vconf_camera_state = 0;
1412 /* get current camera state of vconf key */
1413 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1414 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1416 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1417 vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1420 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1422 return MM_ERROR_NONE;
1425 /* set async state and (set async cancel or set state) are pair. */
1426 _mmcamcorder_set_async_cancel(handle);
1428 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1429 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1431 _ERR_CAMCORDER_CMD_PRECON:
1433 _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
1434 hcamcorder->type, state, ret);
1440 int _mmcamcorder_commit(MMHandleType handle)
1442 int ret = MM_ERROR_NONE;
1443 int state = MM_CAMCORDER_STATE_NONE;
1444 int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1445 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1446 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1448 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1453 _mmcam_dbg_err("Not initialized");
1454 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1458 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1459 _mmcam_dbg_err("Another command is running.");
1460 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1461 goto _ERR_CAMCORDER_CMD_PRECON;
1464 state = _mmcamcorder_get_state(handle);
1465 if (state != state_FROM1 && state != state_FROM2) {
1466 _mmcam_dbg_err("Wrong state(%d)", state);
1467 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1468 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1471 /* set async state */
1472 ret = _mmcamcorder_set_async_state(handle, state_TO);
1473 if (ret != MM_ERROR_NONE) {
1474 _mmcam_dbg_err("Can't set async state");
1475 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1478 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
1479 if (ret != MM_ERROR_NONE) {
1480 goto _ERR_CAMCORDER_CMD;
1483 _mmcamcorder_set_state(handle,state_TO);
1485 /* set camera state to vconf key */
1486 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1487 int vconf_camera_state = 0;
1489 /* get current camera state of vconf key */
1490 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1491 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1493 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1494 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1497 /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
1498 if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
1499 int sessionType = MM_SESSION_TYPE_SHARE;
1500 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
1502 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
1503 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
1504 sessionType = MM_SESSION_TYPE_SHARE;
1507 /* Call session is not ended here */
1508 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
1509 switch (hcamcorder->type) {
1510 case MM_CAMCORDER_MODE_AUDIO:
1511 mm_resource = ASM_RESOURCE_NONE;
1513 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
1515 mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
1519 /* STOP EXCLUSIVE session */
1520 if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
1521 ASM_STATE_STOP, mm_resource, &ret)) {
1522 _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret);
1527 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1529 return MM_ERROR_NONE;
1532 /* set async state and (set async cancel or set state) are pair. */
1533 _mmcamcorder_set_async_cancel(handle);
1535 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1536 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1538 _ERR_CAMCORDER_CMD_PRECON:
1540 _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
1541 hcamcorder->type, state, ret);
1547 int _mmcamcorder_cancel(MMHandleType handle)
1549 int ret = MM_ERROR_NONE;
1550 int state = MM_CAMCORDER_STATE_NONE;
1551 int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1552 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1553 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1554 int sessionType = MM_SESSION_TYPE_SHARE;
1556 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1561 _mmcam_dbg_err("Not initialized");
1562 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1566 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1567 _mmcam_dbg_err("Another command is running.");
1568 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1569 goto _ERR_CAMCORDER_CMD_PRECON;
1572 state = _mmcamcorder_get_state(handle);
1573 if (state != state_FROM1 && state != state_FROM2) {
1574 _mmcam_dbg_err("Wrong state(%d)", state);
1575 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1576 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1579 /* set async state */
1580 ret = _mmcamcorder_set_async_state(handle, state_TO);
1581 if (ret != MM_ERROR_NONE) {
1582 _mmcam_dbg_err("Can't set async state");
1583 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1586 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL);
1587 if (ret != MM_ERROR_NONE) {
1588 goto _ERR_CAMCORDER_CMD;
1591 _mmcamcorder_set_state(handle, state_TO);
1593 /* read session type */
1594 if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
1595 _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
1596 sessionType = MM_SESSION_TYPE_SHARE;
1599 /* Call session is not ended here */
1600 if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
1601 ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
1603 switch (hcamcorder->type) {
1604 case MM_CAMCORDER_MODE_AUDIO:
1605 mm_resource = ASM_RESOURCE_NONE;
1607 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
1609 mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
1613 /* STOP EXCLUSIVE session */
1614 if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
1615 ASM_STATE_STOP, mm_resource, &ret)) {
1616 _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret);
1620 /* set camera state to vconf key */
1621 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1622 int vconf_camera_state = 0;
1624 /* get current camera state of vconf key */
1625 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1626 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1628 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1629 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1632 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1634 return MM_ERROR_NONE;
1637 /* set async state and (set async cancel or set state) are pair. */
1638 _mmcamcorder_set_async_cancel(handle);
1640 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1641 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1643 _ERR_CAMCORDER_CMD_PRECON:
1645 _mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
1646 hcamcorder->type, state, ret);
1650 /* } Internal command functions */
1653 int _mmcamcorder_commit_async_end(MMHandleType handle)
1657 _mmcam_dbg_warn("_mmcamcorder_commit_async_end : MM_CAMCORDER_STATE_PREPARE");
1658 _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_PREPARE);
1660 return MM_ERROR_NONE;
1664 int _mmcamcorder_set_message_callback(MMHandleType handle, MMMessageCallback callback, void *user_data)
1666 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1668 _mmcam_dbg_log("%p", hcamcorder);
1670 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1672 if (callback == NULL) {
1673 _mmcam_dbg_warn("Message Callback is disabled, because application sets it to NULL");
1676 if (!_MMCAMCORDER_TRYLOCK_MESSAGE_CALLBACK(hcamcorder)) {
1677 _mmcam_dbg_warn("Application's message callback is running now");
1678 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1681 /* set message callback to message handle */
1682 hcamcorder->msg_cb = callback;
1683 hcamcorder->msg_cb_param = user_data;
1685 _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
1687 return MM_ERROR_NONE;
1691 int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_video_stream_callback callback, void *user_data)
1693 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1697 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1699 if (callback == NULL) {
1700 _mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
1703 if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
1704 _mmcam_dbg_warn("Application's video stream callback is running now");
1705 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1708 hcamcorder->vstream_cb = callback;
1709 hcamcorder->vstream_cb_param = user_data;
1711 _MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
1713 return MM_ERROR_NONE;
1717 int _mmcamcorder_set_audio_stream_callback(MMHandleType handle, mm_camcorder_audio_stream_callback callback, void *user_data)
1719 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1723 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1725 if (callback == NULL) {
1726 _mmcam_dbg_warn("Audio Stream Callback is disabled, because application sets it to NULL");
1729 if (!_MMCAMCORDER_TRYLOCK_ASTREAM_CALLBACK(hcamcorder)) {
1730 _mmcam_dbg_warn("Application's audio stream callback is running now");
1731 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1734 hcamcorder->astream_cb = callback;
1735 hcamcorder->astream_cb_param = user_data;
1737 _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
1739 return MM_ERROR_NONE;
1743 int _mmcamcorder_set_video_capture_callback(MMHandleType handle, mm_camcorder_video_capture_callback callback, void *user_data)
1745 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1749 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1751 if (callback == NULL) {
1752 _mmcam_dbg_warn("Video Capture Callback is disabled, because application sets it to NULLL");
1755 if (!_MMCAMCORDER_TRYLOCK_VCAPTURE_CALLBACK(hcamcorder)) {
1756 _mmcam_dbg_warn("Application's video capture callback is running now");
1757 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1760 hcamcorder->vcapture_cb = callback;
1761 hcamcorder->vcapture_cb_param = user_data;
1763 _MMCAMCORDER_UNLOCK_VCAPTURE_CALLBACK(hcamcorder);
1765 return MM_ERROR_NONE;
1768 int _mmcamcorder_get_current_state(MMHandleType handle)
1770 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1774 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1776 return _mmcamcorder_get_state(handle);
1779 int _mmcamcorder_init_focusing(MMHandleType handle)
1782 int state = MM_CAMCORDER_STATE_NONE;
1783 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
1784 int af_range = MM_CAMCORDER_AUTO_FOCUS_NORMAL;
1785 int sensor_focus_mode = 0;
1786 int sensor_af_range = 0;
1787 int current_focus_mode = 0;
1788 int current_af_range = 0;
1789 mmf_camcorder_t *hcamcorder = NULL;
1790 _MMCamcorderSubContext *sc = NULL;
1791 mmf_attrs_t *attr = NULL;
1792 GstCameraControl *control = NULL;
1796 hcamcorder = MMF_CAMCORDER(handle);
1797 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1799 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
1800 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1802 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1803 _mmcam_dbg_err("Another command is running.");
1804 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1807 state = _mmcamcorder_get_state(handle);
1809 if (state == MM_CAMCORDER_STATE_CAPTURING ||
1810 state < MM_CAMCORDER_STATE_PREPARE) {
1811 _mmcam_dbg_err( "Not proper state. state[%d]", state );
1812 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1813 return MM_ERROR_CAMCORDER_INVALID_STATE;
1816 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1817 _mmcam_dbg_log("Can't cast Video source into camera control.");
1818 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1819 return MM_ERROR_NONE;
1821 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
1823 ret = gst_camera_control_stop_auto_focus(control);
1825 _mmcam_dbg_err("Auto focusing stop fail.");
1826 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1827 return MM_ERROR_CAMCORDER_DEVICE_IO;
1830 /* Initialize lens position */
1831 attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
1832 mm_camcorder_get_attributes(handle, NULL,
1833 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
1834 MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
1836 sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
1837 sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
1839 gst_camera_control_get_focus(control, ¤t_focus_mode, ¤t_af_range);
1841 if (current_focus_mode != sensor_focus_mode ||
1842 current_af_range != sensor_af_range) {
1843 ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
1845 _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
1849 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1852 _mmcam_dbg_log("Lens init success.");
1853 return MM_ERROR_NONE;
1855 _mmcam_dbg_err("Lens init fail.");
1856 return MM_ERROR_CAMCORDER_DEVICE_IO;
1860 int _mmcamcorder_adjust_focus(MMHandleType handle, int direction)
1863 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
1864 int ret = MM_ERROR_UNKNOWN;
1865 char *err_attr_name = NULL;
1867 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1868 mmf_return_val_if_fail(direction, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1872 state = _mmcamcorder_get_state(handle);
1873 if (state == MM_CAMCORDER_STATE_CAPTURING ||
1874 state < MM_CAMCORDER_STATE_PREPARE) {
1875 _mmcam_dbg_err("Not proper state. state[%d]", state);
1876 return MM_ERROR_CAMCORDER_INVALID_STATE;
1879 /* TODO : call a auto or manual focus function */
1880 ret = mm_camcorder_get_attributes(handle, &err_attr_name,
1881 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
1883 if (ret != MM_ERROR_NONE) {
1884 _mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret);
1885 SAFE_FREE (err_attr_name);
1889 if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) {
1890 return _mmcamcorder_adjust_manual_focus(handle, direction);
1891 } else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO ||
1892 focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ||
1893 focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
1894 return _mmcamcorder_adjust_auto_focus(handle);
1896 _mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode);
1897 return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
1901 int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
1906 int focus_level = 0;
1907 float unit_level = 0;
1908 GstCameraControl *control = NULL;
1909 _MMCamcorderSubContext *sc = NULL;
1910 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1914 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1915 mmf_return_val_if_fail(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL != 1, MM_ERROR_CAMCORDER_NOT_SUPPORTED);
1916 mmf_return_val_if_fail((direction >= MM_CAMCORDER_MF_LENS_DIR_FORWARD) &&
1917 (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
1918 MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1920 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
1921 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1923 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1924 _mmcam_dbg_log("Can't cast Video source into camera control.");
1925 return MM_ERROR_NONE;
1927 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
1929 /* TODO : get max, min level */
1930 if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) {
1931 _mmcam_dbg_warn("Total level of manual focus of MMF is greater than that of the camera driver.");
1934 unit_level = ((float)max_level - (float)min_level)/(float)(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL - 1);
1936 if (!gst_camera_control_get_focus_level(control, &cur_level)) {
1937 _mmcam_dbg_err("Can't get current level of manual focus.");
1938 return MM_ERROR_CAMCORDER_DEVICE_IO;
1941 //TODO : adjust unit level value
1942 if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD) {
1943 focus_level = cur_level + unit_level;
1944 } else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD) {
1945 focus_level = cur_level - unit_level;
1948 if (focus_level > max_level) {
1949 focus_level = max_level;
1950 } else if (focus_level < min_level) {
1951 focus_level = min_level;
1954 if (!gst_camera_control_set_focus_level(control, focus_level)) {
1955 _mmcam_dbg_err("Manual focusing fail.");
1956 return MM_ERROR_CAMCORDER_DEVICE_IO;
1959 return MM_ERROR_NONE;
1963 int _mmcamcorder_adjust_auto_focus(MMHandleType handle)
1966 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1967 GstCameraControl *control = NULL;
1968 _MMCamcorderSubContext *sc = NULL;
1970 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1974 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
1976 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1977 _mmcam_dbg_log("Can't cast Video source into camera control.");
1978 return MM_ERROR_NONE;
1980 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
1983 ret = gst_camera_control_start_auto_focus(control);
1985 _mmcam_dbg_log("Auto focusing start success.");
1986 return MM_ERROR_NONE;
1988 _mmcam_dbg_err("Auto focusing start fail.");
1989 return MM_ERROR_CAMCORDER_DEVICE_IO;
1993 int _mmcamcorder_stop_focusing(MMHandleType handle)
1995 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1996 _MMCamcorderSubContext *sc = NULL;
1999 GstCameraControl *control = NULL;
2001 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2005 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2007 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
2008 _mmcam_dbg_err("Another command is running.");
2009 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2012 state = _mmcamcorder_get_state(handle);
2013 if (state == MM_CAMCORDER_STATE_CAPTURING ||
2014 state < MM_CAMCORDER_STATE_PREPARE) {
2015 _mmcam_dbg_err( "Not proper state. state[%d]", state );
2016 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2017 return MM_ERROR_CAMCORDER_INVALID_STATE;
2020 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2021 _mmcam_dbg_log("Can't cast Video source into camera control.");
2022 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2023 return MM_ERROR_NONE;
2025 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2027 ret = gst_camera_control_stop_auto_focus(control);
2029 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2032 _mmcam_dbg_log("Auto focusing stop success.");
2033 return MM_ERROR_NONE;
2035 _mmcam_dbg_err("Auto focusing stop fail.");
2036 return MM_ERROR_CAMCORDER_DEVICE_IO;
2041 /*-----------------------------------------------
2042 | CAMCORDER INTERNAL LOCAL |
2043 -----------------------------------------------*/
2045 __mmcamcorder_gstreamer_init(camera_conf * conf)
2047 static const int max_argc = 10;
2051 gchar **argv = NULL;
2053 gboolean ret = FALSE;
2054 type_string_array *GSTInitOption = NULL;
2056 mmf_return_val_if_fail(conf, FALSE);
2061 argc = malloc(sizeof(int));
2062 argv = malloc(sizeof(gchar *) * max_argc);
2064 if (!argc || !argv) {
2068 memset(argv, 0, sizeof(gchar *) * max_argc);
2072 argv[0] = g_strdup("mmcamcorder");
2075 _mmcamcorder_conf_get_value_string_array(conf,
2076 CONFIGURE_CATEGORY_MAIN_GENERAL,
2079 if (GSTInitOption != NULL && GSTInitOption->value) {
2080 cnt_str = GSTInitOption->count;
2081 for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
2083 argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
2087 _mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
2089 for (i = 0; i < *argc; i++) {
2090 _mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
2093 /* initializing gstreamer */
2094 __ta__(" gst_init_check",
2095 ret = gst_init_check (argc, &argv, &err);
2099 _mmcam_dbg_err("Could not initialize GStreamer: %s ",
2100 err ? err->message : "unknown error occurred");
2107 for (i = 0; i < *argc; i++) {
2127 _mmcam_dbg_err("failed to initialize gstreamer");
2143 int _mmcamcorder_get_state(MMHandleType handle)
2146 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2148 mmf_return_val_if_fail(hcamcorder, -1);
2150 _MMCAMCORDER_LOCK_STATE(handle);
2152 state = hcamcorder->state;
2153 _mmcam_dbg_log("state=%d",state);
2155 _MMCAMCORDER_UNLOCK_STATE(handle);
2161 void _mmcamcorder_set_state(MMHandleType handle, int state)
2164 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2165 _MMCamcorderMsgItem msg;
2167 mmf_return_if_fail(hcamcorder);
2171 _MMCAMCORDER_LOCK_STATE(handle);
2173 old_state = hcamcorder->state;
2174 if(old_state != state) {
2175 hcamcorder->state = state;
2176 hcamcorder->target_state = state;
2178 _mmcam_dbg_log("set state[%d] and send state-changed message", state);
2180 /* To discern who changes the state */
2181 switch (hcamcorder->state_change_by_system) {
2182 case _MMCAMCORDER_STATE_CHANGE_BY_ASM:
2183 msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM;
2184 msg.param.state.code = hcamcorder->asm_event_code;
2186 case _MMCAMCORDER_STATE_CHANGE_NORMAL:
2188 msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
2189 msg.param.state.code = MM_ERROR_NONE;
2193 msg.param.state.previous = old_state;
2194 msg.param.state.current = state;
2196 _mmcam_dbg_log("_mmcamcroder_send_message : msg : %p, id:%x", &msg, msg.id);
2197 _mmcamcroder_send_message(handle, &msg);
2200 _MMCAMCORDER_UNLOCK_STATE(handle);
2206 int _mmcamcorder_get_async_state(MMHandleType handle)
2209 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2211 _MMCAMCORDER_LOCK_STATE(handle);
2212 state = hcamcorder->target_state;
2214 _MMCAMCORDER_UNLOCK_STATE(handle);
2219 int _mmcamcorder_set_async_state(MMHandleType handle, int target_state)
2221 int error = MM_ERROR_NONE;
2222 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2224 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_CONDITION);
2228 if (hcamcorder->sync_state_change) {
2232 _MMCAMCORDER_LOCK_STATE(handle);
2234 /* check changing state */
2235 if (hcamcorder->state != hcamcorder->target_state) {
2236 _mmcam_dbg_warn("State is changing now.");
2237 error = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2238 goto _SET_ASYNC_END;
2241 /* check already set */
2242 if (hcamcorder->state == target_state) {
2243 _mmcam_dbg_log("Target state already set.");
2244 error = MM_ERROR_CAMCORDER_INVALID_STATE;
2245 goto _SET_ASYNC_END;
2248 hcamcorder->target_state = target_state;
2250 _mmcam_dbg_log("Done");
2253 _MMCAMCORDER_UNLOCK_STATE(handle);
2258 gboolean _mmcamcorder_set_async_cancel(MMHandleType handle)
2260 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2262 mmf_return_val_if_fail(hcamcorder, FALSE);
2266 if (hcamcorder->sync_state_change) {
2270 _MMCAMCORDER_LOCK_STATE(handle);
2272 if (hcamcorder->target_state != hcamcorder->state) {
2273 hcamcorder->target_state = hcamcorder->state;
2274 _mmcam_dbg_log("Async state change is canceled.");
2275 _MMCAMCORDER_UNLOCK_STATE(handle);
2278 _mmcam_dbg_log("Nothing to be cancel or Already processed.");
2281 _MMCAMCORDER_UNLOCK_STATE(handle);
2287 gboolean _mmcamcorder_is_state_changing(MMHandleType handle)
2289 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2291 mmf_return_val_if_fail(hcamcorder, FALSE);
2293 _mmcam_dbg_log("(%d)", (hcamcorder->target_state != hcamcorder->state));
2295 if (hcamcorder->sync_state_change) {
2299 _MMCAMCORDER_LOCK_STATE(handle);
2301 if (hcamcorder->target_state != hcamcorder->state) {
2302 _MMCAMCORDER_UNLOCK_STATE(handle);
2306 _MMCAMCORDER_UNLOCK_STATE(handle);
2312 _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
2315 _MMCamcorderSubContext *sc = NULL;
2319 /* alloc container */
2320 sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext));
2321 mmf_return_val_if_fail(sc != NULL, NULL);
2324 memset(sc, 0x00, sizeof(_MMCamcorderSubContext));
2326 sc->element_num = _MMCamcorder_PIPELINE_ELEMENT_NUM;
2328 /* alloc info for each mode */
2330 case MM_CAMCORDER_MODE_AUDIO:
2331 sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo));
2332 if(sc->info_audio == NULL) {
2333 _mmcam_dbg_err("Failed to alloc info structure");
2337 memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo));
2339 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2341 sc->info_image = malloc( sizeof(_MMCamcorderImageInfo));
2342 if(sc->info_image == NULL) {
2343 _mmcam_dbg_err("Failed to alloc info structure");
2347 memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo));
2349 /* init sound status */
2350 sc->info_image->sound_status = _SOUND_STATUS_INIT;
2352 sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo));
2353 if(sc->info_video == NULL) {
2354 _mmcam_dbg_err("Failed to alloc info structure");
2355 free(sc->info_image);
2359 memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo));
2363 /* alloc element array */
2364 sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
2366 _mmcam_dbg_err("Failed to alloc element structure");
2367 if (type == MM_CAMCORDER_MODE_AUDIO) {
2368 free(sc->info_audio);
2370 free(sc->info_image);
2371 free(sc->info_video);
2377 for (i = 0; i< sc->element_num; i++) {
2378 sc->element[i].id = _MMCAMCORDER_NONE;
2379 sc->element[i].gst = NULL;
2382 sc->fourcc = 0x80000000;
2383 sc->cam_stability_count = 0;
2384 sc->drop_vframe = 0;
2385 sc->pass_first_vframe = 0;
2386 sc->is_modified_rate = FALSE;
2392 void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc)
2402 if (sc->info_image) {
2403 _mmcam_dbg_log("release info_image");
2404 free(sc->info_image);
2405 sc->info_image = NULL;
2408 if (sc->info_video) {
2409 _mmcam_dbg_log("release info_video");
2410 free(sc->info_video);
2411 sc->info_video = NULL;
2414 if (sc->info_audio) {
2415 _mmcam_dbg_log("release info_audio");
2416 free(sc->info_audio);
2417 sc->info_audio = NULL;
2428 int _mmcamcorder_set_functions(MMHandleType handle, int type)
2430 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2435 case MM_CAMCORDER_MODE_AUDIO:
2436 hcamcorder->command = _mmcamcorder_audio_command;
2438 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2440 hcamcorder->command = _mmcamcorder_video_capture_command;
2444 return MM_ERROR_NONE;
2448 gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpointer data)
2450 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2451 _MMCamcorderMsgItem msg;
2452 _MMCamcorderSubContext *sc = NULL;
2454 mmf_return_val_if_fail(hcamcorder, FALSE);
2455 mmf_return_val_if_fail(message, FALSE);
2456 //_mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message));
2458 switch (GST_MESSAGE_TYPE(message)) {
2459 case GST_MESSAGE_UNKNOWN:
2460 _mmcam_dbg_log("GST_MESSAGE_UNKNOWN");
2462 case GST_MESSAGE_EOS:
2464 _mmcam_dbg_log ("Got EOS from element \"%s\".",
2465 GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
2467 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2468 mmf_return_val_if_fail(sc, TRUE);
2470 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
2471 mmf_return_val_if_fail(sc->info_video, TRUE);
2472 if (sc->info_video->b_commiting) {
2473 _mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
2476 mmf_return_val_if_fail(sc->info_audio, TRUE);
2477 if (sc->info_audio->b_commiting) {
2478 _mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
2482 sc->bget_eos = TRUE;
2486 case GST_MESSAGE_ERROR:
2490 gst_message_parse_error(message, &err, &debug);
2492 _mmcam_dbg_err ("GSTERR: %s", err->message);
2493 _mmcam_dbg_err ("Error Debug: %s", debug);
2495 __mmcamcorder_handle_gst_error((MMHandleType)hcamcorder, message, err);
2501 case GST_MESSAGE_WARNING:
2505 gst_message_parse_warning (message, &err, &debug);
2507 _mmcam_dbg_warn("GSTWARN: %s", err->message);
2509 __mmcamcorder_handle_gst_warning((MMHandleType)hcamcorder, message, err);
2515 case GST_MESSAGE_INFO:
2516 _mmcam_dbg_log("GST_MESSAGE_INFO");
2518 case GST_MESSAGE_TAG:
2519 _mmcam_dbg_log("GST_MESSAGE_TAG");
2521 case GST_MESSAGE_BUFFERING:
2522 _mmcam_dbg_log("GST_MESSAGE_BUFFERING");
2524 case GST_MESSAGE_STATE_CHANGED:
2528 GstElement *pipeline = NULL;
2530 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2531 if ((sc) && (sc->element)) {
2532 if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
2533 pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
2534 if (message->src == (GstObject*)pipeline) {
2535 vnewstate = (GValue*)gst_structure_get_value(message->structure, "new-state");
2536 newstate = (GstState)vnewstate->data[0].v_int;
2537 _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]",gst_element_state_get_name(newstate));
2543 case GST_MESSAGE_STATE_DIRTY:
2544 _mmcam_dbg_log("GST_MESSAGE_STATE_DIRTY");
2546 case GST_MESSAGE_STEP_DONE:
2547 _mmcam_dbg_log("GST_MESSAGE_STEP_DONE");
2549 case GST_MESSAGE_CLOCK_PROVIDE:
2550 _mmcam_dbg_log("GST_MESSAGE_CLOCK_PROVIDE");
2552 case GST_MESSAGE_CLOCK_LOST:
2553 _mmcam_dbg_log("GST_MESSAGE_CLOCK_LOST");
2555 case GST_MESSAGE_NEW_CLOCK:
2558 gst_message_parse_new_clock(message, &clock);
2559 _mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL"));
2562 case GST_MESSAGE_STRUCTURE_CHANGE:
2563 _mmcam_dbg_log("GST_MESSAGE_STRUCTURE_CHANGE");
2565 case GST_MESSAGE_STREAM_STATUS:
2566 _mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");
2568 case GST_MESSAGE_APPLICATION:
2569 _mmcam_dbg_log("GST_MESSAGE_APPLICATION");
2571 case GST_MESSAGE_ELEMENT:
2572 _mmcam_dbg_log("GST_MESSAGE_ELEMENT");
2574 if (gst_structure_has_name(message->structure, "avsysvideosrc-AF") ||
2575 gst_structure_has_name(message->structure, "camerasrc-AF")) {
2576 int focus_state = 0;
2578 gst_structure_get_int(message->structure, "focus-state", &focus_state);
2579 _mmcam_dbg_log("Focus State:%d", focus_state);
2581 msg.id = MM_MESSAGE_CAMCORDER_FOCUS_CHANGED;
2582 msg.param.code = focus_state;
2583 _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
2584 } else if (gst_structure_has_name(message->structure, "camerasrc-HDR")) {
2588 gst_structure_get_int(message->structure, "progress", &progress);
2589 gst_structure_get_int(message->structure, "status", &status);
2590 _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status);
2592 msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS;
2593 msg.param.code = progress;
2594 _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
2595 } else if (gst_structure_has_name(message->structure, "camerasrc-FD")) {
2597 const GValue *g_value = gst_structure_get_value(message->structure, "face-info");;
2598 GstCameraControlFaceDetectInfo *fd_info = NULL;
2599 MMCamFaceDetectInfo *cam_fd_info = NULL;
2602 fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
2605 if (fd_info == NULL) {
2606 _mmcam_dbg_warn("fd_info is NULL");
2610 cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo));
2611 if (cam_fd_info == NULL) {
2612 _mmcam_dbg_warn("cam_fd_info alloc failed");
2620 /* set total face count */
2621 cam_fd_info->num_of_faces = fd_info->num_of_faces;
2623 if (cam_fd_info->num_of_faces > 0) {
2624 cam_fd_info->face_info = (MMCamFaceInfo *)malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces);
2625 if (cam_fd_info->face_info) {
2626 /* set information of each face */
2627 for (i = 0 ; i < fd_info->num_of_faces ; i++) {
2628 cam_fd_info->face_info[i].id = fd_info->face_info[i].id;
2629 cam_fd_info->face_info[i].score = fd_info->face_info[i].score;
2630 cam_fd_info->face_info[i].rect.x = fd_info->face_info[i].rect.x;
2631 cam_fd_info->face_info[i].rect.y = fd_info->face_info[i].rect.y;
2632 cam_fd_info->face_info[i].rect.width = fd_info->face_info[i].rect.width;
2633 cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
2635 _mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
2636 fd_info->face_info[i].id,
2637 fd_info->face_info[i].score,
2638 fd_info->face_info[i].rect.x,
2639 fd_info->face_info[i].rect.y,
2640 fd_info->face_info[i].rect.width,
2641 fd_info->face_info[i].rect.height);
2645 _mmcam_dbg_warn("MMCamFaceInfo alloc failed");
2647 /* free allocated memory that is not sent */
2652 cam_fd_info->face_info = NULL;
2656 /* send message - cam_fd_info should be freed by application */
2657 msg.id = MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO;
2658 msg.param.data = cam_fd_info;
2659 msg.param.size = sizeof(MMCamFaceDetectInfo);
2662 _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
2665 /* free fd_info allocated by plugin */
2670 case GST_MESSAGE_SEGMENT_START:
2671 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_START");
2673 case GST_MESSAGE_SEGMENT_DONE:
2674 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_DONE");
2676 case GST_MESSAGE_DURATION:
2677 _mmcam_dbg_log("GST_MESSAGE_DURATION");
2679 case GST_MESSAGE_LATENCY:
2680 _mmcam_dbg_log("GST_MESSAGE_LATENCY");
2682 case GST_MESSAGE_ASYNC_START:
2683 _mmcam_dbg_log("GST_MESSAGE_ASYNC_START");
2685 case GST_MESSAGE_ASYNC_DONE:
2686 _mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");
2688 case GST_MESSAGE_ANY:
2689 _mmcam_dbg_log("GST_MESSAGE_ANY");
2692 _mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message));
2700 GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
2702 GstElement *element = NULL;
2704 gchar *debug_info = NULL;
2706 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2707 _MMCamcorderSubContext *sc = NULL;
2709 mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
2710 mmf_return_val_if_fail(message, GST_BUS_PASS);
2712 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2713 mmf_return_val_if_fail(sc, GST_BUS_PASS);
2715 sc->error_code = MM_ERROR_NONE;
2717 if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
2718 /* parse error message */
2719 gst_message_parse_error(message, &err, &debug_info);
2722 _mmcam_dbg_warn("failed to parse error message");
2723 return GST_BUS_PASS;
2727 _mmcam_dbg_err("GST ERROR : %s", debug_info);
2732 /* set videosrc element to compare */
2733 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2735 /* check domain[RESOURCE] and element[VIDEOSRC] */
2736 if (err->domain == GST_RESOURCE_ERROR &&
2737 GST_ELEMENT_CAST(message->src) == element) {
2738 switch (err->code) {
2739 case GST_RESOURCE_ERROR_BUSY:
2740 _mmcam_dbg_err("Camera device [busy]");
2741 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
2743 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
2744 case GST_RESOURCE_ERROR_OPEN_WRITE:
2745 _mmcam_dbg_err("Camera device [open failed]");
2746 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
2748 case GST_RESOURCE_ERROR_OPEN_READ:
2749 _mmcam_dbg_err("Camera device [register trouble]");
2750 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
2752 case GST_RESOURCE_ERROR_NOT_FOUND:
2753 _mmcam_dbg_err("Camera device [device not found]");
2754 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
2756 case GST_RESOURCE_ERROR_TOO_LAZY:
2757 _mmcam_dbg_err("Camera device [timeout]");
2758 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
2760 case GST_RESOURCE_ERROR_SETTINGS:
2761 _mmcam_dbg_err("Camera device [not supported]");
2762 sc->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
2764 case GST_RESOURCE_ERROR_FAILED:
2765 _mmcam_dbg_err("Camera device [working failed].");
2766 sc->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
2769 _mmcam_dbg_err("Camera device [General(%d)]", err->code);
2770 sc->error_code = MM_ERROR_CAMCORDER_DEVICE;
2774 sc->error_occurs = TRUE;
2779 /* store error code and drop this message if cmd is running */
2780 if (sc->error_code != MM_ERROR_NONE) {
2781 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
2782 _mmcam_dbg_err("cmd is running and will be returned with this error %x",
2784 return GST_BUS_DROP;
2787 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2791 return GST_BUS_PASS;
2795 static int __mmcamcorder_asm_get_event_type(int sessionType)
2797 switch (sessionType) {
2798 case MM_SESSION_TYPE_SHARE:
2799 return ASM_EVENT_SHARE_MMCAMCORDER;
2800 case MM_SESSION_TYPE_EXCLUSIVE:
2801 return ASM_EVENT_EXCLUSIVE_MMCAMCORDER;
2802 case MM_SESSION_TYPE_NOTIFY:
2803 return ASM_EVENT_NOTIFY;
2804 case MM_SESSION_TYPE_CALL:
2805 return ASM_EVENT_CALL;
2806 case MM_SESSION_TYPE_VIDEOCALL:
2807 return ASM_EVENT_VIDEOCALL;
2808 case MM_SESSION_TYPE_ALARM:
2809 return ASM_EVENT_ALARM;
2811 return ASM_EVENT_SHARE_MMCAMCORDER;
2815 ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src,
2816 ASM_sound_commands_t command,
2817 unsigned int sound_status, void* cb_data)
2819 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
2820 int current_state = MM_CAMCORDER_STATE_NONE;
2821 ASM_cb_result_t cb_res = ASM_CB_RES_NONE;
2823 mmf_return_val_if_fail((MMHandleType)hcamcorder, ASM_CB_RES_NONE);
2825 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
2826 if (current_state <= MM_CAMCORDER_STATE_NONE ||
2827 current_state >= MM_CAMCORDER_STATE_NUM) {
2828 _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d, %d)", hcamcorder, command, current_state);
2831 /* set value to inform a status is changed by asm */
2832 hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM;
2833 /* set ASM event code for sending it to application */
2834 hcamcorder->asm_event_code = event_src;
2836 _mmcam_dbg_log("ASM SHARE callback : event code 0x%x, command 0x%x", event_src, command);
2839 case ASM_COMMAND_STOP:
2840 case ASM_COMMAND_PAUSE:
2841 _mmcam_dbg_log("Got msg from asm to Stop or Pause(%d, %d)", command, current_state);
2843 __mmcamcorder_force_stop(hcamcorder);
2844 cb_res = ASM_CB_RES_STOP;
2846 _mmcam_dbg_log("Finish opeartion. Camera is released.(%d)", cb_res);
2848 case ASM_COMMAND_PLAY:
2849 _mmcam_dbg_log("Got msg from asm to Play(%d, %d)", command, current_state);
2851 if (current_state >= MM_CAMCORDER_STATE_PREPARE) {
2852 _mmcam_dbg_log("Already start previewing");
2854 __mmcamcorder_force_resume(hcamcorder);
2857 cb_res = ASM_CB_RES_PLAYING;
2859 _mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res);
2861 case ASM_COMMAND_RESUME:
2863 _MMCamcorderMsgItem msg;
2865 _mmcam_dbg_log("Got msg from asm to Resume(%d, %d)", command, current_state);
2867 msg.id = MM_MESSAGE_READY_TO_RESUME;
2868 _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
2869 cb_res = ASM_CB_RES_PLAYING;
2871 _mmcam_dbg_log("Finish opeartion.(%d)", cb_res);
2874 default: /* should not be reached here */
2875 cb_res = ASM_CB_RES_PLAYING;
2876 _mmcam_dbg_err("Command err.");
2881 hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
2887 ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src,
2888 ASM_sound_commands_t command,
2889 unsigned int sound_status, void* cb_data)
2891 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
2892 int current_state = MM_CAMCORDER_STATE_NONE;
2893 ASM_cb_result_t cb_res = ASM_CB_RES_NONE;
2895 mmf_return_val_if_fail((MMHandleType)hcamcorder, ASM_CB_RES_NONE);
2897 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
2899 _mmcam_dbg_log("ASM EXCLUSIVE callback : event code 0x%x, command 0x%x, current state %d",
2900 event_src, command, current_state);
2902 /* set value to inform a status is changed by asm */
2903 hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM;
2905 /* set ASM event code for sending it to application */
2906 hcamcorder->asm_event_code = event_src;
2909 case ASM_COMMAND_STOP:
2910 case ASM_COMMAND_PAUSE:
2911 _mmcam_dbg_log("Got msg from asm to Stop or Pause(%d, %d)", command, current_state);
2913 __mmcamcorder_force_stop(hcamcorder);
2914 cb_res = ASM_CB_RES_STOP;
2916 _mmcam_dbg_log("Finish opeartion. Camera is released.(%d)", cb_res);
2918 case ASM_COMMAND_PLAY:
2919 _mmcam_dbg_log("Got msg from asm to Play(%d, %d)", command, current_state);
2921 if (current_state >= MM_CAMCORDER_STATE_PREPARE) {
2922 _mmcam_dbg_log("Already start previewing");
2924 __mmcamcorder_force_resume(hcamcorder);
2927 cb_res = ASM_CB_RES_PLAYING;
2929 _mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res);
2931 case ASM_COMMAND_RESUME:
2933 _MMCamcorderMsgItem msg;
2935 _mmcam_dbg_log("Got msg from asm to Resume(%d, %d)", command, current_state);
2937 msg.id = MM_MESSAGE_READY_TO_RESUME;
2938 _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
2939 cb_res = ASM_CB_RES_PLAYING;
2941 _mmcam_dbg_log("Finish opeartion.(%d)", cb_res);
2944 default: /* should not be reached here */
2945 cb_res = ASM_CB_RES_PLAYING;
2946 _mmcam_dbg_err("Command err.");
2951 hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
2957 int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
2959 int ret = MM_ERROR_NONE;
2960 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2961 _MMCamcorderSubContext *sc = NULL;
2962 GstElement *pipeline = NULL;
2964 _mmcam_dbg_log("handle : %x, type : %d", handle, type);
2966 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2968 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2969 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2972 case MM_CAMCORDER_MODE_AUDIO:
2973 __ta__(" _mmcamcorder_create_audio_pipeline",
2974 ret = _mmcamcorder_create_audio_pipeline(handle);
2976 if (ret != MM_ERROR_NONE) {
2980 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2982 __ta__(" _mmcamcorder_create_preview_pipeline",
2983 ret = _mmcamcorder_create_preview_pipeline(handle);
2985 if (ret != MM_ERROR_NONE) {
2989 /* connect capture signal */
2990 if (!sc->bencbin_capture) {
2991 __ta__(" _mmcamcorder_connect_capture_signal",
2992 ret = _mmcamcorder_connect_capture_signal(handle);
2994 if (ret != MM_ERROR_NONE) {
3001 pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
3002 if (type != MM_CAMCORDER_MODE_AUDIO) {
3003 if (hcamcorder->sync_state_change) {
3004 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
3006 ret = _mmcamcorder_gst_set_state_async(handle, pipeline, GST_STATE_READY);
3007 if (ret == GST_STATE_CHANGE_FAILURE) {
3008 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3012 #ifdef _MMCAMCORDER_GET_DEVICE_INFO
3013 if (!_mmcamcorder_get_device_info(handle)) {
3014 _mmcam_dbg_err("Getting device information error!!");
3017 _mmcam_dbg_log("ret[%x]", ret);
3022 void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type)
3024 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3025 _MMCamcorderSubContext *sc = NULL;
3029 mmf_return_if_fail(hcamcorder);
3031 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3032 mmf_return_if_fail(sc);
3036 bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst));
3038 /* Inside each pipeline destroy function, Set GST_STATE_NULL to Main pipeline */
3040 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
3041 _mmcamcorder_destroy_video_capture_pipeline(handle);
3043 case MM_CAMCORDER_MODE_AUDIO:
3044 _mmcamcorder_destroy_audio_pipeline(handle);
3047 _mmcam_dbg_err("unknown type %d", type);
3051 _mmcam_dbg_log("Pipeline clear!!");
3053 /* Remove pipeline message callback */
3054 g_source_remove(hcamcorder->pipeline_cb_event_id);
3056 /* Remove remained message in bus */
3058 GstMessage *gst_msg = NULL;
3059 while ((gst_msg = gst_bus_pop(bus)) != NULL) {
3060 _mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder);
3061 gst_message_unref( gst_msg );
3064 gst_object_unref( bus );
3068 /* checking unreleased element */
3069 for (i = 0 ; i < _MMCamcorder_PIPELINE_ELEMENT_NUM ; i++ ) {
3070 if (sc->element[i].gst) {
3071 if (GST_IS_ELEMENT(sc->element[i].gst)) {
3072 _mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]",
3074 GST_OBJECT_NAME(sc->element[i].gst),
3075 GST_OBJECT_REFCOUNT_VALUE(sc->element[i].gst),
3076 gst_element_state_get_name (GST_STATE (sc->element[i].gst)));
3077 g_object_weak_unref(G_OBJECT(sc->element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc);
3079 _mmcam_dbg_warn("The element[%d] is still aliving, check it", sc->element[i].id);
3082 sc->element[i].id = _MMCAMCORDER_NONE;
3083 sc->element[i].gst = NULL;
3089 int _mmcamcorder_gst_set_state_async(MMHandleType handle, GstElement *pipeline, GstState target_state)
3091 GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3093 _MMCAMCORDER_LOCK_GST_STATE(handle);
3094 setChangeReturn = gst_element_set_state(pipeline, target_state);
3095 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3097 return setChangeReturn;
3101 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
3102 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data)
3104 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
3106 mmf_return_val_if_fail(hcamcorder, FALSE);
3110 _mmcamcorder_set_attribute_to_camsensor((MMHandleType)hcamcorder);
3113 hcamcorder->setting_event_id = 0;
3115 _mmcam_dbg_log("Done");
3120 #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
3123 int _mmcamcorder_gst_set_state (MMHandleType handle, GstElement *pipeline, GstState target_state)
3126 GstState pipeline_state = GST_STATE_VOID_PENDING;
3127 GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3128 GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE;
3129 GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND;
3131 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3133 _mmcam_dbg_log("Set state to %d", target_state);
3135 _MMCAMCORDER_LOCK_GST_STATE(handle);
3137 for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
3138 setChangeReturn = gst_element_set_state(pipeline, target_state);
3139 _mmcam_dbg_log("gst_element_set_state[%d] return %d",
3140 target_state, setChangeReturn);
3141 if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
3142 getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
3143 switch (getChangeReturn) {
3144 case GST_STATE_CHANGE_NO_PREROLL:
3145 _mmcam_dbg_log("status=GST_STATE_CHANGE_NO_PREROLL.");
3146 case GST_STATE_CHANGE_SUCCESS:
3147 /* if we reached the final target state, exit */
3148 if (pipeline_state == target_state) {
3149 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3150 return MM_ERROR_NONE;
3153 case GST_STATE_CHANGE_ASYNC:
3154 _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC.");
3157 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3158 _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE.");
3159 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3162 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3163 _mmcam_dbg_err("timeout of gst_element_get_state()!!");
3164 return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3166 usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL);
3169 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3171 _mmcam_dbg_err("Failure. gst_element_set_state timeout!!");
3173 return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3177 /* For performance check */
3178 int _mmcamcorder_video_current_framerate(MMHandleType handle)
3180 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3181 _MMCamcorderSubContext *sc = NULL;
3183 mmf_return_val_if_fail(hcamcorder, -1);
3185 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3186 mmf_return_val_if_fail(sc, -1);
3188 return sc->kpi.current_fps;
3192 int _mmcamcorder_video_average_framerate(MMHandleType handle)
3194 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3195 _MMCamcorderSubContext *sc = NULL;
3197 mmf_return_val_if_fail(hcamcorder, -1);
3199 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3200 mmf_return_val_if_fail(sc, -1);
3202 return sc->kpi.average_fps;
3206 void _mmcamcorder_video_current_framerate_init(MMHandleType handle)
3208 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3209 _MMCamcorderSubContext *sc = NULL;
3211 mmf_return_if_fail(hcamcorder);
3213 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3214 mmf_return_if_fail(sc);
3216 memset(&(sc->kpi), 0x00, sizeof(_MMCamcorderKPIMeasure));
3221 /* Async state change */
3222 void _mmcamcorder_delete_command_info(__MMCamcorderCmdInfo *cmdinfo)
3229 static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
3234 int result = MM_ERROR_NONE;
3235 int current_state = MM_CAMCORDER_STATE_NONE;
3237 mmf_return_if_fail(hcamcorder);
3239 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3241 _mmcam_dbg_log( "Force STOP MMFW Camcorder" );
3243 for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) {
3244 itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX;
3245 switch (current_state) {
3246 case MM_CAMCORDER_STATE_CAPTURING:
3248 _MMCamcorderSubContext *sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
3249 _MMCamcorderImageInfo *info = NULL;
3251 mmf_return_if_fail(sc);
3252 mmf_return_if_fail((info = sc->info_image));
3254 _mmcam_dbg_log("Stop capturing.");
3256 /* if caturing isn't finished, waiting for 2 sec to finish real capture operation. check 'info->capturing'. */
3257 mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL,
3258 MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
3261 for (i = 0; i < 20 && info->capturing; i++) {
3266 _mmcam_dbg_err("Timeout. Can't check stop capturing.");
3269 while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3270 _mmcam_dbg_warn("Can't stop capturing.(%x)", result);
3275 case MM_CAMCORDER_STATE_RECORDING:
3276 case MM_CAMCORDER_STATE_PAUSED:
3278 _mmcam_dbg_log("Stop recording.");
3280 while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3281 _mmcam_dbg_warn("Can't commit.(%x)", result);
3285 case MM_CAMCORDER_STATE_PREPARE:
3287 _mmcam_dbg_log("Stop preview.");
3289 while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3290 _mmcam_dbg_warn("Can't stop preview.(%x)", result);
3294 case MM_CAMCORDER_STATE_READY:
3296 _mmcam_dbg_log("unrealize");
3298 if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
3299 _mmcam_dbg_warn("Can't unrealize.(%x)", result);
3303 case MM_CAMCORDER_STATE_NULL:
3305 _mmcam_dbg_log("Already stopped.");
3309 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3312 _mmcam_dbg_log( "Done." );
3318 static void __mmcamcorder_force_resume(mmf_camcorder_t *hcamcorder)
3321 int result = MM_ERROR_NONE;
3323 int current_state = MM_CAMCORDER_STATE_NONE;
3325 mmf_return_if_fail(hcamcorder);
3327 _mmcam_dbg_log("Force RESUME MMFW Camcorder");
3329 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3331 for (loop = 0 ; current_state < MM_CAMCORDER_STATE_PREPARE && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) {
3332 itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX;
3334 switch (current_state) {
3335 case MM_CAMCORDER_STATE_NULL:
3336 _mmcam_dbg_log("Realize");
3337 while ((itr_cnt--) && ((result = _mmcamcorder_realize((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3338 _mmcam_dbg_warn("Can't realize.(%x)", result);
3341 case MM_CAMCORDER_STATE_READY:
3342 _mmcam_dbg_log("Start previewing");
3344 while ((itr_cnt--) && ((result = _mmcamcorder_start((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3345 _mmcam_dbg_warn("Can't start previewing.(%x)", result);
3349 _mmcam_dbg_log("Abnormal state.");
3353 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3356 _mmcam_dbg_log( "Done." );
3361 int _mmcamcorder_create_command_loop(MMHandleType handle)
3363 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3364 _MMCamcorderCommand *cmd;
3366 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3370 cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd);
3371 cmd->cmd_queue = g_queue_new();
3372 mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION);
3374 sem_init(&cmd->sema, 0, 0);
3376 if (pthread_create(&cmd->pCommandThread, NULL, _mmcamcorder_command_loop_thread, hcamcorder)) {
3377 perror("Make Command Thread Fail");
3378 return MM_ERROR_COMMON_UNKNOWN;
3381 return MM_ERROR_NONE;
3385 int _mmcamcorder_destroy_command_loop(MMHandleType handle)
3387 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3388 _MMCamcorderCommand *cmd;
3390 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3393 cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd);
3394 mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION);
3396 _mmcamcorder_append_simple_command(handle, _MMCAMCORDER_CMD_QUIT);
3398 sem_post(&cmd->sema); /* why is this needed? */
3400 _mmcam_dbg_log("wait for pthread join");
3402 pthread_join(cmd->pCommandThread, NULL);
3404 _mmcam_dbg_log("pthread join!!");
3406 sem_destroy(&cmd->sema);
3408 while (!g_queue_is_empty(cmd->cmd_queue)) {
3409 __MMCamcorderCmdInfo *info = NULL;
3410 info = g_queue_pop_head(cmd->cmd_queue);
3411 _mmcamcorder_delete_command_info(info);
3413 g_queue_free(cmd->cmd_queue);
3415 _mmcam_dbg_log("Command loop clear.");
3417 return MM_ERROR_NONE;
3421 int _mmcamcorder_append_command(MMHandleType handle, __MMCamcorderCmdInfo *info)
3424 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3425 _MMCamcorderCommand *cmd;
3427 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3431 cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd);
3432 mmf_return_val_if_fail(cmd->cmd_queue, MM_ERROR_CAMCORDER_INVALID_CONDITION);
3434 g_queue_push_tail (cmd->cmd_queue, (gpointer)info);
3436 sem_getvalue(&cmd->sema, &value);
3439 sem_post(&cmd->sema);
3441 /* Don't need to post. */
3444 return MM_ERROR_NONE;
3448 int _mmcamcorder_append_simple_command(MMHandleType handle, _MMCamcorderCommandType type)
3450 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3451 __MMCamcorderCmdInfo *info = NULL;
3453 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3455 _mmcam_dbg_log("Command Type=%d", type);
3457 info = (__MMCamcorderCmdInfo*)malloc(sizeof(__MMCamcorderCmdInfo));
3459 info->handle = handle;
3462 _mmcamcorder_append_command(handle, info);
3464 return MM_ERROR_NONE;
3468 void *_mmcamcorder_command_loop_thread(void *arg)
3470 gboolean bExit_loop = FALSE;
3471 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(arg);
3472 _MMCamcorderCommand *cmd = NULL;
3473 __MMCamcorderCmdInfo *cmdinfo = NULL;
3475 mmf_return_val_if_fail(hcamcorder, NULL);
3477 cmd = (_MMCamcorderCommand *)&(hcamcorder->cmd);
3478 mmf_return_val_if_fail(cmd->cmd_queue, NULL);
3482 while (!bExit_loop) {
3483 sem_wait(&cmd->sema);
3486 while (!g_queue_is_empty (cmd->cmd_queue)) {
3487 int bRet = MM_ERROR_NONE;
3489 cmdinfo = g_queue_pop_head(cmd->cmd_queue);
3490 if (cmdinfo->handle == (MMHandleType)NULL) {
3491 _mmcam_dbg_log("Handle in cmdinfo is Null.");
3492 bRet = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
3494 switch (cmdinfo->type) {
3495 case _MMCAMCORDER_CMD_CREATE:
3496 case _MMCAMCORDER_CMD_DESTROY:
3497 case _MMCAMCORDER_CMD_CAPTURESTART:
3498 case _MMCAMCORDER_CMD_CAPTURESTOP:
3499 case _MMCAMCORDER_CMD_RECORD:
3500 case _MMCAMCORDER_CMD_PAUSE:
3501 case _MMCAMCORDER_CMD_COMMIT:
3502 __ta__("_mmcamcorder_commit",
3503 bRet = _mmcamcorder_commit(cmdinfo->handle);
3506 case _MMCAMCORDER_CMD_CANCEL:
3509 case _MMCAMCORDER_CMD_REALIZE:
3510 __ta__("_mmcamcorder_realize",
3511 bRet = _mmcamcorder_realize(cmdinfo->handle);
3514 case _MMCAMCORDER_CMD_UNREALIZE:
3515 __ta__("_mmcamcorder_unrealize",
3516 bRet = _mmcamcorder_unrealize(cmdinfo->handle);
3519 case _MMCAMCORDER_CMD_START:
3520 __ta__("_mmcamcorder_start",
3521 bRet = _mmcamcorder_start(cmdinfo->handle);
3524 case _MMCAMCORDER_CMD_STOP:
3525 __ta__("_mmcamcorder_stop",
3526 bRet = _mmcamcorder_stop(cmdinfo->handle);
3529 case _MMCAMCORDER_CMD_QUIT:
3530 _mmcam_dbg_log("Exit command loop!!");
3534 _mmcam_dbg_log("Wrong command type!!!");
3539 if (bRet != MM_ERROR_NONE) {
3540 _mmcam_dbg_log("Error on command process!(%x)", bRet);
3544 _mmcamcorder_delete_command_info(cmdinfo);
3557 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error)
3559 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3560 _MMCamcorderMsgItem msg;
3561 gchar *msg_src_element;
3562 _MMCamcorderSubContext *sc = NULL;
3564 return_val_if_fail(hcamcorder, FALSE);
3565 return_val_if_fail(error, FALSE);
3566 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3567 mmf_return_val_if_fail(sc, FALSE);
3571 /* filtering filesink related errors */
3572 if (hcamcorder->state == MM_CAMCORDER_STATE_RECORDING &&
3573 (error->code == GST_RESOURCE_ERROR_WRITE || error->code == GST_RESOURCE_ERROR_SEEK)) {
3574 if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
3575 sc->ferror_send = TRUE;
3576 msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3579 _mmcam_dbg_warn("Skip error");
3584 if (error->domain == GST_CORE_ERROR) {
3585 msg.param.code = __mmcamcorder_gst_handle_core_error(handle, error->code, message);
3586 } else if (error->domain == GST_LIBRARY_ERROR) {
3587 msg.param.code = __mmcamcorder_gst_handle_library_error(handle, error->code, message);
3588 } else if (error->domain == GST_RESOURCE_ERROR) {
3589 msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3590 } else if (error->domain == GST_STREAM_ERROR) {
3591 msg.param.code = __mmcamcorder_gst_handle_stream_error(handle, error->code, message);
3593 _mmcam_dbg_warn("This error domain is not defined.");
3595 /* we treat system error as an internal error */
3596 msg.param.code = MM_ERROR_CAMCORDER_INTERNAL;
3600 msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
3601 _mmcam_dbg_err("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
3602 msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3604 _mmcam_dbg_err("Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
3605 g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3608 #ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
3609 /* Check whether send this error to application */
3610 if (msg.param.code == MM_ERROR_CAMCORDER_GST_FLOW_ERROR) {
3611 _mmcam_dbg_log("We got the error. But skip it.");
3614 #endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
3616 /* post error to application */
3617 sc->error_occurs = TRUE;
3618 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
3619 _mmcamcroder_send_message(handle, &msg);
3625 static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message)
3627 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3628 _MMCamcorderSubContext *sc = NULL;
3629 GstElement *element = NULL;
3633 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3635 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3636 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3638 /* Specific plugin - video encoder plugin */
3639 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst);
3641 if (GST_ELEMENT_CAST(message->src) == element) {
3642 if (code == GST_CORE_ERROR_NEGOTIATION) {
3643 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3645 return MM_ERROR_CAMCORDER_ENCODER;
3652 case GST_CORE_ERROR_STATE_CHANGE:
3653 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3654 case GST_CORE_ERROR_NEGOTIATION:
3655 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3656 case GST_CORE_ERROR_MISSING_PLUGIN:
3657 case GST_CORE_ERROR_SEEK:
3658 case GST_CORE_ERROR_NOT_IMPLEMENTED:
3659 case GST_CORE_ERROR_FAILED:
3660 case GST_CORE_ERROR_TOO_LAZY:
3661 case GST_CORE_ERROR_PAD:
3662 case GST_CORE_ERROR_THREAD:
3663 case GST_CORE_ERROR_EVENT:
3664 case GST_CORE_ERROR_CAPS:
3665 case GST_CORE_ERROR_TAG:
3666 case GST_CORE_ERROR_CLOCK:
3667 case GST_CORE_ERROR_DISABLED:
3669 return MM_ERROR_CAMCORDER_GST_CORE;
3674 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
3676 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3677 return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3681 /* Specific plugin - NONE */
3685 case GST_LIBRARY_ERROR_FAILED:
3686 case GST_LIBRARY_ERROR_TOO_LAZY:
3687 case GST_LIBRARY_ERROR_INIT:
3688 case GST_LIBRARY_ERROR_SHUTDOWN:
3689 case GST_LIBRARY_ERROR_SETTINGS:
3690 case GST_LIBRARY_ERROR_ENCODE:
3692 _mmcam_dbg_err("Library error(%d)", code);
3693 return MM_ERROR_CAMCORDER_GST_LIBRARY;
3698 static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message)
3700 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3701 _MMCamcorderSubContext *sc = NULL;
3702 GstElement *element = NULL;
3704 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3706 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3707 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3711 /* Specific plugin */
3713 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst);
3714 if (GST_ELEMENT_CAST(message->src) == element) {
3715 if (code == GST_RESOURCE_ERROR_WRITE) {
3716 _mmcam_dbg_err("Display device [Off]");
3717 return MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF;
3719 _mmcam_dbg_err("Display device [General(%d)]", code);
3724 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst);
3725 if (GST_ELEMENT_CAST(message->src) == element) {
3726 if (code == GST_RESOURCE_ERROR_FAILED) {
3727 _mmcam_dbg_err("Encoder [Resource error]");
3728 return MM_ERROR_CAMCORDER_ENCODER_BUFFER;
3730 _mmcam_dbg_err("Encoder [General(%d)]", code);
3731 return MM_ERROR_CAMCORDER_ENCODER;
3737 case GST_RESOURCE_ERROR_WRITE:
3738 _mmcam_dbg_err("File write error");
3739 return MM_ERROR_FILE_WRITE;
3740 case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
3741 _mmcam_dbg_err("No left space");
3742 return MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
3743 case GST_RESOURCE_ERROR_OPEN_WRITE:
3744 _mmcam_dbg_err("Out of storage");
3745 return MM_ERROR_OUT_OF_STORAGE;
3746 case GST_RESOURCE_ERROR_SEEK:
3747 _mmcam_dbg_err("File read(seek)");
3748 return MM_ERROR_FILE_READ;
3749 case GST_RESOURCE_ERROR_NOT_FOUND:
3750 case GST_RESOURCE_ERROR_FAILED:
3751 case GST_RESOURCE_ERROR_TOO_LAZY:
3752 case GST_RESOURCE_ERROR_BUSY:
3753 case GST_RESOURCE_ERROR_OPEN_READ:
3754 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3755 case GST_RESOURCE_ERROR_CLOSE:
3756 case GST_RESOURCE_ERROR_READ:
3757 case GST_RESOURCE_ERROR_SYNC:
3758 case GST_RESOURCE_ERROR_SETTINGS:
3760 _mmcam_dbg_err("Resource error(%d)", code);
3761 return MM_ERROR_CAMCORDER_GST_RESOURCE;
3766 static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message)
3768 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3769 _MMCamcorderSubContext *sc = NULL;
3770 GstElement *element =NULL;
3772 mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
3774 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3775 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3779 /* Specific plugin */
3781 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst);
3782 if (GST_ELEMENT_CAST(message->src) == element) {
3784 case GST_STREAM_ERROR_WRONG_TYPE:
3785 _mmcam_dbg_err("Video encoder [wrong stream type]");
3786 return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
3787 case GST_STREAM_ERROR_ENCODE:
3788 _mmcam_dbg_err("Video encoder [encode error]");
3789 return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3790 case GST_STREAM_ERROR_FAILED:
3791 _mmcam_dbg_err("Video encoder [stream failed]");
3792 return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3794 _mmcam_dbg_err("Video encoder [General(%d)]", code);
3795 return MM_ERROR_CAMCORDER_ENCODER;
3799 /* General plugin */
3801 case GST_STREAM_ERROR_FORMAT:
3802 _mmcam_dbg_err("General [negotiation error(%d)]", code);
3803 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3804 case GST_STREAM_ERROR_FAILED:
3805 _mmcam_dbg_err("General [flow error(%d)]", code);
3806 return MM_ERROR_CAMCORDER_GST_FLOW_ERROR;
3807 case GST_STREAM_ERROR_TYPE_NOT_FOUND:
3808 case GST_STREAM_ERROR_DECODE:
3809 case GST_STREAM_ERROR_CODEC_NOT_FOUND:
3810 case GST_STREAM_ERROR_NOT_IMPLEMENTED:
3811 case GST_STREAM_ERROR_TOO_LAZY:
3812 case GST_STREAM_ERROR_ENCODE:
3813 case GST_STREAM_ERROR_DEMUX:
3814 case GST_STREAM_ERROR_MUX:
3815 case GST_STREAM_ERROR_DECRYPT:
3816 case GST_STREAM_ERROR_DECRYPT_NOKEY:
3817 case GST_STREAM_ERROR_WRONG_TYPE:
3819 _mmcam_dbg_err("General [error(%d)]", code);
3820 return MM_ERROR_CAMCORDER_GST_STREAM;
3825 static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessage *message, GError *error)
3827 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3828 gchar *debug = NULL;
3831 return_val_if_fail(hcamcorder, FALSE);
3832 return_val_if_fail(error, FALSE);
3836 gst_message_parse_warning(message, &err, &debug);
3838 if (error->domain == GST_CORE_ERROR) {
3839 _mmcam_dbg_warn("GST warning: GST_CORE domain");
3840 } else if (error->domain == GST_LIBRARY_ERROR) {
3841 _mmcam_dbg_warn("GST warning: GST_LIBRARY domain");
3842 } else if (error->domain == GST_RESOURCE_ERROR) {
3843 _mmcam_dbg_warn("GST warning: GST_RESOURCE domain");
3844 __mmcamcorder_gst_handle_resource_warning(handle, message, error);
3845 } else if (error->domain == GST_STREAM_ERROR ) {
3846 _mmcam_dbg_warn("GST warning: GST_STREAM domain");
3848 _mmcam_dbg_warn("This error domain(%d) is not defined.", error->domain);
3855 if (debug != NULL) {
3856 _mmcam_dbg_err ("Debug: %s", debug);
3865 static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error)
3867 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3868 _MMCamcorderSubContext *sc = NULL;
3869 GstElement *element =NULL;
3870 gchar *msg_src_element;
3872 mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
3874 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3875 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3879 /* Special message handling */
3881 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3882 if (GST_ELEMENT_CAST(message->src) == element) {
3883 if (error->code == GST_RESOURCE_ERROR_FAILED) {
3884 msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
3885 _mmcam_dbg_warn("-Msg src:[%s] Domain:[%s] Error:[%s]",
3886 msg_src_element, g_quark_to_string(error->domain), error->message);
3887 return MM_ERROR_NONE;
3891 /* General plugin */
3892 switch (error->code) {
3893 case GST_RESOURCE_ERROR_WRITE:
3894 case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
3895 case GST_RESOURCE_ERROR_SEEK:
3896 case GST_RESOURCE_ERROR_NOT_FOUND:
3897 case GST_RESOURCE_ERROR_FAILED:
3898 case GST_RESOURCE_ERROR_TOO_LAZY:
3899 case GST_RESOURCE_ERROR_BUSY:
3900 case GST_RESOURCE_ERROR_OPEN_READ:
3901 case GST_RESOURCE_ERROR_OPEN_WRITE:
3902 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3903 case GST_RESOURCE_ERROR_CLOSE:
3904 case GST_RESOURCE_ERROR_READ:
3905 case GST_RESOURCE_ERROR_SYNC:
3906 case GST_RESOURCE_ERROR_SETTINGS:
3908 _mmcam_dbg_warn("General GST warning(%d)", error->code);
3912 return MM_ERROR_NONE;