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