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