src/mm_camcorder_internal.c

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