src/mm_camcorder_internal.c

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /*=======================================================================================
  23 |  INCLUDE FILES                                                                        |
  24 ========================================================================================*/
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <fcntl.h>
  28 #include <gst/gst.h>
  29 #include <gst/gstutils.h>
  30 #include <gst/gstpad.h>
  31 #include <sys/time.h>
  32
  33 #include <mm_error.h>
  34 #include "mm_camcorder_internal.h"
  35 #include <mm_types.h>
  36
  37 #include <gst/video/colorbalance.h>
  38 #include <gst/video/cameracontrol.h>
  39 #include <asm/types.h>
  40
  41 #include <system_info.h>
  42 #include <mm_session.h>
  43 #include <mm_session_private.h>
  44
  45 #include <murphy/common/glib-glue.h>
  46
  47 /*---------------------------------------------------------------------------------------
  48 |    GLOBAL VARIABLE DEFINITIONS for internal                                           |
  49 ---------------------------------------------------------------------------------------*/
  50 int g_mm_camcorder_type = -255;
  51 struct sigaction mm_camcorder_int_old_action;
  52 struct sigaction mm_camcorder_abrt_old_action;
  53 struct sigaction mm_camcorder_segv_old_action;
  54 struct sigaction mm_camcorder_term_old_action;
  55 struct sigaction mm_camcorder_sys_old_action;
  56
  57 /*---------------------------------------------------------------------------------------
  58 |    LOCAL VARIABLE DEFINITIONS for internal                                            |
  59 ---------------------------------------------------------------------------------------*/
  60 #define __MMCAMCORDER_CMD_ITERATE_MAX           3
  61 #define __MMCAMCORDER_SET_GST_STATE_TIMEOUT     5
  62 #define __MMCAMCORDER_FORCE_STOP_TRY_COUNT      30
  63 #define __MMCAMCORDER_FORCE_STOP_WAIT_TIME      100000  /* us */
  64 #define __MMCAMCORDER_SOUND_WAIT_TIMEOUT        3
  65 #define __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN   64
  66
  67
  68 /*---------------------------------------------------------------------------------------
  69 |    LOCAL FUNCTION PROTOTYPES:                                                         |
  70 ---------------------------------------------------------------------------------------*/
  71 /* STATIC INTERNAL FUNCTION */
  72 static gboolean __mmcamcorder_gstreamer_init(camera_conf * conf);
  73
  74 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error);
  75 static gint     __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message);
  76 static gint     __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message);
  77 static gint     __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message);
  78 static gint     __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message);
  79 static gint     __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error);
  80 static gboolean __mmcamcorder_handle_gst_warning(MMHandleType handle, GstMessage *message, GError *error);
  81
  82 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
  83 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
  84 #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
  85
  86 static void __mm_camcorder_signal_handler(int signo);
  87 static void _mmcamcorder_constructor() __attribute__((constructor));
  88
  89 /*=======================================================================================
  90 |  FUNCTION DEFINITIONS                                                                 |
  91 =======================================================================================*/
  92 /*---------------------------------------------------------------------------------------
  93 |    GLOBAL FUNCTION DEFINITIONS:                                                       |
  94 ---------------------------------------------------------------------------------------*/
  95
  96
  97 static void __mm_camcorder_signal_handler(int signo)
  98 {
  99         pid_t my_pid = getpid();
 100         pid_t vconf_recorder_pid = -1;
 101         pid_t vconf_camera_pid = -1;
 102         int vconf_flash_state = VCONFKEY_CAMERA_FLASH_STATE_OFF;
 103
 104         _mmcam_dbg_warn("start - signo [%d], pid [%d], device type [%d]", signo, my_pid, g_mm_camcorder_type);
 105
 106         /* reset vconf key */
 107         switch (g_mm_camcorder_type) {
 108         case MM_VIDEO_DEVICE_NONE:
 109                 vconf_get_int(VCONFKEY_RECORDER_PID, (int *)&vconf_recorder_pid);
 110                 if (my_pid == vconf_recorder_pid) {
 111                         vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
 112                         vconf_set_int(VCONFKEY_RECORDER_PID, -1);
 113                         _mmcam_dbg_warn("set recorder state NULL");
 114                 } else {
 115                         _mmcam_dbg_warn("different pid : my[%d] vconf[%d]", my_pid, vconf_recorder_pid);
 116                 }
 117                 break;
 118         case MM_VIDEO_DEVICE_CAMERA0:
 119         case MM_VIDEO_DEVICE_CAMERA1:
 120                 vconf_get_int(VCONFKEY_CAMERA_FLASH_STATE, &vconf_flash_state);
 121                 vconf_get_int(VCONFKEY_CAMERA_PID, (int *)&vconf_camera_pid);
 122                 if (my_pid == vconf_camera_pid &&
 123                         vconf_flash_state == VCONFKEY_CAMERA_FLASH_STATE_ON) {
 124                         vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
 125                         vconf_set_int(VCONFKEY_CAMERA_PID, -1);
 126                         _mmcam_dbg_warn("set camera flash state OFF");
 127                 }
 128
 129                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
 130                 _mmcam_dbg_warn("set camera state NULL");
 131                 break;
 132         default:
 133                 _mmcam_dbg_warn("unknown type [%d]", g_mm_camcorder_type);
 134                 break;
 135         }
 136
 137         /* call old signal handler */
 138         switch (signo) {
 139         case SIGINT:
 140                 sigaction(SIGINT, &mm_camcorder_int_old_action, NULL);
 141                 raise(signo);
 142                 break;
 143         case SIGABRT:
 144                 sigaction(SIGABRT, &mm_camcorder_abrt_old_action, NULL);
 145                 raise(signo);
 146                 break;
 147         case SIGSEGV:
 148                 sigaction(SIGSEGV, &mm_camcorder_segv_old_action, NULL);
 149                 raise(signo);
 150                 break;
 151         case SIGTERM:
 152                 sigaction(SIGTERM, &mm_camcorder_term_old_action, NULL);
 153                 raise(signo);
 154                 break;
 155         case SIGSYS:
 156                 sigaction(SIGSYS, &mm_camcorder_sys_old_action, NULL);
 157                 raise(signo);
 158                 break;
 159         default:
 160                 break;
 161         }
 162
 163         _mmcam_dbg_warn("done");
 164
 165         return;
 166 }
 167
 168
 169 static void _mmcamcorder_constructor()
 170 {
 171         struct sigaction mm_camcorder_action;
 172         mm_camcorder_action.sa_handler = __mm_camcorder_signal_handler;
 173         mm_camcorder_action.sa_flags = SA_NOCLDSTOP;
 174
 175         _mmcam_dbg_warn("start");
 176
 177         sigemptyset(&mm_camcorder_action.sa_mask);
 178
 179         sigaction(SIGINT, &mm_camcorder_action, &mm_camcorder_int_old_action);
 180         sigaction(SIGABRT, &mm_camcorder_action, &mm_camcorder_abrt_old_action);
 181         sigaction(SIGSEGV, &mm_camcorder_action, &mm_camcorder_segv_old_action);
 182         sigaction(SIGTERM, &mm_camcorder_action, &mm_camcorder_term_old_action);
 183         sigaction(SIGSYS, &mm_camcorder_action, &mm_camcorder_sys_old_action);
 184
 185         _mmcam_dbg_warn("done");
 186
 187         return;
 188 }
 189
 190 /* Internal command functions {*/
 191 int _mmcamcorder_create(MMHandleType *handle, MMCamPreset *info)
 192 {
 193         int ret = MM_ERROR_NONE;
 194         int sys_info_ret = SYSTEM_INFO_ERROR_NONE;
 195         int UseConfCtrl = 0;
 196         int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
 197         int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
 198         int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
 199         int play_capture_sound = TRUE;
 200         int camera_device_count = MM_VIDEO_DEVICE_NUM;
 201         int camera_default_flip = MM_FLIP_NONE;
 202         int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
 203         char *err_attr_name = NULL;
 204         const char *ConfCtrlFile = NULL;
 205         mmf_camcorder_t *hcamcorder = NULL;
 206         type_element *EvasSurfaceElement = NULL;
 207
 208         _mmcam_dbg_log("Entered");
 209
 210         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 211         mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 212
 213         /* Create mmf_camcorder_t handle and initialize every variable */
 214         hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
 215         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY);
 216         memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
 217
 218         /* init values */
 219         hcamcorder->type = 0;
 220         hcamcorder->state = MM_CAMCORDER_STATE_NONE;
 221         hcamcorder->sub_context = NULL;
 222         hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
 223         hcamcorder->capture_in_recording = FALSE;
 224         hcamcorder->session_type = MM_SESSION_TYPE_MEDIA;
 225
 226         pthread_mutex_init(&((hcamcorder->mtsafe).lock), NULL);
 227         pthread_cond_init(&((hcamcorder->mtsafe).cond), NULL);
 228         pthread_mutex_init(&((hcamcorder->mtsafe).cmd_lock), NULL);
 229         pthread_mutex_init(&((hcamcorder->mtsafe).asm_lock), NULL);
 230         pthread_mutex_init(&((hcamcorder->mtsafe).state_lock), NULL);
 231         pthread_mutex_init(&((hcamcorder->mtsafe).gst_state_lock), NULL);
 232         pthread_mutex_init(&((hcamcorder->mtsafe).gst_encode_state_lock), NULL);
 233         pthread_mutex_init(&((hcamcorder->mtsafe).message_cb_lock), NULL);
 234         pthread_mutex_init(&((hcamcorder->mtsafe).vcapture_cb_lock), NULL);
 235         pthread_mutex_init(&((hcamcorder->mtsafe).vstream_cb_lock), NULL);
 236         pthread_mutex_init(&((hcamcorder->mtsafe).astream_cb_lock), NULL);
 237
 238         pthread_mutex_init(&(hcamcorder->sound_lock), NULL);
 239         pthread_cond_init(&(hcamcorder->sound_cond), NULL);
 240         pthread_mutex_init(&(hcamcorder->restart_preview_lock), NULL);
 241
 242         /* Sound mutex/cond init */
 243         pthread_mutex_init(&(hcamcorder->snd_info.open_mutex), NULL);
 244         pthread_cond_init(&(hcamcorder->snd_info.open_cond), NULL);
 245
 246         /* init for sound thread */
 247         pthread_mutex_init(&(hcamcorder->task_thread_lock), NULL);
 248         pthread_cond_init(&(hcamcorder->task_thread_cond), NULL);
 249         hcamcorder->task_thread_state = _MMCAMCORDER_SOUND_STATE_NONE;
 250
 251         /* create task thread */
 252         pthread_create(&(hcamcorder->task_thread), NULL, _mmcamcorder_util_task_thread_func, (void *)hcamcorder);
 253
 254         if (info->videodev_type < MM_VIDEO_DEVICE_NONE ||
 255             info->videodev_type >= MM_VIDEO_DEVICE_NUM) {
 256                 _mmcam_dbg_err("_mmcamcorder_create::video device type is out of range.");
 257                 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
 258                 goto _ERR_DEFAULT_VALUE_INIT;
 259         }
 260
 261         /* set device type */
 262         hcamcorder->device_type = info->videodev_type;
 263         _mmcam_dbg_warn("Device Type : %d", hcamcorder->device_type);
 264
 265         if (MM_ERROR_NONE == _mm_session_util_read_information(-1, &hcamcorder->session_type, &hcamcorder->session_flags)) {
 266                 _mmcam_dbg_log("use sound focus function.");
 267                 hcamcorder->sound_focus_register = TRUE;
 268
 269                 if (MM_ERROR_NONE != mm_sound_focus_get_id(&hcamcorder->sound_focus_id)) {
 270                         _mmcam_dbg_err("mm_sound_focus_get_uniq failed");
 271                         ret = MM_ERROR_POLICY_BLOCKED;
 272                         goto _ERR_DEFAULT_VALUE_INIT;
 273                 }
 274
 275                 if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
 276                                                                          getpid(),
 277                                                                          "media",
 278                                                                          _mmcamcorder_sound_focus_cb,
 279                                                                          hcamcorder)) {
 280                         _mmcam_dbg_err("mm_sound_register_focus failed");
 281                         ret = MM_ERROR_POLICY_BLOCKED;
 282                         goto _ERR_DEFAULT_VALUE_INIT;
 283                 }
 284
 285                 _mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
 286                                hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
 287         } else {
 288                 _mmcam_dbg_log("_mm_session_util_read_information failed. skip sound focus function.");
 289                 hcamcorder->sound_focus_register = FALSE;
 290         }
 291
 292         /* Get Camera Configure information from Camcorder INI file */
 293         _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
 294
 295         if (!(hcamcorder->conf_main)) {
 296                 _mmcam_dbg_err( "Failed to get configure(main) info." );
 297
 298                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 299                 goto _ERR_DEFAULT_VALUE_INIT;
 300         }
 301
 302         hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
 303         if (!(hcamcorder->attributes)) {
 304                 _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
 305
 306                 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 307                 goto _ERR_DEFAULT_VALUE_INIT;
 308         }
 309
 310         if (info->videodev_type != MM_VIDEO_DEVICE_NONE) {
 311                 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 312                                                 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 313                                                 "UseConfCtrl", &UseConfCtrl);
 314
 315                 if (UseConfCtrl) {
 316                         int resolution_width = 0;
 317                         int resolution_height = 0;
 318                         MMCamAttrsInfo fps_info;
 319
 320                         _mmcam_dbg_log( "Enable Configure Control system." );
 321
 322                         switch (info->videodev_type) {
 323                         case MM_VIDEO_DEVICE_CAMERA0:
 324                                 _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
 325                                                                    CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 326                                                                    "ConfCtrlFile0", &ConfCtrlFile);
 327                                 break;
 328                         case MM_VIDEO_DEVICE_CAMERA1:
 329                                 _mmcamcorder_conf_get_value_string((MMHandleType)hcamcorder, hcamcorder->conf_main,
 330                                                                    CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 331                                                                    "ConfCtrlFile1", &ConfCtrlFile);
 332                                 break;
 333                         default:
 334                                 _mmcam_dbg_err( "Not supported camera type." );
 335                                 ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 336                                 goto _ERR_DEFAULT_VALUE_INIT;
 337                         }
 338
 339                         _mmcam_dbg_log("videodev_type : [%d], ConfCtrlPath : [%s]", info->videodev_type, ConfCtrlFile);
 340
 341                         _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_CTRL, ConfCtrlFile, &hcamcorder->conf_ctrl);
 342 /*
 343                         _mmcamcorder_conf_print_info(&hcamcorder->conf_main);
 344                         _mmcamcorder_conf_print_info(&hcamcorder->conf_ctrl);
 345 */
 346                         if (!(hcamcorder->conf_ctrl)) {
 347                                 _mmcam_dbg_err( "Failed to get configure(control) info." );
 348                                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 349                                 goto _ERR_DEFAULT_VALUE_INIT;
 350                         }
 351
 352                         ret = _mmcamcorder_init_convert_table((MMHandleType)hcamcorder);
 353                         if (ret != MM_ERROR_NONE) {
 354                                 _mmcam_dbg_warn("converting table initialize error!!");
 355                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 356                                 goto _ERR_DEFAULT_VALUE_INIT;
 357                         }
 358
 359                         ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_CAMERA|MM_CAMCONVERT_CATEGORY_DISPLAY);
 360                         if (ret != MM_ERROR_NONE) {
 361                                 _mmcam_dbg_warn("converting table initialize error!!");
 362                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 363                                 goto _ERR_DEFAULT_VALUE_INIT;
 364                         }
 365
 366                         /* Get device info, recommend preview fmt and display rotation from INI */
 367                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 368                                                         CONFIGURE_CATEGORY_CTRL_CAMERA,
 369                                                         "RecommendPreviewFormatCapture",
 370                                                         &rcmd_fmt_capture);
 371
 372                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 373                                                         CONFIGURE_CATEGORY_CTRL_CAMERA,
 374                                                         "RecommendPreviewFormatRecord",
 375                                                         &rcmd_fmt_recording);
 376
 377                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 378                                                         CONFIGURE_CATEGORY_CTRL_CAMERA,
 379                                                         "RecommendDisplayRotation",
 380                                                         &rcmd_dpy_rotation);
 381
 382                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 383                                                         CONFIGURE_CATEGORY_MAIN_CAPTURE,
 384                                                         "PlayCaptureSound",
 385                                                         &play_capture_sound);
 386
 387                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 388                                                         CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 389                                                         "DeviceCount",
 390                                                         &camera_device_count);
 391
 392                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 393                                                         CONFIGURE_CATEGORY_CTRL_CAMERA,
 394                                                         "FacingDirection",
 395                                                         &camera_facing_direction);
 396
 397                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 398                                                         CONFIGURE_CATEGORY_CTRL_EFFECT,
 399                                                         "BrightnessStepDenominator",
 400                                                         &hcamcorder->brightness_step_denominator);
 401
 402                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_ctrl,
 403                                                         CONFIGURE_CATEGORY_CTRL_CAPTURE,
 404                                                         "SupportZSL",
 405                                                         &hcamcorder->support_zsl_capture);
 406
 407                         _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",
 408                                        rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
 409                                        play_capture_sound, camera_device_count, camera_facing_direction,
 410                                        hcamcorder->brightness_step_denominator, hcamcorder->support_zsl_capture);
 411
 412                         /* Get UseZeroCopyFormat value from INI */
 413                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 414                                                         CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 415                                                         "UseZeroCopyFormat",
 416                                                         &(hcamcorder->use_zero_copy_format));
 417
 418                         /* Get SupportMediaPacketPreviewCb value from INI */
 419                         _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 420                                                         CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 421                                                         "SupportMediaPacketPreviewCb",
 422                                                         &(hcamcorder->support_media_packet_preview_cb));
 423
 424                         ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
 425                                                     MMCAM_CAMERA_WIDTH, &resolution_width,
 426                                                     MMCAM_CAMERA_HEIGHT, &resolution_height,
 427                                                     NULL);
 428
 429                         mm_camcorder_get_fps_list_by_resolution((MMHandleType)hcamcorder, resolution_width, resolution_height, &fps_info);
 430
 431                         _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
 432                         _mmcam_dbg_log("SupportMediaPacketPreviewCb : %d", hcamcorder->support_media_packet_preview_cb);
 433                         _mmcam_dbg_log("res : %d X %d, Default FPS by resolution  : %d", resolution_width, resolution_height, fps_info.int_array.def);
 434
 435                         if (camera_facing_direction == 1) {
 436                                 if (rcmd_dpy_rotation == MM_DISPLAY_ROTATION_270 || rcmd_dpy_rotation == MM_DISPLAY_ROTATION_90) {
 437                                         camera_default_flip = MM_FLIP_VERTICAL;
 438                                 } else {
 439                                         camera_default_flip = MM_FLIP_HORIZONTAL;
 440                                 }
 441                                 _mmcam_dbg_log("camera_default_flip : [%d]",camera_default_flip);
 442                         }
 443
 444                         mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
 445                                                     MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
 446                                                     MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
 447                                                     MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
 448                                                     MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
 449                                                     MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
 450                                                     MMCAM_SUPPORT_ZSL_CAPTURE, hcamcorder->support_zsl_capture,
 451                                                     MMCAM_SUPPORT_ZERO_COPY_FORMAT, hcamcorder->use_zero_copy_format,
 452                                                     MMCAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB, hcamcorder->support_media_packet_preview_cb,
 453                                                     MMCAM_CAMERA_FPS, fps_info.int_array.def,
 454                                                     MMCAM_DISPLAY_FLIP, camera_default_flip,
 455                                                     "capture-sound-enable", play_capture_sound,
 456                                                     NULL);
 457                         if (err_attr_name) {
 458                                 _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
 459                                 free(err_attr_name);
 460                                 err_attr_name = NULL;
 461                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 462                                 goto _ERR_DEFAULT_VALUE_INIT;
 463                         }
 464
 465                         /* Get default value of brightness */
 466                         mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
 467                                                     MMCAM_FILTER_BRIGHTNESS, &hcamcorder->brightness_default,
 468                                                     NULL);
 469                         if (err_attr_name) {
 470                                 _mmcam_dbg_err("Get brightness FAILED.");
 471                                 free(err_attr_name);
 472                                 err_attr_name = NULL;
 473                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 474                                 goto _ERR_DEFAULT_VALUE_INIT;
 475                         }
 476                         _mmcam_dbg_log("Default brightness : %d", hcamcorder->brightness_default);
 477                 } else {
 478                         _mmcam_dbg_log( "Disable Configure Control system." );
 479                         hcamcorder->conf_ctrl = NULL;
 480                 }
 481         } else {
 482                 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
 483                                                     CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
 484                                                     "DeviceCount",
 485                                                     &camera_device_count);
 486                 mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
 487                                                     MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
 488                                                     NULL);
 489                 if (err_attr_name) {
 490                         _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
 491                         free(err_attr_name);
 492                         err_attr_name = NULL;
 493                         ret = MM_ERROR_CAMCORDER_INTERNAL;
 494                         goto _ERR_DEFAULT_VALUE_INIT;
 495                 }
 496
 497                 ret = _mmcamcorder_init_attr_from_configure((MMHandleType)hcamcorder, MM_CAMCONVERT_CATEGORY_AUDIO);
 498                 if (ret != MM_ERROR_NONE) {
 499                         _mmcam_dbg_warn("init attribute from configure error : 0x%x", ret);
 500                         ret = MM_ERROR_CAMCORDER_INTERNAL;
 501                         goto _ERR_DEFAULT_VALUE_INIT;
 502                 }
 503         }
 504
 505
 506         /* initialize resource manager */
 507         ret = _mmcamcorder_resource_manager_init(&hcamcorder->resource_manager, (void *)hcamcorder);
 508         if (ret != MM_ERROR_NONE) {
 509                 _mmcam_dbg_err("failed to initialize resource manager");
 510                 ret = MM_ERROR_CAMCORDER_INTERNAL;
 511                 goto _ERR_DEFAULT_VALUE_INIT;
 512         }
 513
 514         ret = __mmcamcorder_gstreamer_init(hcamcorder->conf_main);
 515         if (!ret) {
 516                 _mmcam_dbg_err( "Failed to initialize gstreamer!!" );
 517                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 518                 goto _ERR_DEFAULT_VALUE_INIT;
 519         }
 520
 521         /* Make some attributes as read-only type */
 522         _mmcamcorder_lock_readonly_attributes((MMHandleType)hcamcorder);
 523
 524         /* Disable attributes in each model */
 525         _mmcamcorder_set_disabled_attributes((MMHandleType)hcamcorder);
 526
 527         /* Get videosink name for evas surface */
 528         _mmcamcorder_conf_get_element((MMHandleType)hcamcorder, hcamcorder->conf_main,
 529                                       CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
 530                                       "VideosinkElementEvas",
 531                                       &EvasSurfaceElement);
 532         if (EvasSurfaceElement) {
 533                 int attr_index = 0;
 534                 const char *evassink_name = NULL;
 535                 mmf_attribute_t *item_evassink_name = NULL;
 536                 mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
 537
 538                 _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name);
 539                 mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index);
 540                 item_evassink_name = &attrs->items[attr_index];
 541                 mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name));
 542                 mmf_attribute_commit(item_evassink_name);
 543
 544                 _mmcam_dbg_log("Evassink name : %s", evassink_name);
 545         }
 546
 547         /* get shutter sound policy */
 548         vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
 549         _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
 550
 551         /* get model name */
 552         sys_info_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &hcamcorder->model_name);
 553         if (hcamcorder->model_name) {
 554                 _mmcam_dbg_log("model name [%s], sys_info_ret 0x%x", hcamcorder->model_name, sys_info_ret);
 555         } else {
 556                 _mmcam_dbg_warn("failed get model name, sys_info_ret 0x%x", sys_info_ret);
 557         }
 558
 559         /* get software version */
 560         sys_info_ret = system_info_get_platform_string("http://tizen.org/system/build.string", &hcamcorder->software_version);
 561         if (hcamcorder->software_version) {
 562                 _mmcam_dbg_log("software version [%s], sys_info_ret 0x%d", hcamcorder->software_version, sys_info_ret);
 563         } else {
 564                 _mmcam_dbg_warn("failed get software version, sys_info_ret 0x%x", sys_info_ret);
 565         }
 566
 567         /* Set initial state */
 568         _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
 569
 570         _mmcam_dbg_log("created handle %p", hcamcorder);
 571
 572         /* set device type */
 573         g_mm_camcorder_type = info->videodev_type;
 574
 575         *handle = (MMHandleType)hcamcorder;
 576
 577         return MM_ERROR_NONE;
 578
 579 _ERR_DEFAULT_VALUE_INIT:
 580         /* unregister sound focus */
 581         if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
 582                 if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) {
 583                         _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed", hcamcorder->sound_focus_id);
 584                 } else {
 585                         _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done", hcamcorder->sound_focus_id);
 586                 }
 587         } else {
 588                 _mmcam_dbg_warn("no need to unregister sound focus[%d, id %d]",
 589                                hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
 590         }
 591
 592         /* Remove attributes */
 593         if (hcamcorder->attributes) {
 594                 _mmcamcorder_dealloc_attribute((MMHandleType)hcamcorder, hcamcorder->attributes);
 595                 hcamcorder->attributes = 0;
 596         }
 597
 598         /* Release lock, cond */
 599         pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
 600         pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
 601         pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
 602         pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
 603         pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
 604         pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock));
 605         pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock));
 606         pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock));
 607         pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock));
 608         pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock));
 609         pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock));
 610
 611         pthread_mutex_destroy(&(hcamcorder->sound_lock));
 612         pthread_cond_destroy(&(hcamcorder->sound_cond));
 613         pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex));
 614         pthread_cond_destroy(&(hcamcorder->snd_info.open_cond));
 615         pthread_mutex_destroy(&(hcamcorder->restart_preview_lock));
 616
 617         if (hcamcorder->conf_ctrl) {
 618                 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
 619         }
 620
 621         if (hcamcorder->conf_main) {
 622                 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
 623         }
 624
 625         if (hcamcorder->model_name) {
 626                 free(hcamcorder->model_name);
 627                 hcamcorder->model_name = NULL;
 628         }
 629
 630         if (hcamcorder->software_version) {
 631                 free(hcamcorder->software_version);
 632                 hcamcorder->software_version = NULL;
 633         }
 634
 635         if (hcamcorder->task_thread) {
 636                 pthread_mutex_lock(&(hcamcorder->task_thread_lock));
 637                 _mmcam_dbg_log("send signal for task thread exit");
 638                 hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
 639                 pthread_cond_signal(&(hcamcorder->task_thread_cond));
 640                 pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
 641                 pthread_join(hcamcorder->task_thread, NULL);
 642         }
 643         pthread_mutex_destroy(&(hcamcorder->task_thread_lock));
 644         pthread_cond_destroy(&(hcamcorder->task_thread_cond));
 645
 646         /* Release handle */
 647         memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
 648         free(hcamcorder);
 649
 650         return ret;
 651 }
 652
 653
 654 int _mmcamcorder_destroy(MMHandleType handle)
 655 {
 656         int ret = MM_ERROR_NONE;
 657         int state = MM_CAMCORDER_STATE_NONE;
 658         int state_FROM = MM_CAMCORDER_STATE_NULL;
 659
 660         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 661
 662         _mmcam_dbg_log("");
 663
 664         if (!hcamcorder) {
 665                 _mmcam_dbg_err("Not initialized");
 666                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 667                 goto _ERR_CAMCORDER_CMD_PRECON;
 668         }
 669
 670         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
 671                 _mmcam_dbg_err("Another command is running.");
 672                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
 673                 goto _ERR_CAMCORDER_CMD_PRECON;
 674         }
 675
 676         state = _mmcamcorder_get_state(handle);
 677         if (state != state_FROM) {
 678                 _mmcam_dbg_err("Wrong state(%d)", state);
 679                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
 680                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 681         }
 682
 683         /* set exit state for sound thread */
 684         pthread_mutex_lock(&(hcamcorder->task_thread_lock));
 685         _mmcam_dbg_log("send signal for task thread exit");
 686         hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_EXIT;
 687         pthread_cond_signal(&(hcamcorder->task_thread_cond));
 688         pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
 689
 690         pthread_mutex_lock(&(hcamcorder->sound_lock));
 691         while (hcamcorder->capture_sound_count > 0) {
 692                 struct timespec timeout;
 693                 struct timeval tv;
 694
 695                 gettimeofday(&tv, NULL);
 696                 timeout.tv_sec = tv.tv_sec + __MMCAMCORDER_SOUND_WAIT_TIMEOUT;
 697                 timeout.tv_nsec = tv.tv_usec * 1000;
 698
 699                 _mmcam_dbg_warn("capture_sound_count[%d] is not zero. wait signal...",
 700                                 hcamcorder->capture_sound_count);
 701
 702                 if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) {
 703                         _mmcam_dbg_warn("signal received. check again...");
 704                 } else {
 705                         hcamcorder->capture_sound_count = 0;
 706                         _mmcam_dbg_err("capture sound completion wait time out");
 707                         break;
 708                 }
 709         }
 710         pthread_mutex_unlock(&(hcamcorder->sound_lock));
 711
 712         /* Release SubContext and pipeline */
 713         if (hcamcorder->sub_context) {
 714                 if (hcamcorder->sub_context->element) {
 715                         _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
 716                 }
 717
 718                 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
 719                 hcamcorder->sub_context = NULL;
 720         }
 721
 722         /* de-initialize resource manager */
 723         ret = _mmcamcorder_resource_manager_deinit(&hcamcorder->resource_manager);
 724         if (!ret) {
 725                 _mmcam_dbg_err("failed to de-initialize resource manager");
 726         }
 727
 728         /* Remove idle function which is not called yet */
 729         if (hcamcorder->setting_event_id) {
 730                 _mmcam_dbg_log("Remove remaining idle function");
 731                 g_source_remove(hcamcorder->setting_event_id);
 732                 hcamcorder->setting_event_id = 0;
 733         }
 734
 735         /* check current strobe mode */
 736         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
 737                 pid_t my_pid = getpid();
 738                 int camera_pid = -1;
 739                 vconf_get_int(VCONFKEY_CAMERA_PID, &camera_pid);
 740
 741                 if (camera_pid > -1 && my_pid == camera_pid) {
 742                         int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF;
 743
 744                         vconf_set_int(VCONFKEY_CAMERA_PID, -1);
 745                         _mmcam_dbg_log("reset camera pid");
 746
 747                         mm_camcorder_get_attributes(handle, NULL,
 748                                                     MMCAM_STROBE_MODE, &strobe_mode,
 749                                                     NULL);
 750                         if (strobe_mode != MM_CAMCORDER_STROBE_MODE_OFF) {
 751                                 /* set OFF state of vconf key */
 752                                 vconf_set_int(VCONFKEY_CAMERA_FLASH_STATE, VCONFKEY_CAMERA_FLASH_STATE_OFF);
 753                                 _mmcam_dbg_log("reset flash state");
 754                         }
 755                 }
 756         }
 757
 758         /* Remove attributes */
 759         if (hcamcorder->attributes) {
 760                 _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes);
 761                 hcamcorder->attributes = 0;
 762         }
 763
 764         /* Remove exif info */
 765         if (hcamcorder->exif_info) {
 766                 mm_exif_destory_exif_info(hcamcorder->exif_info);
 767                 hcamcorder->exif_info=NULL;
 768
 769         }
 770
 771         /* Release configure info */
 772         if (hcamcorder->conf_ctrl) {
 773                 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
 774         }
 775         if (hcamcorder->conf_main) {
 776                 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
 777         }
 778
 779         /* Remove messages which are not called yet */
 780         _mmcamcorder_remove_message_all(handle);
 781
 782         /* unregister sound focus */
 783         if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
 784                 if (mm_sound_unregister_focus(hcamcorder->sound_focus_id) != MM_ERROR_NONE) {
 785                         _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed",
 786                                        hcamcorder->sound_focus_id);
 787                 } else {
 788                         _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done",
 789                                        hcamcorder->sound_focus_id);
 790                 }
 791         } else {
 792                 _mmcam_dbg_log("no need to unregister sound focus.[%d, id %d]",
 793                                hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
 794         }
 795
 796         /* release model_name */
 797         if (hcamcorder->model_name) {
 798                 free(hcamcorder->model_name);
 799                 hcamcorder->model_name = NULL;
 800         }
 801
 802         if (hcamcorder->software_version) {
 803                 free(hcamcorder->software_version);
 804                 hcamcorder->software_version = NULL;
 805         }
 806
 807         /* join task thread */
 808         _mmcam_dbg_log("task thread join");
 809         pthread_join(hcamcorder->task_thread, NULL);
 810
 811         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 812
 813         /* Release lock, cond */
 814         pthread_mutex_destroy(&((hcamcorder->mtsafe).lock));
 815         pthread_cond_destroy(&((hcamcorder->mtsafe).cond));
 816         pthread_mutex_destroy(&((hcamcorder->mtsafe).cmd_lock));
 817         pthread_mutex_destroy(&((hcamcorder->mtsafe).asm_lock));
 818         pthread_mutex_destroy(&((hcamcorder->mtsafe).state_lock));
 819         pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_state_lock));
 820         pthread_mutex_destroy(&((hcamcorder->mtsafe).gst_encode_state_lock));
 821         pthread_mutex_destroy(&((hcamcorder->mtsafe).message_cb_lock));
 822         pthread_mutex_destroy(&((hcamcorder->mtsafe).vcapture_cb_lock));
 823         pthread_mutex_destroy(&((hcamcorder->mtsafe).vstream_cb_lock));
 824         pthread_mutex_destroy(&((hcamcorder->mtsafe).astream_cb_lock));
 825
 826         pthread_mutex_destroy(&(hcamcorder->sound_lock));
 827         pthread_cond_destroy(&(hcamcorder->sound_cond));
 828         pthread_mutex_destroy(&(hcamcorder->snd_info.open_mutex));
 829         pthread_cond_destroy(&(hcamcorder->snd_info.open_cond));
 830         pthread_mutex_destroy(&(hcamcorder->restart_preview_lock));
 831         pthread_mutex_destroy(&(hcamcorder->task_thread_lock));
 832         pthread_cond_destroy(&(hcamcorder->task_thread_cond));
 833
 834         /* Release handle */
 835         memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
 836         free(hcamcorder);
 837
 838         return MM_ERROR_NONE;
 839
 840 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
 841         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
 842
 843 _ERR_CAMCORDER_CMD_PRECON:
 844         if (hcamcorder) {
 845                 _mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
 846         }
 847
 848         _mmcam_dbg_err("Destroy fail (ret %x)", ret);
 849
 850         return ret;
 851 }
 852
 853
 854 int _mmcamcorder_realize(MMHandleType handle)
 855 {
 856         int ret = MM_ERROR_NONE;
 857         int ret_sound = MM_ERROR_NONE;
 858         int ret_resource = MM_ERROR_NONE;
 859         int state = MM_CAMCORDER_STATE_NONE;
 860         int state_FROM = MM_CAMCORDER_STATE_NULL;
 861         int state_TO = MM_CAMCORDER_STATE_READY;
 862         int display_surface_type = MM_DISPLAY_SURFACE_X;
 863         int pid_for_sound_focus = 0;
 864         double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
 865         char *videosink_element_type = NULL;
 866         const char *videosink_name = NULL;
 867         char *socket_path = NULL;
 868         int socket_path_len;
 869
 870         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 871
 872         /*_mmcam_dbg_log("");*/
 873
 874         if (!hcamcorder) {
 875                 _mmcam_dbg_err("Not initialized");
 876                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
 877                 return ret;
 878         }
 879
 880         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
 881                 _mmcam_dbg_err("Another command is running.");
 882                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
 883                 goto _ERR_CAMCORDER_CMD_PRECON;
 884         }
 885
 886         state = _mmcamcorder_get_state(handle);
 887         if (state != state_FROM) {
 888                 _mmcam_dbg_err("Wrong state(%d)", state);
 889                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
 890                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 891         }
 892
 893         mm_camcorder_get_attributes(handle, NULL,
 894                                     MMCAM_MODE, &hcamcorder->type,
 895                                     NULL);
 896
 897         /* Get profile mode */
 898         _mmcam_dbg_log("Profile mode [%d]", hcamcorder->type);
 899
 900         mm_camcorder_get_attributes(handle, NULL,
 901                                     MMCAM_DISPLAY_SURFACE, &display_surface_type,
 902                                     MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
 903                                     MMCAM_DISPLAY_SHM_SOCKET_PATH, &socket_path, &socket_path_len,
 904                                     NULL);
 905
 906         /* set camera/recorder state to vconf key */
 907         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
 908                 int vconf_camera_state = 0;
 909
 910                 /* get current camera state of vconf key */
 911                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
 912                 if (vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN)) {
 913                         _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
 914                         if(errno == EPERM || errno == EACCES) {
 915                                 ret = MM_ERROR_COMMON_INVALID_PERMISSION;
 916                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 917                         }
 918                 }
 919                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
 920                                vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
 921         } else {
 922                 int vconf_recorder_state = 0;
 923
 924                 /* get current recorder state of vconf key */
 925                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
 926                 if (vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED)) {
 927                         _mmcam_dbg_log("VCONF ERROR %s : cur %d",strerror(errno),errno);
 928                         if (errno == EPERM || errno == EACCES) {
 929                                 ret = MM_ERROR_COMMON_INVALID_PERMISSION;
 930                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 931                         }
 932                 }
 933
 934                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
 935                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
 936         }
 937
 938         /* sound focus */
 939         if (hcamcorder->sound_focus_register) {
 940                 mm_camcorder_get_attributes(handle, NULL,
 941                                             MMCAM_PID_FOR_SOUND_FOCUS, &pid_for_sound_focus,
 942                                             NULL);
 943
 944                 if (pid_for_sound_focus == 0) {
 945                         pid_for_sound_focus = getpid();
 946                         _mmcam_dbg_warn("pid for sound focus is not set, use my pid %d", pid_for_sound_focus);
 947                 }
 948
 949                 /* acquire sound focus or set sound focus watch callback */
 950                 hcamcorder->acquired_focus = 0;
 951                 hcamcorder->sound_focus_watch_id = 0;
 952
 953                 /* check session flags */
 954                 if (hcamcorder->session_flags & MM_SESSION_OPTION_PAUSE_OTHERS) {
 955                         /* acquire sound focus */
 956                         _mmcam_dbg_log("PAUSE_OTHERS - acquire sound focus");
 957
 958                         ret_sound = mm_sound_acquire_focus(0, FOCUS_FOR_BOTH, NULL);
 959                         if (ret_sound != MM_ERROR_NONE) {
 960                                 _mmcam_dbg_err("mm_sound_acquire_focus failed [0x%x]", ret_sound);
 961
 962                                 /* TODO: MM_ERROR_POLICY_BLOCKED_BY_CALL, MM_ERROR_POLICY_BLOCKED_BY_ALARM*/
 963                                 ret = MM_ERROR_POLICY_BLOCKED;
 964                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 965                         }
 966
 967                         hcamcorder->acquired_focus = FOCUS_FOR_BOTH;
 968                 } else if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
 969                         /* do nothing */
 970                         _mmcam_dbg_log("SESSION_UNINTERRUPTIBLE - do nothing for sound focus");
 971                 } else {
 972                         /* set sound focus watch callback */
 973                         _mmcam_dbg_log("ETC - set sound focus watch callback - pid %d", pid_for_sound_focus);
 974
 975                         ret_sound = mm_sound_set_focus_watch_callback_for_session(pid_for_sound_focus,
 976                                                                                   FOCUS_FOR_BOTH,
 977                                                                                   (mm_sound_focus_changed_watch_cb)_mmcamcorder_sound_focus_watch_cb,
 978                                                                                   hcamcorder,
 979                                                                                   &hcamcorder->sound_focus_watch_id);
 980                         if (ret_sound != MM_ERROR_NONE) {
 981                                 _mmcam_dbg_err("mm_sound_set_focus_watch_callback failed [0x%x]", ret_sound);
 982
 983                                 /* TODO: MM_ERROR_POLICY_BLOCKED_BY_CALL, MM_ERROR_POLICY_BLOCKED_BY_ALARM*/
 984                                 ret = MM_ERROR_POLICY_BLOCKED;
 985                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
 986                         }
 987
 988                         _mmcam_dbg_log("sound focus watch cb id %d", hcamcorder->sound_focus_watch_id);
 989                 }
 990         } else {
 991                 _mmcam_dbg_log("no need to register sound focus");
 992         }
 993
 994
 995         /* alloc sub context */
 996         hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
 997         if(!hcamcorder->sub_context) {
 998                 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
 999                 goto _ERR_CAMCORDER_CMD;
1000         }
1001
1002         /* Set basic configure information */
1003         if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
1004                 hcamcorder->sub_context->is_modified_rate = TRUE;
1005         }
1006
1007         _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
1008                                         CONFIGURE_CATEGORY_MAIN_CAPTURE,
1009                                         "UseEncodebin",
1010                                         &(hcamcorder->sub_context->bencbin_capture));
1011         _mmcam_dbg_warn("UseEncodebin [%d]", hcamcorder->sub_context->bencbin_capture);
1012
1013         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1014                 /* get dual stream support info */
1015                 _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_main,
1016                                                 CONFIGURE_CATEGORY_MAIN_RECORD,
1017                                                 "SupportDualStream",
1018                                                 &(hcamcorder->sub_context->info_video->support_dual_stream));
1019                 _mmcam_dbg_warn("SupportDualStream [%d]", hcamcorder->sub_context->info_video->support_dual_stream);
1020         }
1021
1022         if (socket_path == NULL) {
1023                 _mmcam_dbg_warn("Socket Path is not properly set, -> to NullSink.");
1024                 videosink_element_type = strdup("VideosinkElementNull");
1025         } else {
1026                 switch (display_surface_type) {
1027                 case MM_DISPLAY_SURFACE_X:
1028                         videosink_element_type = strdup("VideosinkElementX");
1029                         break;
1030                 case MM_DISPLAY_SURFACE_EVAS:
1031                         videosink_element_type = strdup("VideosinkElementEvas");
1032                         break;
1033                 case MM_DISPLAY_SURFACE_GL:
1034                         videosink_element_type = strdup("VideosinkElementGL");
1035                         break;
1036                 case MM_DISPLAY_SURFACE_NULL:
1037                         videosink_element_type = strdup("VideosinkElementNull");
1038                         break;
1039                 case MM_DISPLAY_SURFACE_REMOTE:
1040                         videosink_element_type = strdup("VideosinkElementRemote");
1041                         break;
1042                 default:
1043                         videosink_element_type = strdup("VideosinkElementX");
1044                         break;
1045                 }
1046         }
1047
1048         /* check string of videosink element */
1049         if (videosink_element_type) {
1050                 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1051                                               CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
1052                                               videosink_element_type,
1053                                               &hcamcorder->sub_context->VideosinkElement);
1054                 free(videosink_element_type);
1055                 videosink_element_type = NULL;
1056         } else {
1057                 _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
1058                                 display_surface_type);
1059
1060                 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1061                                               CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
1062                                               _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
1063                                               &hcamcorder->sub_context->VideosinkElement);
1064         }
1065
1066         _mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
1067         _mmcam_dbg_log("Videosink name : %s", videosink_name);
1068
1069         /* get videoconvert element */
1070         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1071                                       CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
1072                                       "VideoconvertElement",
1073                                       &hcamcorder->sub_context->VideoconvertElement);
1074
1075         _mmcamcorder_conf_get_value_int(handle, hcamcorder->conf_ctrl,
1076                                         CONFIGURE_CATEGORY_CTRL_CAPTURE,
1077                                         "SensorEncodedCapture",
1078                                         &(hcamcorder->sub_context->SensorEncodedCapture));
1079         _mmcam_dbg_log("Support sensor encoded capture : %d", hcamcorder->sub_context->SensorEncodedCapture);
1080
1081         if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
1082                 /* prepare resource manager for camera */
1083                 if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_CAMERA))) {
1084                         _mmcam_dbg_err("could not prepare for camera resource");
1085                         ret = MM_ERROR_CAMCORDER_INTERNAL;
1086                         goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1087                 }
1088
1089                 /* prepare resource manager for "video_overlay only if display surface is X" */
1090                 mm_camcorder_get_attributes(handle, NULL,
1091                                             MMCAM_DISPLAY_SURFACE, &display_surface_type,
1092                                             NULL);
1093                 if(display_surface_type == MM_DISPLAY_SURFACE_X) {
1094                         if((_mmcamcorder_resource_manager_prepare(&hcamcorder->resource_manager, RESOURCE_TYPE_VIDEO_OVERLAY))) {
1095                                 _mmcam_dbg_err("could not prepare for video overlay resource");
1096                                 ret = MM_ERROR_CAMCORDER_INTERNAL;
1097                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1098                         }
1099                 }
1100                 /* acquire resources */
1101                 if((hcamcorder->resource_manager.rset && _mmcamcorder_resource_manager_acquire(&hcamcorder->resource_manager))) {
1102                         _mmcam_dbg_err("could not acquire resources");
1103                         _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
1104                         goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1105                 }
1106         }
1107
1108         /* create pipeline */
1109         ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type);
1110         if (ret != MM_ERROR_NONE) {
1111                 /* check internal error of gstreamer */
1112                 if (hcamcorder->error_code != MM_ERROR_NONE) {
1113                         ret = hcamcorder->error_code;
1114                         _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1115                 }
1116
1117                 /* release sub context */
1118                 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1119                 hcamcorder->sub_context = NULL;
1120                 goto _ERR_CAMCORDER_CMD;
1121         }
1122
1123         /* set command function */
1124         ret = _mmcamcorder_set_functions(handle, hcamcorder->type);
1125         if (ret != MM_ERROR_NONE) {
1126                 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
1127                 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1128                 hcamcorder->sub_context = NULL;
1129                 goto _ERR_CAMCORDER_CMD;
1130         }
1131
1132         _mmcamcorder_set_state(handle, state_TO);
1133
1134         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1135
1136         return MM_ERROR_NONE;
1137
1138 _ERR_CAMCORDER_CMD:
1139         /* release hw resources */
1140         if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
1141                 ret_resource = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
1142                 if (ret_resource == MM_ERROR_RESOURCE_INVALID_STATE) {
1143                         _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
1144                 }
1145                 else if (ret_resource != MM_ERROR_NONE) {
1146                         _mmcam_dbg_err("failed to release resource, ret_resource(0x%x)", ret_resource);
1147                 }
1148                 ret_resource = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
1149                 if (ret_resource != MM_ERROR_NONE) {
1150                         _mmcam_dbg_err("failed to unprepare resource manager, ret_resource(0x%x)", ret_resource);
1151                 }
1152         }
1153         /* rollback camera state to vconf key */
1154         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1155                 int vconf_camera_state = 0;
1156
1157                 /* get current camera state of vconf key */
1158                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1159                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
1160
1161                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1162                                vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
1163         } else {
1164                 int vconf_recorder_state = 0;
1165
1166                 /* get current recorder state of vconf key */
1167                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1168                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
1169
1170                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1171                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
1172         }
1173
1174 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1175         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1176
1177         if (hcamcorder->sound_focus_register) {
1178                 if (hcamcorder->sound_focus_watch_id > 0) {
1179                         if (mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id) != MM_ERROR_NONE) {
1180                                 _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] failed",
1181                                                 hcamcorder->sound_focus_watch_id);
1182                         } else {
1183                                 _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback[id %d] done",
1184                                                 hcamcorder->sound_focus_watch_id);
1185                         }
1186                 }
1187
1188                 if (hcamcorder->acquired_focus > 0) {
1189                                 if (mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL) != MM_ERROR_NONE) {
1190                                         _mmcam_dbg_err("mm_sound_release_focus[focus %d] failed",
1191                                                        hcamcorder->acquired_focus);
1192                                 } else {
1193                                         _mmcam_dbg_err("mm_sound_release_focus[focus %d] done",
1194                                                        hcamcorder->acquired_focus);
1195                                 }
1196                 }
1197         }
1198
1199 _ERR_CAMCORDER_CMD_PRECON:
1200         _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
1201                        hcamcorder->type, state, ret);
1202
1203         return ret;
1204 }
1205
1206
1207 int _mmcamcorder_unrealize(MMHandleType handle)
1208 {
1209         int ret = MM_ERROR_NONE;
1210         int state = MM_CAMCORDER_STATE_NONE;
1211         int state_FROM = MM_CAMCORDER_STATE_READY;
1212         int state_TO = MM_CAMCORDER_STATE_NULL;
1213
1214         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1215
1216         _mmcam_dbg_log("");
1217
1218         if (!hcamcorder) {
1219                 _mmcam_dbg_err("Not initialized");
1220                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1221                 return ret;
1222         }
1223
1224         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1225                 _mmcam_dbg_err("Another command is running.");
1226                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1227                 goto _ERR_CAMCORDER_CMD_PRECON;
1228         }
1229
1230         state = _mmcamcorder_get_state(handle);
1231         if (state != state_FROM) {
1232                 _mmcam_dbg_err("Wrong state(%d)", state);
1233                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1234                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1235         }
1236
1237         /* Release SubContext */
1238         if (hcamcorder->sub_context) {
1239                 /* destroy pipeline */
1240                 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
1241                 /* Deallocate SubContext */
1242                 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1243                 hcamcorder->sub_context = NULL;
1244         }
1245
1246         if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO_CAPTURE) {
1247                 ret = _mmcamcorder_resource_manager_release(&hcamcorder->resource_manager);
1248                 if (ret == MM_ERROR_RESOURCE_INVALID_STATE) {
1249                         _mmcam_dbg_warn("it could be in the middle of resource callback or there's no acquired resource");
1250                         ret = MM_ERROR_NONE;
1251                 }
1252                 else if (ret != MM_ERROR_NONE) {
1253                         _mmcam_dbg_err("failed to release resource, ret(0x%x)", ret);
1254                         ret = MM_ERROR_CAMCORDER_INTERNAL;
1255                         goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1256                 }
1257                 ret = _mmcamcorder_resource_manager_unprepare(&hcamcorder->resource_manager);
1258                 if (ret != MM_ERROR_NONE) {
1259                         _mmcam_dbg_err("failed to unprepare resource manager, ret(0x%x)", ret);
1260                 }
1261         }
1262
1263         /* Deinitialize main context member */
1264         hcamcorder->command = NULL;
1265
1266         _mmcam_dbg_log("focus register %d, session flag 0x%x, state_change_by_system %d",
1267                        hcamcorder->sound_focus_register, hcamcorder->session_flags, hcamcorder->state_change_by_system);
1268
1269         /* release sound focus or unset sound focus watch callback */
1270         if (hcamcorder->sound_focus_register) {
1271                 int ret_sound = MM_ERROR_NONE;
1272
1273                 _mmcam_dbg_log("state_change_by_system %d, session flag 0x%x, acquired_focus %d, sound_focus_id %d, sound_focus_watch_id %d",
1274                                hcamcorder->state_change_by_system, hcamcorder->session_flags, hcamcorder->acquired_focus,
1275                                hcamcorder->sound_focus_id, hcamcorder->sound_focus_watch_id);
1276
1277                 if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM &&
1278                     hcamcorder->sound_focus_watch_id > 0) {
1279                         ret_sound = mm_sound_unset_focus_watch_callback(hcamcorder->sound_focus_watch_id);
1280                         if (ret_sound != MM_ERROR_NONE) {
1281                                 _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback failed [0x%x]",
1282                                                 ret_sound);
1283                         } else {
1284                                 _mmcam_dbg_warn("mm_sound_unset_focus_watch_callback done");
1285                         }
1286                 } else {
1287                         _mmcam_dbg_warn("no need to unset watch callback.[state_change_by_system %d, sound_focus_watch_id %d]",
1288                                         hcamcorder->state_change_by_system, hcamcorder->sound_focus_watch_id);
1289                 }
1290
1291                 if (hcamcorder->acquired_focus > 0) {
1292                         ret_sound = mm_sound_release_focus(0, hcamcorder->acquired_focus, NULL);
1293                         if (ret_sound != MM_ERROR_NONE) {
1294                                 _mmcam_dbg_warn("mm_sound_release_focus failed [0x%x]",
1295                                                 ret_sound);
1296                         } else {
1297                                 _mmcam_dbg_log("mm_sound_release_focus done");
1298                         }
1299                 } else {
1300                         _mmcam_dbg_warn("no need to release focus - current acquired focus %d",
1301                                         hcamcorder->acquired_focus);
1302                 }
1303         }
1304
1305         /* set camera state to vconf key */
1306         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1307                 int vconf_camera_state = 0;
1308
1309                 /* get current camera state of vconf key */
1310                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1311                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
1312
1313                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1314                                vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
1315         } else {
1316                 int vconf_recorder_state = 0;
1317
1318                 /* get current recorder state of vconf key */
1319                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1320                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_NULL);
1321
1322                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1323                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_NULL);
1324         }
1325
1326         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1327
1328         _mmcamcorder_set_state(handle, state_TO);
1329
1330         return MM_ERROR_NONE;
1331
1332 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1333         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1334
1335 _ERR_CAMCORDER_CMD_PRECON:
1336         /* send message */
1337         _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
1338                        hcamcorder->type, state, ret);
1339
1340         return ret;
1341 }
1342
1343 int _mmcamcorder_start(MMHandleType handle)
1344 {
1345         int ret = MM_ERROR_NONE;
1346         int state = MM_CAMCORDER_STATE_NONE;
1347         int state_FROM = MM_CAMCORDER_STATE_READY;
1348         int state_TO =MM_CAMCORDER_STATE_PREPARE;
1349
1350         _MMCamcorderSubContext *sc = NULL;
1351         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1352
1353         _mmcam_dbg_log("");
1354
1355         if (!hcamcorder) {
1356                 _mmcam_dbg_err("Not initialized");
1357                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1358                 return ret;
1359         }
1360
1361         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1362         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1363
1364         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1365                 _mmcam_dbg_err("Another command is running.");
1366                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1367                 goto _ERR_CAMCORDER_CMD_PRECON;
1368         }
1369
1370         state = _mmcamcorder_get_state(handle);
1371         if (state != state_FROM) {
1372                 _mmcam_dbg_err("Wrong state(%d)", state);
1373                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1374                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1375         }
1376
1377         /* initialize error code */
1378         hcamcorder->error_code = MM_ERROR_NONE;
1379
1380         /* set attributes related sensor */
1381         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1382                 _mmcamcorder_set_attribute_to_camsensor(handle);
1383         }
1384
1385         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
1386         if (ret != MM_ERROR_NONE) {
1387                 /* check internal error of gstreamer */
1388                 if (hcamcorder->error_code != MM_ERROR_NONE) {
1389                         ret = hcamcorder->error_code;
1390                         _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1391                 }
1392                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1393         }
1394
1395         _mmcamcorder_set_state(handle, state_TO);
1396
1397         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1398                 int vconf_camera_state = 0;
1399
1400                 /* check camera state of vconf key */
1401                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1402
1403                 /* set camera state to vconf key */
1404                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1405
1406                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1407                                vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1408         }
1409
1410         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1411
1412         return MM_ERROR_NONE;
1413
1414 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1415         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1416
1417 _ERR_CAMCORDER_CMD_PRECON:
1418         /* check internal error of gstreamer */
1419         if (hcamcorder->error_code != MM_ERROR_NONE) {
1420                 ret = hcamcorder->error_code;
1421                 hcamcorder->error_code = MM_ERROR_NONE;
1422
1423                 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1424         }
1425
1426         _mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
1427                        hcamcorder->type, state, ret);
1428
1429         return ret;
1430 }
1431
1432 int _mmcamcorder_stop(MMHandleType handle)
1433 {
1434         int ret = MM_ERROR_NONE;
1435         int state = MM_CAMCORDER_STATE_NONE;
1436         int state_FROM = MM_CAMCORDER_STATE_PREPARE;
1437         int state_TO = MM_CAMCORDER_STATE_READY;
1438
1439         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1440
1441         _mmcam_dbg_log("");
1442
1443         if (!hcamcorder) {
1444                 _mmcam_dbg_err("Not initialized");
1445                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1446                 return ret;
1447         }
1448
1449         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1450                 _mmcam_dbg_err("Another command is running.");
1451                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1452                 goto _ERR_CAMCORDER_CMD_PRECON;
1453         }
1454
1455         state = _mmcamcorder_get_state(handle);
1456         if (state != state_FROM) {
1457                 _mmcam_dbg_err("Wrong state(%d)", state);
1458                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1459                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1460         }
1461
1462         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_STOP);
1463         if (ret != MM_ERROR_NONE) {
1464                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1465         }
1466
1467         _mmcamcorder_set_state(handle, state_TO);
1468
1469         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1470                 int vconf_camera_state = 0;
1471
1472                 /* check camera state of vconf key */
1473                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1474
1475                 /* set camera state to vconf key */
1476                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
1477
1478                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1479                                vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
1480         }
1481
1482         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1483
1484         return MM_ERROR_NONE;
1485
1486 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1487         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1488
1489 _ERR_CAMCORDER_CMD_PRECON:
1490         /* send message */
1491         _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
1492                        hcamcorder->type, state, ret);
1493
1494         return ret;
1495 }
1496
1497
1498 int _mmcamcorder_capture_start(MMHandleType handle)
1499 {
1500         int ret = MM_ERROR_NONE;
1501         int state = MM_CAMCORDER_STATE_NONE;
1502         int state_FROM_0 = MM_CAMCORDER_STATE_PREPARE;
1503         int state_FROM_1 = MM_CAMCORDER_STATE_RECORDING;
1504         int state_FROM_2 = MM_CAMCORDER_STATE_PAUSED;
1505         int state_TO = MM_CAMCORDER_STATE_CAPTURING;
1506
1507         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1508
1509         _mmcam_dbg_log("");
1510
1511         if (!hcamcorder) {
1512                 _mmcam_dbg_err("Not initialized");
1513                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1514                 return ret;
1515         }
1516
1517         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1518                 _mmcam_dbg_err("Another command is running.");
1519                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1520                 goto _ERR_CAMCORDER_CMD_PRECON;
1521         }
1522
1523         state = _mmcamcorder_get_state(handle);
1524         if (state != state_FROM_0 &&
1525             state != state_FROM_1 &&
1526             state != state_FROM_2) {
1527                 _mmcam_dbg_err("Wrong state(%d)", state);
1528                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1529                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1530         }
1531
1532         /* Handle capture in recording case */
1533         if (state == state_FROM_1 || state == state_FROM_2) {
1534                 if (hcamcorder->capture_in_recording == TRUE) {
1535                         _mmcam_dbg_err("Capturing in recording (%d)", state);
1536                         ret = MM_ERROR_CAMCORDER_DEVICE_BUSY;
1537                         goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1538                 } else {
1539                         pthread_mutex_lock(&(hcamcorder->task_thread_lock));
1540                         if (hcamcorder->task_thread_state == _MMCAMCORDER_TASK_THREAD_STATE_NONE) {
1541                                 hcamcorder->capture_in_recording = TRUE;
1542                                 hcamcorder->task_thread_state = _MMCAMCORDER_TASK_THREAD_STATE_CHECK_CAPTURE_IN_RECORDING;
1543                                 _mmcam_dbg_log("send signal for capture in recording");
1544                                 pthread_cond_signal(&(hcamcorder->task_thread_cond));
1545                                 pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
1546                         } else {
1547                                 _mmcam_dbg_err("task thread busy : %d", hcamcorder->task_thread_state);
1548                                 pthread_mutex_unlock(&(hcamcorder->task_thread_lock));
1549                                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1550                                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1551                         }
1552                 }
1553         }
1554
1555         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CAPTURE);
1556         if (ret != MM_ERROR_NONE) {
1557                 goto _ERR_CAMCORDER_CMD;
1558         }
1559
1560         /* Do not change state when recording snapshot capture */
1561         if (state == state_FROM_0) {
1562                 _mmcamcorder_set_state(handle, state_TO);
1563         }
1564
1565         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1566
1567         /* Init break continuous shot attr */
1568         if (mm_camcorder_set_attributes(handle, NULL, "capture-break-cont-shot", 0, NULL) != MM_ERROR_NONE) {
1569                 _mmcam_dbg_warn("capture-break-cont-shot set 0 failed");
1570         }
1571
1572         return MM_ERROR_NONE;
1573
1574 _ERR_CAMCORDER_CMD:
1575         if (hcamcorder->capture_in_recording) {
1576                 hcamcorder->capture_in_recording = FALSE;
1577         }
1578
1579 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1580         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1581
1582 _ERR_CAMCORDER_CMD_PRECON:
1583         /* send message */
1584         _mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
1585                        hcamcorder->type, state, ret);
1586
1587         return ret;
1588 }
1589
1590 int _mmcamcorder_capture_stop(MMHandleType handle)
1591 {
1592         int ret = MM_ERROR_NONE;
1593         int state = MM_CAMCORDER_STATE_NONE;
1594         int state_FROM = MM_CAMCORDER_STATE_CAPTURING;
1595         int state_TO = MM_CAMCORDER_STATE_PREPARE;
1596         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1597
1598         _mmcam_dbg_log("");
1599
1600         if (!hcamcorder) {
1601                 _mmcam_dbg_err("Not initialized");
1602                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1603                 return ret;
1604         }
1605
1606         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1607                 _mmcam_dbg_err("Another command is running.");
1608                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1609                 goto _ERR_CAMCORDER_CMD_PRECON;
1610         }
1611
1612         state = _mmcamcorder_get_state(handle);
1613         if (state != state_FROM) {
1614                 _mmcam_dbg_err("Wrong state(%d)", state);
1615                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1616                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1617         }
1618
1619         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PREVIEW_START);
1620         if (ret != MM_ERROR_NONE) {
1621                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1622         }
1623
1624         _mmcamcorder_set_state(handle, state_TO);
1625
1626         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1627
1628         return MM_ERROR_NONE;
1629
1630 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1631         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1632
1633 _ERR_CAMCORDER_CMD_PRECON:
1634         /* send message */
1635         _mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
1636                        hcamcorder->type, state, ret);
1637
1638         return ret;
1639 }
1640
1641 int _mmcamcorder_record(MMHandleType handle)
1642 {
1643         int ret = MM_ERROR_NONE;
1644         int state = MM_CAMCORDER_STATE_NONE;
1645         int state_FROM1 = MM_CAMCORDER_STATE_PREPARE;
1646         int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1647         int state_TO = MM_CAMCORDER_STATE_RECORDING;
1648
1649         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1650
1651         _mmcam_dbg_log("");
1652
1653         if (!hcamcorder) {
1654                 _mmcam_dbg_err("Not initialized");
1655                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1656                 return ret;
1657         }
1658
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;
1663         }
1664
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;
1670         }
1671
1672         /* initialize error code */
1673         hcamcorder->error_code = MM_ERROR_NONE;
1674
1675         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_RECORD);
1676         if (ret != MM_ERROR_NONE) {
1677                 /* check internal error of gstreamer */
1678                 if (hcamcorder->error_code != MM_ERROR_NONE) {
1679                         ret = hcamcorder->error_code;
1680                         _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1681                 }
1682                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1683         }
1684
1685         _mmcamcorder_set_state(handle, state_TO);
1686
1687         /* set camera state to vconf key */
1688         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1689                 int vconf_camera_state = 0;
1690
1691                 /* get current camera state of vconf key */
1692                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1693                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING);
1694
1695                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1696                                vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING);
1697         } else {
1698                 int vconf_recorder_state = 0;
1699
1700                 /* get current recorder state of vconf key */
1701                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1702                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING);
1703
1704                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1705                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING);
1706         }
1707
1708         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1709
1710         return MM_ERROR_NONE;
1711
1712 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1713         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1714
1715 _ERR_CAMCORDER_CMD_PRECON:
1716         /* check internal error of gstreamer */
1717         if (hcamcorder->error_code != MM_ERROR_NONE) {
1718                 ret = hcamcorder->error_code;
1719                 hcamcorder->error_code = MM_ERROR_NONE;
1720
1721                 _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
1722         }
1723
1724         _mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
1725                        hcamcorder->type, state, ret);
1726
1727         return ret;
1728 }
1729
1730
1731 int _mmcamcorder_pause(MMHandleType handle)
1732 {
1733         int ret = MM_ERROR_NONE;
1734         int state = MM_CAMCORDER_STATE_NONE;
1735         int state_FROM = MM_CAMCORDER_STATE_RECORDING;
1736         int state_TO = MM_CAMCORDER_STATE_PAUSED;
1737
1738         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1739
1740         _mmcam_dbg_log("");
1741
1742         if (!hcamcorder) {
1743                 _mmcam_dbg_err("Not initialized");
1744                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1745                 return ret;
1746         }
1747
1748         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1749                 _mmcam_dbg_err("Another command is running.");
1750                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1751                 goto _ERR_CAMCORDER_CMD_PRECON;
1752         }
1753
1754         state = _mmcamcorder_get_state(handle);
1755         if (state != state_FROM) {
1756                 _mmcam_dbg_err("Wrong state(%d)", state);
1757                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1758                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1759         }
1760
1761         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_PAUSE);
1762         if (ret != MM_ERROR_NONE) {
1763                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1764         }
1765
1766         _mmcamcorder_set_state(handle, state_TO);
1767
1768         /* set camera state to vconf key */
1769         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1770                 int vconf_camera_state = 0;
1771
1772                 /* get current camera state of vconf key */
1773                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1774                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1775
1776                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1777                                vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
1778         } else {
1779                 int vconf_recorder_state = 0;
1780
1781                 /* get current recorder state of vconf key */
1782                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1783                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
1784
1785                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1786                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_RECORDING_PAUSE);
1787         }
1788
1789         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1790
1791         return MM_ERROR_NONE;
1792
1793 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1794         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1795
1796 _ERR_CAMCORDER_CMD_PRECON:
1797         /* send message */
1798         _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
1799                        hcamcorder->type, state, ret);
1800
1801         return ret;
1802 }
1803
1804
1805 int _mmcamcorder_commit(MMHandleType handle)
1806 {
1807         int ret = MM_ERROR_NONE;
1808         int state = MM_CAMCORDER_STATE_NONE;
1809         int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1810         int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1811         int state_TO = MM_CAMCORDER_STATE_PREPARE;
1812
1813         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1814
1815         _mmcam_dbg_log("");
1816
1817         if (!hcamcorder) {
1818                 _mmcam_dbg_err("Not initialized");
1819                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1820                 return ret;
1821         }
1822
1823         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1824                 _mmcam_dbg_err("Another command is running.");
1825                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1826                 goto _ERR_CAMCORDER_CMD_PRECON;
1827         }
1828
1829         state = _mmcamcorder_get_state(handle);
1830         if (state != state_FROM1 && state != state_FROM2) {
1831                 _mmcam_dbg_err("Wrong state(%d)", state);
1832                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1833                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1834         }
1835
1836         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_COMMIT);
1837         if (ret != MM_ERROR_NONE) {
1838                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1839         }
1840
1841         /* set camera state to vconf key */
1842         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1843                 int vconf_camera_state = 0;
1844
1845                 /* get current camera state of vconf key */
1846                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1847                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1848
1849                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1850                                vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1851         } else {
1852                 int vconf_recorder_state = 0;
1853
1854                 /* get current recorder state of vconf key */
1855                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1856                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
1857
1858                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1859                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
1860         }
1861
1862         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1863
1864         _mmcamcorder_set_state(handle,state_TO);
1865
1866         return MM_ERROR_NONE;
1867
1868 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1869         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1870
1871 _ERR_CAMCORDER_CMD_PRECON:
1872         /* send message */
1873         _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
1874                        hcamcorder->type, state, ret);
1875
1876         return ret;
1877 }
1878
1879
1880 int _mmcamcorder_cancel(MMHandleType handle)
1881 {
1882         int ret = MM_ERROR_NONE;
1883         int state = MM_CAMCORDER_STATE_NONE;
1884         int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
1885         int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
1886         int state_TO = MM_CAMCORDER_STATE_PREPARE;
1887
1888         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1889
1890         _mmcam_dbg_log("");
1891
1892         if (!hcamcorder) {
1893                 _mmcam_dbg_err("Not initialized");
1894                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1895                 return ret;
1896         }
1897
1898         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1899                 _mmcam_dbg_err("Another command is running.");
1900                 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1901                 goto _ERR_CAMCORDER_CMD_PRECON;
1902         }
1903
1904         state = _mmcamcorder_get_state(handle);
1905         if (state != state_FROM1 && state != state_FROM2) {
1906                 _mmcam_dbg_err("Wrong state(%d)", state);
1907                 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1908                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1909         }
1910
1911         ret = hcamcorder->command((MMHandleType)hcamcorder, _MMCamcorder_CMD_CANCEL);
1912         if (ret != MM_ERROR_NONE) {
1913                 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1914         }
1915
1916         _mmcamcorder_set_state(handle, state_TO);
1917
1918         /* set camera state to vconf key */
1919         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
1920                 int vconf_camera_state = 0;
1921
1922                 /* get current camera state of vconf key */
1923                 vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
1924                 vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
1925
1926                 _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
1927                                vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
1928         } else {
1929                 int vconf_recorder_state = 0;
1930
1931                 /* get current recorder state of vconf key */
1932                 vconf_get_int(VCONFKEY_RECORDER_STATE, &vconf_recorder_state);
1933                 vconf_set_int(VCONFKEY_RECORDER_STATE, VCONFKEY_RECORDER_STATE_CREATED);
1934
1935                 _mmcam_dbg_log("VCONFKEY_RECORDER_STATE prev %d -> cur %d",
1936                                vconf_recorder_state, VCONFKEY_RECORDER_STATE_CREATED);
1937         }
1938
1939         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1940
1941         return MM_ERROR_NONE;
1942
1943 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1944         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1945
1946 _ERR_CAMCORDER_CMD_PRECON:
1947         /* send message */
1948         _mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
1949                        hcamcorder->type, state, ret);
1950
1951         return ret;
1952 }
1953 /* } Internal command functions */
1954
1955
1956 int _mmcamcorder_commit_async_end(MMHandleType handle)
1957 {
1958         _mmcam_dbg_log("");
1959
1960         _mmcam_dbg_warn("_mmcamcorder_commit_async_end : MM_CAMCORDER_STATE_PREPARE");
1961         _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_PREPARE);
1962
1963         return MM_ERROR_NONE;
1964 }
1965
1966
1967 int _mmcamcorder_set_message_callback(MMHandleType handle, MMMessageCallback callback, void *user_data)
1968 {
1969         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1970
1971         _mmcam_dbg_log("%p", hcamcorder);
1972
1973         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1974
1975         if (callback == NULL) {
1976                 _mmcam_dbg_warn("Message Callback is disabled, because application sets it to NULL");
1977         }
1978
1979         if (!_MMCAMCORDER_TRYLOCK_MESSAGE_CALLBACK(hcamcorder)) {
1980                 _mmcam_dbg_warn("Application's message callback is running now");
1981                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
1982         }
1983
1984         /* set message callback to message handle */
1985         hcamcorder->msg_cb = callback;
1986         hcamcorder->msg_cb_param = user_data;
1987
1988         _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
1989
1990         return MM_ERROR_NONE;
1991 }
1992
1993
1994 int _mmcamcorder_set_video_stream_callback(MMHandleType handle, mm_camcorder_video_stream_callback callback, void *user_data)
1995 {
1996         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1997
1998         /*_mmcam_dbg_log("");*/
1999
2000         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2001
2002         if (callback == NULL) {
2003                 _mmcam_dbg_warn("Video Stream Callback is disabled, because application sets it to NULL");
2004         }
2005
2006         if (!_MMCAMCORDER_TRYLOCK_VSTREAM_CALLBACK(hcamcorder)) {
2007                 _mmcam_dbg_warn("Application's video stream callback is running now");
2008                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
2009         }
2010
2011         hcamcorder->vstream_cb = callback;
2012         hcamcorder->vstream_cb_param = user_data;
2013
2014         _MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
2015
2016         return MM_ERROR_NONE;
2017 }
2018
2019
2020 int _mmcamcorder_set_audio_stream_callback(MMHandleType handle, mm_camcorder_audio_stream_callback callback, void *user_data)
2021 {
2022         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2023
2024         _mmcam_dbg_log("");
2025
2026         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2027
2028         if (callback == NULL) {
2029                 _mmcam_dbg_warn("Audio Stream Callback is disabled, because application sets it to NULL");
2030         }
2031
2032         if (!_MMCAMCORDER_TRYLOCK_ASTREAM_CALLBACK(hcamcorder)) {
2033                 _mmcam_dbg_warn("Application's audio stream callback is running now");
2034                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
2035         }
2036
2037         hcamcorder->astream_cb = callback;
2038         hcamcorder->astream_cb_param = user_data;
2039
2040         _MMCAMCORDER_UNLOCK_ASTREAM_CALLBACK(hcamcorder);
2041
2042         return MM_ERROR_NONE;
2043 }
2044
2045
2046 int _mmcamcorder_set_video_capture_callback(MMHandleType handle, mm_camcorder_video_capture_callback callback, void *user_data)
2047 {
2048         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2049
2050         _mmcam_dbg_log("");
2051
2052         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2053
2054         if (callback == NULL) {
2055                 _mmcam_dbg_warn("Video Capture Callback is disabled, because application sets it to NULLL");
2056         }
2057
2058         if (!_MMCAMCORDER_TRYLOCK_VCAPTURE_CALLBACK(hcamcorder)) {
2059                 _mmcam_dbg_warn("Application's video capture callback is running now");
2060                 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
2061         }
2062
2063         hcamcorder->vcapture_cb = callback;
2064         hcamcorder->vcapture_cb_param = user_data;
2065
2066         _MMCAMCORDER_UNLOCK_VCAPTURE_CALLBACK(hcamcorder);
2067
2068         return MM_ERROR_NONE;
2069 }
2070
2071 int _mmcamcorder_get_current_state(MMHandleType handle)
2072 {
2073         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2074
2075         _mmcam_dbg_log("");
2076
2077         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2078
2079         return _mmcamcorder_get_state(handle);
2080 }
2081
2082 int _mmcamcorder_init_focusing(MMHandleType handle)
2083 {
2084         int ret = TRUE;
2085         int state = MM_CAMCORDER_STATE_NONE;
2086         int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2087         int af_range = MM_CAMCORDER_AUTO_FOCUS_NORMAL;
2088         int sensor_focus_mode = 0;
2089         int sensor_af_range = 0;
2090         int current_focus_mode = 0;
2091         int current_af_range = 0;
2092         mmf_camcorder_t *hcamcorder = NULL;
2093         _MMCamcorderSubContext *sc = NULL;
2094         GstCameraControl *control = NULL;
2095
2096         _mmcam_dbg_log("");
2097
2098         hcamcorder = MMF_CAMCORDER(handle);
2099         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2100
2101         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2102         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2103
2104         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
2105                 _mmcam_dbg_err("Another command is running.");
2106                 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2107         }
2108
2109         state = _mmcamcorder_get_state(handle);
2110
2111         if (state == MM_CAMCORDER_STATE_CAPTURING ||
2112             state < MM_CAMCORDER_STATE_PREPARE) {
2113                 _mmcam_dbg_err( "Not proper state. state[%d]", state );
2114                 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2115                 return MM_ERROR_CAMCORDER_INVALID_STATE;
2116         }
2117
2118         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2119                 _mmcam_dbg_log("Can't cast Video source into camera control.");
2120                 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2121                 return MM_ERROR_NONE;
2122         }
2123
2124         control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2125         if (control == NULL) {
2126                 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2127                 return MM_ERROR_CAMCORDER_INTERNAL;
2128         }
2129
2130         ret = gst_camera_control_stop_auto_focus(control);
2131         if (!ret) {
2132                 _mmcam_dbg_err("Auto focusing stop fail.");
2133                 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2134                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2135         }
2136
2137         /* Initialize lens position */
2138         mm_camcorder_get_attributes(handle, NULL,
2139                                     MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2140                                     MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
2141                                     NULL);
2142         sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
2143         sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
2144
2145         gst_camera_control_get_focus(control, &current_focus_mode, &current_af_range);
2146
2147         if (current_focus_mode != sensor_focus_mode ||
2148             current_af_range != sensor_af_range) {
2149                 ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
2150         } else {
2151                 _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
2152                 ret = TRUE;
2153         }
2154
2155         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2156
2157         if (ret) {
2158                 _mmcam_dbg_log("Lens init success.");
2159                 return MM_ERROR_NONE;
2160         } else {
2161                 _mmcam_dbg_err("Lens init fail.");
2162                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2163         }
2164 }
2165
2166 int _mmcamcorder_adjust_focus(MMHandleType handle, int direction)
2167 {
2168         int state;
2169         int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2170         int ret = MM_ERROR_UNKNOWN;
2171         char *err_attr_name = NULL;
2172
2173         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2174         mmf_return_val_if_fail(direction, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
2175
2176         /*_mmcam_dbg_log("");*/
2177
2178         if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
2179                 _mmcam_dbg_err("Another command is running.");
2180                 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2181         }
2182
2183         state = _mmcamcorder_get_state(handle);
2184         if (state == MM_CAMCORDER_STATE_CAPTURING ||
2185             state < MM_CAMCORDER_STATE_PREPARE) {
2186                 _mmcam_dbg_err("Not proper state. state[%d]", state);
2187                 _MMCAMCORDER_UNLOCK_CMD(handle);
2188                 return MM_ERROR_CAMCORDER_INVALID_STATE;
2189         }
2190
2191         /* TODO : call a auto or manual focus function */
2192         ret = mm_camcorder_get_attributes(handle, &err_attr_name,
2193                                           MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2194                                           NULL);
2195         if (ret != MM_ERROR_NONE) {
2196                 _mmcam_dbg_warn("Get focus-mode fail. (%s:%x)", err_attr_name, ret);
2197                 SAFE_FREE (err_attr_name);
2198                 _MMCAMCORDER_UNLOCK_CMD(handle);
2199                 return ret;
2200         }
2201
2202         if (focus_mode == MM_CAMCORDER_FOCUS_MODE_MANUAL) {
2203                 ret = _mmcamcorder_adjust_manual_focus(handle, direction);
2204         } else if (focus_mode == MM_CAMCORDER_FOCUS_MODE_AUTO ||
2205                    focus_mode == MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ||
2206                    focus_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
2207                 ret = _mmcamcorder_adjust_auto_focus(handle);
2208         } else {
2209                 _mmcam_dbg_err("It doesn't adjust focus. Focusing mode(%d)", focus_mode);
2210                 ret = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
2211         }
2212
2213         _MMCAMCORDER_UNLOCK_CMD(handle);
2214
2215         return ret;
2216 }
2217
2218 int _mmcamcorder_adjust_manual_focus(MMHandleType handle, int direction)
2219 {
2220         int max_level = 0;
2221         int min_level = 0;
2222         int cur_level = 0;
2223         int focus_level = 0;
2224         float unit_level = 0;
2225         GstCameraControl *control = NULL;
2226         _MMCamcorderSubContext *sc = NULL;
2227         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2228
2229         _mmcam_dbg_log("");
2230
2231         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2232         mmf_return_val_if_fail(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL != 1, MM_ERROR_CAMCORDER_NOT_SUPPORTED);
2233         mmf_return_val_if_fail((direction >= MM_CAMCORDER_MF_LENS_DIR_FORWARD) &&
2234                                (direction <= MM_CAMCORDER_MF_LENS_DIR_BACKWARD),
2235                                MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
2236
2237         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2238         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2239
2240         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2241                 _mmcam_dbg_log("Can't cast Video source into camera control.");
2242                 return MM_ERROR_NONE;
2243         }
2244
2245         control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2246         if (control == NULL) {
2247                 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2248                 return MM_ERROR_CAMCORDER_INTERNAL;
2249         }
2250
2251         /* TODO : get max, min level */
2252         if (max_level - min_level + 1 < _MMFCAMCORDER_FOCUS_TOTAL_LEVEL) {
2253                 _mmcam_dbg_warn("Total level  of manual focus of MMF is greater than that of the camera driver.");
2254         }
2255
2256         unit_level = ((float)max_level - (float)min_level)/(float)(_MMFCAMCORDER_FOCUS_TOTAL_LEVEL - 1);
2257
2258         if (!gst_camera_control_get_focus_level(control, &cur_level)) {
2259                 _mmcam_dbg_err("Can't get current level of manual focus.");
2260                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2261         }
2262
2263         //TODO : adjust unit level value
2264         if (direction == MM_CAMCORDER_MF_LENS_DIR_FORWARD) {
2265                 focus_level = cur_level + unit_level;
2266         } else if (direction == MM_CAMCORDER_MF_LENS_DIR_BACKWARD) {
2267                 focus_level = cur_level - unit_level;
2268         }
2269
2270         if (focus_level > max_level) {
2271                 focus_level = max_level;
2272         } else if (focus_level < min_level) {
2273                 focus_level = min_level;
2274         }
2275
2276         if (!gst_camera_control_set_focus_level(control, focus_level)) {
2277                 _mmcam_dbg_err("Manual focusing fail.");
2278                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2279         }
2280
2281         return MM_ERROR_NONE;
2282 }
2283
2284
2285 int _mmcamcorder_adjust_auto_focus(MMHandleType handle)
2286 {
2287         gboolean ret;
2288         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2289         GstCameraControl *control = NULL;
2290         _MMCamcorderSubContext *sc = NULL;
2291
2292         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2293
2294         /*_mmcam_dbg_log("");*/
2295
2296         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2297
2298         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2299                 _mmcam_dbg_log("Can't cast Video source into camera control.");
2300                 return MM_ERROR_NONE;
2301         }
2302
2303         control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2304         if (control) {
2305                 /* Start AF */
2306                 ret = gst_camera_control_start_auto_focus(control);
2307         } else {
2308                 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2309                 ret = FALSE;
2310         }
2311
2312         if (ret) {
2313                 _mmcam_dbg_log("Auto focusing start success.");
2314                 return MM_ERROR_NONE;
2315         } else {
2316                 _mmcam_dbg_err("Auto focusing start fail.");
2317                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2318         }
2319 }
2320
2321 int _mmcamcorder_stop_focusing(MMHandleType handle)
2322 {
2323         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2324         _MMCamcorderSubContext *sc = NULL;
2325
2326         int ret, state;
2327         GstCameraControl *control = NULL;
2328
2329         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
2330
2331         /*_mmcam_dbg_log("");*/
2332
2333         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2334
2335         if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
2336                 _mmcam_dbg_err("Another command is running.");
2337                 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
2338         }
2339
2340         state = _mmcamcorder_get_state(handle);
2341         if (state == MM_CAMCORDER_STATE_CAPTURING ||
2342             state < MM_CAMCORDER_STATE_PREPARE) {
2343                 _mmcam_dbg_err( "Not proper state. state[%d]", state );
2344                 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2345                 return MM_ERROR_CAMCORDER_INVALID_STATE;
2346         }
2347
2348         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2349                 _mmcam_dbg_log("Can't cast Video source into camera control.");
2350                 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2351                 return MM_ERROR_NONE;
2352         }
2353
2354         control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2355         if (control) {
2356                 ret = gst_camera_control_stop_auto_focus(control);
2357         } else {
2358                 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2359                 ret = FALSE;
2360         }
2361
2362         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
2363
2364         if (ret) {
2365                 _mmcam_dbg_log("Auto focusing stop success.");
2366                 return MM_ERROR_NONE;
2367         } else {
2368                 _mmcam_dbg_err("Auto focusing stop fail.");
2369                 return MM_ERROR_CAMCORDER_DEVICE_IO;
2370         }
2371 }
2372
2373
2374 /*-----------------------------------------------
2375 |         CAMCORDER INTERNAL LOCAL              |
2376 -----------------------------------------------*/
2377 static gboolean
2378 __mmcamcorder_gstreamer_init(camera_conf * conf)
2379 {
2380         static const int max_argc = 10;
2381         int i = 0;
2382         int cnt_str = 0;
2383         gint *argc = NULL;
2384         gchar **argv = NULL;
2385         GError *err = NULL;
2386         gboolean ret = FALSE;
2387         type_string_array *GSTInitOption = NULL;
2388
2389         mmf_return_val_if_fail(conf, FALSE);
2390
2391         _mmcam_dbg_log("");
2392
2393         /* alloc */
2394         argc = malloc(sizeof(int));
2395         argv = malloc(sizeof(gchar *) * max_argc);
2396
2397         if (!argc || !argv) {
2398                 goto ERROR;
2399         }
2400
2401         memset(argv, 0, sizeof(gchar *) * max_argc);
2402
2403         /* add initial */
2404         *argc = 1;
2405         argv[0] = g_strdup("mmcamcorder");
2406
2407         /* add gst_param */
2408         _mmcamcorder_conf_get_value_string_array(conf,
2409                                                  CONFIGURE_CATEGORY_MAIN_GENERAL,
2410                                                  "GSTInitOption",
2411                                                  &GSTInitOption);
2412         if (GSTInitOption != NULL && GSTInitOption->value) {
2413                 cnt_str = GSTInitOption->count;
2414                 for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
2415                 {
2416                         argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
2417                 }
2418         }
2419
2420         _mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
2421
2422         for (i = 0; i < *argc; i++) {
2423                 _mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
2424         }
2425
2426         /* initializing gstreamer */
2427         ret = gst_init_check (argc, &argv, &err);
2428         if (!ret) {
2429                 _mmcam_dbg_err("Could not initialize GStreamer: %s ",
2430                                err ? err->message : "unknown error occurred");
2431                 if (err) {
2432                         g_error_free (err);
2433                 }
2434         }
2435
2436         /* release */
2437         for (i = 0; i < *argc; i++) {
2438                 if (argv[i]) {
2439                         g_free(argv[i]);
2440                         argv[i] = NULL;
2441                 }
2442         }
2443
2444         if (argv) {
2445                 free(argv);
2446                 argv = NULL;
2447         }
2448
2449         if (argc) {
2450                 free(argc);
2451                 argc = NULL;
2452         }
2453
2454         return ret;
2455
2456 ERROR:
2457         _mmcam_dbg_err("failed to initialize gstreamer");
2458
2459         if (argv) {
2460                 free(argv);
2461                 argv = NULL;
2462         }
2463
2464         if (argc) {
2465                 free(argc);
2466                 argc = NULL;
2467         }
2468
2469         return FALSE;
2470 }
2471
2472
2473 int _mmcamcorder_get_state(MMHandleType handle)
2474 {
2475         int state;
2476         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2477
2478         mmf_return_val_if_fail(hcamcorder, -1);
2479
2480         _MMCAMCORDER_LOCK_STATE(handle);
2481
2482         state = hcamcorder->state;
2483         /*_mmcam_dbg_log("state=%d",state);*/
2484
2485         _MMCAMCORDER_UNLOCK_STATE(handle);
2486
2487         return state;
2488 }
2489
2490
2491 void _mmcamcorder_set_state(MMHandleType handle, int state)
2492 {
2493         int old_state;
2494         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2495         _MMCamcorderMsgItem msg;
2496
2497         mmf_return_if_fail(hcamcorder);
2498
2499         /*_mmcam_dbg_log("");*/
2500
2501         _MMCAMCORDER_LOCK_STATE(handle);
2502
2503         old_state = hcamcorder->state;
2504         if(old_state != state) {
2505                 hcamcorder->state = state;
2506                 hcamcorder->target_state = state;
2507
2508                 _mmcam_dbg_log("set state[%d] and send state-changed message", state);
2509
2510                 /* To discern who changes the state */
2511                 switch (hcamcorder->state_change_by_system) {
2512                 case _MMCAMCORDER_STATE_CHANGE_BY_ASM:
2513                         msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM;
2514                         msg.param.state.code = hcamcorder->interrupt_code;
2515                         break;
2516                 case _MMCAMCORDER_STATE_CHANGE_BY_RM:
2517                         msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_RM;
2518                         msg.param.state.code = MM_ERROR_NONE;
2519                         break;
2520                 case _MMCAMCORDER_STATE_CHANGE_NORMAL:
2521                 default:
2522                         msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
2523                         msg.param.state.code = MM_ERROR_NONE;
2524                         break;
2525                 }
2526
2527                 msg.param.state.previous = old_state;
2528                 msg.param.state.current = state;
2529
2530                 /*_mmcam_dbg_log("_mmcamcorder_send_message : msg : %p, id:%x", &msg, msg.id);*/
2531                 _mmcamcorder_send_message(handle, &msg);
2532         }
2533
2534         _MMCAMCORDER_UNLOCK_STATE(handle);
2535
2536         return;
2537 }
2538
2539
2540 int _mmcamcorder_get_async_state(MMHandleType handle)
2541 {
2542         int state;
2543         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2544
2545         _MMCAMCORDER_LOCK_STATE(handle);
2546         state = hcamcorder->target_state;
2547
2548         _MMCAMCORDER_UNLOCK_STATE(handle);
2549
2550         return state;
2551 }
2552
2553
2554 _MMCamcorderSubContext *_mmcamcorder_alloc_subcontext(int type)
2555 {
2556         int i;
2557         _MMCamcorderSubContext *sc = NULL;
2558
2559         /*_mmcam_dbg_log("");*/
2560
2561         /* alloc container */
2562         sc = (_MMCamcorderSubContext *)malloc(sizeof(_MMCamcorderSubContext));
2563         mmf_return_val_if_fail(sc != NULL, NULL);
2564
2565         /* init members */
2566         memset(sc, 0x00, sizeof(_MMCamcorderSubContext));
2567
2568         sc->element_num = _MMCAMCORDER_PIPELINE_ELEMENT_NUM;
2569         sc->encode_element_num = _MMCAMCORDER_ENCODE_PIPELINE_ELEMENT_NUM;
2570
2571         /* alloc info for each mode */
2572         switch (type) {
2573         case MM_CAMCORDER_MODE_AUDIO:
2574                 sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo));
2575                 if(!sc->info_audio) {
2576                         _mmcam_dbg_err("Failed to alloc info structure");
2577                         goto ALLOC_SUBCONTEXT_FAILED;
2578                 }
2579                 memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo));
2580                 break;
2581         case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2582         default:
2583                 sc->info_image = malloc( sizeof(_MMCamcorderImageInfo));
2584                 if(!sc->info_image) {
2585                         _mmcam_dbg_err("Failed to alloc info structure");
2586                         goto ALLOC_SUBCONTEXT_FAILED;
2587                 }
2588                 memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo));
2589
2590                 /* init sound status */
2591                 sc->info_image->sound_status = _SOUND_STATUS_INIT;
2592
2593                 sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo));
2594                 if(!sc->info_video) {
2595                         _mmcam_dbg_err("Failed to alloc info structure");
2596                         goto ALLOC_SUBCONTEXT_FAILED;
2597                 }
2598                 memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo));
2599                 pthread_mutex_init(&(sc->info_video->size_check_lock), NULL);
2600                 break;
2601         }
2602
2603         /* alloc element array */
2604         sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
2605         if(!sc->element) {
2606                 _mmcam_dbg_err("Failed to alloc element structure");
2607                 goto ALLOC_SUBCONTEXT_FAILED;
2608         }
2609
2610         sc->encode_element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->encode_element_num);
2611         if(!sc->encode_element) {
2612                 _mmcam_dbg_err("Failed to alloc encode element structure");
2613                 goto ALLOC_SUBCONTEXT_FAILED;
2614         }
2615
2616         for (i = 0 ; i < sc->element_num ; i++) {
2617                 sc->element[i].id = _MMCAMCORDER_NONE;
2618                 sc->element[i].gst = NULL;
2619         }
2620
2621         for (i = 0 ; i < sc->encode_element_num ; i++) {
2622                 sc->encode_element[i].id = _MMCAMCORDER_NONE;
2623                 sc->encode_element[i].gst = NULL;
2624         }
2625
2626         sc->fourcc = 0x80000000;
2627         sc->cam_stability_count = 0;
2628         sc->drop_vframe = 0;
2629         sc->pass_first_vframe = 0;
2630         sc->is_modified_rate = FALSE;
2631
2632         return sc;
2633
2634 ALLOC_SUBCONTEXT_FAILED:
2635         if (sc) {
2636                 if (sc->info_audio) {
2637                         free(sc->info_audio);
2638                         sc->info_audio = NULL;
2639                 }
2640                 if (sc->info_image) {
2641                         free(sc->info_image);
2642                         sc->info_image = NULL;
2643                 }
2644                 if (sc->info_video) {
2645                         pthread_mutex_destroy(&(sc->info_video->size_check_lock));
2646                         free(sc->info_video);
2647                         sc->info_video = NULL;
2648                 }
2649                 if (sc->element) {
2650                         free(sc->element);
2651                         sc->element = NULL;
2652                 }
2653                 if (sc->encode_element) {
2654                         free(sc->encode_element);
2655                         sc->encode_element = NULL;
2656                 }
2657                 free(sc);
2658                 sc = NULL;
2659         }
2660
2661         return NULL;
2662 }
2663
2664
2665 void _mmcamcorder_dealloc_subcontext(_MMCamcorderSubContext *sc)
2666 {
2667         _mmcam_dbg_log("");
2668
2669         if (sc) {
2670                 if (sc->element) {
2671                         _mmcam_dbg_log("release element");
2672                         free(sc->element);
2673                         sc->element = NULL;
2674                 }
2675
2676                 if (sc->encode_element) {
2677                         _mmcam_dbg_log("release encode_element");
2678                         free(sc->encode_element);
2679                         sc->encode_element = NULL;
2680                 }
2681
2682                 if (sc->info_image) {
2683                         _mmcam_dbg_log("release info_image");
2684                         free(sc->info_image);
2685                         sc->info_image = NULL;
2686                 }
2687
2688                 if (sc->info_video) {
2689                         _mmcam_dbg_log("release info_video");
2690                         if (sc->info_video->filename) {
2691                                 free(sc->info_video->filename);
2692                                 sc->info_video->filename = NULL;
2693                         }
2694                         pthread_mutex_destroy(&(sc->info_video->size_check_lock));
2695                         free(sc->info_video);
2696                         sc->info_video = NULL;
2697                 }
2698
2699                 if (sc->info_audio) {
2700                         _mmcam_dbg_log("release info_audio");
2701                         if (sc->info_audio->filename) {
2702                                 free(sc->info_audio->filename);
2703                                 sc->info_audio->filename = NULL;
2704                         }
2705                         free(sc->info_audio);
2706                         sc->info_audio = NULL;
2707                 }
2708
2709                 free(sc);
2710                 sc = NULL;
2711         }
2712
2713         return;
2714 }
2715
2716
2717 int _mmcamcorder_set_functions(MMHandleType handle, int type)
2718 {
2719         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2720
2721         /*_mmcam_dbg_log("");*/
2722
2723         switch (type) {
2724         case MM_CAMCORDER_MODE_AUDIO:
2725                 hcamcorder->command = _mmcamcorder_audio_command;
2726                 break;
2727         case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
2728         default:
2729                 hcamcorder->command = _mmcamcorder_video_capture_command;
2730                 break;
2731         }
2732
2733         return MM_ERROR_NONE;
2734 }
2735
2736
2737 gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpointer data)
2738 {
2739         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2740         _MMCamcorderSubContext *sc = NULL;
2741
2742         mmf_return_val_if_fail(hcamcorder, FALSE);
2743         mmf_return_val_if_fail(message, FALSE);
2744         //_mmcam_dbg_log("message type=(%d)", GST_MESSAGE_TYPE(message));
2745
2746         switch (GST_MESSAGE_TYPE(message)) {
2747         case GST_MESSAGE_UNKNOWN:
2748                 _mmcam_dbg_log("GST_MESSAGE_UNKNOWN");
2749                 break;
2750         case GST_MESSAGE_EOS:
2751         {
2752                 _mmcam_dbg_log ("Got EOS from element \"%s\".",
2753                                 GST_STR_NULL(GST_ELEMENT_NAME(GST_MESSAGE_SRC(message))));
2754
2755                 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2756                 mmf_return_val_if_fail(sc, TRUE);
2757
2758                 if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
2759                         mmf_return_val_if_fail(sc->info_video, TRUE);
2760                         if (sc->info_video->b_commiting) {
2761                                 _mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
2762                         }
2763                 } else {
2764                         mmf_return_val_if_fail(sc->info_audio, TRUE);
2765                         if (sc->info_audio->b_commiting) {
2766                                 _mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
2767                         }
2768                 }
2769
2770                 sc->bget_eos = TRUE;
2771
2772                 break;
2773         }
2774         case GST_MESSAGE_ERROR:
2775         {
2776                 GError *err;
2777                 gchar *debug;
2778                 gst_message_parse_error(message, &err, &debug);
2779
2780                 _mmcam_dbg_err ("GSTERR: %s", err->message);
2781                 _mmcam_dbg_err ("Error Debug: %s", debug);
2782
2783                 __mmcamcorder_handle_gst_error((MMHandleType)hcamcorder, message, err);
2784
2785                 g_error_free (err);
2786                 g_free (debug);
2787                 break;
2788         }
2789         case GST_MESSAGE_WARNING:
2790         {
2791                 GError *err;
2792                 gchar *debug;
2793                 gst_message_parse_warning (message, &err, &debug);
2794
2795                 _mmcam_dbg_warn("GSTWARN: %s", err->message);
2796
2797                 __mmcamcorder_handle_gst_warning((MMHandleType)hcamcorder, message, err);
2798
2799                 g_error_free (err);
2800                 g_free (debug);
2801                 break;
2802         }
2803         case GST_MESSAGE_INFO:
2804                 _mmcam_dbg_log("GST_MESSAGE_INFO");
2805                 break;
2806         case GST_MESSAGE_TAG:
2807                 _mmcam_dbg_log("GST_MESSAGE_TAG");
2808                 break;
2809         case GST_MESSAGE_BUFFERING:
2810                 _mmcam_dbg_log("GST_MESSAGE_BUFFERING");
2811                 break;
2812         case GST_MESSAGE_STATE_CHANGED:
2813         {
2814                 const GValue *vnewstate;
2815                 GstState newstate;
2816                 GstElement *pipeline = NULL;
2817
2818                 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2819                 if ((sc) && (sc->element)) {
2820                         if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
2821                                 pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
2822                                 if (message->src == (GstObject*)pipeline) {
2823                                         vnewstate = gst_structure_get_value(gst_message_get_structure(message), "new-state");
2824                                         newstate = (GstState)vnewstate->data[0].v_int;
2825                                         _mmcam_dbg_log("GST_MESSAGE_STATE_CHANGED[%s]",gst_element_state_get_name(newstate));
2826                                 }
2827                         }
2828                 }
2829                 break;
2830         }
2831         case GST_MESSAGE_STATE_DIRTY:
2832                 _mmcam_dbg_log("GST_MESSAGE_STATE_DIRTY");
2833                 break;
2834         case GST_MESSAGE_STEP_DONE:
2835                 _mmcam_dbg_log("GST_MESSAGE_STEP_DONE");
2836                 break;
2837         case GST_MESSAGE_CLOCK_PROVIDE:
2838                 _mmcam_dbg_log("GST_MESSAGE_CLOCK_PROVIDE");
2839                 break;
2840         case GST_MESSAGE_CLOCK_LOST:
2841                 _mmcam_dbg_log("GST_MESSAGE_CLOCK_LOST");
2842                 break;
2843         case GST_MESSAGE_NEW_CLOCK:
2844         {
2845                 GstClock *pipe_clock = NULL;
2846                 gst_message_parse_new_clock(message, &pipe_clock);
2847                 /*_mmcam_dbg_log("GST_MESSAGE_NEW_CLOCK : %s", (clock ? GST_OBJECT_NAME (clock) : "NULL"));*/
2848                 break;
2849         }
2850         case GST_MESSAGE_STRUCTURE_CHANGE:
2851                 _mmcam_dbg_log("GST_MESSAGE_STRUCTURE_CHANGE");
2852                 break;
2853         case GST_MESSAGE_STREAM_STATUS:
2854                 /*_mmcam_dbg_log("GST_MESSAGE_STREAM_STATUS");*/
2855                 break;
2856         case GST_MESSAGE_APPLICATION:
2857                 _mmcam_dbg_log("GST_MESSAGE_APPLICATION");
2858                 break;
2859         case GST_MESSAGE_ELEMENT:
2860                 /*_mmcam_dbg_log("GST_MESSAGE_ELEMENT");*/
2861                 break;
2862         case GST_MESSAGE_SEGMENT_START:
2863                 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_START");
2864                 break;
2865         case GST_MESSAGE_SEGMENT_DONE:
2866                 _mmcam_dbg_log("GST_MESSAGE_SEGMENT_DONE");
2867                 break;
2868         case GST_MESSAGE_DURATION_CHANGED:
2869                 _mmcam_dbg_log("GST_MESSAGE_DURATION_CHANGED");
2870                 break;
2871         case GST_MESSAGE_LATENCY:
2872                 _mmcam_dbg_log("GST_MESSAGE_LATENCY");
2873                 break;
2874         case GST_MESSAGE_ASYNC_START:
2875                 _mmcam_dbg_log("GST_MESSAGE_ASYNC_START");
2876                 break;
2877         case GST_MESSAGE_ASYNC_DONE:
2878                 /*_mmcam_dbg_log("GST_MESSAGE_ASYNC_DONE");*/
2879                 break;
2880         case GST_MESSAGE_ANY:
2881                 _mmcam_dbg_log("GST_MESSAGE_ANY");
2882                 break;
2883         case GST_MESSAGE_QOS:
2884 //              _mmcam_dbg_log("GST_MESSAGE_QOS");
2885                 break;
2886         default:
2887                 _mmcam_dbg_log("not handled message type=(%d)", GST_MESSAGE_TYPE(message));
2888                 break;
2889         }
2890
2891         return TRUE;
2892 }
2893
2894
2895 GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
2896 {
2897         GstElement *element = NULL;
2898         GError *err = NULL;
2899         gchar *debug_info = NULL;
2900
2901         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
2902         _MMCamcorderSubContext *sc = NULL;
2903
2904         mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
2905         mmf_return_val_if_fail(message, GST_BUS_PASS);
2906
2907         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
2908         mmf_return_val_if_fail(sc, GST_BUS_PASS);
2909
2910         if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
2911                 /* parse error message */
2912                 gst_message_parse_error(message, &err, &debug_info);
2913
2914                 if (debug_info) {
2915                         _mmcam_dbg_err("GST ERROR : %s", debug_info);
2916                         g_free(debug_info);
2917                         debug_info = NULL;
2918                 }
2919
2920                 if (!err) {
2921                         _mmcam_dbg_warn("failed to parse error message");
2922                         return GST_BUS_PASS;
2923                 }
2924
2925                 /* set videosrc element to compare */
2926                 element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2927
2928                 /* check domain[RESOURCE] and element[VIDEOSRC] */
2929                 if (err->domain == GST_RESOURCE_ERROR &&
2930                     GST_ELEMENT_CAST(message->src) == element) {
2931                         switch (err->code) {
2932                         case GST_RESOURCE_ERROR_BUSY:
2933                                 _mmcam_dbg_err("Camera device [busy]");
2934                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
2935                                 break;
2936                         case GST_RESOURCE_ERROR_OPEN_WRITE:
2937                                 _mmcam_dbg_err("Camera device [open failed]");
2938                                 hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
2939                                 //sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN; // SECURITY PART REQUEST PRIVILEGE
2940                                 break;
2941                         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
2942                                 _mmcam_dbg_err("Camera device [open failed]");
2943                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
2944                                 break;
2945                         case GST_RESOURCE_ERROR_OPEN_READ:
2946                                 _mmcam_dbg_err("Camera device [register trouble]");
2947                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
2948                                 break;
2949                         case GST_RESOURCE_ERROR_NOT_FOUND:
2950                                 _mmcam_dbg_err("Camera device [device not found]");
2951                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
2952                                 break;
2953                         case GST_RESOURCE_ERROR_TOO_LAZY:
2954                                 _mmcam_dbg_err("Camera device [timeout]");
2955                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
2956                                 break;
2957                         case GST_RESOURCE_ERROR_SETTINGS:
2958                                 _mmcam_dbg_err("Camera device [not supported]");
2959                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
2960                                 break;
2961                         case GST_RESOURCE_ERROR_FAILED:
2962                                 _mmcam_dbg_err("Camera device [working failed].");
2963                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
2964                                 break;
2965                         default:
2966                                 _mmcam_dbg_err("Camera device [General(%d)]", err->code);
2967                                 hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE;
2968                                 break;
2969                         }
2970
2971                         hcamcorder->error_occurs = TRUE;
2972                 }
2973
2974                 g_error_free(err);
2975
2976                 /* store error code and drop this message if cmd is running */
2977                 if (hcamcorder->error_code != MM_ERROR_NONE) {
2978                         _MMCamcorderMsgItem msg;
2979
2980                         /* post error to application */
2981                         hcamcorder->error_occurs = TRUE;
2982                         msg.id = MM_MESSAGE_CAMCORDER_ERROR;
2983                         msg.param.code = hcamcorder->error_code;
2984                         _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
2985
2986                         goto DROP_MESSAGE;
2987                 }
2988         } else if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ELEMENT) {
2989                 _MMCamcorderMsgItem msg;
2990
2991                 if (gst_structure_has_name(gst_message_get_structure(message), "avsysvideosrc-AF") ||
2992                     gst_structure_has_name(gst_message_get_structure(message), "camerasrc-AF")) {
2993                         int focus_state = 0;
2994
2995                         gst_structure_get_int(gst_message_get_structure(message), "focus-state", &focus_state);
2996                         _mmcam_dbg_log("Focus State:%d", focus_state);
2997
2998                         msg.id = MM_MESSAGE_CAMCORDER_FOCUS_CHANGED;
2999                         msg.param.code = focus_state;
3000                         _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3001
3002                         goto DROP_MESSAGE;
3003                 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-HDR")) {
3004                         int progress = 0;
3005                         int status = 0;
3006
3007                         if (gst_structure_get_int(gst_message_get_structure(message), "progress", &progress)) {
3008                                 gst_structure_get_int(gst_message_get_structure(message), "status", &status);
3009                                 _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status);
3010
3011                                 msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS;
3012                                 msg.param.code = progress;
3013                                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3014                         }
3015
3016                         goto DROP_MESSAGE;
3017                 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-FD")) {
3018                         int i = 0;
3019                         const GValue *g_value = gst_structure_get_value(gst_message_get_structure(message), "face-info");;
3020                         GstCameraControlFaceDetectInfo *fd_info = NULL;
3021                         MMCamFaceDetectInfo *cam_fd_info = NULL;
3022
3023                         if (g_value) {
3024                                 fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
3025                         }
3026
3027                         if (fd_info == NULL) {
3028                                 _mmcam_dbg_warn("fd_info is NULL");
3029                                 goto DROP_MESSAGE;
3030                         }
3031
3032                         cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo));
3033                         if (cam_fd_info == NULL) {
3034                                 _mmcam_dbg_warn("cam_fd_info alloc failed");
3035
3036                                 free(fd_info);
3037                                 fd_info = NULL;
3038
3039                                 goto DROP_MESSAGE;
3040                         }
3041
3042                         /* set total face count */
3043                         cam_fd_info->num_of_faces = fd_info->num_of_faces;
3044
3045                         if (cam_fd_info->num_of_faces > 0) {
3046                                 cam_fd_info->face_info = (MMCamFaceInfo *)malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces);
3047                                 if (cam_fd_info->face_info) {
3048                                         /* set information of each face */
3049                                         for (i = 0 ; i < fd_info->num_of_faces ; i++) {
3050                                                 cam_fd_info->face_info[i].id = fd_info->face_info[i].id;
3051                                                 cam_fd_info->face_info[i].score = fd_info->face_info[i].score;
3052                                                 cam_fd_info->face_info[i].rect.x = fd_info->face_info[i].rect.x;
3053                                                 cam_fd_info->face_info[i].rect.y = fd_info->face_info[i].rect.y;
3054                                                 cam_fd_info->face_info[i].rect.width = fd_info->face_info[i].rect.width;
3055                                                 cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
3056                                                 /*
3057                                                 _mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
3058                                                                fd_info->face_info[i].id,
3059                                                                fd_info->face_info[i].score,
3060                                                                fd_info->face_info[i].rect.x,
3061                                                                fd_info->face_info[i].rect.y,
3062                                                                fd_info->face_info[i].rect.width,
3063                                                                fd_info->face_info[i].rect.height);
3064                                                 */
3065                                         }
3066                                 } else {
3067                                         _mmcam_dbg_warn("MMCamFaceInfo alloc failed");
3068
3069                                         /* free allocated memory that is not sent */
3070                                         free(cam_fd_info);
3071                                         cam_fd_info = NULL;
3072                                 }
3073                         } else {
3074                                 cam_fd_info->face_info = NULL;
3075                         }
3076
3077                         if (cam_fd_info) {
3078                                 /* send message  - cam_fd_info should be freed by application */
3079                                 msg.id = MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO;
3080                                 msg.param.data = cam_fd_info;
3081                                 msg.param.size = sizeof(MMCamFaceDetectInfo);
3082                                 msg.param.code = 0;
3083
3084                                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3085                         }
3086
3087                         /* free fd_info allocated by plugin */
3088                         free(fd_info);
3089                         fd_info = NULL;
3090
3091                         goto DROP_MESSAGE;
3092                 } else if (gst_structure_has_name(gst_message_get_structure(message), "camerasrc-Capture")) {
3093                         int capture_done = FALSE;
3094
3095                         if (gst_structure_get_int(gst_message_get_structure(message), "capture-done", &capture_done)) {
3096                                 sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
3097                                 if (sc && sc->info_image) {
3098                                         /* play capture sound */
3099                                         _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
3100                                 }
3101                         }
3102
3103                         goto DROP_MESSAGE;
3104                 }
3105         }
3106
3107         return GST_BUS_PASS;
3108 DROP_MESSAGE:
3109         gst_message_unref(message);
3110         message = NULL;
3111
3112         return GST_BUS_DROP;
3113 }
3114
3115
3116 GstBusSyncReply _mmcamcorder_audio_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
3117 {
3118         GstElement *element = NULL;
3119         GError *err = NULL;
3120         gchar *debug_info = NULL;
3121
3122         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
3123         _MMCamcorderSubContext *sc = NULL;
3124
3125         mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
3126         mmf_return_val_if_fail(message, GST_BUS_PASS);
3127
3128         sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
3129         mmf_return_val_if_fail(sc, GST_BUS_PASS);
3130
3131         if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
3132                 /* parse error message */
3133                 gst_message_parse_error(message, &err, &debug_info);
3134
3135                 if (debug_info) {
3136                         _mmcam_dbg_err("GST ERROR : %s", debug_info);
3137                         g_free(debug_info);
3138                         debug_info = NULL;
3139                 }
3140
3141                 if (!err) {
3142                         _mmcam_dbg_warn("failed to parse error message");
3143                         return GST_BUS_PASS;
3144                 }
3145
3146                 /* set videosrc element to compare */
3147                 element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst);
3148
3149                 /* check domain[RESOURCE] and element[VIDEOSRC] */
3150                 if (err->domain == GST_RESOURCE_ERROR &&
3151                     GST_ELEMENT_CAST(message->src) == element) {
3152                         _MMCamcorderMsgItem msg;
3153                         switch (err->code) {
3154                         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3155                         case GST_RESOURCE_ERROR_OPEN_WRITE:
3156                                 _mmcam_dbg_err("audio device [open failed]");
3157                                 hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
3158                                 /* post error to application */
3159                                 hcamcorder->error_occurs = TRUE;
3160                                 msg.id = MM_MESSAGE_CAMCORDER_ERROR;
3161                                 msg.param.code = hcamcorder->error_code;
3162                                 _mmcam_dbg_err(" error : sc->error_occurs %d", hcamcorder->error_occurs);
3163                                 g_error_free(err);
3164                                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3165                                 gst_message_unref(message);
3166                                 message = NULL;
3167                                 return GST_BUS_DROP;
3168                         default:
3169                                 break;
3170                         }
3171                 }
3172
3173                 g_error_free(err);
3174
3175         }
3176
3177         return GST_BUS_PASS;
3178 }
3179
3180
3181 void _mmcamcorder_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
3182                                  mm_sound_focus_state_e focus_state, const char *reason_for_change,
3183                                  const char *additional_info, void *user_data)
3184 {
3185         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
3186         int current_state = MM_CAMCORDER_STATE_NONE;
3187
3188         mmf_return_if_fail((MMHandleType)hcamcorder);
3189
3190         current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3191         if (current_state <= MM_CAMCORDER_STATE_NONE ||
3192             current_state >= MM_CAMCORDER_STATE_NUM) {
3193                 _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
3194                 return;
3195         }
3196
3197         _mmcam_dbg_log("sound focus callback : focus state %d, reason %s",
3198                        focus_state, reason_for_change ? reason_for_change : "N/A");
3199
3200         if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
3201                 _mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
3202                 return;
3203         }
3204
3205         _MMCAMCORDER_LOCK_ASM(hcamcorder);
3206
3207         /* set value to inform a status is changed by asm */
3208         hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM;
3209
3210         /* check the reason */
3211         if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3212             !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3213             !strncmp(reason_for_change, "voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3214             !strncmp(reason_for_change, "call-voice", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) {
3215                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
3216         } else if (!strncmp(reason_for_change, "alarm", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) {
3217                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
3218         } else {
3219                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
3220         }
3221
3222         if (focus_state == FOCUS_IS_RELEASED) {
3223                 hcamcorder->acquired_focus &= ~focus_type;
3224
3225                 _mmcam_dbg_log("FOCUS is released [type %d, remained focus %d] : Stop pipeline[state:%d]",
3226                                focus_type, hcamcorder->acquired_focus, current_state);
3227
3228                 __mmcamcorder_force_stop(hcamcorder);
3229
3230                 _mmcam_dbg_log("Finish opeartion. Pipeline is released");
3231         } else if (focus_state == FOCUS_IS_ACQUIRED) {
3232                 _MMCamcorderMsgItem msg;
3233
3234                 hcamcorder->acquired_focus |= focus_type;
3235
3236                 _mmcam_dbg_log("FOCUS is acquired [type %d, new focus %d]",
3237                                focus_type, hcamcorder->acquired_focus);
3238
3239                 msg.id = MM_MESSAGE_READY_TO_RESUME;
3240                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3241
3242                 _mmcam_dbg_log("Finish opeartion");
3243         } else {
3244                 _mmcam_dbg_log("unknown focus state %d", focus_state);
3245         }
3246
3247         /* restore value */
3248         hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
3249
3250         _MMCAMCORDER_UNLOCK_ASM(hcamcorder);
3251
3252         return;
3253 }
3254
3255
3256 void _mmcamcorder_sound_focus_watch_cb(mm_sound_focus_type_e focus_type, mm_sound_focus_state_e focus_state,
3257                                        const char *reason_for_change, const char *additional_info, void *user_data)
3258 {
3259         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(user_data);
3260         int current_state = MM_CAMCORDER_STATE_NONE;
3261
3262         mmf_return_if_fail((MMHandleType)hcamcorder);
3263
3264         current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3265         if (current_state <= MM_CAMCORDER_STATE_NONE ||
3266             current_state >= MM_CAMCORDER_STATE_NUM) {
3267                 _mmcam_dbg_err("Abnormal state. Or null handle. (%p, %d)", hcamcorder, current_state);
3268                 return;
3269         }
3270
3271         _mmcam_dbg_log("sound focus watch callback : focus state %d, reason %s",
3272                        focus_state, reason_for_change ? reason_for_change : "N/A");
3273
3274         if (hcamcorder->session_flags & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
3275                 _mmcam_dbg_warn("session flag is UNINTERRUPTIBLE. do nothing.");
3276                 return;
3277         }
3278
3279         _MMCAMCORDER_LOCK_ASM(hcamcorder);
3280
3281         /* set value to inform a status is changed by asm */
3282         hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM;
3283
3284         /* check the reason */
3285         if (!strncmp(reason_for_change, "ringtone-voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3286             !strncmp(reason_for_change, "ringtone-call", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3287             !strncmp(reason_for_change, "voip", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN) ||
3288             !strncmp(reason_for_change, "call-voice", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) {
3289                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
3290         } else if (!strncmp(reason_for_change, "alarm", __MMCAMCORDER_FOCUS_CHANGE_REASON_LEN)) {
3291                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
3292         } else {
3293                 hcamcorder->interrupt_code = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
3294         }
3295
3296         if (focus_state == FOCUS_IS_RELEASED) {
3297                 _MMCamcorderMsgItem msg;
3298
3299                 _mmcam_dbg_log("other process's FOCUS is acquired");
3300
3301                 msg.id = MM_MESSAGE_READY_TO_RESUME;
3302                 _mmcamcorder_send_message((MMHandleType)hcamcorder, &msg);
3303
3304                 _mmcam_dbg_log("Finish opeartion");
3305         } else if (focus_state == FOCUS_IS_ACQUIRED) {
3306                 _mmcam_dbg_log("other process's FOCUS is released : Stop pipeline[state:%d]", current_state);
3307
3308                 __mmcamcorder_force_stop(hcamcorder);
3309
3310                 _mmcam_dbg_log("Finish opeartion. Pipeline is released");
3311         } else {
3312                 _mmcam_dbg_log("unknown focus state %d", focus_state);
3313         }
3314
3315         /* restore value */
3316         hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
3317
3318         _MMCAMCORDER_UNLOCK_ASM(hcamcorder);
3319
3320         return;
3321 }
3322
3323
3324 int _mmcamcorder_create_pipeline(MMHandleType handle, int type)
3325 {
3326         int ret = MM_ERROR_NONE;
3327         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3328         _MMCamcorderSubContext *sc = NULL;
3329         GstElement *pipeline = NULL;
3330
3331         _mmcam_dbg_log("handle : %x, type : %d", handle, type);
3332
3333         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3334
3335         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3336         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3337
3338         switch (type) {
3339         case MM_CAMCORDER_MODE_AUDIO:
3340                 ret = _mmcamcorder_create_audio_pipeline(handle);
3341                 if (ret != MM_ERROR_NONE) {
3342                         return ret;
3343                 }
3344                 break;
3345         case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
3346         default:
3347                 ret = _mmcamcorder_create_preview_pipeline(handle);
3348                 if (ret != MM_ERROR_NONE) {
3349                         return ret;
3350                 }
3351
3352                 /* connect capture signal */
3353                 if (!sc->bencbin_capture) {
3354                         ret = _mmcamcorder_connect_capture_signal(handle);
3355                         if (ret != MM_ERROR_NONE) {
3356                                 return ret;
3357                         }
3358                 }
3359                 break;
3360         }
3361
3362         pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
3363         if (type != MM_CAMCORDER_MODE_AUDIO) {
3364                 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
3365         }
3366 #ifdef _MMCAMCORDER_GET_DEVICE_INFO
3367         if (!_mmcamcorder_get_device_info(handle)) {
3368                 _mmcam_dbg_err("Getting device information error!!");
3369         }
3370 #endif
3371
3372         _mmcam_dbg_log("ret[%x]", ret);
3373         if (ret != MM_ERROR_NONE) {
3374                 _mmcam_dbg_err("error : destroy pipeline");
3375                 _mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
3376         }
3377
3378         return ret;
3379 }
3380
3381
3382 void _mmcamcorder_destroy_pipeline(MMHandleType handle, int type)
3383 {
3384         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3385         _MMCamcorderSubContext *sc = NULL;
3386         gint i = 0;
3387         int element_num = 0;
3388         _MMCamcorderGstElement *element = NULL;
3389         GstBus *bus = NULL;
3390
3391         mmf_return_if_fail(hcamcorder);
3392
3393         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3394         mmf_return_if_fail(sc);
3395
3396         _mmcam_dbg_log("");
3397
3398         /* Inside each pipeline destroy function, Set GST_STATE_NULL to Main pipeline */
3399         switch (type) {
3400         case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
3401                 element = sc->element;
3402                 element_num = sc->element_num;
3403                 bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst));
3404                 _mmcamcorder_destroy_video_capture_pipeline(handle);
3405                 break;
3406         case MM_CAMCORDER_MODE_AUDIO:
3407                 element = sc->encode_element;
3408                 element_num = sc->encode_element_num;
3409                 bus = gst_pipeline_get_bus(GST_PIPELINE(sc->encode_element[_MMCAMCORDER_ENCODE_MAIN_PIPE].gst));
3410                 _mmcamcorder_destroy_audio_pipeline(handle);
3411                 break;
3412         default:
3413                 _mmcam_dbg_err("unknown type %d", type);
3414                 break;
3415         }
3416
3417         _mmcam_dbg_log("Pipeline clear!!");
3418
3419         /* Remove pipeline message callback */
3420         if (hcamcorder->pipeline_cb_event_id > 0) {
3421                 g_source_remove(hcamcorder->pipeline_cb_event_id);
3422                 hcamcorder->pipeline_cb_event_id = 0;
3423         }
3424
3425         /* Remove remained message in bus */
3426         if (bus) {
3427                 GstMessage *gst_msg = NULL;
3428                 while ((gst_msg = gst_bus_pop(bus)) != NULL) {
3429                         _mmcamcorder_pipeline_cb_message(bus, gst_msg, (gpointer)hcamcorder);
3430                         gst_message_unref( gst_msg );
3431                         gst_msg = NULL;
3432                 }
3433                 gst_object_unref( bus );
3434                 bus = NULL;
3435         }
3436
3437         /* checking unreleased element */
3438         for (i = 0 ; i < element_num ; i++ ) {
3439                 if (element[i].gst) {
3440                         if (GST_IS_ELEMENT(element[i].gst)) {
3441                                 _mmcam_dbg_warn("Still alive element - ID[%d], name [%s], ref count[%d], status[%s]",
3442                                                 element[i].id,
3443                                                 GST_OBJECT_NAME(element[i].gst),
3444                                                 GST_OBJECT_REFCOUNT(element[i].gst),
3445                                                 gst_element_state_get_name(GST_STATE(element[i].gst)));
3446                                 g_object_weak_unref(G_OBJECT(element[i].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sc);
3447                         } else {
3448                                 _mmcam_dbg_warn("The element[%d] is still aliving, check it", element[i].id);
3449                         }
3450
3451                         element[i].id = _MMCAMCORDER_NONE;
3452                         element[i].gst = NULL;
3453                 }
3454         }
3455
3456         return;
3457 }
3458
3459
3460 int _mmcamcorder_gst_set_state_async(MMHandleType handle, GstElement *pipeline, GstState target_state)
3461 {
3462         GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3463
3464         _MMCAMCORDER_LOCK_GST_STATE(handle);
3465         setChangeReturn = gst_element_set_state(pipeline, target_state);
3466         _MMCAMCORDER_UNLOCK_GST_STATE(handle);
3467
3468         return setChangeReturn;
3469 }
3470
3471
3472 #ifdef _MMCAMCORDER_USE_SET_ATTR_CB
3473 static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data)
3474 {
3475         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
3476
3477         mmf_return_val_if_fail(hcamcorder, FALSE);
3478
3479         _mmcam_dbg_log("");
3480
3481         _mmcamcorder_set_attribute_to_camsensor((MMHandleType)hcamcorder);
3482
3483         /* initialize */
3484         hcamcorder->setting_event_id = 0;
3485
3486         _mmcam_dbg_log("Done");
3487
3488         /* once */
3489         return FALSE;
3490 }
3491 #endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
3492
3493
3494 int _mmcamcorder_gst_set_state(MMHandleType handle, GstElement *pipeline, GstState target_state)
3495 {
3496         unsigned int k = 0;
3497         _MMCamcorderSubContext *sc = NULL;
3498         GstState pipeline_state = GST_STATE_VOID_PENDING;
3499         GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
3500         GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE;
3501         GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND;
3502         pthread_mutex_t *state_lock = NULL;
3503
3504         mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3505         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3506         mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3507
3508         if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst == pipeline) {
3509                 _mmcam_dbg_log("Set state to %d - PREVIEW PIPELINE", target_state);
3510                 state_lock = &_MMCAMCORDER_GET_GST_STATE_LOCK(handle);
3511         } else {
3512                 _mmcam_dbg_log("Set state to %d - ENDODE PIPELINE", target_state);
3513                 state_lock = &_MMCAMCORDER_GET_GST_ENCODE_STATE_LOCK(handle);
3514         }
3515
3516         pthread_mutex_lock(state_lock);
3517
3518         for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
3519                 setChangeReturn = gst_element_set_state(pipeline, target_state);
3520                 _mmcam_dbg_log("gst_element_set_state[%d] return %d",
3521                                target_state, setChangeReturn);
3522                 if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
3523                         getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
3524                         switch (getChangeReturn) {
3525                         case GST_STATE_CHANGE_NO_PREROLL:
3526                                 _mmcam_dbg_log("status=GST_STATE_CHANGE_NO_PREROLL.");
3527                         case GST_STATE_CHANGE_SUCCESS:
3528                                 /* if we reached the final target state, exit */
3529                                 if (pipeline_state == target_state) {
3530                                         _mmcam_dbg_log("Set state to %d - DONE", target_state);
3531                                         pthread_mutex_unlock(state_lock);
3532                                         return MM_ERROR_NONE;
3533                                 }
3534                                 break;
3535                         case GST_STATE_CHANGE_ASYNC:
3536                                 _mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC.");
3537                                 break;
3538                         default:
3539                                 pthread_mutex_unlock(state_lock);
3540                                 _mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE.");
3541                                 return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3542                         }
3543
3544                         pthread_mutex_unlock(state_lock);
3545
3546                         _mmcam_dbg_err("timeout of gst_element_get_state()!!");
3547
3548                         return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3549                 }
3550
3551                 usleep(_MMCAMCORDER_STATE_CHECK_INTERVAL);
3552         }
3553
3554         pthread_mutex_unlock(state_lock);
3555
3556         _mmcam_dbg_err("Failure. gst_element_set_state timeout!!");
3557
3558         return MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT;
3559 }
3560
3561
3562 /* For performance check */
3563 int _mmcamcorder_video_current_framerate(MMHandleType handle)
3564 {
3565         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3566         _MMCamcorderSubContext *sc = NULL;
3567
3568         mmf_return_val_if_fail(hcamcorder, -1);
3569
3570         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3571         mmf_return_val_if_fail(sc, -1);
3572
3573         return sc->kpi.current_fps;
3574 }
3575
3576
3577 int _mmcamcorder_video_average_framerate(MMHandleType handle)
3578 {
3579         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3580         _MMCamcorderSubContext *sc = NULL;
3581
3582         mmf_return_val_if_fail(hcamcorder, -1);
3583
3584         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3585         mmf_return_val_if_fail(sc, -1);
3586
3587         return sc->kpi.average_fps;
3588 }
3589
3590
3591 void _mmcamcorder_video_current_framerate_init(MMHandleType handle)
3592 {
3593         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3594         _MMCamcorderSubContext *sc = NULL;
3595
3596         mmf_return_if_fail(hcamcorder);
3597
3598         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3599         mmf_return_if_fail(sc);
3600
3601         memset(&(sc->kpi), 0x00, sizeof(_MMCamcorderKPIMeasure));
3602
3603         return;
3604 }
3605
3606
3607 void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder)
3608 {
3609         int i = 0;
3610         int loop = 0;
3611         int itr_cnt = 0;
3612         int result = MM_ERROR_NONE;
3613         int cmd_try_count = 0;
3614         int current_state = MM_CAMCORDER_STATE_NONE;
3615
3616         mmf_return_if_fail(hcamcorder);
3617
3618         /* check command running */
3619         do {
3620                 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
3621                         if (cmd_try_count++ < __MMCAMCORDER_FORCE_STOP_TRY_COUNT) {
3622                                 _mmcam_dbg_warn("Another command is running. try again after %d ms", __MMCAMCORDER_FORCE_STOP_WAIT_TIME/1000);
3623                                 usleep(__MMCAMCORDER_FORCE_STOP_WAIT_TIME);
3624                         } else {
3625                                 _mmcam_dbg_err("wait timeout");
3626                                 break;
3627                         }
3628                 } else {
3629                         _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
3630                         break;
3631                 }
3632         } while (TRUE);
3633
3634         current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3635
3636         _mmcam_dbg_warn("Force STOP MMFW Camcorder");
3637
3638         for (loop = 0 ; current_state > MM_CAMCORDER_STATE_NULL && loop < __MMCAMCORDER_CMD_ITERATE_MAX * 3 ; loop++) {
3639                 itr_cnt = __MMCAMCORDER_CMD_ITERATE_MAX;
3640                 switch (current_state) {
3641                 case MM_CAMCORDER_STATE_CAPTURING:
3642                 {
3643                         _MMCamcorderSubContext *sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
3644                         _MMCamcorderImageInfo *info = NULL;
3645
3646                         mmf_return_if_fail(sc);
3647                         mmf_return_if_fail((info = sc->info_image));
3648
3649                         _mmcam_dbg_warn("Stop capturing.");
3650
3651                         /* if caturing isn't finished, waiting for 2 sec to finish real capture operation. check 'info->capturing'. */
3652                         mm_camcorder_set_attributes((MMHandleType)hcamcorder, NULL,
3653                                                     MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT, TRUE,
3654                                                     NULL);
3655
3656                         for (i = 0; i < 20 && info->capturing; i++) {
3657                                 usleep(100000);
3658                         }
3659
3660                         if (i == 20) {
3661                                 _mmcam_dbg_err("Timeout. Can't check stop capturing.");
3662                         }
3663
3664                         while ((itr_cnt--) && ((result = _mmcamcorder_capture_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3665                                         _mmcam_dbg_warn("Can't stop capturing.(%x)", result);
3666                         }
3667
3668                         break;
3669                 }
3670                 case MM_CAMCORDER_STATE_RECORDING:
3671                 case MM_CAMCORDER_STATE_PAUSED:
3672                 {
3673                         _mmcam_dbg_warn("Stop recording.");
3674
3675                         while ((itr_cnt--) && ((result = _mmcamcorder_commit((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3676                                 _mmcam_dbg_warn("Can't commit.(%x)", result);
3677                         }
3678                         break;
3679                 }
3680                 case MM_CAMCORDER_STATE_PREPARE:
3681                 {
3682                         _mmcam_dbg_warn("Stop preview.");
3683
3684                         while ((itr_cnt--) && ((result = _mmcamcorder_stop((MMHandleType)hcamcorder)) != MM_ERROR_NONE)) {
3685                                 _mmcam_dbg_warn("Can't stop preview.(%x)", result);
3686                         }
3687                         break;
3688                 }
3689                 case MM_CAMCORDER_STATE_READY:
3690                 {
3691                         _mmcam_dbg_warn("unrealize");
3692
3693                         if ((result = _mmcamcorder_unrealize((MMHandleType)hcamcorder)) != MM_ERROR_NONE) {
3694                                 _mmcam_dbg_warn("Can't unrealize.(%x)", result);
3695                         }
3696                         break;
3697                 }
3698                 case MM_CAMCORDER_STATE_NULL:
3699                 default:
3700                         _mmcam_dbg_warn("Already stopped.");
3701                         break;
3702                 }
3703
3704                 current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
3705         }
3706
3707         _mmcam_dbg_warn( "Done." );
3708
3709         return;
3710 }
3711
3712
3713 static gboolean __mmcamcorder_handle_gst_error(MMHandleType handle, GstMessage *message, GError *error)
3714 {
3715         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3716         _MMCamcorderMsgItem msg;
3717         gchar *msg_src_element;
3718         _MMCamcorderSubContext *sc = NULL;
3719
3720         return_val_if_fail(hcamcorder, FALSE);
3721         return_val_if_fail(error, FALSE);
3722         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3723         mmf_return_val_if_fail(sc, FALSE);
3724
3725         _mmcam_dbg_log("");
3726
3727         /* filtering filesink related errors */
3728         if (hcamcorder->state == MM_CAMCORDER_STATE_RECORDING &&
3729             (error->code ==  GST_RESOURCE_ERROR_WRITE || error->code ==  GST_RESOURCE_ERROR_SEEK)) {
3730                 if (sc->ferror_count == 2 && sc->ferror_send == FALSE) {
3731                         sc->ferror_send = TRUE;
3732                         msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3733                 } else {
3734                         sc->ferror_count++;
3735                         _mmcam_dbg_warn("Skip error");
3736                         return TRUE;
3737                 }
3738         }
3739
3740         if (error->domain == GST_CORE_ERROR) {
3741                 msg.param.code = __mmcamcorder_gst_handle_core_error(handle, error->code, message);
3742         } else if (error->domain == GST_LIBRARY_ERROR) {
3743                 msg.param.code = __mmcamcorder_gst_handle_library_error(handle, error->code, message);
3744         } else if (error->domain == GST_RESOURCE_ERROR) {
3745                 msg.param.code = __mmcamcorder_gst_handle_resource_error(handle, error->code, message);
3746         } else if (error->domain == GST_STREAM_ERROR) {
3747                 msg.param.code = __mmcamcorder_gst_handle_stream_error(handle, error->code, message);
3748         } else {
3749                 _mmcam_dbg_warn("This error domain is not defined.");
3750
3751                 /* we treat system error as an internal error */
3752                 msg.param.code = MM_ERROR_CAMCORDER_INTERNAL;
3753         }
3754
3755         if (message->src) {
3756                 msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
3757                 _mmcam_dbg_err("-Msg src : [%s] Domain : [%s]   Error : [%s]  Code : [%d] is tranlated to error code : [0x%x]",
3758                                msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3759         } else {
3760                 _mmcam_dbg_err("Domain : [%s]   Error : [%s]  Code : [%d] is tranlated to error code : [0x%x]",
3761                                g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
3762         }
3763
3764 #ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
3765         /* Check whether send this error to application */
3766         if (msg.param.code == MM_ERROR_CAMCORDER_GST_FLOW_ERROR) {
3767                 _mmcam_dbg_log("We got the error. But skip it.");
3768                 return TRUE;
3769         }
3770 #endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
3771
3772         /* post error to application */
3773         hcamcorder->error_occurs = TRUE;
3774         msg.id = MM_MESSAGE_CAMCORDER_ERROR;
3775         _mmcamcorder_send_message(handle, &msg);
3776
3777         return TRUE;
3778 }
3779
3780
3781 static gint __mmcamcorder_gst_handle_core_error(MMHandleType handle, int code, GstMessage *message)
3782 {
3783         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3784         _MMCamcorderSubContext *sc = NULL;
3785         GstElement *element = NULL;
3786
3787         _mmcam_dbg_log("");
3788
3789         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3790
3791         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3792         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3793
3794         /* Specific plugin - video encoder plugin */
3795         element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3796
3797         if (GST_ELEMENT_CAST(message->src) == element) {
3798                 if (code == GST_CORE_ERROR_NEGOTIATION) {
3799                         return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3800                 } else {
3801                         return MM_ERROR_CAMCORDER_ENCODER;
3802                 }
3803         }
3804
3805         /* General */
3806         switch (code)
3807         {
3808                 case GST_CORE_ERROR_STATE_CHANGE:
3809                         return MM_ERROR_CAMCORDER_GST_STATECHANGE;
3810                 case GST_CORE_ERROR_NEGOTIATION:
3811                         return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3812                 case GST_CORE_ERROR_MISSING_PLUGIN:
3813                 case GST_CORE_ERROR_SEEK:
3814                 case GST_CORE_ERROR_NOT_IMPLEMENTED:
3815                 case GST_CORE_ERROR_FAILED:
3816                 case GST_CORE_ERROR_TOO_LAZY:
3817                 case GST_CORE_ERROR_PAD:
3818                 case GST_CORE_ERROR_THREAD:
3819                 case GST_CORE_ERROR_EVENT:
3820                 case GST_CORE_ERROR_CAPS:
3821                 case GST_CORE_ERROR_TAG:
3822                 case GST_CORE_ERROR_CLOCK:
3823                 case GST_CORE_ERROR_DISABLED:
3824                 default:
3825                         return MM_ERROR_CAMCORDER_GST_CORE;
3826                 break;
3827         }
3828 }
3829
3830 static gint __mmcamcorder_gst_handle_library_error(MMHandleType handle, int code, GstMessage *message)
3831 {
3832         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3833         return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3834
3835         _mmcam_dbg_log("");
3836
3837         /* Specific plugin - NONE */
3838
3839         /* General */
3840         switch (code) {
3841         case GST_LIBRARY_ERROR_FAILED:
3842         case GST_LIBRARY_ERROR_TOO_LAZY:
3843         case GST_LIBRARY_ERROR_INIT:
3844         case GST_LIBRARY_ERROR_SHUTDOWN:
3845         case GST_LIBRARY_ERROR_SETTINGS:
3846         case GST_LIBRARY_ERROR_ENCODE:
3847         default:
3848                 _mmcam_dbg_err("Library error(%d)", code);
3849                 return MM_ERROR_CAMCORDER_GST_LIBRARY;
3850         }
3851 }
3852
3853
3854 static gint __mmcamcorder_gst_handle_resource_error(MMHandleType handle, int code, GstMessage *message)
3855 {
3856         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3857         _MMCamcorderSubContext *sc = NULL;
3858         GstElement *element = NULL;
3859
3860         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3861
3862         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3863         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3864
3865         _mmcam_dbg_log("");
3866
3867         /* Specific plugin */
3868         /* video sink */
3869         element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst);
3870         if (GST_ELEMENT_CAST(message->src) == element) {
3871                 if (code == GST_RESOURCE_ERROR_WRITE) {
3872                         _mmcam_dbg_err("Display device [Off]");
3873                         return MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF;
3874                 } else {
3875                         _mmcam_dbg_err("Display device [General(%d)]", code);
3876                 }
3877         }
3878
3879         /* encodebin */
3880         element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3881         if (GST_ELEMENT_CAST(message->src) == element) {
3882                 if (code == GST_RESOURCE_ERROR_FAILED) {
3883                         _mmcam_dbg_err("Encoder [Resource error]");
3884                         return MM_ERROR_CAMCORDER_ENCODER_BUFFER;
3885                 } else {
3886                         _mmcam_dbg_err("Encoder [General(%d)]", code);
3887                         return MM_ERROR_CAMCORDER_ENCODER;
3888                 }
3889         }
3890
3891         /* General */
3892         switch (code) {
3893         case GST_RESOURCE_ERROR_WRITE:
3894                 _mmcam_dbg_err("File write error");
3895                 return MM_ERROR_FILE_WRITE;
3896         case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
3897                 _mmcam_dbg_err("No left space");
3898                 return MM_MESSAGE_CAMCORDER_NO_FREE_SPACE;
3899         case GST_RESOURCE_ERROR_OPEN_WRITE:
3900                 _mmcam_dbg_err("Out of storage");
3901                 return MM_ERROR_OUT_OF_STORAGE;
3902         case GST_RESOURCE_ERROR_SEEK:
3903                 _mmcam_dbg_err("File read(seek)");
3904                 return MM_ERROR_FILE_READ;
3905         case GST_RESOURCE_ERROR_NOT_FOUND:
3906         case GST_RESOURCE_ERROR_FAILED:
3907         case GST_RESOURCE_ERROR_TOO_LAZY:
3908         case GST_RESOURCE_ERROR_BUSY:
3909         case GST_RESOURCE_ERROR_OPEN_READ:
3910         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
3911         case GST_RESOURCE_ERROR_CLOSE:
3912         case GST_RESOURCE_ERROR_READ:
3913         case GST_RESOURCE_ERROR_SYNC:
3914         case GST_RESOURCE_ERROR_SETTINGS:
3915         default:
3916                 _mmcam_dbg_err("Resource error(%d)", code);
3917                 return MM_ERROR_CAMCORDER_GST_RESOURCE;
3918         }
3919 }
3920
3921
3922 static gint __mmcamcorder_gst_handle_stream_error(MMHandleType handle, int code, GstMessage *message)
3923 {
3924         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3925         _MMCamcorderSubContext *sc = NULL;
3926         GstElement *element =NULL;
3927
3928         mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
3929
3930         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3931         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3932
3933         _mmcam_dbg_log("");
3934
3935         /* Specific plugin */
3936         /* video encoder */
3937         element = GST_ELEMENT_CAST(sc->encode_element[_MMCAMCORDER_ENCSINK_VENC].gst);
3938         if (GST_ELEMENT_CAST(message->src) == element) {
3939                 switch (code) {
3940                 case GST_STREAM_ERROR_WRONG_TYPE:
3941                         _mmcam_dbg_err("Video encoder [wrong stream type]");
3942                         return MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE;
3943                 case GST_STREAM_ERROR_ENCODE:
3944                         _mmcam_dbg_err("Video encoder [encode error]");
3945                         return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3946                 case GST_STREAM_ERROR_FAILED:
3947                         _mmcam_dbg_err("Video encoder [stream failed]");
3948                         return MM_ERROR_CAMCORDER_ENCODER_WORKING;
3949                 default:
3950                         _mmcam_dbg_err("Video encoder [General(%d)]", code);
3951                         return MM_ERROR_CAMCORDER_ENCODER;
3952                 }
3953         }
3954
3955         /* General plugin */
3956         switch (code) {
3957         case GST_STREAM_ERROR_FORMAT:
3958                 _mmcam_dbg_err("General [negotiation error(%d)]", code);
3959                 return MM_ERROR_CAMCORDER_GST_NEGOTIATION;
3960         case GST_STREAM_ERROR_FAILED:
3961                 _mmcam_dbg_err("General [flow error(%d)]", code);
3962                 return MM_ERROR_CAMCORDER_GST_FLOW_ERROR;
3963         case GST_STREAM_ERROR_TYPE_NOT_FOUND:
3964         case GST_STREAM_ERROR_DECODE:
3965         case GST_STREAM_ERROR_CODEC_NOT_FOUND:
3966         case GST_STREAM_ERROR_NOT_IMPLEMENTED:
3967         case GST_STREAM_ERROR_TOO_LAZY:
3968         case GST_STREAM_ERROR_ENCODE:
3969         case GST_STREAM_ERROR_DEMUX:
3970         case GST_STREAM_ERROR_MUX:
3971         case GST_STREAM_ERROR_DECRYPT:
3972         case GST_STREAM_ERROR_DECRYPT_NOKEY:
3973         case GST_STREAM_ERROR_WRONG_TYPE:
3974         default:
3975                 _mmcam_dbg_err("General [error(%d)]", code);
3976                 return MM_ERROR_CAMCORDER_GST_STREAM;
3977         }
3978 }
3979
3980
3981 static gboolean __mmcamcorder_handle_gst_warning (MMHandleType handle, GstMessage *message, GError *error)
3982 {
3983         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3984         gchar *debug = NULL;
3985         GError *err = NULL;
3986
3987         return_val_if_fail(hcamcorder, FALSE);
3988         return_val_if_fail(error, FALSE);
3989
3990         _mmcam_dbg_log("");
3991
3992         gst_message_parse_warning(message, &err, &debug);
3993
3994         if (error->domain == GST_CORE_ERROR) {
3995                 _mmcam_dbg_warn("GST warning: GST_CORE domain");
3996         } else if (error->domain == GST_LIBRARY_ERROR) {
3997                 _mmcam_dbg_warn("GST warning: GST_LIBRARY domain");
3998         } else if (error->domain == GST_RESOURCE_ERROR) {
3999                 _mmcam_dbg_warn("GST warning: GST_RESOURCE domain");
4000                 __mmcamcorder_gst_handle_resource_warning(handle, message, error);
4001         } else if (error->domain == GST_STREAM_ERROR ) {
4002                 _mmcam_dbg_warn("GST warning: GST_STREAM domain");
4003         } else {
4004                 _mmcam_dbg_warn("This error domain(%d) is not defined.", error->domain);
4005         }
4006
4007         if (err != NULL) {
4008                 g_error_free(err);
4009                 err = NULL;
4010         }
4011         if (debug != NULL) {
4012                 _mmcam_dbg_err ("Debug: %s", debug);
4013                 g_free(debug);
4014                 debug = NULL;
4015         }
4016
4017         return TRUE;
4018 }
4019
4020
4021 static gint __mmcamcorder_gst_handle_resource_warning(MMHandleType handle, GstMessage *message , GError *error)
4022 {
4023         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4024         _MMCamcorderSubContext *sc = NULL;
4025         GstElement *element =NULL;
4026         gchar *msg_src_element;
4027
4028         mmf_return_val_if_fail( hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
4029
4030         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4031         mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
4032
4033         _mmcam_dbg_log("");
4034
4035         /* Special message handling */
4036         /* video source */
4037         element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
4038         if (GST_ELEMENT_CAST(message->src) == element) {
4039                 if (error->code == GST_RESOURCE_ERROR_FAILED) {
4040                         msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
4041                         _mmcam_dbg_warn("-Msg src:[%s] Domain:[%s] Error:[%s]",
4042                                        msg_src_element, g_quark_to_string(error->domain), error->message);
4043                         return MM_ERROR_NONE;
4044                 }
4045         }
4046
4047         /* General plugin */
4048         switch (error->code) {
4049         case GST_RESOURCE_ERROR_WRITE:
4050         case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
4051         case GST_RESOURCE_ERROR_SEEK:
4052         case GST_RESOURCE_ERROR_NOT_FOUND:
4053         case GST_RESOURCE_ERROR_FAILED:
4054         case GST_RESOURCE_ERROR_TOO_LAZY:
4055         case GST_RESOURCE_ERROR_BUSY:
4056         case GST_RESOURCE_ERROR_OPEN_READ:
4057         case GST_RESOURCE_ERROR_OPEN_WRITE:
4058         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
4059         case GST_RESOURCE_ERROR_CLOSE:
4060         case GST_RESOURCE_ERROR_READ:
4061         case GST_RESOURCE_ERROR_SYNC:
4062         case GST_RESOURCE_ERROR_SETTINGS:
4063         default:
4064                 _mmcam_dbg_warn("General GST warning(%d)", error->code);
4065                 break;
4066         }
4067
4068         return MM_ERROR_NONE;
4069 }
4070
4071 int _mmcamcorder_get_video_caps(MMHandleType handle, char **caps)
4072 {
4073         GstPad *pad = NULL;
4074         GstCaps *sink_caps = NULL;
4075         _MMCamcorderSubContext *sc = NULL;
4076
4077         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4078         _mmcam_dbg_warn("Entered ");
4079         pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
4080         if(!pad) {
4081                 _mmcam_dbg_err("static pad is NULL");
4082                 return MM_ERROR_CAMCORDER_INVALID_STATE;
4083         }
4084
4085         sink_caps = gst_pad_get_current_caps(pad);
4086         gst_object_unref( pad );
4087         if(!sink_caps) {
4088                 _mmcam_dbg_err("fail to get caps");
4089                 return MM_ERROR_CAMCORDER_INVALID_STATE;
4090         }
4091
4092         *caps = gst_caps_to_string(sink_caps);
4093         _mmcam_dbg_err("video caps : %s", *caps);
4094         gst_caps_unref(sink_caps);
4095
4096         return MM_ERROR_NONE;
4097 }