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