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