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 ========================================================================================*/
29 #include <gst/gstutils.h>
30 #include <gst/gstpad.h>
34 #include "mm_camcorder_internal.h"
37 #include <gst/video/colorbalance.h>
38 #include <gst/video/cameracontrol.h>
39 #include <asm/types.h>
41 #include <system_info.h>
43 /*---------------------------------------------------------------------------------------
44 | GLOBAL VARIABLE DEFINITIONS for internal |
45 ---------------------------------------------------------------------------------------*/
46 int g_mm_camcorder_type = -255;
47 struct sigaction mm_camcorder_int_old_action;
48 struct sigaction mm_camcorder_abrt_old_action;
49 struct sigaction mm_camcorder_segv_old_action;
50 struct sigaction mm_camcorder_term_old_action;
51 struct sigaction mm_camcorder_sys_old_action;
53 /*---------------------------------------------------------------------------------------
54 | LOCAL VARIABLE DEFINITIONS for internal |
55 ---------------------------------------------------------------------------------------*/
56 #define __MMCAMCORDER_CMD_ITERATE_MAX 3
57 #define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 3
58 #define __MMCAMCORDER_SOUND_WAIT_TIMEOUT 3
59 #define __MMCAMCORDER_PATH_CAMERA_RESOURCE "/usr/share/sounds/mm-camcorder/camera_resource"
60 #define __MMCAMCORDER_PATH_RECORDER_RESOURCE "/usr/share/sounds/mm-camcorder/recorder_resource"
63 /*---------------------------------------------------------------------------------------
64 | LOCAL FUNCTION PROTOTYPES: |
65 ---------------------------------------------------------------------------------------*/
66 /* STATIC INTERNAL FUNCTION */
67 static gboolean __mmcamcorder_gstreamer_init(camera_conf * conf);
69 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error);
70 static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message);
71 static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message);
72 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message);
73 static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message);
74 static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
75 static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
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 static void __mm_camcorder_signal_handler(int signo);
83 static void _mmcamcorder_constructor() __attribute__((constructor));
85 /*=======================================================================================
86 | FUNCTION DEFINITIONS |
87 =======================================================================================*/
88 /*---------------------------------------------------------------------------------------
89 | GLOBAL FUNCTION DEFINITIONS: |
90 ---------------------------------------------------------------------------------------*/
93 static void __mm_camcorder_signal_handler(int signo)
95 pid_t my_pid = getpid();
96 pid_t vconf_recorder_pid = -1;
97 pid_t vconf_camera_pid = -1;
98 int vconf_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF;
100 _mmcam_dbg_warn("start - signo [%d], pid [%d], device type [%d]", signo, my_pid, g_mm_camcorder_type);
102 /* reset vconf key */
103 switch (g_mm_camcorder_type) {
104 case MM_VIDEO_DEVICE_NONE:
105 vconf_get_int(VCONFKEY_RECORDER_PID, (int *)&vconf_recorder_pid);
106 if (my_pid == vconf_recorder_pid) {
107 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
108 vconf_set_int(VCONFKEY_RECORDER_PID, -1);
109 _mmcam_dbg_warn("set recorder state NULL");
111 _mmcam_dbg_warn("different pid : my[%d] vconf[%d]", my_pid, vconf_recorder_pid);
114 case MM_VIDEO_DEVICE_CAMERA0:
115 case MM_VIDEO_DEVICE_CAMERA1:
116 vconf_get_int(VCONFKEY_CAMERA_FLASH_STATE, &vconf_flash_state);
117 vconf_get_int(VCONFKEY_CAMERA_PID, (int *)&vconf_camera_pid);
118 if (my_pid == vconf_camera_pid &&
119 vconf_flash_state == VCONFKEY_CAMERA_FLASH_STATE_ON) {
120 vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
121 vconf_set_int(VCONFKEY_CAMERA_PID, -1);
122 _mmcam_dbg_warn("set camera flash state OFF");
125 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
126 _mmcam_dbg_warn("set camera state NULL");
129 _mmcam_dbg_warn("unknown type [%d]", g_mm_camcorder_type);
133 /* call old signal handler */
136 sigaction(SIGINT, &mm_camcorder_int_old_action, NULL);
140 sigaction(SIGABRT, &mm_camcorder_abrt_old_action, NULL);
144 sigaction(SIGSEGV, &mm_camcorder_segv_old_action, NULL);
148 sigaction(SIGTERM, &mm_camcorder_term_old_action, NULL);
152 sigaction(SIGSYS, &mm_camcorder_sys_old_action, NULL);
159 _mmcam_dbg_warn("done");
165 static void _mmcamcorder_constructor()
167 struct sigaction mm_camcorder_action;
168 mm_camcorder_action.sa_handler = __mm_camcorder_signal_handler;
169 mm_camcorder_action.sa_flags = SA_NOCLDSTOP;
171 _mmcam_dbg_warn("start");
173 sigemptyset(&mm_camcorder_action.sa_mask);
175 sigaction(SIGINT, &mm_camcorder_action, &mm_camcorder_int_old_action);
176 sigaction(SIGABRT, &mm_camcorder_action, &mm_camcorder_abrt_old_action);
177 sigaction(SIGSEGV, &mm_camcorder_action, &mm_camcorder_segv_old_action);
178 sigaction(SIGTERM, &mm_camcorder_action, &mm_camcorder_term_old_action);
179 sigaction(SIGSYS, &mm_camcorder_action, &mm_camcorder_sys_old_action);
181 _mmcam_dbg_warn("done");
187 /* Internal command functions {*/
188 int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
190 int ret = MM_ERROR_NONE;
191 int sys_info_ret = SYSTEM_INFO_ERROR_NONE;
193 int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
194 int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
195 int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
196 int play_capture_sound = TRUE;
197 int camera_device_count = MM_VIDEO_DEVICE_NUM;
198 int camera_default_flip = MM_FLIP_NONE;
199 int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
200 int resource_fd = -1;
201 char *err_attr_name = NULL;
202 const char *ConfCtrlFile = NULL;
203 mmf_camcorder_t *hcamcorder = NULL;
204 type_element *EvasSurfaceElement = NULL;
206 _mmcam_dbg_log("Entered");
208 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
209 mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
211 /* Create mmf_camcorder_t handle and initialize every variable */
212 hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
213 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY);
214 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
217 hcamcorder->type = 0;
218 hcamcorder->state = MM_CAMCORDER_STATE_NONE;
219 hcamcorder->sub_context = NULL;
220 hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
221 hcamcorder->capture_in_recording = FALSE;
223 pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL);
224 pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL);
225 pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL);
226 pthread_mutex_init(&((hcamcorder->mtsafe).asm_lock), NULL);
227 pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL);
228 pthread_mutex_init(&((hcamcorder->mtsafe).gst_state_lock), NULL);
229 pthread_mutex_init(&((hcamcorder->mtsafe).gst_encode_state_lock), NULL);
230 pthread_mutex_init(&((hcamcorder->mtsafe).message_cb_lock), NULL);
231 pthread_mutex_init(&((hcamcorder->mtsafe).vcapture_cb_lock), NULL);
232 pthread_mutex_init(&((hcamcorder->mtsafe).vstream_cb_lock), NULL);
233 pthread_mutex_init(&((hcamcorder->mtsafe).astream_cb_lock), NULL);
235 pthread_mutex_init(&(hcamcorder->sound_lock), NULL);
236 pthread_cond_init(&(hcamcorder->sound_cond), NULL);
237 pthread_mutex_init(&(hcamcorder->restart_preview_lock), NULL);
239 /* Sound mutex/cond init */
240 pthread_mutex_init(&(hcamcorder->snd_info.open_mutex), NULL);
241 pthread_cond_init(&(hcamcorder->snd_info.open_cond), NULL);
243 /* init for sound thread */
244 pthread_mutex_init(&(hcamcorder->task_thread_lock), NULL);
245 pthread_cond_init(&(hcamcorder->task_thread_cond), NULL);
246 hcamcorder->task_thread_state = _MMCAMCORDER_SOUND_STATE_NONE;
248 /* create task thread */
249 pthread_create(&(hcamcorder->task_thread), NULL, _mmcamcorder_util_task_thread_func, (void *)hcamcorder);
251 /* get root directory */
252 ret = _mmcamcorder_get_root_directory(&hcamcorder->root_directory);
253 if (ret != MM_ERROR_NONE) {
254 goto _ERR_DEFAULT_VALUE_INIT;
257 if (info->videodev_type < MM_VIDEO_DEVICE_NONE ||
258 info->videodev_type >= MM_VIDEO_DEVICE_NUM) {
259 _mmcam_dbg_err("_mmcamcorder_create::video device type is out of range.");
260 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
261 goto _ERR_DEFAULT_VALUE_INIT;
264 /* set device type */
265 hcamcorder->device_type = info->videodev_type;
266 _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type);
268 if (hcamcorder->device_type == MM_VIDEO_DEVICE_NONE) {
269 resource_fd = open(__MMCAMCORDER_PATH_RECORDER_RESOURCE, O_RDONLY);
271 resource_fd = open(__MMCAMCORDER_PATH_CAMERA_RESOURCE, O_RDONLY);
274 if (resource_fd < 0) {
275 _mmcam_dbg_log("open error %s : cur %d",strerror(errno),errno);
276 if(errno == EPERM || errno == EACCES) {
277 ret = MM_ERROR_COMMON_INVALID_PERMISSION;
279 ret = MM_ERROR_CAMCORDER_INTERNAL;
281 goto _ERR_DEFAULT_VALUE_INIT;
285 _mmcam_dbg_warn("permission check done");
288 /* Get Camera Configure information from Camcorder INI file */
289 _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
291 if (!(hcamcorder->conf_main)) {
292 _mmcam_dbg_err( "Failed to get configure(main) info." );
294 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
295 goto _ERR_AFTER_ASM_REGISTER;
298 hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
299 if (!(hcamcorder->attributes)) {
300 _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
302 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
303 goto _ERR_AFTER_ASM_REGISTER;
306 if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
307 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
308 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
309 "UseConfCtrl", &UseConfCtrl);
312 int resolution_width = 0;
313 int resolution_height = 0;
314 MMCamAttrsInfo fps_info;
316 _mmcam_dbg_log( "Enable Configure Control system." );
318 switch (info->videodev_type) {
319 case MM_VIDEO_DEVICE_CAMERA0:
320 _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
321 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
322 "ConfCtrlFile0", &ConfCtrlFile);
324 case MM_VIDEO_DEVICE_CAMERA1:
325 _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
326 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
327 "ConfCtrlFile1", &ConfCtrlFile);
330 _mmcam_dbg_err( "Not supported camera type." );
331 ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
332 goto _ERR_AFTER_ASM_REGISTER;
335 _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile);
337 _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl);
339 _mmcamcorder_conf_print_info(&hcamcorder->conf_main);
340 _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
342 if (!(hcamcorder->conf_ctrl)) {
343 _mmcam_dbg_err( "Failed to get configure(control) info." );
344 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
345 goto _ERR_AFTER_ASM_REGISTER;
348 ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
349 if (ret != MM_ERROR_NONE) {
350 _mmcam_dbg_warn("converting table initialize error!!");
351 ret = MM_ERROR_CAMCORDER_INTERNAL;
352 goto _ERR_AFTER_ASM_REGISTER;
355 ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, info->videodev_type);
356 if (ret != MM_ERROR_NONE) {
357 _mmcam_dbg_warn("converting table initialize error!!");
358 ret = MM_ERROR_CAMCORDER_INTERNAL;
359 goto _ERR_AFTER_ASM_REGISTER;
362 /* Get device info, recommend preview fmt and display rotation from INI */
363 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
364 CONFIGURE_CATEGORY_CTRL_CAMERA,
365 "RecommendPreviewFormatCapture",
368 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
369 CONFIGURE_CATEGORY_CTRL_CAMERA,
370 "RecommendPreviewFormatRecord",
371 &rcmd_fmt_recording);
373 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
374 CONFIGURE_CATEGORY_CTRL_CAMERA,
375 "RecommendDisplayRotation",
378 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
379 CONFIGURE_CATEGORY_MAIN_CAPTURE,
381 &play_capture_sound);
383 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
384 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
386 &camera_device_count);
388 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
389 CONFIGURE_CATEGORY_CTRL_CAMERA,
391 &camera_facing_direction);
393 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
394 CONFIGURE_CATEGORY_CTRL_EFFECT,
395 "BrightnessStepDenominator",
396 &hcamcorder->brightness_step_denominator);
398 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
399 CONFIGURE_CATEGORY_CTRL_CAPTURE,
401 &hcamcorder->support_zsl_capture);
403 _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot %d, cap snd %d, dev cnt %d, cam facing dir %d, step denom %d, support zsl %d",
404 rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
405 play_capture_sound, camera_device_count, camera_facing_direction,
406 hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
408 /* Get UseZeroCopyFormat value from INI */
409 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
410 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
412 &(hcamcorder->use_zero_copy_format));
414 /* Get SupportMediaPacketPreviewCb value from INI */
415 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
416 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
417 "SupportMediaPacketPreviewCb",
418 &(hcamcorder->support_media_packet_preview_cb));
420 ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
421 MMCAM_CAMERA_WIDTH, &resolution_width,
422 MMCAM_CAMERA_HEIGHT, &resolution_height,
425 mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
427 _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
428 _mmcam_dbg_log("SupportMediaPacketPreviewCb : %d", hcamcorder->support_media_packet_preview_cb);
429 _mmcam_dbg_log("res : %d X %d, Default FPS by resolution : %d", resolution_width, resolution_height, fps_info.int_array.def);
431 if (camera_facing_direction == 1) {
432 if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) {
433 camera_default_flip = MM_FLIP_VERTICAL;
435 camera_default_flip = MM_FLIP_HORIZONTAL;
437 _mmcam_dbg_log("camera_default_flip : [%d]",camera_default_flip);
440 mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
441 MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
442 MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
443 MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
444 MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
445 MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
446 MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
447 MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
448 MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
449 MMCAM_CAMERA_FPS, fps_info.int_array.def,
450 MMCAM_DISPLAY_FLIP, camera_default_flip,
451 "capture-sound-enable", play_capture_sound,
454 _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
456 err_attr_name = NULL;
457 ret = MM_ERROR_CAMCORDER_INTERNAL;
458 goto _ERR_AFTER_ASM_REGISTER;
461 /* Get default value of brightness */
462 mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
463 MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
466 _mmcam_dbg_err("Get brightness FAILED.");
468 err_attr_name = NULL;
469 ret = MM_ERROR_CAMCORDER_INTERNAL;
470 goto _ERR_AFTER_ASM_REGISTER;
472 _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
474 _mmcam_dbg_log( "Disable Configure Control system." );
475 hcamcorder->conf_ctrl = NULL;
478 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
479 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
481 &camera_device_count);
482 mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
483 MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
486 _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
488 err_attr_name = NULL;
489 ret = MM_ERROR_CAMCORDER_INTERNAL;
490 goto _ERR_AFTER_ASM_REGISTER;
493 ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, info->videodev_type);
494 if (ret != MM_ERROR_NONE) {
495 _mmcam_dbg_warn("init attribute from configure error : 0x%x", ret);
496 ret = MM_ERROR_CAMCORDER_INTERNAL;
497 goto _ERR_AFTER_ASM_REGISTER;
501 ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
503 _mmcam_dbg_err( "Failed to initialize gstreamer!!" );
504 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
505 goto _ERR_AFTER_ASM_REGISTER;
508 /* Make some attributes as read-only type */
509 _mmcamcorder_lock_readonly_attributes((MMHandleType)hcamcorder);
511 /* Disable attributes in each model */
512 _mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder);
514 /* Get videosink name for evas surface */
515 _mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main,
516 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
517 "VideosinkElementEvas",
518 &EvasSurfaceElement);
519 if (EvasSurfaceElement) {
521 const char *evassink_name = NULL;
522 mmf_attribute_t *item_evassink_name = NULL;
523 mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
525 _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name);
526 mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index);
527 item_evassink_name = &attrs->items[attr_index];
528 mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name));
529 mmf_attribute_commit(item_evassink_name);
531 _mmcam_dbg_log("Evassink name : %s", evassink_name);
534 /* get shutter sound policy */
535 vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
536 _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
539 sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
540 if (hcamcorder->model_name) {
541 _mmcam_dbg_log("model name [%s], sys_info_ret 0x%x", hcamcorder->model_name, sys_info_ret);
543 _mmcam_dbg_warn("failed get model name, sys_info_ret 0x%x", sys_info_ret);
546 /* get software version */
547 sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
548 if (hcamcorder->software_version) {
549 _mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret);
551 _mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret);
554 /* Set initial state */
555 _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
557 _mmcam_dbg_log("created handle %p", hcamcorder);
559 /* set device type */
560 g_mm_camcorder_type = info->videodev_type;
562 *handle = (MMHandleType)hcamcorder;
564 return MM_ERROR_NONE;
566 _ERR_AFTER_ASM_REGISTER:
568 _ERR_DEFAULT_VALUE_INIT:
569 /* Release lock, cond */
570 pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
571 pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
572 pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
573 pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
574 pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
575 pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock));
576 pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock));
577 pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock));
578 pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock));
579 pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock));
580 pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock));
582 pthread_mutex_destroy(&(hcamcorder->sound_lock));
583 pthread_cond_destroy(&(hcamcorder->sound_cond));
584 pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex));
585 pthread_cond_destroy(&(hcamcorder->snd_info.open_cond));
586 pthread_mutex_destroy(&(hcamcorder->restart_preview_lock));
588 if (hcamcorder->conf_ctrl) {
589 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
592 if (hcamcorder->conf_main) {
593 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
596 if (hcamcorder->model_name) {
597 free(hcamcorder->model_name);
598 hcamcorder->model_name = NULL;
601 if (hcamcorder->software_version) {
602 free(hcamcorder->software_version);
603 hcamcorder->software_version = NULL;
606 if (hcamcorder->task_thread) {
607 pthread_mutex_lock(&(hcamcorder->task_thread_lock));
608 _mmcam_dbg_log("send signal for task thread exit");
609 hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
610 pthread_cond_signal(&(hcamcorder->task_thread_cond));
611 pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
612 pthread_join(hcamcorder->task_thread, NULL);
614 pthread_mutex_destroy(&(hcamcorder->task_thread_lock));
615 pthread_cond_destroy(&(hcamcorder->task_thread_cond));
617 if (hcamcorder->root_directory) {
618 free(hcamcorder->root_directory);
619 hcamcorder->root_directory = NULL;
623 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
630 int _mmcamcorder_destroy(MMHandleType handle)
632 int ret = MM_ERROR_NONE;
633 int state = MM_CAMCORDER_STATE_NONE;
634 int state_FROM = MM_CAMCORDER_STATE_NULL;
636 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
641 _mmcam_dbg_err("Not initialized");
642 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
643 goto _ERR_CAMCORDER_CMD_PRECON;
646 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
647 _mmcam_dbg_err("Another command is running.");
648 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
649 goto _ERR_CAMCORDER_CMD_PRECON;
652 state = _mmcamcorder_get_state(handle);
653 if (state != state_FROM) {
654 _mmcam_dbg_err("Wrong state(%d)", state);
655 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
656 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
659 /* set exit state for sound thread */
660 pthread_mutex_lock(&(hcamcorder->task_thread_lock));
661 _mmcam_dbg_log("send signal for task thread exit");
662 hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
663 pthread_cond_signal(&(hcamcorder->task_thread_cond));
664 pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
666 pthread_mutex_lock(&(hcamcorder->sound_lock));
667 while (hcamcorder->capture_sound_count > 0) {
668 struct timespec timeout;
671 gettimeofday(&tv, NULL);
672 timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_SOUND_WAIT_TIMEOUT;
673 timeout.tv_nsec = tv.tv_usec * 1000;
675 _mmcam_dbg_warn("capture_sound_count[%d] is not zero. wait signal...",
676 hcamcorder->capture_sound_count);
678 if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) {
679 _mmcam_dbg_warn("signal received. check again...");
681 hcamcorder->capture_sound_count = 0;
682 _mmcam_dbg_err("capture sound completion wait time out");
686 pthread_mutex_unlock(&(hcamcorder->sound_lock));
688 /* Release SubContext and pipeline */
689 if (hcamcorder->sub_context) {
690 if (hcamcorder->sub_context->element) {
691 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
694 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
695 hcamcorder->sub_context = NULL;
698 /* Remove idle function which is not called yet */
699 if (hcamcorder->setting_event_id) {
700 _mmcam_dbg_log("Remove remaining idle function");
701 g_source_remove(hcamcorder->setting_event_id);
702 hcamcorder->setting_event_id = 0;
705 /* check current strobe mode */
706 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
707 pid_t my_pid = getpid();
709 vconf_get_int(VCONFKEY_CAMERA_PID, &camera_pid);
711 if (camera_pid > -1 && my_pid == camera_pid) {
712 int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF;
714 vconf_set_int(VCONFKEY_CAMERA_PID, -1);
715 _mmcam_dbg_log("reset camera pid");
717 mm_camcorder_get_attributes(handle, NULL,
718 MMCAM_STROBE_MODE, &strobe_mode,
720 if (strobe_mode != MM_CAMCORDER_STROBE_MODE_OFF) {
721 /* set OFF state of vconf key */
722 vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
723 _mmcam_dbg_log("reset flash state");
728 /* Remove attributes */
729 if (hcamcorder->attributes) {
730 _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes);
731 hcamcorder->attributes = 0;
734 /* Remove exif info */
735 if (hcamcorder->exif_info) {
736 mm_exif_destory_exif_info(hcamcorder->exif_info);
737 hcamcorder->exif_info=NULL;
741 /* Release configure info */
742 if (hcamcorder->conf_ctrl) {
743 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
745 if (hcamcorder->conf_main) {
746 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
749 /* Remove messages which are not called yet */
750 _mmcamcorder_remove_message_all(handle);
752 /* release model_name */
753 if (hcamcorder->model_name) {
754 free(hcamcorder->model_name);
755 hcamcorder->model_name = NULL;
758 if (hcamcorder->software_version) {
759 free(hcamcorder->software_version);
760 hcamcorder->software_version = NULL;
763 /* join task thread */
764 _mmcam_dbg_log("task thread join");
765 pthread_join(hcamcorder->task_thread, NULL);
767 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
769 /* Release lock, cond */
770 pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
771 pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
772 pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
773 pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
774 pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
775 pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock));
776 pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock));
777 pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock));
778 pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock));
779 pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock));
780 pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock));
782 pthread_mutex_destroy(&(hcamcorder->sound_lock));
783 pthread_cond_destroy(&(hcamcorder->sound_cond));
784 pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex));
785 pthread_cond_destroy(&(hcamcorder->snd_info.open_cond));
786 pthread_mutex_destroy(&(hcamcorder->restart_preview_lock));
787 pthread_mutex_destroy(&(hcamcorder->task_thread_lock));
788 pthread_cond_destroy(&(hcamcorder->task_thread_cond));
790 /* Release internal root directory string */
791 if (hcamcorder->root_directory) {
792 free(hcamcorder->root_directory);
793 hcamcorder->root_directory = NULL;
797 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
800 return MM_ERROR_NONE;
802 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
803 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
805 _ERR_CAMCORDER_CMD_PRECON:
807 _mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
810 _mmcam_dbg_err("Destroy fail (ret %x)", ret);
816 int _mmcamcorder_realize(MMHandleType handle)
818 int ret = MM_ERROR_NONE;
819 int state = MM_CAMCORDER_STATE_NONE;
820 int state_FROM = MM_CAMCORDER_STATE_NULL;
821 int state_TO = MM_CAMCORDER_STATE_READY;
822 int display_surface_type = MM_DISPLAY_SURFACE_X;
823 double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
824 char *videosink_element_type = NULL;
825 const char *videosink_name = NULL;
827 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
829 /*_mmcam_dbg_log("");*/
832 _mmcam_dbg_err("Not initialized");
833 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
837 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
838 _mmcam_dbg_err("Another command is running.");
839 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
840 goto _ERR_CAMCORDER_CMD_PRECON;
843 state = _mmcamcorder_get_state(handle);
844 if (state != state_FROM) {
845 _mmcam_dbg_err("Wrong state(%d)", state);
846 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
847 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
850 mm_camcorder_get_attributes(handle, NULL,
851 MMCAM_MODE, &hcamcorder->type,
854 /* Get profile mode */
855 _mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
857 mm_camcorder_get_attributes(handle, NULL,
858 MMCAM_DISPLAY_SURFACE, &display_surface_type,
859 MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
862 /* set camera/recorder state to vconf key */
863 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
864 int vconf_camera_state = 0;
866 /* get current camera state of vconf key */
867 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
868 if (vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN)) {
869 _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
870 if(errno == EPERM || errno == EACCES) {
871 ret = MM_ERROR_COMMON_INVALID_PERMISSION;
872 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
875 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
876 vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
878 int vconf_recorder_state = 0;
880 /* get current recorder state of vconf key */
881 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
882 if (vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED)) {
883 _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
884 if (errno == EPERM || errno == EACCES) {
885 ret = MM_ERROR_COMMON_INVALID_PERMISSION;
886 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
890 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
891 vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
894 /* alloc sub context */
895 hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
896 if(!hcamcorder->sub_context) {
897 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
898 goto _ERR_CAMCORDER_CMD;
901 /* Set basic configure information */
902 if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
903 hcamcorder->sub_context->is_modified_rate = TRUE;
906 _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
907 CONFIGURE_CATEGORY_MAIN_CAPTURE,
909 &(hcamcorder->sub_context->bencbin_capture));
910 _mmcam_dbg_warn("UseEncodebin [%d]", hcamcorder->sub_context->bencbin_capture);
912 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
913 /* get dual stream support info */
914 _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
915 CONFIGURE_CATEGORY_MAIN_RECORD,
917 &(hcamcorder->sub_context->info_video->support_dual_stream));
918 _mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream);
921 switch (display_surface_type) {
922 case MM_DISPLAY_SURFACE_X:
923 videosink_element_type = strdup("VideosinkElementX");
925 case MM_DISPLAY_SURFACE_EVAS:
926 videosink_element_type = strdup("VideosinkElementEvas");
928 case MM_DISPLAY_SURFACE_GL:
929 videosink_element_type = strdup("VideosinkElementGL");
931 case MM_DISPLAY_SURFACE_NULL:
932 videosink_element_type = strdup("VideosinkElementNull");
935 videosink_element_type = strdup("VideosinkElementX");
939 /* check string of videosink element */
940 if (videosink_element_type) {
941 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
942 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
943 videosink_element_type,
944 &hcamcorder->sub_context->VideosinkElement);
945 free(videosink_element_type);
946 videosink_element_type = NULL;
948 _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
949 display_surface_type);
951 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
952 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
953 _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
954 &hcamcorder->sub_context->VideosinkElement);
957 _mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
958 _mmcam_dbg_log("Videosink name : %s", videosink_name);
960 /* get videoconvert element */
961 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
962 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
963 "VideoconvertElement",
964 &hcamcorder->sub_context->VideoconvertElement);
966 _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl,
967 CONFIGURE_CATEGORY_CTRL_CAPTURE,
968 "SensorEncodedCapture",
969 &(hcamcorder->sub_context->SensorEncodedCapture));
970 _mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture);
972 /* create pipeline */
973 ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type);
974 if (ret != MM_ERROR_NONE) {
975 /* check internal error of gstreamer */
976 if (hcamcorder->error_code != MM_ERROR_NONE) {
977 ret = hcamcorder->error_code;
978 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
981 /* release sub context */
982 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
983 hcamcorder->sub_context = NULL;
984 goto _ERR_CAMCORDER_CMD;
987 /* set command function */
988 ret = _mmcamcorder_set_functions(handle, hcamcorder->type);
989 if (ret != MM_ERROR_NONE) {
990 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
991 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
992 hcamcorder->sub_context = NULL;
993 goto _ERR_CAMCORDER_CMD;
996 _mmcamcorder_set_state(handle, state_TO);
998 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1000 return MM_ERROR_NONE;
1003 /* rollback camera state to vconf key */
1004 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1005 int vconf_camera_state = 0;
1007 /* get current camera state of vconf key */
1008 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1009 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
1011 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1012 vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
1014 int vconf_recorder_state = 0;
1016 /* get current recorder state of vconf key */
1017 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1018 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
1020 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1021 vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
1024 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1025 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1027 _ERR_CAMCORDER_CMD_PRECON:
1028 _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
1029 hcamcorder->type, state, ret);
1035 int _mmcamcorder_unrealize(MMHandleType handle)
1037 int ret = MM_ERROR_NONE;
1038 int state = MM_CAMCORDER_STATE_NONE;
1039 int state_FROM = MM_CAMCORDER_STATE_READY;
1040 int state_TO = MM_CAMCORDER_STATE_NULL;
1042 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1047 _mmcam_dbg_err("Not initialized");
1048 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1052 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1053 _mmcam_dbg_err("Another command is running.");
1054 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1055 goto _ERR_CAMCORDER_CMD_PRECON;
1058 state = _mmcamcorder_get_state(handle);
1059 if (state != state_FROM) {
1060 _mmcam_dbg_err("Wrong state(%d)", state);
1061 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1062 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1065 /* Release SubContext */
1066 if (hcamcorder->sub_context) {
1067 /* destroy pipeline */
1068 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
1069 /* Deallocate SubContext */
1070 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1071 hcamcorder->sub_context = NULL;
1074 /* Deinitialize main context member */
1075 hcamcorder->command = NULL;
1078 /* set camera state to vconf key */
1079 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1080 int vconf_camera_state = 0;
1082 /* get current camera state of vconf key */
1083 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1084 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
1086 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1087 vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
1089 int vconf_recorder_state = 0;
1091 /* get current recorder state of vconf key */
1092 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1093 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
1095 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1096 vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
1099 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1101 _mmcamcorder_set_state(handle, state_TO);
1103 return MM_ERROR_NONE;
1105 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1106 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1108 _ERR_CAMCORDER_CMD_PRECON:
1110 _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
1111 hcamcorder->type, state, ret);
1116 int _mmcamcorder_start(MMHandleType handle)
1118 int ret = MM_ERROR_NONE;
1119 int state = MM_CAMCORDER_STATE_NONE;
1120 int state_FROM = MM_CAMCORDER_STATE_READY;
1121 int state_TO =MM_CAMCORDER_STATE_PREPARE;
1123 _MMCamcorderSubContext *sc = NULL;
1124 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1129 _mmcam_dbg_err("Not initialized");
1130 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1134 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1135 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1137 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1138 _mmcam_dbg_err("Another command is running.");
1139 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1140 goto _ERR_CAMCORDER_CMD_PRECON;
1143 state = _mmcamcorder_get_state(handle);
1144 if (state != state_FROM) {
1145 _mmcam_dbg_err("Wrong state(%d)", state);
1146 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1147 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1150 /* initialize error code */
1151 hcamcorder->error_code = MM_ERROR_NONE;
1153 /* set attributes related sensor */
1154 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1155 _mmcamcorder_set_attribute_to_camsensor(handle);
1158 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
1159 if (ret != MM_ERROR_NONE) {
1160 /* check internal error of gstreamer */
1161 if (hcamcorder->error_code != MM_ERROR_NONE) {
1162 ret = hcamcorder->error_code;
1163 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1165 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1168 _mmcamcorder_set_state(handle, state_TO);
1170 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1171 int vconf_camera_state = 0;
1173 /* check camera state of vconf key */
1174 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1176 /* set camera state to vconf key */
1177 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1179 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1180 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1183 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1185 return MM_ERROR_NONE;
1187 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1188 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1190 _ERR_CAMCORDER_CMD_PRECON:
1191 /* check internal error of gstreamer */
1192 if (hcamcorder->error_code != MM_ERROR_NONE) {
1193 ret = hcamcorder->error_code;
1194 hcamcorder->error_code = MM_ERROR_NONE;
1196 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1199 _mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
1200 hcamcorder->type, state, ret);
1205 int _mmcamcorder_stop(MMHandleType handle)
1207 int ret = MM_ERROR_NONE;
1208 int state = MM_CAMCORDER_STATE_NONE;
1209 int state_FROM = MM_CAMCORDER_STATE_PREPARE;
1210 int state_TO = MM_CAMCORDER_STATE_READY;
1212 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1217 _mmcam_dbg_err("Not initialized");
1218 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1222 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1223 _mmcam_dbg_err("Another command is running.");
1224 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1225 goto _ERR_CAMCORDER_CMD_PRECON;
1228 state = _mmcamcorder_get_state(handle);
1229 if (state != state_FROM) {
1230 _mmcam_dbg_err("Wrong state(%d)", state);
1231 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1232 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1235 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP);
1236 if (ret != MM_ERROR_NONE) {
1237 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1240 _mmcamcorder_set_state(handle, state_TO);
1242 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1243 int vconf_camera_state = 0;
1245 /* check camera state of vconf key */
1246 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1248 /* set camera state to vconf key */
1249 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
1251 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1252 vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
1255 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1257 return MM_ERROR_NONE;
1259 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1260 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1262 _ERR_CAMCORDER_CMD_PRECON:
1264 _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
1265 hcamcorder->type, state, ret);
1271 int _mmcamcorder_capture_start(MMHandleType handle)
1273 int ret = MM_ERROR_NONE;
1274 int state = MM_CAMCORDER_STATE_NONE;
1275 int state_FROM_0 = MM_CAMCORDER_STATE_PREPARE;
1276 int state_FROM_1 = MM_CAMCORDER_STATE_RECORDING;
1277 int state_FROM_2 = MM_CAMCORDER_STATE_PAUSED;
1278 int state_TO = MM_CAMCORDER_STATE_CAPTURING;
1280 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1285 _mmcam_dbg_err("Not initialized");
1286 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1290 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1291 _mmcam_dbg_err("Another command is running.");
1292 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1293 goto _ERR_CAMCORDER_CMD_PRECON;
1296 state = _mmcamcorder_get_state(handle);
1297 if (state != state_FROM_0 &&
1298 state != state_FROM_1 &&
1299 state != state_FROM_2) {
1300 _mmcam_dbg_err("Wrong state(%d)", state);
1301 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1302 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1305 /* Handle capture in recording case */
1306 if (state == state_FROM_1 || state == state_FROM_2) {
1307 if (hcamcorder->capture_in_recording == TRUE) {
1308 _mmcam_dbg_err("Capturing in recording (%d)", state);
1309 ret = MM_ERROR_CAMCORDER_DEVICE_BUSY;
1310 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1312 hcamcorder->capture_in_recording = TRUE;
1316 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE);
1317 if (ret != MM_ERROR_NONE) {
1318 goto _ERR_CAMCORDER_CMD;
1321 /* Do not change state when recording snapshot capture */
1322 if (state == state_FROM_0) {
1323 _mmcamcorder_set_state(handle, state_TO);
1326 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1328 /* Init break continuous shot attr */
1329 if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE) {
1330 _mmcam_dbg_warn("capture-break-cont-shot set 0 failed");
1333 return MM_ERROR_NONE;
1336 if (hcamcorder->capture_in_recording) {
1337 hcamcorder->capture_in_recording = FALSE;
1340 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1341 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1343 _ERR_CAMCORDER_CMD_PRECON:
1345 _mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
1346 hcamcorder->type, state, ret);
1351 int _mmcamcorder_capture_stop(MMHandleType handle)
1353 int ret = MM_ERROR_NONE;
1354 int state = MM_CAMCORDER_STATE_NONE;
1355 int state_FROM = MM_CAMCORDER_STATE_CAPTURING;
1356 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1357 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1362 _mmcam_dbg_err("Not initialized");
1363 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1367 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1368 _mmcam_dbg_err("Another command is running.");
1369 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1370 goto _ERR_CAMCORDER_CMD_PRECON;
1373 state = _mmcamcorder_get_state(handle);
1374 if (state != state_FROM) {
1375 _mmcam_dbg_err("Wrong state(%d)", state);
1376 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1377 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1380 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
1381 if (ret != MM_ERROR_NONE) {
1382 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1385 _mmcamcorder_set_state(handle, state_TO);
1387 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1389 return MM_ERROR_NONE;
1391 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1392 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1394 _ERR_CAMCORDER_CMD_PRECON:
1396 _mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
1397 hcamcorder->type, state, ret);
1402 int _mmcamcorder_record(MMHandleType handle)
1404 int ret = MM_ERROR_NONE;
1405 int state = MM_CAMCORDER_STATE_NONE;
1406 int state_FROM1 = MM_CAMCORDER_STATE_PREPARE;
1407 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1408 int state_TO = MM_CAMCORDER_STATE_RECORDING;
1410 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1415 _mmcam_dbg_err("Not initialized");
1416 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1420 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1421 _mmcam_dbg_err("Another command is running.");
1422 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1423 goto _ERR_CAMCORDER_CMD_PRECON;
1426 state = _mmcamcorder_get_state(handle);
1427 if (state != state_FROM1 && state != state_FROM2) {
1428 _mmcam_dbg_err("Wrong state(%d)", state);
1429 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1430 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1433 /* initialize error code */
1434 hcamcorder->error_code = MM_ERROR_NONE;
1436 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
1437 if (ret != MM_ERROR_NONE) {
1438 /* check internal error of gstreamer */
1439 if (hcamcorder->error_code != MM_ERROR_NONE) {
1440 ret = hcamcorder->error_code;
1441 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1443 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1446 _mmcamcorder_set_state(handle, state_TO);
1448 /* set camera state to vconf key */
1449 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1450 int vconf_camera_state = 0;
1452 /* get current camera state of vconf key */
1453 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1454 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING);
1456 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1457 vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING);
1459 int vconf_recorder_state = 0;
1461 /* get current recorder state of vconf key */
1462 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1463 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING);
1465 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1466 vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING);
1469 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1471 return MM_ERROR_NONE;
1473 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1474 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1476 _ERR_CAMCORDER_CMD_PRECON:
1477 /* check internal error of gstreamer */
1478 if (hcamcorder->error_code != MM_ERROR_NONE) {
1479 ret = hcamcorder->error_code;
1480 hcamcorder->error_code = MM_ERROR_NONE;
1482 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1485 _mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
1486 hcamcorder->type, state, ret);
1492 int _mmcamcorder_pause(MMHandleType handle)
1494 int ret = MM_ERROR_NONE;
1495 int state = MM_CAMCORDER_STATE_NONE;
1496 int state_FROM = MM_CAMCORDER_STATE_RECORDING;
1497 int state_TO = MM_CAMCORDER_STATE_PAUSED;
1499 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1504 _mmcam_dbg_err("Not initialized");
1505 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1509 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1510 _mmcam_dbg_err("Another command is running.");
1511 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1512 goto _ERR_CAMCORDER_CMD_PRECON;
1515 state = _mmcamcorder_get_state(handle);
1516 if (state != state_FROM) {
1517 _mmcam_dbg_err("Wrong state(%d)", state);
1518 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1519 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1522 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE);
1523 if (ret != MM_ERROR_NONE) {
1524 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1527 _mmcamcorder_set_state(handle, state_TO);
1529 /* set camera state to vconf key */
1530 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1531 int vconf_camera_state = 0;
1533 /* get current camera state of vconf key */
1534 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1535 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1537 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1538 vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1540 int vconf_recorder_state = 0;
1542 /* get current recorder state of vconf key */
1543 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1544 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
1546 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1547 vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
1550 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1552 return MM_ERROR_NONE;
1554 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1555 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1557 _ERR_CAMCORDER_CMD_PRECON:
1559 _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
1560 hcamcorder->type, state, ret);
1566 int _mmcamcorder_commit(MMHandleType handle)
1568 int ret = MM_ERROR_NONE;
1569 int state = MM_CAMCORDER_STATE_NONE;
1570 int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1571 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1572 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1574 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1579 _mmcam_dbg_err("Not initialized");
1580 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1584 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1585 _mmcam_dbg_err("Another command is running.");
1586 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1587 goto _ERR_CAMCORDER_CMD_PRECON;
1590 state = _mmcamcorder_get_state(handle);
1591 if (state != state_FROM1 && state != state_FROM2) {
1592 _mmcam_dbg_err("Wrong state(%d)", state);
1593 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1594 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1597 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
1598 if (ret != MM_ERROR_NONE) {
1599 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1602 /* set camera state to vconf key */
1603 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1604 int vconf_camera_state = 0;
1606 /* get current camera state of vconf key */
1607 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1608 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1610 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1611 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1613 int vconf_recorder_state = 0;
1615 /* get current recorder state of vconf key */
1616 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1617 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
1619 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1620 vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
1623 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1625 _mmcamcorder_set_state(handle,state_TO);
1627 return MM_ERROR_NONE;
1629 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1630 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1632 _ERR_CAMCORDER_CMD_PRECON:
1634 _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
1635 hcamcorder->type, state, ret);
1641 int _mmcamcorder_cancel(MMHandleType handle)
1643 int ret = MM_ERROR_NONE;
1644 int state = MM_CAMCORDER_STATE_NONE;
1645 int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1646 int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1647 int state_TO = MM_CAMCORDER_STATE_PREPARE;
1649 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1654 _mmcam_dbg_err("Not initialized");
1655 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1659 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1660 _mmcam_dbg_err("Another command is running.");
1661 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1662 goto _ERR_CAMCORDER_CMD_PRECON;
1665 state = _mmcamcorder_get_state(handle);
1666 if (state != state_FROM1 && state != state_FROM2) {
1667 _mmcam_dbg_err("Wrong state(%d)", state);
1668 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1669 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1672 ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL);
1673 if (ret != MM_ERROR_NONE) {
1674 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1677 _mmcamcorder_set_state(handle, state_TO);
1679 /* set camera state to vconf key */
1680 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1681 int vconf_camera_state = 0;
1683 /* get current camera state of vconf key */
1684 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1685 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1687 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1688 vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1690 int vconf_recorder_state = 0;
1692 /* get current recorder state of vconf key */
1693 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1694 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
1696 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1697 vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
1700 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1702 return MM_ERROR_NONE;
1704 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1705 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1707 _ERR_CAMCORDER_CMD_PRECON:
1709 _mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
1710 hcamcorder->type, state, ret);
1714 /* } Internal command functions */
1717 int _mmcamcorder_commit_async_end(MMHandleType handle)
1721 _mmcam_dbg_warn("_mmcamcorder_commit_async_end : MM_CAMCORDER_STATE_PREPARE");
1722 _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_PREPARE);
1724 return MM_ERROR_NONE;
1728 int _mmcamcorder_set_message_callback(MMHandleType handle, MMMessageCallback callback, void *user_data)
1730 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1732 _mmcam_dbg_log("%p", hcamcorder);
1734 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1736 if (callback == NULL) {
1737 _mmcam_dbg_warn("Message Callback is disabled, because application sets it to NULL");
1740 if (!_MMCAMCORDER_TRYLOCK_MESSAGE_CALLBACK(hcamcorder)) {
1741 _mmcam_dbg_warn("Application's message callback is running now");
1742 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1745 /* set message callback to message handle */
1746 hcamcorder->msg_cb = callback;
1747 hcamcorder->msg_cb_param = user_data;
1749 _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
1751 return MM_ERROR_NONE;
1755 int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_video_stream_callback callback, void *user_data)
1757 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1759 /*_mmcam_dbg_log("");*/
1761 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1763 if (callback == NULL) {
1764 _mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
1767 if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
1768 _mmcam_dbg_warn("Application's video stream callback is running now");
1769 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1772 hcamcorder->vstream_cb = callback;
1773 hcamcorder->vstream_cb_param = user_data;
1775 _MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
1777 return MM_ERROR_NONE;
1781 int _mmcamcorder_set_audio_stream_callback(MMHandleType handle, mm_camcorder_audio_stream_callback callback, void *user_data)
1783 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1787 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1789 if (callback == NULL) {
1790 _mmcam_dbg_warn("Audio Stream Callback is disabled, because application sets it to NULL");
1793 if (!_MMCAMCORDER_TRYLOCK_ASTREAM_CALLBACK(hcamcorder)) {
1794 _mmcam_dbg_warn("Application's audio stream callback is running now");
1795 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1798 hcamcorder->astream_cb = callback;
1799 hcamcorder->astream_cb_param = user_data;
1801 _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
1803 return MM_ERROR_NONE;
1807 int _mmcamcorder_set_video_capture_callback(MMHandleType handle, mm_camcorder_video_capture_callback callback, void *user_data)
1809 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1813 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1815 if (callback == NULL) {
1816 _mmcam_dbg_warn("Video Capture Callback is disabled, because application sets it to NULLL");
1819 if (!_MMCAMCORDER_TRYLOCK_VCAPTURE_CALLBACK(hcamcorder)) {
1820 _mmcam_dbg_warn("Application's video capture callback is running now");
1821 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1824 hcamcorder->vcapture_cb = callback;
1825 hcamcorder->vcapture_cb_param = user_data;
1827 _MMCAMCORDER_UNLOCK_VCAPTURE_CALLBACK(hcamcorder);
1829 return MM_ERROR_NONE;
1832 int _mmcamcorder_get_current_state(MMHandleType handle)
1834 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1838 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1840 return _mmcamcorder_get_state(handle);
1843 int _mmcamcorder_init_focusing(MMHandleType handle)
1846 int state = MM_CAMCORDER_STATE_NONE;
1847 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
1848 int af_range = MM_CAMCORDER_AUTO_FOCUS_NORMAL;
1849 int sensor_focus_mode = 0;
1850 int sensor_af_range = 0;
1851 int current_focus_mode = 0;
1852 int current_af_range = 0;
1853 mmf_camcorder_t *hcamcorder = NULL;
1854 _MMCamcorderSubContext *sc = NULL;
1855 GstCameraControl *control = NULL;
1859 hcamcorder = MMF_CAMCORDER(handle);
1860 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1862 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
1863 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1865 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1866 _mmcam_dbg_err("Another command is running.");
1867 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1870 state = _mmcamcorder_get_state(handle);
1872 if (state == MM_CAMCORDER_STATE_CAPTURING ||
1873 state < MM_CAMCORDER_STATE_PREPARE) {
1874 _mmcam_dbg_err( "Not proper state. state[%d]", state );
1875 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1876 return MM_ERROR_CAMCORDER_INVALID_STATE;
1879 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1880 _mmcam_dbg_log("Can't cast Video source into camera control.");
1881 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1882 return MM_ERROR_NONE;
1885 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
1886 if (control == NULL) {
1887 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
1888 return MM_ERROR_CAMCORDER_INTERNAL;
1891 ret = gst_camera_control_stop_auto_focus(control);
1893 _mmcam_dbg_err("Auto focusing stop fail.");
1894 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1895 return MM_ERROR_CAMCORDER_DEVICE_IO;
1898 /* Initialize lens position */
1899 mm_camcorder_get_attributes(handle, NULL,
1900 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
1901 MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
1903 sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
1904 sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
1906 gst_camera_control_get_focus(control, ¤t_focus_mode, ¤t_af_range);
1908 if (current_focus_mode != sensor_focus_mode ||
1909 current_af_range != sensor_af_range) {
1910 ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
1912 _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
1916 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1919 _mmcam_dbg_log("Lens init success.");
1920 return MM_ERROR_NONE;
1922 _mmcam_dbg_err("Lens init fail.");
1923 return MM_ERROR_CAMCORDER_DEVICE_IO;
1927 int _mmcamcorder_adjust_focus(MMHandleType handle, int direction)
1930 int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
1931 int ret = MM_ERROR_UNKNOWN;
1932 char *err_attr_name = NULL;
1934 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1935 mmf_return_val_if_fail(direction, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1937 /*_mmcam_dbg_log("");*/
1939 if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
1940 _mmcam_dbg_err("Another command is running.");
1941 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1944 state = _mmcamcorder_get_state(handle);
1945 if (state == MM_CAMCORDER_STATE_CAPTURING ||
1946 state < MM_CAMCORDER_STATE_PREPARE) {
1947 _mmcam_dbg_err("Not proper state. state[%d]", state);
1948 _MMCAMCORDER_UNLOCK_CMD(handle);
1949 return MM_ERROR_CAMCORDER_INVALID_STATE;
1952 /* TODO : call a auto or manual focus function */
1953 ret = mm_camcorder_get_attributes(handle, &err_attr_name,
1954 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
1956 if (ret != MM_ERROR_NONE) {
1957 _mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret);
1958 SAFE_FREE (err_attr_name);
1959 _MMCAMCORDER_UNLOCK_CMD(handle);
1963 if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) {
1964 ret = _mmcamcorder_adjust_manual_focus(handle, direction);
1965 } else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO ||
1966 focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ||
1967 focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
1968 ret = _mmcamcorder_adjust_auto_focus(handle);
1970 _mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode);
1971 ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
1974 _MMCAMCORDER_UNLOCK_CMD(handle);
1979 int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
1984 int focus_level = 0;
1985 float unit_level = 0;
1986 GstCameraControl *control = NULL;
1987 _MMCamcorderSubContext *sc = NULL;
1988 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1992 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1993 mmf_return_val_if_fail(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL != 1, MM_ERROR_CAMCORDER_NOT_SUPPORTED);
1994 mmf_return_val_if_fail((direction >= MM_CAMCORDER_MF_LENS_DIR_FORWARD) &&
1995 (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
1996 MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1998 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
1999 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2001 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2002 _mmcam_dbg_log("Can't cast Video source into camera control.");
2003 return MM_ERROR_NONE;
2006 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2007 if (control == NULL) {
2008 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2009 return MM_ERROR_CAMCORDER_INTERNAL;
2012 /* TODO : get max, min level */
2013 if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) {
2014 _mmcam_dbg_warn("Total level of manual focus of MMF is greater than that of the camera driver.");
2017 unit_level = ((float)max_level - (float)min_level)/(float)(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL - 1);
2019 if (!gst_camera_control_get_focus_level(control, &cur_level)) {
2020 _mmcam_dbg_err("Can't get current level of manual focus.");
2021 return MM_ERROR_CAMCORDER_DEVICE_IO;
2024 //TODO : adjust unit level value
2025 if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD) {
2026 focus_level = cur_level + unit_level;
2027 } else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD) {
2028 focus_level = cur_level - unit_level;
2031 if (focus_level > max_level) {
2032 focus_level = max_level;
2033 } else if (focus_level < min_level) {
2034 focus_level = min_level;
2037 if (!gst_camera_control_set_focus_level(control, focus_level)) {
2038 _mmcam_dbg_err("Manual focusing fail.");
2039 return MM_ERROR_CAMCORDER_DEVICE_IO;
2042 return MM_ERROR_NONE;
2046 int _mmcamcorder_adjust_auto_focus(MMHandleType handle)
2049 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2050 GstCameraControl *control = NULL;
2051 _MMCamcorderSubContext *sc = NULL;
2053 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2055 /*_mmcam_dbg_log("");*/
2057 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2059 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2060 _mmcam_dbg_log("Can't cast Video source into camera control.");
2061 return MM_ERROR_NONE;
2064 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2067 ret = gst_camera_control_start_auto_focus(control);
2069 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2074 _mmcam_dbg_log("Auto focusing start success.");
2075 return MM_ERROR_NONE;
2077 _mmcam_dbg_err("Auto focusing start fail.");
2078 return MM_ERROR_CAMCORDER_DEVICE_IO;
2082 int _mmcamcorder_stop_focusing(MMHandleType handle)
2084 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2085 _MMCamcorderSubContext *sc = NULL;
2088 GstCameraControl *control = NULL;
2090 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2092 /*_mmcam_dbg_log("");*/
2094 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2096 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
2097 _mmcam_dbg_err("Another command is running.");
2098 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2101 state = _mmcamcorder_get_state(handle);
2102 if (state == MM_CAMCORDER_STATE_CAPTURING ||
2103 state < MM_CAMCORDER_STATE_PREPARE) {
2104 _mmcam_dbg_err( "Not proper state. state[%d]", state );
2105 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2106 return MM_ERROR_CAMCORDER_INVALID_STATE;
2109 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2110 _mmcam_dbg_log("Can't cast Video source into camera control.");
2111 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2112 return MM_ERROR_NONE;
2115 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2117 ret = gst_camera_control_stop_auto_focus(control);
2119 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2123 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2126 _mmcam_dbg_log("Auto focusing stop success.");
2127 return MM_ERROR_NONE;
2129 _mmcam_dbg_err("Auto focusing stop fail.");
2130 return MM_ERROR_CAMCORDER_DEVICE_IO;
2135 /*-----------------------------------------------
2136 | CAMCORDER INTERNAL LOCAL |
2137 -----------------------------------------------*/
2139 __mmcamcorder_gstreamer_init(camera_conf * conf)
2141 static const int max_argc = 10;
2145 gchar **argv = NULL;
2147 gboolean ret = FALSE;
2148 type_string_array *GSTInitOption = NULL;
2150 mmf_return_val_if_fail(conf, FALSE);
2155 argc = malloc(sizeof(int));
2156 argv = malloc(sizeof(gchar *) * max_argc);
2158 if (!argc || !argv) {
2162 memset(argv, 0, sizeof(gchar *) * max_argc);
2166 argv[0] = g_strdup("mmcamcorder");
2169 _mmcamcorder_conf_get_value_string_array(conf,
2170 CONFIGURE_CATEGORY_MAIN_GENERAL,
2173 if (GSTInitOption != NULL && GSTInitOption->value) {
2174 cnt_str = GSTInitOption->count;
2175 for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
2177 argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
2181 _mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
2183 for (i = 0; i < *argc; i++) {
2184 _mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
2187 /* initializing gstreamer */
2188 ret = gst_init_check (argc, &argv, &err);
2190 _mmcam_dbg_err("Could not initialize GStreamer: %s ",
2191 err ? err->message : "unknown error occurred");
2198 for (i = 0; i < *argc; i++) {
2218 _mmcam_dbg_err("failed to initialize gstreamer");
2234 int _mmcamcorder_get_state(MMHandleType handle)
2237 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2239 mmf_return_val_if_fail(hcamcorder, -1);
2241 _MMCAMCORDER_LOCK_STATE(handle);
2243 state = hcamcorder->state;
2244 /*_mmcam_dbg_log("state=%d",state);*/
2246 _MMCAMCORDER_UNLOCK_STATE(handle);
2252 void _mmcamcorder_set_state(MMHandleType handle, int state)
2255 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2256 _MMCamcorderMsgItem msg;
2258 mmf_return_if_fail(hcamcorder);
2260 /*_mmcam_dbg_log("");*/
2262 _MMCAMCORDER_LOCK_STATE(handle);
2264 old_state = hcamcorder->state;
2265 if(old_state != state) {
2266 hcamcorder->state = state;
2267 hcamcorder->target_state = state;
2269 _mmcam_dbg_log("set state[%d] and send state-changed message", state);
2271 msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
2272 msg.param.state.code = MM_ERROR_NONE;
2273 msg.param.state.previous = old_state;
2274 msg.param.state.current = state;
2276 /*_mmcam_dbg_log("_mmcamcorder_send_message : msg : %p, id:%x", &msg, msg.id);*/
2277 _mmcamcorder_send_message(handle, &msg);
2280 _MMCAMCORDER_UNLOCK_STATE(handle);
2286 int _mmcamcorder_get_async_state(MMHandleType handle)
2289 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2291 _MMCAMCORDER_LOCK_STATE(handle);
2292 state = hcamcorder->target_state;
2294 _MMCAMCORDER_UNLOCK_STATE(handle);
2300 _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
2303 _MMCamcorderSubContext *sc = NULL;
2305 /*_mmcam_dbg_log("");*/
2307 /* alloc container */
2308 sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext));
2309 mmf_return_val_if_fail(sc != NULL, NULL);
2312 memset(sc, 0x00, sizeof(_MMCamcorderSubContext));
2314 sc->element_num = _MMCAMCORDER_PIPELINE_ELEMENT_NUM;
2315 sc->encode_element_num = _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM;
2317 /* alloc info for each mode */
2319 case MM_CAMCORDER_MODE_AUDIO:
2320 sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo));
2321 if(!sc->info_audio) {
2322 _mmcam_dbg_err("Failed to alloc info structure");
2323 goto ALLOC_SUBCONTEXT_FAILED;
2325 memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo));
2327 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2329 sc->info_image = malloc( sizeof(_MMCamcorderImageInfo));
2330 if(!sc->info_image) {
2331 _mmcam_dbg_err("Failed to alloc info structure");
2332 goto ALLOC_SUBCONTEXT_FAILED;
2334 memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo));
2336 /* init sound status */
2337 sc->info_image->sound_status = _SOUND_STATUS_INIT;
2339 sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo));
2340 if(!sc->info_video) {
2341 _mmcam_dbg_err("Failed to alloc info structure");
2342 goto ALLOC_SUBCONTEXT_FAILED;
2344 memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo));
2345 pthread_mutex_init(&(sc->info_video->size_check_lock), NULL);
2349 /* alloc element array */
2350 sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
2352 _mmcam_dbg_err("Failed to alloc element structure");
2353 goto ALLOC_SUBCONTEXT_FAILED;
2356 sc->encode_element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->encode_element_num);
2357 if(!sc->encode_element) {
2358 _mmcam_dbg_err("Failed to alloc encode element structure");
2359 goto ALLOC_SUBCONTEXT_FAILED;
2362 for (i = 0 ; i < sc->element_num ; i++) {
2363 sc->element[i].id = _MMCAMCORDER_NONE;
2364 sc->element[i].gst = NULL;
2367 for (i = 0 ; i < sc->encode_element_num ; i++) {
2368 sc->encode_element[i].id = _MMCAMCORDER_NONE;
2369 sc->encode_element[i].gst = NULL;
2372 sc->fourcc = 0x80000000;
2373 sc->cam_stability_count = 0;
2374 sc->drop_vframe = 0;
2375 sc->pass_first_vframe = 0;
2376 sc->is_modified_rate = FALSE;
2380 ALLOC_SUBCONTEXT_FAILED:
2382 if (sc->info_audio) {
2383 free(sc->info_audio);
2384 sc->info_audio = NULL;
2386 if (sc->info_image) {
2387 free(sc->info_image);
2388 sc->info_image = NULL;
2390 if (sc->info_video) {
2391 pthread_mutex_destroy(&(sc->info_video->size_check_lock));
2392 free(sc->info_video);
2393 sc->info_video = NULL;
2399 if (sc->encode_element) {
2400 free(sc->encode_element);
2401 sc->encode_element = NULL;
2411 void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc)
2417 _mmcam_dbg_log("release element");
2422 if (sc->encode_element) {
2423 _mmcam_dbg_log("release encode_element");
2424 free(sc->encode_element);
2425 sc->encode_element = NULL;
2428 if (sc->info_image) {
2429 _mmcam_dbg_log("release info_image");
2430 free(sc->info_image);
2431 sc->info_image = NULL;
2434 if (sc->info_video) {
2435 _mmcam_dbg_log("release info_video");
2436 if (sc->info_video->filename) {
2437 free(sc->info_video->filename);
2438 sc->info_video->filename = NULL;
2440 pthread_mutex_destroy(&(sc->info_video->size_check_lock));
2441 free(sc->info_video);
2442 sc->info_video = NULL;
2445 if (sc->info_audio) {
2446 _mmcam_dbg_log("release info_audio");
2447 if (sc->info_audio->filename) {
2448 free(sc->info_audio->filename);
2449 sc->info_audio->filename = NULL;
2451 free(sc->info_audio);
2452 sc->info_audio = NULL;
2463 int _mmcamcorder_set_functions(MMHandleType handle, int type)
2465 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2467 /*_mmcam_dbg_log("");*/
2470 case MM_CAMCORDER_MODE_AUDIO:
2471 hcamcorder->command = _mmcamcorder_audio_command;
2473 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2475 hcamcorder->command = _mmcamcorder_video_capture_command;
2479 return MM_ERROR_NONE;
2483 gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpointer data)
2485 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2486 _MMCamcorderSubContext *sc = NULL;
2488 mmf_return_val_if_fail(hcamcorder, FALSE);
2489 mmf_return_val_if_fail(message, FALSE);
2490 //_mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message));
2492 switch (GST_MESSAGE_TYPE(message)) {
2493 case GST_MESSAGE_UNKNOWN:
2494 _mmcam_dbg_log("GST_MESSAGE_UNKNOWN");
2496 case GST_MESSAGE_EOS:
2498 _mmcam_dbg_log ("Got EOS from element \"%s\".",
2499 GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
2501 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2502 mmf_return_val_if_fail(sc, TRUE);
2504 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
2505 mmf_return_val_if_fail(sc->info_video, TRUE);
2506 if (sc->info_video->b_commiting) {
2507 _mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
2510 mmf_return_val_if_fail(sc->info_audio, TRUE);
2511 if (sc->info_audio->b_commiting) {
2512 _mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
2516 sc->bget_eos = TRUE;
2520 case GST_MESSAGE_ERROR:
2524 gst_message_parse_error(message, &err, &debug);
2526 _mmcam_dbg_err ("GSTERR: %s", err->message);
2527 _mmcam_dbg_err ("Error Debug: %s", debug);
2529 __mmcamcorder_handle_gst_error((MMHandleType)hcamcorder, message, err);
2535 case GST_MESSAGE_WARNING:
2539 gst_message_parse_warning (message, &err, &debug);
2541 _mmcam_dbg_warn("GSTWARN: %s", err->message);
2543 __mmcamcorder_handle_gst_warning((MMHandleType)hcamcorder, message, err);
2549 case GST_MESSAGE_INFO:
2550 _mmcam_dbg_log("GST_MESSAGE_INFO");
2552 case GST_MESSAGE_TAG:
2553 _mmcam_dbg_log("GST_MESSAGE_TAG");
2555 case GST_MESSAGE_BUFFERING:
2556 _mmcam_dbg_log("GST_MESSAGE_BUFFERING");
2558 case GST_MESSAGE_STATE_CHANGED:
2560 const GValue *vnewstate;
2562 GstElement *pipeline = NULL;
2564 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2565 if ((sc) && (sc->element)) {
2566 if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
2567 pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
2568 if (message->src == (GstObject*)pipeline) {
2569 vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state");
2570 newstate = (GstState)vnewstate->data[0].v_int;
2571 _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]",gst_element_state_get_name(newstate));
2577 case GST_MESSAGE_STATE_DIRTY:
2578 _mmcam_dbg_log("GST_MESSAGE_STATE_DIRTY");
2580 case GST_MESSAGE_STEP_DONE:
2581 _mmcam_dbg_log("GST_MESSAGE_STEP_DONE");
2583 case GST_MESSAGE_CLOCK_PROVIDE:
2584 _mmcam_dbg_log("GST_MESSAGE_CLOCK_PROVIDE");
2586 case GST_MESSAGE_CLOCK_LOST:
2587 _mmcam_dbg_log("GST_MESSAGE_CLOCK_LOST");
2589 case GST_MESSAGE_NEW_CLOCK:
2591 GstClock *pipe_clock = NULL;
2592 gst_message_parse_new_clock(message, &pipe_clock);
2593 /*_mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL"));*/
2596 case GST_MESSAGE_STRUCTURE_CHANGE:
2597 _mmcam_dbg_log("GST_MESSAGE_STRUCTURE_CHANGE");
2599 case GST_MESSAGE_STREAM_STATUS:
2600 /*_mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");*/
2602 case GST_MESSAGE_APPLICATION:
2603 _mmcam_dbg_log("GST_MESSAGE_APPLICATION");
2605 case GST_MESSAGE_ELEMENT:
2606 /*_mmcam_dbg_log("GST_MESSAGE_ELEMENT");*/
2608 case GST_MESSAGE_SEGMENT_START:
2609 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_START");
2611 case GST_MESSAGE_SEGMENT_DONE:
2612 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_DONE");
2614 case GST_MESSAGE_DURATION_CHANGED:
2615 _mmcam_dbg_log("GST_MESSAGE_DURATION_CHANGED");
2617 case GST_MESSAGE_LATENCY:
2618 _mmcam_dbg_log("GST_MESSAGE_LATENCY");
2620 case GST_MESSAGE_ASYNC_START:
2621 _mmcam_dbg_log("GST_MESSAGE_ASYNC_START");
2623 case GST_MESSAGE_ASYNC_DONE:
2624 /*_mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");*/
2626 case GST_MESSAGE_ANY:
2627 _mmcam_dbg_log("GST_MESSAGE_ANY");
2629 case GST_MESSAGE_QOS:
2630 // _mmcam_dbg_log("GST_MESSAGE_QOS");
2633 _mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message));
2641 GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
2643 GstElement *element = NULL;
2645 gchar *debug_info = NULL;
2647 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2648 _MMCamcorderSubContext *sc = NULL;
2650 mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
2651 mmf_return_val_if_fail(message, GST_BUS_PASS);
2653 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2654 mmf_return_val_if_fail(sc, GST_BUS_PASS);
2656 if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
2657 /* parse error message */
2658 gst_message_parse_error(message, &err, &debug_info);
2661 _mmcam_dbg_err("GST ERROR : %s", debug_info);
2667 _mmcam_dbg_warn("failed to parse error message");
2668 return GST_BUS_PASS;
2671 /* set videosrc element to compare */
2672 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2674 /* check domain[RESOURCE] and element[VIDEOSRC] */
2675 if (err->domain == GST_RESOURCE_ERROR &&
2676 GST_ELEMENT_CAST(message->src) == element) {
2677 switch (err->code) {
2678 case GST_RESOURCE_ERROR_BUSY:
2679 _mmcam_dbg_err("Camera device [busy]");
2680 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
2682 case GST_RESOURCE_ERROR_OPEN_WRITE:
2683 _mmcam_dbg_err("Camera device [open failed]");
2684 hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
2685 //sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE
2687 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
2688 _mmcam_dbg_err("Camera device [open failed]");
2689 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
2691 case GST_RESOURCE_ERROR_OPEN_READ:
2692 _mmcam_dbg_err("Camera device [register trouble]");
2693 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
2695 case GST_RESOURCE_ERROR_NOT_FOUND:
2696 _mmcam_dbg_err("Camera device [device not found]");
2697 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
2699 case GST_RESOURCE_ERROR_TOO_LAZY:
2700 _mmcam_dbg_err("Camera device [timeout]");
2701 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
2703 case GST_RESOURCE_ERROR_SETTINGS:
2704 _mmcam_dbg_err("Camera device [not supported]");
2705 hcamcorder->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
2707 case GST_RESOURCE_ERROR_FAILED:
2708 _mmcam_dbg_err("Camera device [working failed].");
2709 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
2712 _mmcam_dbg_err("Camera device [General(%d)]", err->code);
2713 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE;
2717 hcamcorder->error_occurs = TRUE;
2722 /* store error code and drop this message if cmd is running */
2723 if (hcamcorder->error_code != MM_ERROR_NONE) {
2724 _MMCamcorderMsgItem msg;
2726 /* post error to application */
2727 hcamcorder->error_occurs = TRUE;
2728 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
2729 msg.param.code = hcamcorder->error_code;
2730 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2734 } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ELEMENT) {
2735 _MMCamcorderMsgItem msg;
2737 if (gst_structure_has_name(gst_message_get_structure(message), "avsysvideosrc-AF") ||
2738 gst_structure_has_name(gst_message_get_structure(message), "camerasrc-AF")) {
2739 int focus_state = 0;
2741 gst_structure_get_int(gst_message_get_structure(message), "focus-state", &focus_state);
2742 _mmcam_dbg_log("Focus State:%d", focus_state);
2744 msg.id = MM_MESSAGE_CAMCORDER_FOCUS_CHANGED;
2745 msg.param.code = focus_state;
2746 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2749 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-HDR")) {
2753 if (gst_structure_get_int(gst_message_get_structure(message), "progress", &progress)) {
2754 gst_structure_get_int(gst_message_get_structure(message), "status", &status);
2755 _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status);
2757 msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS;
2758 msg.param.code = progress;
2759 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2763 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-FD")) {
2765 const GValue *g_value = gst_structure_get_value(gst_message_get_structure(message), "face-info");;
2766 GstCameraControlFaceDetectInfo *fd_info = NULL;
2767 MMCamFaceDetectInfo *cam_fd_info = NULL;
2770 fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
2773 if (fd_info == NULL) {
2774 _mmcam_dbg_warn("fd_info is NULL");
2778 cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo));
2779 if (cam_fd_info == NULL) {
2780 _mmcam_dbg_warn("cam_fd_info alloc failed");
2788 /* set total face count */
2789 cam_fd_info->num_of_faces = fd_info->num_of_faces;
2791 if (cam_fd_info->num_of_faces > 0) {
2792 cam_fd_info->face_info = (MMCamFaceInfo *)malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces);
2793 if (cam_fd_info->face_info) {
2794 /* set information of each face */
2795 for (i = 0 ; i < fd_info->num_of_faces ; i++) {
2796 cam_fd_info->face_info[i].id = fd_info->face_info[i].id;
2797 cam_fd_info->face_info[i].score = fd_info->face_info[i].score;
2798 cam_fd_info->face_info[i].rect.x = fd_info->face_info[i].rect.x;
2799 cam_fd_info->face_info[i].rect.y = fd_info->face_info[i].rect.y;
2800 cam_fd_info->face_info[i].rect.width = fd_info->face_info[i].rect.width;
2801 cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
2803 _mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
2804 fd_info->face_info[i].id,
2805 fd_info->face_info[i].score,
2806 fd_info->face_info[i].rect.x,
2807 fd_info->face_info[i].rect.y,
2808 fd_info->face_info[i].rect.width,
2809 fd_info->face_info[i].rect.height);
2813 _mmcam_dbg_warn("MMCamFaceInfo alloc failed");
2815 /* free allocated memory that is not sent */
2820 cam_fd_info->face_info = NULL;
2824 /* send message - cam_fd_info should be freed by application */
2825 msg.id = MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO;
2826 msg.param.data = cam_fd_info;
2827 msg.param.size = sizeof(MMCamFaceDetectInfo);
2830 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2833 /* free fd_info allocated by plugin */
2838 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-Capture")) {
2839 int capture_done = FALSE;
2841 if (gst_structure_get_int(gst_message_get_structure(message), "capture-done", &capture_done)) {
2842 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2843 if (sc && sc->info_image) {
2844 /* play capture sound */
2845 _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
2853 return GST_BUS_PASS;
2855 gst_message_unref(message);
2858 return GST_BUS_DROP;
2862 GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
2864 GstElement *element = NULL;
2866 gchar *debug_info = NULL;
2868 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2869 _MMCamcorderSubContext *sc = NULL;
2871 mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
2872 mmf_return_val_if_fail(message, GST_BUS_PASS);
2874 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2875 mmf_return_val_if_fail(sc, GST_BUS_PASS);
2877 if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
2878 /* parse error message */
2879 gst_message_parse_error(message, &err, &debug_info);
2882 _mmcam_dbg_err("GST ERROR : %s", debug_info);
2888 _mmcam_dbg_warn("failed to parse error message");
2889 return GST_BUS_PASS;
2892 /* set videosrc element to compare */
2893 element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
2895 /* check domain[RESOURCE] and element[VIDEOSRC] */
2896 if (err->domain == GST_RESOURCE_ERROR &&
2897 GST_ELEMENT_CAST(message->src) == element) {
2898 _MMCamcorderMsgItem msg;
2899 switch (err->code) {
2900 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
2901 case GST_RESOURCE_ERROR_OPEN_WRITE:
2902 _mmcam_dbg_err("audio device [open failed]");
2903 hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
2904 /* post error to application */
2905 hcamcorder->error_occurs = TRUE;
2906 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
2907 msg.param.code = hcamcorder->error_code;
2908 _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
2910 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2911 gst_message_unref(message);
2913 return GST_BUS_DROP;
2923 return GST_BUS_PASS;
2927 int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
2929 int ret = MM_ERROR_NONE;
2930 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2931 _MMCamcorderSubContext *sc = NULL;
2932 GstElement *pipeline = NULL;
2934 _mmcam_dbg_log("handle : %x, type : %d", handle, type);
2936 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2938 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2939 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2942 case MM_CAMCORDER_MODE_AUDIO:
2943 ret = _mmcamcorder_create_audio_pipeline(handle);
2944 if (ret != MM_ERROR_NONE) {
2948 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2950 ret = _mmcamcorder_create_preview_pipeline(handle);
2951 if (ret != MM_ERROR_NONE) {
2955 /* connect capture signal */
2956 if (!sc->bencbin_capture) {
2957 ret = _mmcamcorder_connect_capture_signal(handle);
2958 if (ret != MM_ERROR_NONE) {
2965 pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
2966 if (type != MM_CAMCORDER_MODE_AUDIO) {
2967 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
2969 #ifdef _MMCAMCORDER_GET_DEVICE_INFO
2970 if (!_mmcamcorder_get_device_info(handle)) {
2971 _mmcam_dbg_err("Getting device information error!!");
2975 _mmcam_dbg_log("ret[%x]", ret);
2976 if (ret != MM_ERROR_NONE) {
2977 _mmcam_dbg_err("error : destroy pipeline");
2978 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
2985 void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type)
2987 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2988 _MMCamcorderSubContext *sc = NULL;
2990 int element_num = 0;
2991 _MMCamcorderGstElement *element = NULL;
2994 mmf_return_if_fail(hcamcorder);
2996 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2997 mmf_return_if_fail(sc);
3001 /* Inside each pipeline destroy function, Set GST_STATE_NULL to Main pipeline */
3003 case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
3004 element = sc->element;
3005 element_num = sc->element_num;
3006 bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst));
3007 _mmcamcorder_destroy_video_capture_pipeline(handle);
3009 case MM_CAMCORDER_MODE_AUDIO:
3010 element = sc->encode_element;
3011 element_num = sc->encode_element_num;
3012 bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst));
3013 _mmcamcorder_destroy_audio_pipeline(handle);
3016 _mmcam_dbg_err("unknown type %d", type);
3020 _mmcam_dbg_log("Pipeline clear!!");
3022 /* Remove pipeline message callback */
3023 if (hcamcorder->pipeline_cb_event_id > 0) {
3024 g_source_remove(hcamcorder->pipeline_cb_event_id);
3025 hcamcorder->pipeline_cb_event_id = 0;
3028 /* Remove remained message in bus */
3030 GstMessage *gst_msg = NULL;
3031 while ((gst_msg = gst_bus_pop(bus)) != NULL) {
3032 _mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder);
3033 gst_message_unref( gst_msg );
3036 gst_object_unref( bus );
3040 /* checking unreleased element */
3041 for (i = 0 ; i < element_num ; i++ ) {
3042 if (element[i].gst) {
3043 if (GST_IS_ELEMENT(element[i].gst)) {
3044 _mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]",
3046 GST_OBJECT_NAME(element[i].gst),
3047 GST_OBJECT_REFCOUNT(element[i].gst),
3048 gst_element_state_get_name(GST_STATE(element[i].gst)));
3049 g_object_weak_unref(G_OBJECT(element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc);
3051 _mmcam_dbg_warn("The element[%d] is still aliving, check it", element[i].id);
3054 element[i].id = _MMCAMCORDER_NONE;
3055 element[i].gst = NULL;
3063 int _mmcamcorder_gst_set_state_async(MMHandleType handle, GstElement *pipeline, GstState target_state)
3065 GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3067 _MMCAMCORDER_LOCK_GST_STATE(handle);
3068 setChangeReturn = gst_element_set_state(pipeline, target_state);
3069 _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3071 return setChangeReturn;
3075 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
3076 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data)
3078 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
3080 mmf_return_val_if_fail(hcamcorder, FALSE);
3084 _mmcamcorder_set_attribute_to_camsensor((MMHandleType)hcamcorder);
3087 hcamcorder->setting_event_id = 0;
3089 _mmcam_dbg_log("Done");
3094 #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
3097 int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstState target_state)
3100 _MMCamcorderSubContext *sc = NULL;
3101 GstState pipeline_state = GST_STATE_VOID_PENDING;
3102 GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3103 GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE;
3104 GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND;
3105 pthread_mutex_t *state_lock = NULL;
3107 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3108 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3109 mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3111 if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst == pipeline) {
3112 _mmcam_dbg_log("Set state to %d - PREVIEW PIPELINE", target_state);
3113 state_lock = &_MMCAMCORDER_GET_GST_STATE_LOCK(handle);
3115 _mmcam_dbg_log("Set state to %d - ENDODE PIPELINE", target_state);
3116 state_lock = &_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle);
3119 pthread_mutex_lock(state_lock);
3121 for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
3122 setChangeReturn = gst_element_set_state(pipeline, target_state);
3123 _mmcam_dbg_log("gst_element_set_state[%d] return %d",
3124 target_state, setChangeReturn);
3125 if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
3126 getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
3127 switch (getChangeReturn) {
3128 case GST_STATE_CHANGE_NO_PREROLL:
3129 _mmcam_dbg_log("status=GST_STATE_CHANGE_NO_PREROLL.");
3130 case GST_STATE_CHANGE_SUCCESS:
3131 /* if we reached the final target state, exit */
3132 if (pipeline_state == target_state) {
3133 _mmcam_dbg_log("Set state to %d - DONE", target_state);
3134 pthread_mutex_unlock(state_lock);
3135 return MM_ERROR_NONE;
3138 case GST_STATE_CHANGE_ASYNC:
3139 _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC.");
3142 pthread_mutex_unlock(state_lock);
3143 _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE.");
3144 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3147 pthread_mutex_unlock(state_lock);
3149 _mmcam_dbg_err("timeout of gst_element_get_state()!!");
3151 return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3154 usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL);
3157 pthread_mutex_unlock(state_lock);
3159 _mmcam_dbg_err("Failure. gst_element_set_state timeout!!");
3161 return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3165 /* For performance check */
3166 int _mmcamcorder_video_current_framerate(MMHandleType handle)
3168 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3169 _MMCamcorderSubContext *sc = NULL;
3171 mmf_return_val_if_fail(hcamcorder, -1);
3173 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3174 mmf_return_val_if_fail(sc, -1);
3176 return sc->kpi.current_fps;
3180 int _mmcamcorder_video_average_framerate(MMHandleType handle)
3182 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3183 _MMCamcorderSubContext *sc = NULL;
3185 mmf_return_val_if_fail(hcamcorder, -1);
3187 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3188 mmf_return_val_if_fail(sc, -1);
3190 return sc->kpi.average_fps;
3194 void _mmcamcorder_video_current_framerate_init(MMHandleType handle)
3196 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3197 _MMCamcorderSubContext *sc = NULL;
3199 mmf_return_if_fail(hcamcorder);
3201 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3202 mmf_return_if_fail(sc);
3204 memset(&(sc->kpi), 0x00, sizeof(_MMCamcorderKPIMeasure));
3210 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error)
3212 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3213 _MMCamcorderMsgItem msg;
3214 gchar *msg_src_element;
3215 _MMCamcorderSubContext *sc = NULL;
3217 return_val_if_fail(hcamcorder, FALSE);
3218 return_val_if_fail(error, FALSE);
3219 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3220 mmf_return_val_if_fail(sc, FALSE);
3224 /* filtering filesink related errors */
3225 if (hcamcorder->state == MM_CAMCORDER_STATE_RECORDING &&
3226 (error->code == GST_RESOURCE_ERROR_WRITE || error->code == GST_RESOURCE_ERROR_SEEK)) {
3227 if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
3228 sc->ferror_send = TRUE;
3229 msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3232 _mmcam_dbg_warn("Skip error");
3237 if (error->domain == GST_CORE_ERROR) {
3238 msg.param.code = __mmcamcorder_gst_handle_core_error(handle, error->code, message);
3239 } else if (error->domain == GST_LIBRARY_ERROR) {
3240 msg.param.code = __mmcamcorder_gst_handle_library_error(handle, error->code, message);
3241 } else if (error->domain == GST_RESOURCE_ERROR) {
3242 msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3243 } else if (error->domain == GST_STREAM_ERROR) {
3244 msg.param.code = __mmcamcorder_gst_handle_stream_error(handle, error->code, message);
3246 _mmcam_dbg_warn("This error domain is not defined.");
3248 /* we treat system error as an internal error */
3249 msg.param.code = MM_ERROR_CAMCORDER_INTERNAL;
3253 msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
3254 _mmcam_dbg_err("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
3255 msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3257 _mmcam_dbg_err("Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
3258 g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3261 #ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
3262 /* Check whether send this error to application */
3263 if (msg.param.code == MM_ERROR_CAMCORDER_GST_FLOW_ERROR) {
3264 _mmcam_dbg_log("We got the error. But skip it.");
3267 #endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
3269 /* post error to application */
3270 hcamcorder->error_occurs = TRUE;
3271 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
3272 _mmcamcorder_send_message(handle, &msg);
3278 static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message)
3280 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3281 _MMCamcorderSubContext *sc = NULL;
3282 GstElement *element = NULL;
3286 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3288 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3289 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3291 /* Specific plugin - video encoder plugin */
3292 element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3294 if (GST_ELEMENT_CAST(message->src) == element) {
3295 if (code == GST_CORE_ERROR_NEGOTIATION) {
3296 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3298 return MM_ERROR_CAMCORDER_ENCODER;
3305 case GST_CORE_ERROR_STATE_CHANGE:
3306 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3307 case GST_CORE_ERROR_NEGOTIATION:
3308 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3309 case GST_CORE_ERROR_MISSING_PLUGIN:
3310 case GST_CORE_ERROR_SEEK:
3311 case GST_CORE_ERROR_NOT_IMPLEMENTED:
3312 case GST_CORE_ERROR_FAILED:
3313 case GST_CORE_ERROR_TOO_LAZY:
3314 case GST_CORE_ERROR_PAD:
3315 case GST_CORE_ERROR_THREAD:
3316 case GST_CORE_ERROR_EVENT:
3317 case GST_CORE_ERROR_CAPS:
3318 case GST_CORE_ERROR_TAG:
3319 case GST_CORE_ERROR_CLOCK:
3320 case GST_CORE_ERROR_DISABLED:
3322 return MM_ERROR_CAMCORDER_GST_CORE;
3327 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
3329 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3330 return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3334 /* Specific plugin - NONE */
3338 case GST_LIBRARY_ERROR_FAILED:
3339 case GST_LIBRARY_ERROR_TOO_LAZY:
3340 case GST_LIBRARY_ERROR_INIT:
3341 case GST_LIBRARY_ERROR_SHUTDOWN:
3342 case GST_LIBRARY_ERROR_SETTINGS:
3343 case GST_LIBRARY_ERROR_ENCODE:
3345 _mmcam_dbg_err("Library error(%d)", code);
3346 return MM_ERROR_CAMCORDER_GST_LIBRARY;
3351 static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message)
3353 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3354 _MMCamcorderSubContext *sc = NULL;
3355 GstElement *element = NULL;
3357 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3359 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3360 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3364 /* Specific plugin */
3366 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst);
3367 if (GST_ELEMENT_CAST(message->src) == element) {
3368 if (code == GST_RESOURCE_ERROR_WRITE) {
3369 _mmcam_dbg_err("Display device [Off]");
3370 return MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF;
3372 _mmcam_dbg_err("Display device [General(%d)]", code);
3377 element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3378 if (GST_ELEMENT_CAST(message->src) == element) {
3379 if (code == GST_RESOURCE_ERROR_FAILED) {
3380 _mmcam_dbg_err("Encoder [Resource error]");
3381 return MM_ERROR_CAMCORDER_ENCODER_BUFFER;
3383 _mmcam_dbg_err("Encoder [General(%d)]", code);
3384 return MM_ERROR_CAMCORDER_ENCODER;
3390 case GST_RESOURCE_ERROR_WRITE:
3391 _mmcam_dbg_err("File write error");
3392 return MM_ERROR_FILE_WRITE;
3393 case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
3394 _mmcam_dbg_err("No left space");
3395 return MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
3396 case GST_RESOURCE_ERROR_OPEN_WRITE:
3397 _mmcam_dbg_err("Out of storage");
3398 return MM_ERROR_OUT_OF_STORAGE;
3399 case GST_RESOURCE_ERROR_SEEK:
3400 _mmcam_dbg_err("File read(seek)");
3401 return MM_ERROR_FILE_READ;
3402 case GST_RESOURCE_ERROR_NOT_FOUND:
3403 case GST_RESOURCE_ERROR_FAILED:
3404 case GST_RESOURCE_ERROR_TOO_LAZY:
3405 case GST_RESOURCE_ERROR_BUSY:
3406 case GST_RESOURCE_ERROR_OPEN_READ:
3407 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3408 case GST_RESOURCE_ERROR_CLOSE:
3409 case GST_RESOURCE_ERROR_READ:
3410 case GST_RESOURCE_ERROR_SYNC:
3411 case GST_RESOURCE_ERROR_SETTINGS:
3413 _mmcam_dbg_err("Resource error(%d)", code);
3414 return MM_ERROR_CAMCORDER_GST_RESOURCE;
3419 static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message)
3421 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3422 _MMCamcorderSubContext *sc = NULL;
3423 GstElement *element =NULL;
3425 mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
3427 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3428 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3432 /* Specific plugin */
3434 element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3435 if (GST_ELEMENT_CAST(message->src) == element) {
3437 case GST_STREAM_ERROR_WRONG_TYPE:
3438 _mmcam_dbg_err("Video encoder [wrong stream type]");
3439 return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
3440 case GST_STREAM_ERROR_ENCODE:
3441 _mmcam_dbg_err("Video encoder [encode error]");
3442 return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3443 case GST_STREAM_ERROR_FAILED:
3444 _mmcam_dbg_err("Video encoder [stream failed]");
3445 return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3447 _mmcam_dbg_err("Video encoder [General(%d)]", code);
3448 return MM_ERROR_CAMCORDER_ENCODER;
3452 /* General plugin */
3454 case GST_STREAM_ERROR_FORMAT:
3455 _mmcam_dbg_err("General [negotiation error(%d)]", code);
3456 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3457 case GST_STREAM_ERROR_FAILED:
3458 _mmcam_dbg_err("General [flow error(%d)]", code);
3459 return MM_ERROR_CAMCORDER_GST_FLOW_ERROR;
3460 case GST_STREAM_ERROR_TYPE_NOT_FOUND:
3461 case GST_STREAM_ERROR_DECODE:
3462 case GST_STREAM_ERROR_CODEC_NOT_FOUND:
3463 case GST_STREAM_ERROR_NOT_IMPLEMENTED:
3464 case GST_STREAM_ERROR_TOO_LAZY:
3465 case GST_STREAM_ERROR_ENCODE:
3466 case GST_STREAM_ERROR_DEMUX:
3467 case GST_STREAM_ERROR_MUX:
3468 case GST_STREAM_ERROR_DECRYPT:
3469 case GST_STREAM_ERROR_DECRYPT_NOKEY:
3470 case GST_STREAM_ERROR_WRONG_TYPE:
3472 _mmcam_dbg_err("General [error(%d)]", code);
3473 return MM_ERROR_CAMCORDER_GST_STREAM;
3478 static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessage *message, GError *error)
3480 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3481 gchar *debug = NULL;
3484 return_val_if_fail(hcamcorder, FALSE);
3485 return_val_if_fail(error, FALSE);
3489 gst_message_parse_warning(message, &err, &debug);
3491 if (error->domain == GST_CORE_ERROR) {
3492 _mmcam_dbg_warn("GST warning: GST_CORE domain");
3493 } else if (error->domain == GST_LIBRARY_ERROR) {
3494 _mmcam_dbg_warn("GST warning: GST_LIBRARY domain");
3495 } else if (error->domain == GST_RESOURCE_ERROR) {
3496 _mmcam_dbg_warn("GST warning: GST_RESOURCE domain");
3497 __mmcamcorder_gst_handle_resource_warning(handle, message, error);
3498 } else if (error->domain == GST_STREAM_ERROR ) {
3499 _mmcam_dbg_warn("GST warning: GST_STREAM domain");
3501 _mmcam_dbg_warn("This error domain(%d) is not defined.", error->domain);
3508 if (debug != NULL) {
3509 _mmcam_dbg_err ("Debug: %s", debug);
3518 static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error)
3520 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3521 _MMCamcorderSubContext *sc = NULL;
3522 GstElement *element =NULL;
3523 gchar *msg_src_element;
3525 mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
3527 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3528 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3532 /* Special message handling */
3534 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3535 if (GST_ELEMENT_CAST(message->src) == element) {
3536 if (error->code == GST_RESOURCE_ERROR_FAILED) {
3537 msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
3538 _mmcam_dbg_warn("-Msg src:[%s] Domain:[%s] Error:[%s]",
3539 msg_src_element, g_quark_to_string(error->domain), error->message);
3540 return MM_ERROR_NONE;
3544 /* General plugin */
3545 switch (error->code) {
3546 case GST_RESOURCE_ERROR_WRITE:
3547 case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
3548 case GST_RESOURCE_ERROR_SEEK:
3549 case GST_RESOURCE_ERROR_NOT_FOUND:
3550 case GST_RESOURCE_ERROR_FAILED:
3551 case GST_RESOURCE_ERROR_TOO_LAZY:
3552 case GST_RESOURCE_ERROR_BUSY:
3553 case GST_RESOURCE_ERROR_OPEN_READ:
3554 case GST_RESOURCE_ERROR_OPEN_WRITE:
3555 case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3556 case GST_RESOURCE_ERROR_CLOSE:
3557 case GST_RESOURCE_ERROR_READ:
3558 case GST_RESOURCE_ERROR_SYNC:
3559 case GST_RESOURCE_ERROR_SETTINGS:
3561 _mmcam_dbg_warn("General GST warning(%d)", error->code);
3565 return MM_ERROR_NONE;