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