src/mm_camcorder_internal.c

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