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