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