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