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