src/mm_camcorder_internal.c

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