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