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