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