src/mm_camcorder_attribute.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 /*=======================================================================================
  24 |  INCLUDE FILES                                                                        |
  25 =======================================================================================*/
  26 #include "mm_camcorder_internal.h"
  27 #include "mm_camcorder_gstcommon.h"
  28
  29 #include <gst/video/colorbalance.h>
  30 #include <gst/video/cameracontrol.h>
  31 #include <gst/video/videooverlay.h>
  32 #ifdef HAVE_WAYLAND
  33 #include <gst/wayland/wayland.h>
  34 #endif
  35
  36 /*-----------------------------------------------------------------------
  37 |    MACRO DEFINITIONS:                                                 |
  38 -----------------------------------------------------------------------*/
  39 #define MMCAMCORDER_DEFAULT_CAMERA_WIDTH        640
  40 #define MMCAMCORDER_DEFAULT_CAMERA_HEIGHT       480
  41 #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE (1024*1024*10)
  42 #define MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL 1000
  43
  44 /*---------------------------------------------------------------------------------------
  45 |    GLOBAL VARIABLE DEFINITIONS for internal                                           |
  46 ---------------------------------------------------------------------------------------*/
  47
  48 /*-----------------------------------------------------------------------
  49 |    LOCAL VARIABLE DEFINITIONS for internal                            |
  50 -----------------------------------------------------------------------*/
  51 /*      Readonly attributes list.
  52 *       If you want to make some attributes read only, write down here.
  53 *       It will make them read only after composing whole attributes.
  54 */
  55
  56 static int readonly_attributes[] = {
  57         MM_CAM_CAMERA_DEVICE_COUNT,
  58         MM_CAM_CAMERA_DEVICE_NAME,
  59         MM_CAM_CAMERA_FACING_DIRECTION,
  60         MM_CAM_CAMERA_SHUTTER_SPEED,
  61         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
  62         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
  63         MM_CAM_CAPTURED_SCREENNAIL,
  64         MM_CAM_RECOMMEND_DISPLAY_ROTATION,
  65         MM_CAM_SUPPORT_ZSL_CAPTURE,
  66         MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
  67         MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB
  68 };
  69
  70 /*-----------------------------------------------------------------------
  71 |    LOCAL FUNCTION PROTOTYPES:                                         |
  72 -----------------------------------------------------------------------*/
  73 /* STATIC INTERNAL FUNCTION */
  74 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height);
  75 static int  __mmcamcorder_set_conf_to_valid_info(MMHandleType handle);
  76 static int  __mmcamcorder_release_conf_valid_info(MMHandleType handle);
  77 static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx);
  78 static int  __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args);
  79
  80 /*=======================================================================
  81 |  FUNCTION DEFINITIONS                                                 |
  82 =======================================================================*/
  83 /*-----------------------------------------------------------------------
  84 |    GLOBAL FUNCTION DEFINITIONS:                                       |
  85 -----------------------------------------------------------------------*/
  86 MMHandleType
  87 _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
  88 {
  89         _mmcam_dbg_log( "" );
  90
  91         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
  92         MMHandleType attrs = 0;
  93         mmf_attrs_construct_info_t *attrs_const_info = NULL;
  94         unsigned int attr_count = 0;
  95         unsigned int idx;
  96
  97         static int depth[] = {MM_CAMCORDER_AUDIO_FORMAT_PCM_U8, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE};
  98         static int flip_list[] = { MM_FLIP_NONE };
  99         static int rotation_list[] = { MM_VIDEO_INPUT_ROTATION_NONE };
 100         static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
 101         static int tag_orientation_values[] =
 102                 {
 103                         1,      /*The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
 104                         2,      /*the 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
 105                         3,      /*the 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
 106                         4,      /*the 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.*/
 107                         5,      /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual top.*/
 108                         6,      /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual top.*/
 109                         7,      /*the 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.*/
 110                         8,      /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.*/
 111                 };
 112
 113         if (hcamcorder == NULL) {
 114                 _mmcam_dbg_err("handle is NULL");
 115                 return 0;
 116         }
 117
 118         /* Create attribute constructor */
 119         _mmcam_dbg_log("start");
 120
 121         /* alloc 'mmf_attrs_construct_info_t' */
 122         attr_count = MM_CAM_ATTRIBUTE_NUM;
 123         attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
 124         if (!attrs_const_info) {
 125                 _mmcam_dbg_err("Fail to alloc constructor.");
 126                 return 0;
 127         }
 128
 129         /* alloc default attribute info */
 130         hcamcorder->cam_attrs_const_info = (mm_cam_attr_construct_info *)malloc(sizeof(mm_cam_attr_construct_info) * attr_count);
 131         if (hcamcorder->cam_attrs_const_info == NULL) {
 132                 _mmcam_dbg_err("failed to alloc default attribute info");
 133                 free(attrs_const_info);
 134                 attrs_const_info = NULL;
 135                 return 0;
 136         }
 137
 138         /* basic attributes' info */
 139         mm_cam_attr_construct_info temp_info[] = {
 140                 //0
 141                 {
 142                         MM_CAM_MODE,                        /* ID */
 143                         "mode",                             /* Name */
 144                         MMF_VALUE_TYPE_INT,                 /* Type */
 145                         MM_ATTRS_FLAG_RW,                   /* Flag */
 146                         {(void*)MM_CAMCORDER_MODE_VIDEO_CAPTURE},     /* Default value */
 147                         MM_ATTRS_VALID_TYPE_INT_RANGE,      /* Validity type */
 148                         {.int_min = MM_CAMCORDER_MODE_VIDEO_CAPTURE},    /* Validity val1 (min, *array,...) */
 149                         {.int_max = MM_CAMCORDER_MODE_AUDIO},            /* Validity val2 (max, count, ...) */
 150                         NULL,                               /* Runtime setting function of the attribute */
 151                 },
 152                 {
 153                         MM_CAM_AUDIO_DEVICE,
 154                         "audio-device",
 155                         MMF_VALUE_TYPE_INT,
 156                         MM_ATTRS_FLAG_RW,
 157                         {(void*)MM_AUDIO_DEVICE_MIC},
 158                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 159                         {NULL},
 160                         {0},
 161                         NULL,
 162                 },
 163                 {
 164                         MM_CAM_CAMERA_DEVICE_COUNT,
 165                         "camera-device-count",
 166                         MMF_VALUE_TYPE_INT,
 167                         MM_ATTRS_FLAG_RW,
 168                         {(void*)MM_VIDEO_DEVICE_NUM},
 169                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 170                         {.int_min = MM_VIDEO_DEVICE_NONE},
 171                         {.int_max = MM_VIDEO_DEVICE_NUM},
 172                         NULL,
 173                 },
 174                 {
 175                         MM_CAM_AUDIO_ENCODER,
 176                         "audio-encoder",
 177                         MMF_VALUE_TYPE_INT,
 178                         MM_ATTRS_FLAG_RW,
 179                         {(void*)MM_AUDIO_CODEC_AMR},
 180                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 181                         {NULL},
 182                         {0},
 183                         NULL,
 184                 },
 185                 {
 186                         MM_CAM_VIDEO_ENCODER,
 187                         "video-encoder",
 188                         MMF_VALUE_TYPE_INT,
 189                         MM_ATTRS_FLAG_RW,
 190                         {(void*)MM_VIDEO_CODEC_MPEG4},
 191                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 192                         {NULL},
 193                         {0},
 194                         NULL,
 195                 },
 196                 {
 197                         MM_CAM_IMAGE_ENCODER,
 198                         "image-encoder",
 199                         MMF_VALUE_TYPE_INT,
 200                         MM_ATTRS_FLAG_RW,
 201                         {(void*)MM_IMAGE_CODEC_JPEG},
 202                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 203                         {NULL},
 204                         {0},
 205                         NULL,
 206                 },
 207                 {
 208                         MM_CAM_FILE_FORMAT,
 209                         "file-format",
 210                         MMF_VALUE_TYPE_INT,
 211                         MM_ATTRS_FLAG_RW,
 212                         {(void*)MM_FILE_FORMAT_MP4},
 213                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 214                         {NULL},
 215                         {0},
 216                         NULL,
 217                 },
 218                 {
 219                         MM_CAM_CAMERA_DEVICE_NAME,
 220                         "camera-device-name",
 221                         MMF_VALUE_TYPE_STRING,
 222                         MM_ATTRS_FLAG_RW,
 223                         {(void*)NULL},
 224                         MM_ATTRS_VALID_TYPE_NONE,
 225                         {0},
 226                         {0},
 227                         NULL,
 228                 },
 229                 {
 230                         MM_CAM_AUDIO_SAMPLERATE,
 231                         "audio-samplerate",
 232                         MMF_VALUE_TYPE_INT,
 233                         MM_ATTRS_FLAG_RW,
 234                         {(void*)8000},
 235                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 236                         {.int_min = 0},
 237                         {.int_max = _MMCAMCORDER_MAX_INT},
 238                         NULL,
 239                 },
 240                 {
 241                         MM_CAM_AUDIO_FORMAT,
 242                         "audio-format",
 243                         MMF_VALUE_TYPE_INT,
 244                         MM_ATTRS_FLAG_RW,
 245                         {(void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE},
 246                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 247                         {depth},
 248                         {ARRAY_SIZE(depth)},
 249                         NULL,
 250                 },
 251                 //10
 252                 {
 253                         MM_CAM_AUDIO_CHANNEL,
 254                         "audio-channel",
 255                         MMF_VALUE_TYPE_INT,
 256                         MM_ATTRS_FLAG_RW,
 257                         {(void*)2},
 258                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 259                         {.int_min = 1},
 260                         {.int_max = 2},
 261                         NULL,
 262                 },
 263                 {
 264                         MM_CAM_AUDIO_VOLUME,
 265                         "audio-volume",
 266                         MMF_VALUE_TYPE_DOUBLE,
 267                         MM_ATTRS_FLAG_RW,
 268                         {(void*)1},
 269                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 270                         {.double_min = 0.0},
 271                         {.double_max = 10.0},
 272                         _mmcamcorder_commit_audio_volume,
 273                 },
 274                 {
 275                         MM_CAM_AUDIO_INPUT_ROUTE,
 276                         "audio-input-route",
 277                         MMF_VALUE_TYPE_INT,
 278                         MM_ATTRS_FLAG_RW,
 279                         {(void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
 280                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 281                         {.int_min = MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
 282                         {.int_max = MM_AUDIOROUTE_CAPTURE_STEREOMIC_ONLY},
 283                         _mmcamcorder_commit_audio_input_route,
 284                 },
 285                 {
 286                         MM_CAM_FILTER_SCENE_MODE,
 287                         "filter-scene-mode",
 288                         MMF_VALUE_TYPE_INT,
 289                         MM_ATTRS_FLAG_RW,
 290                         {(void*)0},
 291                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 292                         {0},
 293                         {0},
 294                         _mmcamcorder_commit_filter_scene_mode,
 295                 },
 296                 {
 297                         MM_CAM_FILTER_BRIGHTNESS,
 298                         "filter-brightness",
 299                         MMF_VALUE_TYPE_INT,
 300                         MM_ATTRS_FLAG_RW,
 301                         {(void*)1},
 302                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 303                         {.int_min = 0},
 304                         {.int_max = -1},
 305                         _mmcamcorder_commit_filter,
 306                 },
 307                 {
 308                         MM_CAM_FILTER_CONTRAST,
 309                         "filter-contrast",
 310                         MMF_VALUE_TYPE_INT,
 311                         MM_ATTRS_FLAG_RW,
 312                         {(void*)0},
 313                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 314                         {.int_min = 0},
 315                         {.int_max = -1},
 316                         _mmcamcorder_commit_filter,
 317                 },
 318                 {
 319                         MM_CAM_FILTER_WB,
 320                         "filter-wb",
 321                         MMF_VALUE_TYPE_INT,
 322                         MM_ATTRS_FLAG_RW,
 323                         {(void*)0},
 324                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 325                         {0},
 326                         {0},
 327                         _mmcamcorder_commit_filter,
 328                 },
 329                 {
 330                         MM_CAM_FILTER_COLOR_TONE,
 331                         "filter-color-tone",
 332                         MMF_VALUE_TYPE_INT,
 333                         MM_ATTRS_FLAG_RW,
 334                         {(void*)0},
 335                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 336                         {0},
 337                         {0},
 338                         _mmcamcorder_commit_filter,
 339                 },
 340                 {
 341                         MM_CAM_FILTER_SATURATION,
 342                         "filter-saturation",
 343                         MMF_VALUE_TYPE_INT,
 344                         MM_ATTRS_FLAG_RW,
 345                         {(void*)0},
 346                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 347                         {.int_min = 0},
 348                         {.int_max = -1},
 349                         _mmcamcorder_commit_filter,
 350                 },
 351                 {
 352                         MM_CAM_FILTER_HUE,
 353                         "filter-hue",
 354                         MMF_VALUE_TYPE_INT,
 355                         MM_ATTRS_FLAG_RW,
 356                         {(void*)0},
 357                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 358                         {.int_min = 0},
 359                         {.int_max = -1},
 360                         _mmcamcorder_commit_filter,
 361                 },
 362                 //20
 363                 {
 364                         MM_CAM_FILTER_SHARPNESS,
 365                         "filter-sharpness",
 366                         MMF_VALUE_TYPE_INT,
 367                         MM_ATTRS_FLAG_RW,
 368                         {(void*)0},
 369                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 370                         {.int_min = 0},
 371                         {.int_max = -1},
 372                         _mmcamcorder_commit_filter,
 373                 },
 374                 {
 375                         MM_CAM_CAMERA_FORMAT,
 376                         "camera-format",
 377                         MMF_VALUE_TYPE_INT,
 378                         MM_ATTRS_FLAG_RW,
 379                         {(void*)MM_PIXEL_FORMAT_YUYV},
 380                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 381                         {0},
 382                         {0},
 383                         NULL,
 384                 },
 385                 {
 386                         MM_CAM_CAMERA_RECORDING_MOTION_RATE,
 387                         "camera-recording-motion-rate",
 388                         MMF_VALUE_TYPE_DOUBLE,
 389                         MM_ATTRS_FLAG_RW,
 390                         {(void*)1},
 391                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 392                         {.double_min = 0.0},
 393                         {.double_max = _MMCAMCORDER_MAX_DOUBLE},
 394                         _mmcamcorder_commit_camera_recording_motion_rate,
 395                 },
 396                 {
 397                         MM_CAM_CAMERA_FPS,
 398                         "camera-fps",
 399                         MMF_VALUE_TYPE_INT,
 400                         MM_ATTRS_FLAG_RW,
 401                         {(void*)30},
 402                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 403                         {0},
 404                         {1024},
 405                         _mmcamcorder_commit_camera_fps,
 406                 },
 407                 {
 408                         MM_CAM_CAMERA_WIDTH,
 409                         "camera-width",
 410                         MMF_VALUE_TYPE_INT,
 411                         MM_ATTRS_FLAG_RW,
 412                         {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
 413                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 414                         {0},
 415                         {0},
 416                         _mmcamcorder_commit_camera_width,
 417                 },
 418                 {
 419                         MM_CAM_CAMERA_HEIGHT,
 420                         "camera-height",
 421                         MMF_VALUE_TYPE_INT,
 422                         MM_ATTRS_FLAG_RW,
 423                         {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
 424                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 425                         {0},
 426                         {0},
 427                         _mmcamcorder_commit_camera_height,
 428                 },
 429                 {
 430                         MM_CAM_CAMERA_DIGITAL_ZOOM,
 431                         "camera-digital-zoom",
 432                         MMF_VALUE_TYPE_INT,
 433                         MM_ATTRS_FLAG_RW,
 434                         {(void*)10},
 435                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 436                         {.int_min = 0},
 437                         {.int_max = -1},
 438                         _mmcamcorder_commit_camera_zoom,
 439                 },
 440                 {
 441                         MM_CAM_CAMERA_OPTICAL_ZOOM,
 442                         "camera-optical-zoom",
 443                         MMF_VALUE_TYPE_INT,
 444                         MM_ATTRS_FLAG_RW,
 445                         {(void*)0},
 446                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 447                         {.int_min = 0},
 448                         {.int_max = -1},
 449                         _mmcamcorder_commit_camera_zoom,
 450                 },
 451                 {
 452                         MM_CAM_CAMERA_FOCUS_MODE,
 453                         "camera-focus-mode",
 454                         MMF_VALUE_TYPE_INT,
 455                         MM_ATTRS_FLAG_RW,
 456                         {(void*)MM_CAMCORDER_FOCUS_MODE_NONE},
 457                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 458                         {0},
 459                         {0},
 460                         _mmcamcorder_commit_camera_focus_mode,
 461                 },
 462                 {
 463                         MM_CAM_CAMERA_AF_SCAN_RANGE,
 464                         "camera-af-scan-range",
 465                         MMF_VALUE_TYPE_INT,
 466                         MM_ATTRS_FLAG_RW,
 467                         {(void*)0},
 468                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 469                         {0},
 470                         {0},
 471                         _mmcamcorder_commit_camera_af_scan_range,
 472                 },
 473                 //30
 474                 {
 475                         MM_CAM_CAMERA_EXPOSURE_MODE,
 476                         "camera-exposure-mode",
 477                         MMF_VALUE_TYPE_INT,
 478                         MM_ATTRS_FLAG_RW,
 479                         {(void*)0},
 480                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 481                         {0},
 482                         {0},
 483                         _mmcamcorder_commit_camera_capture_mode,
 484                 },
 485                 {
 486                         MM_CAM_CAMERA_EXPOSURE_VALUE,
 487                         "camera-exposure-value",
 488                         MMF_VALUE_TYPE_INT,
 489                         MM_ATTRS_FLAG_RW,
 490                         {(void*)0},
 491                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 492                         {.int_min = 0},
 493                         {.int_max = -1},
 494                         _mmcamcorder_commit_camera_capture_mode,
 495                 },
 496                 {
 497                         MM_CAM_CAMERA_F_NUMBER,
 498                         "camera-f-number",
 499                         MMF_VALUE_TYPE_INT,
 500                         MM_ATTRS_FLAG_RW,
 501                         {(void*)0},
 502                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 503                         {0},
 504                         {0},
 505                         _mmcamcorder_commit_camera_capture_mode,
 506                 },
 507                 {
 508                         MM_CAM_CAMERA_SHUTTER_SPEED,
 509                         "camera-shutter-speed",
 510                         MMF_VALUE_TYPE_INT,
 511                         MM_ATTRS_FLAG_RW,
 512                         {(void*)0},
 513                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 514                         {0},
 515                         {0},
 516                         _mmcamcorder_commit_camera_capture_mode,
 517                 },
 518                 {
 519                         MM_CAM_CAMERA_ISO,
 520                         "camera-iso",
 521                         MMF_VALUE_TYPE_INT,
 522                         MM_ATTRS_FLAG_RW,
 523                         {(void*)0},
 524                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 525                         {0},
 526                         {0},
 527                         _mmcamcorder_commit_camera_capture_mode,
 528                 },
 529                 {
 530                         MM_CAM_CAMERA_WDR,
 531                         "camera-wdr",
 532                         MMF_VALUE_TYPE_INT,
 533                         MM_ATTRS_FLAG_RW,
 534                         {(void*)0},
 535                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 536                         {0},
 537                         {0},
 538                         _mmcamcorder_commit_camera_wdr,
 539                 },
 540                 {
 541                         MM_CAM_CAMERA_ANTI_HANDSHAKE,
 542                         "camera-anti-handshake",
 543                         MMF_VALUE_TYPE_INT,
 544                         MM_ATTRS_FLAG_RW,
 545                         {(void*)0},
 546                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 547                         {0},
 548                         {0},
 549                         _mmcamcorder_commit_camera_anti_handshake,
 550                 },
 551                 {
 552                         MM_CAM_CAMERA_FPS_AUTO,
 553                         "camera-fps-auto",
 554                         MMF_VALUE_TYPE_INT,
 555                         MM_ATTRS_FLAG_RW,
 556                         {(void*)FALSE},
 557                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 558                         {.int_min = 0},
 559                         {.int_max = 1},
 560                         NULL,
 561                 },
 562                 {
 563                         MM_CAM_CAMERA_DELAY_ATTR_SETTING,
 564                         "camera-delay-attr-setting",
 565                         MMF_VALUE_TYPE_INT,
 566                         MM_ATTRS_FLAG_RW,
 567                         {(void*)FALSE},
 568                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 569                         {.int_min = 0},
 570                         {.int_max = 1},
 571                         NULL,
 572                 },
 573                 {
 574                         MM_CAM_AUDIO_ENCODER_BITRATE,
 575                         "audio-encoder-bitrate",
 576                         MMF_VALUE_TYPE_INT,
 577                         MM_ATTRS_FLAG_RW,
 578                         {(void*)0},
 579                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 580                         {.int_min = 0},
 581                         {.int_max = _MMCAMCORDER_MAX_INT},
 582                         NULL,
 583                 },
 584                 // 40
 585                 {
 586                         MM_CAM_VIDEO_ENCODER_BITRATE,
 587                         "video-encoder-bitrate",
 588                         MMF_VALUE_TYPE_INT,
 589                         MM_ATTRS_FLAG_RW,
 590                         {(void*)0},
 591                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 592                         {.int_min = 0},
 593                         {.int_max = _MMCAMCORDER_MAX_INT},
 594                         NULL,
 595                 },
 596                 {
 597                         MM_CAM_IMAGE_ENCODER_QUALITY,
 598                         "image-encoder-quality",
 599                         MMF_VALUE_TYPE_INT,
 600                         MM_ATTRS_FLAG_RW,
 601                         {(void*)95},
 602                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 603                         {.int_min = 0},
 604                         {.int_max = -1},
 605                         _mmcamcorder_commit_image_encoder_quality,
 606                 },
 607                 {
 608                         MM_CAM_CAPTURE_FORMAT,
 609                         "capture-format",
 610                         MMF_VALUE_TYPE_INT,
 611                         MM_ATTRS_FLAG_RW,
 612                         {(void*)MM_PIXEL_FORMAT_ENCODED},
 613                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 614                         {0},
 615                         {0},
 616                         NULL,
 617                 },
 618                 {
 619                         MM_CAM_CAPTURE_WIDTH,
 620                         "capture-width",
 621                         MMF_VALUE_TYPE_INT,
 622                         MM_ATTRS_FLAG_RW,
 623                         {(void*)1600},
 624                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 625                         {0},
 626                         {0},
 627                         _mmcamcorder_commit_capture_width ,
 628                 },
 629                 {
 630                         MM_CAM_CAPTURE_HEIGHT,
 631                         "capture-height",
 632                         MMF_VALUE_TYPE_INT,
 633                         MM_ATTRS_FLAG_RW,
 634                         {(void*)1200},
 635                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 636                         {0},
 637                         {0},
 638                         _mmcamcorder_commit_capture_height,
 639                 },
 640                 {
 641                         MM_CAM_CAPTURE_COUNT,
 642                         "capture-count",
 643                         MMF_VALUE_TYPE_INT,
 644                         MM_ATTRS_FLAG_RW,
 645                         {(void*)1},
 646                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 647                         {.int_min = 0},
 648                         {.int_max = -1},
 649                         _mmcamcorder_commit_capture_count,
 650                 },
 651                 {
 652                         MM_CAM_CAPTURE_INTERVAL,
 653                         "capture-interval",
 654                         MMF_VALUE_TYPE_INT,
 655                         MM_ATTRS_FLAG_RW,
 656                         {(void*)0},
 657                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 658                         {.int_min = 0},
 659                         {.int_max = _MMCAMCORDER_MAX_INT},
 660                         NULL,
 661                 },
 662                 {
 663                         MM_CAM_CAPTURE_BREAK_CONTINUOUS_SHOT,
 664                         "capture-break-cont-shot",
 665                         MMF_VALUE_TYPE_INT,
 666                         MM_ATTRS_FLAG_RW,
 667                         {(void*)FALSE},
 668                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 669                         {.int_min = 0},
 670                         {.int_max = 1},
 671                         _mmcamcorder_commit_capture_break_cont_shot,
 672                 },
 673                 {
 674                         MM_CAM_DISPLAY_HANDLE,
 675                         "display-handle",
 676                         MMF_VALUE_TYPE_DATA,
 677                         MM_ATTRS_FLAG_RW,
 678                         {(void*)NULL},
 679                         MM_ATTRS_VALID_TYPE_NONE,
 680                         {0},
 681                         {0},
 682                         _mmcamcorder_commit_display_handle,
 683                 },
 684                 {
 685                         MM_CAM_DISPLAY_DEVICE,
 686                         "display-device",
 687                         MMF_VALUE_TYPE_INT,
 688                         MM_ATTRS_FLAG_RW,
 689                         {(void*)MM_DISPLAY_DEVICE_MAINLCD},
 690                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 691                         {0},
 692                         {0},
 693                         NULL,
 694                 },
 695                 // 50
 696                 {
 697                         MM_CAM_DISPLAY_SURFACE,
 698                         "display-surface",
 699                         MMF_VALUE_TYPE_INT,
 700                         MM_ATTRS_FLAG_RW,
 701                         {(void*)MM_DISPLAY_SURFACE_OVERLAY},
 702                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 703                         {0},
 704                         {0},
 705                         NULL,
 706                 },
 707                 {
 708                         MM_CAM_DISPLAY_RECT_X,
 709                         "display-rect-x",
 710                         MMF_VALUE_TYPE_INT,
 711                         MM_ATTRS_FLAG_RW,
 712                         {(void*)0},
 713                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 714                         {.int_min = 0},
 715                         {.int_max = _MMCAMCORDER_MAX_INT},
 716                         _mmcamcorder_commit_display_rect,
 717                 },
 718                 {
 719                         MM_CAM_DISPLAY_RECT_Y,
 720                         "display-rect-y",
 721                         MMF_VALUE_TYPE_INT,
 722                         MM_ATTRS_FLAG_RW,
 723                         {(void*)0},
 724                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 725                         {.int_min = 0},
 726                         {.int_max = _MMCAMCORDER_MAX_INT},
 727                         _mmcamcorder_commit_display_rect,
 728                 },
 729                 {
 730                         MM_CAM_DISPLAY_RECT_WIDTH,
 731                         "display-rect-width",
 732                         MMF_VALUE_TYPE_INT,
 733                         MM_ATTRS_FLAG_RW,
 734                         {(void*)0},
 735                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 736                         {.int_min = 0},
 737                         {.int_max = _MMCAMCORDER_MAX_INT},
 738                         _mmcamcorder_commit_display_rect,
 739                 },
 740                 {
 741                         MM_CAM_DISPLAY_RECT_HEIGHT,
 742                         "display-rect-height",
 743                         MMF_VALUE_TYPE_INT,
 744                         MM_ATTRS_FLAG_RW,
 745                         {(void*)0},
 746                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 747                         {.int_min = 0},
 748                         {.int_max = _MMCAMCORDER_MAX_INT},
 749                         _mmcamcorder_commit_display_rect,
 750                 },
 751                 {
 752                         MM_CAM_DISPLAY_SOURCE_X,
 753                         "display-src-x",
 754                         MMF_VALUE_TYPE_INT,
 755                         MM_ATTRS_FLAG_RW,
 756                         {(void*)0},
 757                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 758                         {.int_min = 0},
 759                         {.int_max = _MMCAMCORDER_MAX_INT},
 760                         NULL,
 761                 },
 762                 {
 763                         MM_CAM_DISPLAY_SOURCE_Y,
 764                         "display-src-y",
 765                         MMF_VALUE_TYPE_INT,
 766                         MM_ATTRS_FLAG_RW,
 767                         {(void*)0},
 768                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 769                         {.int_min = 0},
 770                         {.int_max = _MMCAMCORDER_MAX_INT},
 771                         NULL,
 772                 },
 773                 {
 774                         MM_CAM_DISPLAY_SOURCE_WIDTH,
 775                         "display-src-width",
 776                         MMF_VALUE_TYPE_INT,
 777                         MM_ATTRS_FLAG_RW,
 778                         {(void*)0},
 779                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 780                         {.int_min = 0},
 781                         {.int_max = _MMCAMCORDER_MAX_INT},
 782                         NULL,
 783                 },
 784                 {
 785                         MM_CAM_DISPLAY_SOURCE_HEIGHT,
 786                         "display-src-height",
 787                         MMF_VALUE_TYPE_INT,
 788                         MM_ATTRS_FLAG_RW,
 789                         {(void*)0},
 790                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 791                         {.int_min = 0},
 792                         {.int_max = _MMCAMCORDER_MAX_INT},
 793                         NULL,
 794                 },
 795                 {
 796                         MM_CAM_DISPLAY_ROTATION,
 797                         "display-rotation",
 798                         MMF_VALUE_TYPE_INT,
 799                         MM_ATTRS_FLAG_RW,
 800                         {(void*)MM_DISPLAY_ROTATION_NONE},
 801                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 802                         {.int_min = MM_DISPLAY_ROTATION_NONE},
 803                         {.int_max = MM_DISPLAY_ROTATION_270},
 804                         _mmcamcorder_commit_display_rotation,
 805                 },
 806                 { // 60
 807                         MM_CAM_DISPLAY_VISIBLE,
 808                         "display-visible",
 809                         MMF_VALUE_TYPE_INT,
 810                         MM_ATTRS_FLAG_RW,
 811                         {(void*)1},
 812                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 813                         {visible_values},
 814                         {ARRAY_SIZE(visible_values)},
 815                         _mmcamcorder_commit_display_visible,
 816                 },
 817                 {
 818                         MM_CAM_DISPLAY_SCALE,
 819                         "display-scale",
 820                         MMF_VALUE_TYPE_INT,
 821                         MM_ATTRS_FLAG_RW,
 822                         {(void*)0},
 823                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 824                         {.int_min = MM_DISPLAY_SCALE_DEFAULT},
 825                         {.int_max = MM_DISPLAY_SCALE_TRIPLE_LENGTH},
 826                         _mmcamcorder_commit_display_scale,
 827                 },
 828                 {
 829                         MM_CAM_DISPLAY_GEOMETRY_METHOD,
 830                         "display-geometry-method",
 831                         MMF_VALUE_TYPE_INT,
 832                         MM_ATTRS_FLAG_RW,
 833                         {(void*)0},
 834                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 835                         {.int_min = MM_DISPLAY_METHOD_LETTER_BOX},
 836                         {.int_max = MM_DISPLAY_METHOD_CUSTOM_ROI},
 837                         _mmcamcorder_commit_display_geometry_method,
 838                 },
 839                 {
 840                         MM_CAM_TARGET_FILENAME,
 841                         "target-filename",
 842                         MMF_VALUE_TYPE_STRING,
 843                         MM_ATTRS_FLAG_RW,
 844                         {(void*)NULL},
 845                         MM_ATTRS_VALID_TYPE_NONE,
 846                         {0},
 847                         {0},
 848                         _mmcamcorder_commit_target_filename,
 849                 },
 850                 {
 851                         MM_CAM_TARGET_MAX_SIZE,
 852                         "target-max-size",
 853                         MMF_VALUE_TYPE_INT,
 854                         MM_ATTRS_FLAG_RW,
 855                         {(void*)0},
 856                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 857                         {.int_min = 0},
 858                         {.int_max = _MMCAMCORDER_MAX_INT},
 859                         NULL,
 860                 },
 861                 {
 862                         MM_CAM_TARGET_TIME_LIMIT,
 863                         "target-time-limit",
 864                         MMF_VALUE_TYPE_INT,
 865                         MM_ATTRS_FLAG_RW,
 866                         {(void*)0},
 867                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 868                         {.int_min = 0},
 869                         {.int_max = _MMCAMCORDER_MAX_INT},
 870                         NULL,
 871                 },
 872                 {
 873                         MM_CAM_TAG_ENABLE,
 874                         "tag-enable",
 875                         MMF_VALUE_TYPE_INT,
 876                         MM_ATTRS_FLAG_RW,
 877                         {(void*)0},
 878                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 879                         {.int_min = 0},
 880                         {.int_max = 1},
 881                         NULL,
 882                 },
 883                 {
 884                         MM_CAM_TAG_IMAGE_DESCRIPTION,
 885                         "tag-image-description",
 886                         MMF_VALUE_TYPE_STRING,
 887                         MM_ATTRS_FLAG_RW,
 888                         {(void*)NULL},
 889                         MM_ATTRS_VALID_TYPE_NONE,
 890                         {0},
 891                         {0},
 892                         NULL,
 893                 },
 894                 {
 895                         MM_CAM_TAG_ORIENTATION,
 896                         "tag-orientation",
 897                         MMF_VALUE_TYPE_INT,
 898                         MM_ATTRS_FLAG_RW,
 899                         {(void*)1},
 900                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 901                         {tag_orientation_values},
 902                         {ARRAY_SIZE(tag_orientation_values)},
 903                         NULL,
 904                 },
 905                 {
 906                         MM_CAM_TAG_SOFTWARE,
 907                         "tag-software",
 908                         MMF_VALUE_TYPE_STRING,
 909                         MM_ATTRS_FLAG_RW,
 910                         {(void*)NULL},
 911                         MM_ATTRS_VALID_TYPE_NONE,
 912                         {0},
 913                         {0},
 914                         NULL,
 915                 },
 916                 //70
 917                 {
 918                         MM_CAM_TAG_LATITUDE,
 919                         "tag-latitude",
 920                         MMF_VALUE_TYPE_DOUBLE,
 921                         MM_ATTRS_FLAG_RW,
 922                         {(void*)0},
 923                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 924                         {.double_min = -360.0},
 925                         {.double_max = 360.0},
 926                         NULL,
 927                 },
 928                 {
 929                         MM_CAM_TAG_LONGITUDE,
 930                         "tag-longitude",
 931                         MMF_VALUE_TYPE_DOUBLE,
 932                         MM_ATTRS_FLAG_RW,
 933                         {(void*)0},
 934                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 935                         {.double_min = -360.0},
 936                         {.double_max = 360.0},
 937                         NULL,
 938                 },
 939                 {
 940                         MM_CAM_TAG_ALTITUDE,
 941                         "tag-altitude",
 942                         MMF_VALUE_TYPE_DOUBLE,
 943                         MM_ATTRS_FLAG_RW,
 944                         {(void*)0},
 945                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
 946                         {.double_min = -999999.0},
 947                         {.double_max = 999999.0},
 948                         NULL,
 949                 },
 950                 {
 951                         MM_CAM_STROBE_CONTROL,
 952                         "strobe-control",
 953                         MMF_VALUE_TYPE_INT,
 954                         MM_ATTRS_FLAG_RW,
 955                         {(void*)0},
 956                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 957                         {.int_min = 0},
 958                         {.int_max = -1},
 959                         _mmcamcorder_commit_strobe,
 960                 },
 961                 {
 962                         MM_CAM_STROBE_CAPABILITIES,
 963                         "strobe-capabilities",
 964                         MMF_VALUE_TYPE_INT,
 965                         MM_ATTRS_FLAG_RW,
 966                         {(void*)0},
 967                         MM_ATTRS_VALID_TYPE_INT_RANGE,
 968                         {.int_min = 0},
 969                         {.int_max = -1},
 970                         _mmcamcorder_commit_strobe,
 971                 },
 972                 {
 973                         MM_CAM_STROBE_MODE,
 974                         "strobe-mode",
 975                         MMF_VALUE_TYPE_INT,
 976                         MM_ATTRS_FLAG_RW,
 977                         {(void*)0},
 978                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 979                         {0},
 980                         {0},
 981                         _mmcamcorder_commit_strobe,
 982                 },
 983                 {
 984                         MM_CAM_DETECT_MODE,
 985                         "detect-mode",
 986                         MMF_VALUE_TYPE_INT,
 987                         MM_ATTRS_FLAG_RW,
 988                         {(void*)0},
 989                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
 990                         {0},
 991                         {0},
 992                         _mmcamcorder_commit_detect,
 993                 },
 994                 {
 995                         MM_CAM_DETECT_NUMBER,
 996                         "detect-number",
 997                         MMF_VALUE_TYPE_INT,
 998                         MM_ATTRS_FLAG_RW,
 999                         {(void*)0},
1000                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1001                         {.int_min = 0},
1002                         {.int_max = -1},
1003                         _mmcamcorder_commit_detect,
1004                 },
1005                 {
1006                         MM_CAM_DETECT_FOCUS_SELECT,
1007                         "detect-focus-select",
1008                         MMF_VALUE_TYPE_INT,
1009                         MM_ATTRS_FLAG_RW,
1010                         {(void*)0},
1011                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1012                         {.int_min = 0},
1013                         {.int_max = -1},
1014                         _mmcamcorder_commit_detect,
1015                 },
1016                 {
1017                         MM_CAM_DETECT_SELECT_NUMBER,
1018                         "detect-select-number",
1019                         MMF_VALUE_TYPE_INT,
1020                         MM_ATTRS_FLAG_RW,
1021                         {(void*)0},
1022                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1023                         {.int_min = 0},
1024                         {.int_max = -1},
1025                         _mmcamcorder_commit_detect,
1026                 },
1027                 //80
1028                 {
1029                         MM_CAM_DETECT_STATUS,
1030                         "detect-status",
1031                         MMF_VALUE_TYPE_INT,
1032                         MM_ATTRS_FLAG_RW,
1033                         {(void*)0},
1034                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1035                         {0},
1036                         {0},
1037                         _mmcamcorder_commit_detect,
1038                 },
1039                 {
1040                         MM_CAM_CAPTURE_ZERO_SYSTEMLAG,
1041                         "capture-zero-systemlag",
1042                         MMF_VALUE_TYPE_INT,
1043                         MM_ATTRS_FLAG_RW,
1044                         {(void*)FALSE},
1045                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1046                         {.int_min = 0},
1047                         {.int_max = 1},
1048                         NULL,
1049                 },
1050                 {
1051                         MM_CAM_CAMERA_AF_TOUCH_X,
1052                         "camera-af-touch-x",
1053                         MMF_VALUE_TYPE_INT,
1054                         MM_ATTRS_FLAG_RW,
1055                         {(void*)0},
1056                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1057                         {.int_min = 0},
1058                         {.int_max = _MMCAMCORDER_MAX_INT},
1059                         _mmcamcorder_commit_camera_af_touch_area,
1060                 },
1061                 {
1062                         MM_CAM_CAMERA_AF_TOUCH_Y,
1063                         "camera-af-touch-y",
1064                         MMF_VALUE_TYPE_INT,
1065                         MM_ATTRS_FLAG_RW,
1066                         {(void*)0},
1067                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1068                         {.int_min = 0},
1069                         {.int_max = _MMCAMCORDER_MAX_INT},
1070                         _mmcamcorder_commit_camera_af_touch_area,
1071                 },
1072                 {
1073                         MM_CAM_CAMERA_AF_TOUCH_WIDTH,
1074                         "camera-af-touch-width",
1075                         MMF_VALUE_TYPE_INT,
1076                         MM_ATTRS_FLAG_RW,
1077                         {(void*)0},
1078                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1079                         {.int_min = 0},
1080                         {.int_max = _MMCAMCORDER_MAX_INT},
1081                         _mmcamcorder_commit_camera_af_touch_area,
1082                 },
1083                 {
1084                         MM_CAM_CAMERA_AF_TOUCH_HEIGHT,
1085                         "camera-af-touch-height",
1086                         MMF_VALUE_TYPE_INT,
1087                         MM_ATTRS_FLAG_RW,
1088                         {(void*)0},
1089                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1090                         {.int_min = 0},
1091                         {.int_max = _MMCAMCORDER_MAX_INT},
1092                         _mmcamcorder_commit_camera_af_touch_area,
1093                 },
1094                 {
1095                         MM_CAM_CAMERA_FOCAL_LENGTH,
1096                         "camera-focal-length",
1097                         MMF_VALUE_TYPE_DOUBLE,
1098                         MM_ATTRS_FLAG_RW,
1099                         {(void*)0},
1100                         MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
1101                         {.double_min = 0.0},
1102                         {.double_max = 1000.0},
1103                         _mmcamcorder_commit_camera_capture_mode,
1104                 },
1105                 {
1106                         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
1107                         "recommend-preview-format-for-capture",
1108                         MMF_VALUE_TYPE_INT,
1109                         MM_ATTRS_FLAG_RW,
1110                         {(void*)MM_PIXEL_FORMAT_YUYV},
1111                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1112                         {.int_min = MM_PIXEL_FORMAT_NV12},
1113                         {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1114                         NULL,
1115                 },
1116                 {
1117                         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
1118                         "recommend-preview-format-for-recording",
1119                         MMF_VALUE_TYPE_INT,
1120                         MM_ATTRS_FLAG_RW,
1121                         {(void*)MM_PIXEL_FORMAT_NV12},
1122                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1123                         {.int_min = MM_PIXEL_FORMAT_NV12},
1124                         {.int_max = (MM_PIXEL_FORMAT_NUM-1)},
1125                         NULL,
1126                 },
1127                 {
1128                         MM_CAM_TAG_GPS_ENABLE,
1129                         "tag-gps-enable",
1130                         MMF_VALUE_TYPE_INT,
1131                         MM_ATTRS_FLAG_RW,
1132                         {(void*)FALSE},
1133                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1134                         {.int_min = 0},
1135                         {.int_max = 1},
1136                         NULL,
1137                 },
1138                 // 90
1139                 {
1140                         MM_CAM_TAG_GPS_TIME_STAMP,
1141                         "tag-gps-time-stamp",
1142                         MMF_VALUE_TYPE_DOUBLE,
1143                         MM_ATTRS_FLAG_RW,
1144                         {(void*)0},
1145                         MM_ATTRS_VALID_TYPE_NONE,
1146                         {0},
1147                         {0},
1148                         NULL,
1149                 },
1150                 {
1151                         MM_CAM_TAG_GPS_DATE_STAMP,
1152                         "tag-gps-date-stamp",
1153                         MMF_VALUE_TYPE_STRING,
1154                         MM_ATTRS_FLAG_RW,
1155                         {(void*)NULL},
1156                         MM_ATTRS_VALID_TYPE_NONE,
1157                         {0},
1158                         {0},
1159                         NULL,
1160                 },
1161                 {
1162                         MM_CAM_TAG_GPS_PROCESSING_METHOD,
1163                         "tag-gps-processing-method",
1164                         MMF_VALUE_TYPE_STRING,
1165                         MM_ATTRS_FLAG_RW,
1166                         {(void*)NULL},
1167                         MM_ATTRS_VALID_TYPE_NONE,
1168                         {0},
1169                         {0},
1170                         NULL,
1171                 },
1172                 {
1173                         MM_CAM_CAMERA_ROTATION,
1174                         "camera-rotation",
1175                         MMF_VALUE_TYPE_INT,
1176                         MM_ATTRS_FLAG_RW,
1177                         {(void*)MM_VIDEO_INPUT_ROTATION_NONE},
1178                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1179                         {rotation_list},
1180                         {ARRAY_SIZE(rotation_list)},
1181                         _mmcamcorder_commit_camera_rotate,
1182                 },
1183                 {
1184                         MM_CAM_CAPTURED_SCREENNAIL,
1185                         "captured-screennail",
1186                         MMF_VALUE_TYPE_DATA,
1187                         MM_ATTRS_FLAG_READABLE,
1188                         {(void*)NULL},
1189                         MM_ATTRS_VALID_TYPE_NONE,
1190                         {0},
1191                         {0},
1192                         NULL,
1193                 },
1194                 {
1195                         MM_CAM_CAPTURE_SOUND_ENABLE,
1196                         "capture-sound-enable",
1197                         MMF_VALUE_TYPE_INT,
1198                         MM_ATTRS_FLAG_RW,
1199                         {(void*)TRUE},
1200                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1201                         {.int_min = 0},
1202                         {.int_max = 1},
1203                         _mmcamcorder_commit_capture_sound_enable,
1204                 },
1205                 {
1206                         MM_CAM_RECOMMEND_DISPLAY_ROTATION,
1207                         "recommend-display-rotation",
1208                         MMF_VALUE_TYPE_INT,
1209                         MM_ATTRS_FLAG_RW,
1210                         {(void*)MM_DISPLAY_ROTATION_270},
1211                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1212                         {.int_min = MM_DISPLAY_ROTATION_NONE},
1213                         {.int_max = MM_DISPLAY_ROTATION_270},
1214                         NULL,
1215                 },
1216                 {
1217                         MM_CAM_CAMERA_FLIP,
1218                         "camera-flip",
1219                         MMF_VALUE_TYPE_INT,
1220                         MM_ATTRS_FLAG_RW,
1221                         {(void*)MM_FLIP_NONE},
1222                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1223                         {flip_list},
1224                         {ARRAY_SIZE(flip_list)},
1225                         _mmcamcorder_commit_camera_flip,
1226                 },
1227                 {
1228                         MM_CAM_CAMERA_HDR_CAPTURE,
1229                         "camera-hdr-capture",
1230                         MMF_VALUE_TYPE_INT,
1231                         MM_ATTRS_FLAG_RW,
1232                         {(void*)FALSE},
1233                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1234                         {0},
1235                         {0},
1236                         _mmcamcorder_commit_camera_hdr_capture,
1237                 },
1238                 {
1239                         MM_CAM_DISPLAY_MODE,
1240                         "display-mode",
1241                         MMF_VALUE_TYPE_INT,
1242                         MM_ATTRS_FLAG_RW,
1243                         {(void*)MM_DISPLAY_MODE_DEFAULT},
1244                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1245                         {0},
1246                         {0},
1247                         _mmcamcorder_commit_display_mode,
1248                 },
1249                 //100
1250                 {
1251                         MM_CAM_AUDIO_DISABLE,
1252                         "audio-disable",
1253                         MMF_VALUE_TYPE_INT,
1254                         MM_ATTRS_FLAG_RW,
1255                         {(void*)FALSE},
1256                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1257                         {.int_min = FALSE},
1258                         {.int_max = TRUE},
1259                         _mmcamcorder_commit_audio_disable,
1260                 },
1261                 {
1262                         MM_CAM_RECOMMEND_CAMERA_WIDTH,
1263                         "recommend-camera-width",
1264                         MMF_VALUE_TYPE_INT,
1265                         MM_ATTRS_FLAG_RW,
1266                         {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
1267                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1268                         {0},
1269                         {0},
1270                         NULL,
1271                 },
1272                 {
1273                         MM_CAM_RECOMMEND_CAMERA_HEIGHT,
1274                         "recommend-camera-height",
1275                         MMF_VALUE_TYPE_INT,
1276                         MM_ATTRS_FLAG_RW,
1277                         {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
1278                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1279                         {0},
1280                         {0},
1281                         NULL,
1282                 },
1283                 {
1284                         MM_CAM_CAPTURED_EXIF_RAW_DATA,
1285                         "captured-exif-raw-data",
1286                         MMF_VALUE_TYPE_DATA,
1287                         MM_ATTRS_FLAG_READABLE,
1288                         {(void*)NULL},
1289                         MM_ATTRS_VALID_TYPE_NONE,
1290                         {0},
1291                         {0},
1292                         NULL,
1293                 },
1294                 {
1295                         MM_CAM_DISPLAY_EVAS_SURFACE_SINK,
1296                         "display-evas-surface-sink",
1297                         MMF_VALUE_TYPE_STRING,
1298                         MM_ATTRS_FLAG_READABLE,
1299                         {(void*)NULL},
1300                         MM_ATTRS_VALID_TYPE_NONE,
1301                         {0},
1302                         {0},
1303                         NULL,
1304                 },
1305                 {
1306                         MM_CAM_DISPLAY_EVAS_DO_SCALING,
1307                         "display-evas-do-scaling",
1308                         MMF_VALUE_TYPE_INT,
1309                         MM_ATTRS_FLAG_RW,
1310                         {(void*)TRUE},
1311                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1312                         {.int_min = FALSE},
1313                         {.int_max = TRUE},
1314                         _mmcamcorder_commit_display_evas_do_scaling,
1315                 },
1316                 {
1317                         MM_CAM_CAMERA_FACING_DIRECTION,
1318                         "camera-facing-direction",
1319                         MMF_VALUE_TYPE_INT,
1320                         MM_ATTRS_FLAG_RW,
1321                         {(void*)MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1322                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1323                         {.int_min = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
1324                         {.int_max = MM_CAMCORDER_CAMERA_FACING_DIRECTION_FRONT},
1325                         NULL,
1326                 },
1327                 {
1328                         MM_CAM_DISPLAY_FLIP,
1329                         "display-flip",
1330                         MMF_VALUE_TYPE_INT,
1331                         MM_ATTRS_FLAG_RW,
1332                         {(void*)MM_FLIP_NONE},
1333                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1334                         {.int_min = MM_FLIP_NONE},
1335                         {.int_max = MM_FLIP_BOTH},
1336                         _mmcamcorder_commit_display_flip,
1337                 },
1338                 {
1339                         MM_CAM_CAMERA_VIDEO_STABILIZATION,
1340                         "camera-video-stabilization",
1341                         MMF_VALUE_TYPE_INT,
1342                         MM_ATTRS_FLAG_RW,
1343                         {(void*)MM_CAMCORDER_VIDEO_STABILIZATION_OFF},
1344                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1345                         {0},
1346                         {0},
1347                         _mmcamcorder_commit_camera_video_stabilization,
1348                 },
1349                 {
1350                         MM_CAM_TAG_VIDEO_ORIENTATION,
1351                         "tag-video-orientation",
1352                         MMF_VALUE_TYPE_INT,
1353                         MM_ATTRS_FLAG_RW,
1354                         {(void*)MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1355                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1356                         {.int_min = MM_CAMCORDER_TAG_VIDEO_ORT_NONE},
1357                         {.int_max = MM_CAMCORDER_TAG_VIDEO_ORT_270},
1358                         NULL,
1359                 },
1360                 //110
1361                 {
1362                         MM_CAM_VIDEO_WIDTH,
1363                         "video-width",
1364                         MMF_VALUE_TYPE_INT,
1365                         MM_ATTRS_FLAG_RW,
1366                         {(void*)0},
1367                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1368                         {0},
1369                         {0},
1370                         _mmcamcorder_commit_video_size,
1371                 },
1372                 {
1373                         MM_CAM_VIDEO_HEIGHT,
1374                         "video-height",
1375                         MMF_VALUE_TYPE_INT,
1376                         MM_ATTRS_FLAG_RW,
1377                         {(void*)0},
1378                         MM_ATTRS_VALID_TYPE_INT_ARRAY,
1379                         {0},
1380                         {0},
1381                         _mmcamcorder_commit_video_size,
1382                 },
1383                 {
1384                         MM_CAM_SUPPORT_ZSL_CAPTURE,
1385                         "support-zsl-capture",
1386                         MMF_VALUE_TYPE_INT,
1387                         MM_ATTRS_FLAG_RW,
1388                         {(void*)FALSE},
1389                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1390                         {.int_min = FALSE},
1391                         {.int_max = TRUE},
1392                         NULL,
1393                 },
1394                 {
1395                         MM_CAM_SUPPORT_ZERO_COPY_FORMAT,
1396                         "support-zero-copy-format",
1397                         MMF_VALUE_TYPE_INT,
1398                         MM_ATTRS_FLAG_RW,
1399                         {(void*)FALSE},
1400                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1401                         {.int_min = FALSE},
1402                         {.int_max = TRUE},
1403                         NULL,
1404                 },
1405                 {
1406                         MM_CAM_SUPPORT_MEDIA_PACKET_PREVIEW_CB,
1407                         "support-media-packet-preview-cb",
1408                         MMF_VALUE_TYPE_INT,
1409                         MM_ATTRS_FLAG_RW,
1410                         {(void*)FALSE},
1411                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1412                         {.int_min = FALSE},
1413                         {.int_max = TRUE},
1414                         NULL,
1415                 },
1416                 {
1417                         MM_CAM_ENCODED_PREVIEW_BITRATE,
1418                         "encoded-preview-bitrate",
1419                         MMF_VALUE_TYPE_INT,
1420                         MM_ATTRS_FLAG_RW,
1421                         {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_BITRATE},
1422                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1423                         {.int_min = 0},
1424                         {.int_max = _MMCAMCORDER_MAX_INT},
1425                         _mmcamcorder_commit_encoded_preview_bitrate,
1426                 },
1427                 {
1428                         MM_CAM_ENCODED_PREVIEW_GOP_INTERVAL,
1429                         "encoded-preview-gop-interval",
1430                         MMF_VALUE_TYPE_INT,
1431                         MM_ATTRS_FLAG_RW,
1432                         {(void*)MMCAMCORDER_DEFAULT_ENCODED_PREVIEW_GOP_INTERVAL},
1433                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1434                         {.int_min = 0},
1435                         {.int_max = _MMCAMCORDER_MAX_INT},
1436                         _mmcamcorder_commit_encoded_preview_gop_interval,
1437                 },
1438                 {
1439                         MM_CAM_RECORDER_TAG_ENABLE,
1440                         "recorder-tag-enable",
1441                         MMF_VALUE_TYPE_INT,
1442                         MM_ATTRS_FLAG_RW,
1443                         {(void*)FALSE},
1444                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1445                         {.int_min = FALSE},
1446                         {.int_max = TRUE},
1447                         NULL,
1448                 },
1449                 {
1450                         MM_CAM_DISPLAY_SOCKET_PATH,
1451                         "display-socket-path",
1452                         MMF_VALUE_TYPE_STRING,
1453                         MM_ATTRS_FLAG_RW,
1454                         {(void*)NULL},
1455                         MM_ATTRS_VALID_TYPE_NONE,
1456                         {0},
1457                         {0},
1458                         NULL,
1459                 },
1460                 {
1461                         MM_CAM_PID_FOR_SOUND_FOCUS,
1462                         "pid-for-sound-focus",
1463                         MMF_VALUE_TYPE_INT,
1464                         MM_ATTRS_FLAG_RW,
1465                         {(void*)0},
1466                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1467                         {.int_min = 0},
1468                         {.int_max = _MMCAMCORDER_MAX_INT},
1469                         _mmcamcorder_commit_pid_for_sound_focus,
1470                 },
1471                 //120
1472                 {
1473                         MM_CAM_ROOT_DIRECTORY,
1474                         "root-directory",
1475                         MMF_VALUE_TYPE_STRING,
1476                         MM_ATTRS_FLAG_RW,
1477                         {(void*)NULL},
1478                         MM_ATTRS_VALID_TYPE_NONE,
1479                         {0},
1480                         {0},
1481                         NULL,
1482                 },
1483                 {
1484                         MM_CAM_SOUND_STREAM_TYPE,
1485                         "sound-stream-type",
1486                         MMF_VALUE_TYPE_STRING,
1487                         MM_ATTRS_FLAG_RW,
1488                         {(void*)NULL},
1489                         MM_ATTRS_VALID_TYPE_NONE,
1490                         {0},
1491                         {0},
1492                         NULL,
1493                 },
1494                 {
1495                         MM_CAM_SOUND_STREAM_INDEX,
1496                         "sound-stream-index",
1497                         MMF_VALUE_TYPE_INT,
1498                         MM_ATTRS_FLAG_RW,
1499                         {(void*)-1},
1500                         MM_ATTRS_VALID_TYPE_INT_RANGE,
1501                         {.int_min = -1},
1502                         {.int_max = _MMCAMCORDER_MAX_INT},
1503                         _mmcamcorder_commit_sound_stream_info,
1504                 }
1505         };
1506
1507         memcpy(hcamcorder->cam_attrs_const_info, temp_info, sizeof(mm_cam_attr_construct_info) * attr_count);
1508
1509         for (idx = 0 ; idx < attr_count ; idx++) {
1510                 /* attribute order check. This should be same. */
1511                 if (idx != hcamcorder->cam_attrs_const_info[idx].attrid) {
1512                         _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
1513                         free(attrs_const_info);
1514                         attrs_const_info = NULL;
1515                         free(hcamcorder->cam_attrs_const_info);
1516                         hcamcorder->cam_attrs_const_info = NULL;
1517                         return 0;
1518                 }
1519
1520                 attrs_const_info[idx].name = hcamcorder->cam_attrs_const_info[idx].name;
1521                 attrs_const_info[idx].value_type = hcamcorder->cam_attrs_const_info[idx].value_type;
1522                 attrs_const_info[idx].flags = hcamcorder->cam_attrs_const_info[idx].flags;
1523                 attrs_const_info[idx].default_value = hcamcorder->cam_attrs_const_info[idx].default_value.value_void;
1524         }
1525
1526         /* Camcorder Attributes */
1527         _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
1528
1529         attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
1530                                         attrs_const_info,
1531                                         attr_count,
1532                                         _mmcamcorder_commit_camcorder_attrs,
1533                                         (void *)handle);
1534
1535         free(attrs_const_info);
1536         attrs_const_info = NULL;
1537
1538         if (attrs == 0) {
1539                 _mmcam_dbg_err("Fail to alloc attribute handle");
1540                 free(hcamcorder->cam_attrs_const_info);
1541                 hcamcorder->cam_attrs_const_info = NULL;
1542                 return 0;
1543         }
1544
1545         __mmcamcorder_set_conf_to_valid_info(handle);
1546
1547         for (idx = 0; idx < attr_count; idx++)
1548         {
1549 /*              _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type
1550                         , cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
1551 */
1552                 mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
1553
1554                 switch (hcamcorder->cam_attrs_const_info[idx].validity_type)
1555                 {
1556                         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1557                                 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
1558                                     hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1559                                         mmf_attrs_set_valid_array(attrs, idx,
1560                                                                   (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
1561                                                                   hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1562                                                                   hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1563                                 }
1564                         break;
1565                         case MM_ATTRS_VALID_TYPE_INT_RANGE:
1566                                 mmf_attrs_set_valid_range(attrs, idx,
1567                                                           hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
1568                                                           hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
1569                                                           hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1570                         break;
1571                         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1572                                 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
1573                                     hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1574                                         mmf_attrs_set_valid_double_array(attrs, idx,
1575                                                                          (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
1576                                                                          hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1577                                                                          hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1578                                 }
1579                         break;
1580                         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1581                                 mmf_attrs_set_valid_double_range(attrs, idx,
1582                                                                  hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
1583                                                                  hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
1584                                                                  hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1585                         break;
1586                         case MM_ATTRS_VALID_TYPE_NONE:
1587                         break;
1588                         case MM_ATTRS_VALID_TYPE_INVALID:
1589                         default:
1590                                 _mmcam_dbg_err("Valid type error.");
1591                         break;
1592                 }
1593         }
1594
1595         __mmcamcorder_release_conf_valid_info(handle);
1596
1597         return attrs;
1598 }
1599
1600
1601 void
1602 _mmcamcorder_dealloc_attribute(MMHandleType handle, MMHandleType attrs)
1603 {
1604         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1605
1606         if (hcamcorder == NULL) {
1607                 _mmcam_dbg_err("handle is NULL");
1608                 return;
1609         }
1610
1611         _mmcam_dbg_log("");
1612
1613         if (attrs) {
1614                 mmf_attrs_free(attrs);
1615                 _mmcam_dbg_log("released attribute");
1616         }
1617
1618         if (hcamcorder->cam_attrs_const_info) {
1619                 free(hcamcorder->cam_attrs_const_info);
1620                 hcamcorder->cam_attrs_const_info = NULL;
1621                 _mmcam_dbg_log("released attribute info");
1622         }
1623 }
1624
1625
1626 int
1627 _mmcamcorder_get_attributes(MMHandleType handle,  char **err_attr_name, const char *attribute_name, va_list var_args)
1628 {
1629         MMHandleType attrs = 0;
1630         int ret = MM_ERROR_NONE;
1631
1632         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1633 //      mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1634
1635         attrs = MMF_CAMCORDER_ATTRS(handle);
1636         mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
1637
1638         ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
1639
1640         return ret;
1641 }
1642
1643
1644 int
1645 _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1646 {
1647         MMHandleType attrs = 0;
1648         int ret = MM_ERROR_NONE;
1649         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1650
1651         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1652 //      mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1653
1654         if (!_MMCAMCORDER_TRYLOCK_CMD(handle)) {
1655                 _mmcam_dbg_err("Another command is running.");
1656                 return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1657         }
1658
1659         attrs = MMF_CAMCORDER_ATTRS(handle);
1660         if (attrs) {
1661                 ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
1662         } else {
1663                 _mmcam_dbg_err("handle 0x%x, attrs is NULL, attr name [%s]", handle, attribute_name);
1664                 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1665         }
1666
1667         if (ret == MM_ERROR_NONE) {
1668                 hcamcorder->error_code = MM_ERROR_NONE;
1669                 ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
1670         }
1671
1672         _MMCAMCORDER_UNLOCK_CMD(handle);
1673
1674         if (ret != MM_ERROR_NONE) {
1675                 if (hcamcorder->error_code != MM_ERROR_NONE) {
1676                         _mmcam_dbg_err("error_code is not NONE. origin 0x%x, modified 0x%x", ret, hcamcorder->error_code);
1677                         ret = hcamcorder->error_code;
1678                         hcamcorder->error_code = MM_ERROR_NONE;
1679                 }
1680
1681                 _mmcam_dbg_err("failed error code 0x%x - handle %p", ret, (mmf_camcorder_t *)handle);
1682         }
1683
1684         return ret;
1685 }
1686
1687
1688 int
1689 _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCamAttrsInfo *info)
1690 {
1691         MMHandleType attrs = 0;
1692         MMAttrsInfo attrinfo;
1693         int ret = MM_ERROR_NONE;
1694
1695         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1696         mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1697         mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1698
1699         attrs = MMF_CAMCORDER_ATTRS(handle);
1700         mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1701
1702         ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
1703
1704         if (ret == MM_ERROR_NONE)
1705         {
1706                 memset(info, 0x00, sizeof(MMCamAttrsInfo));
1707                 info->type = attrinfo.type;
1708                 info->flag = attrinfo.flag;
1709                 info->validity_type= attrinfo.validity_type;
1710
1711                 switch(attrinfo.validity_type)
1712                 {
1713                         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1714                                 info->int_array.array = attrinfo.int_array.array;
1715                                 info->int_array.count = attrinfo.int_array.count;
1716                                 info->int_array.def = attrinfo.int_array.dval;
1717                         break;
1718                         case MM_ATTRS_VALID_TYPE_INT_RANGE:
1719                                 info->int_range.min = attrinfo.int_range.min;
1720                                 info->int_range.max = attrinfo.int_range.max;
1721                                 info->int_range.def = attrinfo.int_range.dval;
1722                         break;
1723                         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1724                                 info->double_array.array = attrinfo.double_array.array;
1725                                 info->double_array.count = attrinfo.double_array.count;
1726                                 info->double_array.def = attrinfo.double_array.dval;
1727                         break;
1728                         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1729                                 info->double_range.min = attrinfo.double_range.min;
1730                                 info->double_range.max = attrinfo.double_range.max;
1731                                 info->double_range.def = attrinfo.double_range.dval;
1732                         break;
1733                         case MM_ATTRS_VALID_TYPE_NONE:
1734                         break;
1735                         case MM_ATTRS_VALID_TYPE_INVALID:
1736                         default:
1737                         break;
1738                 }
1739         }
1740
1741         return ret;
1742 }
1743
1744
1745 bool
1746 _mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
1747 {
1748         bool bret = FALSE;
1749         mmf_camcorder_t *hcamcorder = NULL;
1750
1751         mmf_return_val_if_fail(commit_param, FALSE);
1752         mmf_return_val_if_fail(attr_idx >= 0, FALSE);
1753         mmf_return_val_if_fail(attr_name, FALSE);
1754         mmf_return_val_if_fail(value, FALSE);
1755
1756         hcamcorder = MMF_CAMCORDER(commit_param);
1757
1758         if (hcamcorder->cam_attrs_const_info[attr_idx].attr_commit) {
1759                 bret = hcamcorder->cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
1760         } else {
1761                 bret = TRUE;
1762         }
1763
1764         return bret;
1765 }
1766
1767
1768 int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
1769 {
1770         int *format = NULL;
1771         int total_count = 0;
1772
1773         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1774
1775         if (hcamcorder == NULL) {
1776                 _mmcam_dbg_err("handle is NULL");
1777                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1778         }
1779
1780         /* Audio encoder */
1781         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER, &format);
1782         hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = format;
1783         hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = total_count;
1784
1785         /* Video encoder */
1786         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER, &format);
1787         hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = format;
1788         hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = total_count;
1789
1790         /* Image encoder */
1791         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER, &format);
1792         hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = format;
1793         hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = total_count;
1794
1795         /* File format */
1796         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_MUX, &format);
1797         hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = format;
1798         hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = total_count;
1799
1800         return MM_ERROR_NONE;
1801 }
1802
1803
1804 int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
1805 {
1806         int *allocated_memory = NULL;
1807
1808         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1809
1810         if (hcamcorder == NULL) {
1811                 _mmcam_dbg_err("handle is NULL");
1812                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1813         }
1814
1815         _mmcam_dbg_log("START");
1816
1817         /* Audio encoder info */
1818         allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array);
1819         if (allocated_memory) {
1820                 free(allocated_memory);
1821                 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_1.int_array = NULL;
1822                 hcamcorder->cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value_2.count = 0;
1823         }
1824
1825         /* Video encoder info */
1826         allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array);
1827         if (allocated_memory) {
1828                 free(allocated_memory);
1829                 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_1.int_array = NULL;
1830                 hcamcorder->cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value_2.count = 0;
1831         }
1832
1833         /* Image encoder info */
1834         allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array);
1835         if (allocated_memory) {
1836                 free(allocated_memory);
1837                 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_1.int_array = NULL;
1838                 hcamcorder->cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value_2.count = 0;
1839         }
1840
1841         /* File format info */
1842         allocated_memory = (int *)(hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array);
1843         if (allocated_memory) {
1844                 free(allocated_memory);
1845                 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_1.int_array = NULL;
1846                 hcamcorder->cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value_2.count = 0;
1847         }
1848
1849         _mmcam_dbg_log("DONE");
1850
1851         return MM_ERROR_NONE;
1852 }
1853
1854
1855 bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1856 {
1857         MMHandleType attr = 0;
1858         int current_state = MM_CAMCORDER_STATE_NONE;
1859
1860         attr = MMF_CAMCORDER_ATTRS(handle);
1861         mmf_return_val_if_fail(attr, FALSE);
1862
1863         /*_mmcam_dbg_log("(%d)", attr_idx);*/
1864
1865         current_state = _mmcamcorder_get_state(handle);
1866         if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1867                 int flags = MM_ATTRS_FLAG_NONE;
1868                 int capture_width, capture_height;
1869                 MMCamAttrsInfo info;
1870
1871                 mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
1872                 flags = info.flag;
1873
1874                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
1875                         mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &capture_height, NULL);
1876                         capture_width = value->value.i_val;
1877
1878                         /* Check whether they are valid pair */
1879                         return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1880                 }
1881
1882                 return TRUE;
1883         } else {
1884                 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1885                 return FALSE;
1886         }
1887 }
1888
1889
1890 bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1891 {
1892         int current_state = MM_CAMCORDER_STATE_NONE;
1893
1894         current_state = _mmcamcorder_get_state(handle);
1895
1896         if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1897                 int capture_width, capture_height;
1898
1899                 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &capture_width, NULL);
1900                 capture_height = value->value.i_val;
1901
1902                 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1903         } else {
1904                 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1905
1906                 return FALSE;
1907         }
1908 }
1909
1910
1911 bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1912 {
1913         int current_state = _mmcamcorder_get_state( handle);
1914         int ivalue = value->value.i_val;
1915
1916         mmf_camcorder_t        *hcamcorder = MMF_CAMCORDER(handle);
1917         _MMCamcorderSubContext *sc = NULL;
1918         GstCameraControl       *control = NULL;
1919         type_element           *VideosrcElement = NULL;
1920
1921         const char *videosrc_name = NULL;
1922
1923         _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1924                                       CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
1925                                       "VideosrcElement",
1926                                       &VideosrcElement );
1927         _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
1928
1929         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1930         if (!sc)
1931                 return TRUE;
1932
1933         if (ivalue && current_state == MM_CAMCORDER_STATE_CAPTURING) {
1934                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
1935                         _mmcam_dbg_warn("Can't cast Video source into camera control.");
1936                         return TRUE;
1937                 }
1938
1939                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
1940                 if (control) {
1941                         gst_camera_control_set_capture_command(control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT);
1942                         _mmcam_dbg_warn("Commit Break continuous shot : Set command OK. current state[%d]", current_state);
1943                 } else {
1944                         _mmcam_dbg_warn("cast CAMERA_CONTROL failed");
1945                 }
1946         } else {
1947                 _mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state );
1948         }
1949
1950         return TRUE;
1951 }
1952
1953
1954 bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1955 {
1956         int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
1957         int current_state = MM_CAMCORDER_STATE_NONE;
1958
1959         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1960
1961         mmf_return_val_if_fail(hcamcorder, FALSE);
1962
1963         current_state = _mmcamcorder_get_state(handle);
1964         mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
1965
1966         _mmcam_dbg_log("current state %d, mode %d, set count %d",
1967                        current_state, mode, value->value.i_val);
1968
1969         if (mode != MM_CAMCORDER_MODE_AUDIO &&
1970             current_state != MM_CAMCORDER_STATE_CAPTURING) {
1971                 return TRUE;
1972         } else {
1973                 _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
1974                 return FALSE;
1975         }
1976 }
1977
1978
1979 bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1980 {
1981         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1982
1983         mmf_return_val_if_fail(hcamcorder, FALSE);
1984
1985         _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
1986
1987         /* return error when disable shutter sound if policy is TRUE */
1988         if (!value->value.i_val &&
1989             hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
1990                 _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
1991                 return FALSE;
1992         } else {
1993                 _mmcam_dbg_log("set value [%d] success", value->value.i_val);
1994                 return TRUE;
1995         }
1996 }
1997
1998
1999 bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2000 {
2001         int current_state = MM_CAMCORDER_STATE_NONE;
2002         _MMCamcorderSubContext *sc = NULL;
2003         bool bret = FALSE;
2004
2005         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2006         if (!sc) {
2007                 return TRUE;
2008         }
2009
2010         current_state = _mmcamcorder_get_state( handle);
2011
2012         if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED)) {
2013                 double mslNewVal = 0;
2014                 mslNewVal = value->value.d_val;
2015
2016                 if (sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst) {
2017                         if (mslNewVal == 0.0) {
2018                                 /* Because data probe of audio src do the same job, it doesn't need to set mute here. Already null raw data. */
2019                                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", 1.0);
2020                         } else {
2021                                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "mute", FALSE);
2022                                 MMCAMCORDER_G_OBJECT_SET(sc->encode_element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", mslNewVal);
2023                         }
2024                 }
2025
2026                 _mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
2027                 bret = TRUE;
2028         } else {
2029                 _mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
2030                 bret = TRUE;
2031         }
2032
2033         return bret;
2034 }
2035
2036
2037 bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2038 {
2039         MMCamAttrsInfo fps_info;
2040         int resolution_width = 0;
2041         int resolution_height = 0;
2042         int i;
2043         int ret;
2044
2045         _mmcam_dbg_log("FPS(%d)", value->value.i_val);
2046
2047         ret = mm_camcorder_get_attributes(handle, NULL,
2048                                           MMCAM_CAMERA_WIDTH, &resolution_width,
2049                                           MMCAM_CAMERA_HEIGHT, &resolution_height,
2050                                           NULL);
2051
2052         if(ret != MM_ERROR_NONE) {
2053                 _mmcam_dbg_err("FAILED : coult not get resolution values.");
2054                 return FALSE;
2055         }
2056
2057         ret = mm_camcorder_get_fps_list_by_resolution(handle, resolution_width, resolution_height, &fps_info);
2058         if (ret != MM_ERROR_NONE) {
2059                 _mmcam_dbg_err("FAILED : coult not get FPS values by resolution.");
2060                 return FALSE;
2061         }
2062
2063         for (i = 0 ; i < fps_info.int_array.count ; i++) {
2064                 if(value->value.i_val == fps_info.int_array.array[i]) {
2065                         return TRUE;
2066                 }
2067         }
2068
2069         _mmcam_dbg_err("FAILED : %d is not supported FPS", value->value.i_val);
2070         return FALSE;
2071 }
2072
2073
2074 bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2075 {
2076         int current_state = MM_CAMCORDER_STATE_NONE;
2077         _MMCamcorderSubContext *sc = NULL;
2078
2079         mmf_return_val_if_fail(handle, FALSE);
2080
2081         current_state = _mmcamcorder_get_state(handle);
2082
2083         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2084                 _mmcam_dbg_warn("invalid state %d", current_state);
2085                 return FALSE;
2086         }
2087
2088         /* Verify recording motion rate */
2089         if (value->value.d_val > 0.0) {
2090                 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2091                 if (!sc) {
2092                         return TRUE;
2093                 }
2094
2095                 /* set is_slow flag */
2096                 if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
2097                         sc->is_modified_rate = TRUE;
2098                 } else {
2099                         sc->is_modified_rate = FALSE;
2100                 }
2101
2102                 _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
2103                 return TRUE;
2104         } else {
2105                 _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
2106                 return FALSE;
2107         }
2108 }
2109
2110
2111 bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2112 {
2113         MMHandleType attr = 0;
2114         int current_state = MM_CAMCORDER_STATE_NONE;
2115         int ret = 0;
2116         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2117         _MMCamcorderSubContext *sc = NULL;
2118
2119         mmf_return_val_if_fail(hcamcorder, FALSE);
2120
2121         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2122         if (!sc) {
2123                 return TRUE;
2124         }
2125
2126         attr = MMF_CAMCORDER_ATTRS(handle);
2127         mmf_return_val_if_fail(attr, FALSE);
2128
2129         _mmcam_dbg_log("Width(%d)", value->value.i_val);
2130
2131         current_state = _mmcamcorder_get_state(handle);
2132
2133         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2134                 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2135                 return FALSE;
2136         } else {
2137                 int flags = MM_ATTRS_FLAG_NONE;
2138                 MMCamAttrsInfo info;
2139                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, &info);
2140                 flags = info.flag;
2141
2142                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2143                         int width = value->value.i_val;
2144                         int height = 0;
2145                         int preview_format = MM_PIXEL_FORMAT_NV12;
2146                         int codec_type = MM_IMAGE_CODEC_JPEG;
2147
2148                         mm_camcorder_get_attributes(handle, NULL,
2149                                                     MMCAM_CAMERA_HEIGHT, &height,
2150                                                     MMCAM_CAMERA_FORMAT, &preview_format,
2151                                                     MMCAM_IMAGE_ENCODER, &codec_type,
2152                                                     NULL);
2153
2154                         if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2155                                 if (hcamcorder->resolution_changed == FALSE) {
2156                                         _mmcam_dbg_log("no need to restart preview");
2157                                         return TRUE;
2158                                 }
2159
2160                                 hcamcorder->resolution_changed = FALSE;
2161
2162                                 if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
2163                                         _mmcam_dbg_log("restart preview");
2164
2165                                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2166                                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2167
2168                                         _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2169
2170                                         /* get preview format */
2171                                         sc->info_image->preview_format = preview_format;
2172                                         sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2173                                         ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2174
2175                                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2176                                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2177
2178                                         _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2179
2180                                         /* unlock */
2181                                         g_mutex_unlock(&hcamcorder->restart_preview_lock);
2182                                 } else {
2183                                         _mmcam_dbg_err("currently locked for preview restart");
2184                                         return FALSE;
2185                                 }
2186                         } else {
2187                                 /* get preview format */
2188                                 sc->info_image->preview_format = preview_format;
2189                                 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2190                                 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2191                         }
2192
2193                         return ret;
2194                 }
2195
2196                 return TRUE;
2197         }
2198 }
2199
2200
2201 bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2202 {
2203         int ret = 0;
2204         int current_state = MM_CAMCORDER_STATE_NONE;
2205         MMHandleType attr = 0;
2206         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2207         _MMCamcorderSubContext *sc = NULL;
2208
2209         mmf_return_val_if_fail(hcamcorder, FALSE);
2210
2211         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2212         if (!sc) {
2213                 return TRUE;
2214         }
2215
2216         attr = MMF_CAMCORDER_ATTRS(hcamcorder);
2217         mmf_return_val_if_fail(attr, FALSE);
2218
2219         _mmcam_dbg_log("Height(%d)", value->value.i_val);
2220         current_state = _mmcamcorder_get_state(handle);
2221
2222         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2223                 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2224                 return FALSE;
2225         } else {
2226                 int width = 0;
2227                 int height = value->value.i_val;
2228                 int preview_format = MM_PIXEL_FORMAT_NV12;
2229                 int codec_type = MM_IMAGE_CODEC_JPEG;
2230                 int video_stabilization = 0;
2231
2232                 mm_camcorder_get_attributes(handle, NULL,
2233                                             MMCAM_CAMERA_WIDTH, &width,
2234                                             MMCAM_CAMERA_FORMAT, &preview_format,
2235                                             MMCAM_IMAGE_ENCODER, &codec_type,
2236                                             MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
2237                                             NULL);
2238
2239                 sc->info_video->preview_width = width;
2240                 sc->info_video->preview_height = height;
2241
2242                 if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2243                         if (hcamcorder->resolution_changed == FALSE) {
2244                                 _mmcam_dbg_log("no need to restart preview");
2245                                 return TRUE;
2246                         }
2247
2248                         hcamcorder->resolution_changed = FALSE;
2249
2250                         if (g_mutex_trylock(&hcamcorder->restart_preview_lock)) {
2251                                 _mmcam_dbg_log("restart preview");
2252
2253                                 _mmcam_dbg_log("set empty buffers");
2254
2255                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
2256                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
2257
2258                                 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
2259
2260                                 /* get preview format */
2261                                 sc->info_image->preview_format = preview_format;
2262                                 sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2263
2264                                 ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2265
2266                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
2267                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
2268
2269                                 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
2270
2271                                 /* unlock */
2272                                 g_mutex_unlock(&hcamcorder->restart_preview_lock);
2273                         } else {
2274                                 _mmcam_dbg_err("currently locked for preview restart");
2275                                 return FALSE;
2276                         }
2277                 } else {
2278                         /* get preview format */
2279                         sc->info_image->preview_format = preview_format;
2280                         sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codec_type, hcamcorder->use_zero_copy_format);
2281                         ret = _mmcamcorder_set_camera_resolution(handle, width, height);
2282                 }
2283
2284                 return ret;
2285         }
2286 }
2287
2288
2289 bool _mmcamcorder_commit_video_size(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2290 {
2291         int current_state = MM_CAMCORDER_STATE_NONE;
2292         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2293
2294         mmf_return_val_if_fail(hcamcorder, FALSE);
2295
2296         current_state = _mmcamcorder_get_state(handle);
2297         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2298                 _mmcam_dbg_err("Video Resolution can't be changed.(state=%d)", current_state);
2299                 return FALSE;
2300         } else {
2301                 _mmcam_dbg_warn("Video Resolution %d [attr_idx %d] ",
2302                                 value->value.i_val, attr_idx);
2303                 return TRUE;
2304         }
2305 }
2306
2307
2308 bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2309 {
2310         _MMCamcorderSubContext *sc = NULL;
2311         int current_state = MM_CAMCORDER_STATE_NONE;
2312         GstCameraControl *control = NULL;
2313         int zoom_level = value->value.i_val;
2314         int zoom_type;
2315
2316         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2317         if (!sc) {
2318                 return TRUE;
2319         }
2320
2321         _mmcam_dbg_log("(%d)", attr_idx);
2322
2323         current_state = _mmcamcorder_get_state(handle);
2324         if (current_state < MM_CAMCORDER_STATE_READY) {
2325                 _mmcam_dbg_log("will be applied when preview starts");
2326                 return TRUE;
2327         } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2328                 _mmcam_dbg_warn("Can not set while CAPTURING");
2329                 return FALSE;
2330         }
2331
2332         if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) {
2333                 zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
2334         } else {
2335                 zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
2336         }
2337
2338         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2339                 int ret = FALSE;
2340
2341                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2342                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2343                         return TRUE;
2344                 }
2345
2346                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2347                 if (control == NULL) {
2348                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2349                         return FALSE;
2350                 }
2351
2352                 ret = gst_camera_control_set_zoom(control, zoom_type, zoom_level);
2353                 if (ret) {
2354                         _mmcam_dbg_log("Succeed in operating Zoom[%d].", zoom_level);
2355                         return TRUE;
2356                 } else {
2357                         _mmcam_dbg_warn("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
2358                 }
2359         } else {
2360                 _mmcam_dbg_log("pointer of video src is null");
2361         }
2362
2363         return FALSE;
2364 }
2365
2366
2367 bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2368 {
2369         MMHandleType attr = 0;
2370         int current_state = MM_CAMCORDER_STATE_NONE;
2371         _MMCamcorderSubContext *sc = NULL;
2372         GstCameraControl *control = NULL;
2373         int mslVal;
2374         int set_focus_mode = 0;
2375         int cur_focus_mode = 0;
2376         int cur_focus_range = 0;
2377
2378         attr = MMF_CAMCORDER_ATTRS(handle);
2379         mmf_return_val_if_fail(attr, FALSE);
2380
2381         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2382         if (!sc)
2383                 return TRUE;
2384
2385         _mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
2386
2387         /* check whether set or not */
2388         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2389                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2390                 return TRUE;
2391         }
2392
2393         current_state = _mmcamcorder_get_state(handle);
2394         if (current_state < MM_CAMCORDER_STATE_NULL) {
2395                 _mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
2396                 return TRUE;
2397         }
2398
2399         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2400                 int flags = MM_ATTRS_FLAG_NONE;
2401                 MMCamAttrsInfo info;
2402
2403                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2404                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2405                         return TRUE;
2406                 }
2407
2408                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2409                 if (control == NULL) {
2410                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2411                         return FALSE;
2412                 }
2413
2414                 mslVal = value->value.i_val;
2415                 set_focus_mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
2416
2417                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
2418                 flags = info.flag;
2419
2420                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2421                         if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
2422                                 if (set_focus_mode != cur_focus_mode) {
2423                                         if (gst_camera_control_set_focus(control, set_focus_mode, cur_focus_range)) {
2424                                                 _mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
2425                                                 return TRUE;
2426                                         } else {
2427                                                 _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
2428                                         }
2429                                 } else {
2430                                         _mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
2431                                         return TRUE;
2432                                 }
2433                         } else {
2434                                 _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
2435                         }
2436                 }
2437         } else {
2438                 _mmcam_dbg_log("pointer of video src is null");
2439         }
2440
2441         return TRUE;
2442 }
2443
2444
2445 bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2446 {
2447         _MMCamcorderSubContext *sc = NULL;
2448         GstCameraControl *control = NULL;
2449         int current_state = MM_CAMCORDER_STATE_NONE;
2450         int mslVal = 0;
2451         int newVal = 0;
2452         int cur_focus_mode = 0;
2453         int cur_focus_range = 0;
2454         int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2455         int converted_mode = 0;
2456
2457         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2458         if (!sc)
2459                 return TRUE;
2460
2461         _mmcam_dbg_log("(%d)", attr_idx);
2462
2463         /* check whether set or not */
2464         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2465                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2466                 return TRUE;
2467         }
2468
2469         mslVal = value->value.i_val;
2470         newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
2471
2472         current_state = _mmcamcorder_get_state(handle);
2473         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2474                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2475                 return TRUE;
2476         }
2477
2478         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2479                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2480                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2481                         return TRUE;
2482                 }
2483
2484                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2485                 if (control == NULL) {
2486                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2487                         return FALSE;
2488                 }
2489
2490                 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
2491                 converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
2492
2493                 if (gst_camera_control_get_focus(control, &cur_focus_mode, &cur_focus_range)) {
2494                         if ((newVal != cur_focus_range) || (converted_mode != cur_focus_mode)) {
2495                                 if (gst_camera_control_set_focus(control, converted_mode, newVal)) {
2496                                         //_mmcam_dbg_log("Succeed in setting AF mode[%d]", mslVal);
2497                                         return TRUE;
2498                                 } else {
2499                                         _mmcam_dbg_warn("Failed to set AF mode[%d]", mslVal);
2500                                 }
2501                         } else {
2502                                 //_mmcam_dbg_log("No need to set AF mode. Current[%d]", mslVal);
2503                                 return TRUE;
2504                         }
2505                 } else {
2506                         _mmcam_dbg_warn("Failed to get AF mode, so do not set new AF mode[%d]", mslVal);
2507                 }
2508         } else {
2509                 _mmcam_dbg_log("pointer of video src is null");
2510         }
2511
2512         return FALSE;
2513 }
2514
2515
2516 bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2517 {
2518         _MMCamcorderSubContext *sc = NULL;
2519         GstCameraControl *control = NULL;
2520         GstCameraControlRectType set_area = { 0, 0, 0, 0 };
2521         GstCameraControlRectType get_area = { 0, 0, 0, 0 };
2522
2523         int current_state = MM_CAMCORDER_STATE_NONE;
2524         int ret = FALSE;
2525         int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2526
2527         gboolean do_set = FALSE;
2528
2529         MMCamAttrsInfo info_y;
2530         MMCamAttrsInfo info_w;
2531         MMCamAttrsInfo info_h;
2532
2533         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2534         if (!sc) {
2535                 return TRUE;
2536         }
2537
2538         _mmcam_dbg_log("(%d)", attr_idx);
2539
2540         current_state = _mmcamcorder_get_state(handle);
2541         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2542                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2543                 return TRUE;
2544         }
2545
2546         ret = mm_camcorder_get_attributes(handle, NULL,
2547                                           MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2548                                           NULL);
2549         if (ret != MM_ERROR_NONE) {
2550                 _mmcam_dbg_warn("Failed to get FOCUS MODE.[%x]", ret);
2551                 return FALSE;
2552         }
2553
2554         if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS)) {
2555                 _mmcam_dbg_warn("Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode);
2556                 return FALSE;
2557         }
2558
2559         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2560                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2561                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2562                         return TRUE;
2563                 }
2564
2565                 memset(&info_y, 0x0, sizeof(MMCamAttrsInfo));
2566                 memset(&info_w, 0x0, sizeof(MMCamAttrsInfo));
2567                 memset(&info_h, 0x0, sizeof(MMCamAttrsInfo));
2568
2569                 switch (attr_idx) {
2570                 case MM_CAM_CAMERA_AF_TOUCH_X:
2571                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y);
2572                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2573                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2574                         if (!((info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
2575                                 set_area.x = value->value.i_val;
2576                                 mm_camcorder_get_attributes(handle, NULL,
2577                                                             MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2578                                                             MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2579                                                             MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2580                                                             NULL);
2581                                 do_set = TRUE;
2582                         } else {
2583                                 _mmcam_dbg_log("Just store AF area[x:%d]", value->value.i_val);
2584                                 return TRUE;
2585                         }
2586                         break;
2587                 case MM_CAM_CAMERA_AF_TOUCH_Y:
2588                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2589                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2590                         if (!((info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED)) {
2591                                 set_area.y = value->value.i_val;
2592                                 mm_camcorder_get_attributes(handle, NULL,
2593                                                             MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2594                                                             MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2595                                                             MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2596                                                             NULL);
2597                                 do_set = TRUE;
2598                         } else {
2599                                 _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val );
2600                                 return TRUE;
2601                         }
2602                         break;
2603                 case MM_CAM_CAMERA_AF_TOUCH_WIDTH:
2604                         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2605                         if (!(info_h.flag & MM_ATTRS_FLAG_MODIFIED)) {
2606                                 set_area.width = value->value.i_val;
2607                                 mm_camcorder_get_attributes(handle, NULL,
2608                                                             MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2609                                                             MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2610                                                             MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2611                                                             NULL);
2612                                 do_set = TRUE;
2613                         } else {
2614                                 _mmcam_dbg_log("Just store AF area[width:%d]", value->value.i_val);
2615                                 return TRUE;
2616                         }
2617                         break;
2618                 case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
2619                         set_area.height = value->value.i_val;
2620                         mm_camcorder_get_attributes(handle, NULL,
2621                                                     MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2622                                                     MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2623                                                     MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2624                                                     NULL);
2625                         do_set = TRUE;
2626                         break;
2627                 default:
2628                         break;
2629                 }
2630
2631                 if (do_set) {
2632                         _MMCamcorderVideoInfo *info = sc->info_video;
2633
2634                         if (info == NULL) {
2635                                 _mmcam_dbg_err("video info is NULL");
2636                                 return FALSE;
2637                         }
2638
2639                         control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2640                         if (control == NULL) {
2641                                 _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2642                                 return FALSE;
2643                         }
2644
2645                         /* convert area */
2646                         if (current_state >= MM_CAMCORDER_STATE_RECORDING && info->support_dual_stream == FALSE &&
2647                             (info->preview_width != info->video_width || info->preview_height != info->video_height)) {
2648                                 float ratio_width = 0.0;
2649                                 float ratio_height = 0.0;
2650
2651                                 if (info->preview_width != 0 && info->preview_height != 0) {
2652                                         ratio_width = (float)info->video_width / (float)info->preview_width;
2653                                         ratio_height = (float)info->video_height / (float)info->preview_height;
2654
2655                                         _mmcam_dbg_log("original area %d,%d,%dx%d, resolution ratio : width %f, height %f",
2656                                                        set_area.x, set_area.y, set_area.width, set_area.height, ratio_width, ratio_height);
2657
2658                                         set_area.x = (int)((float)set_area.x * ratio_width);
2659                                         set_area.y = (int)((float)set_area.y * ratio_height);
2660                                         set_area.width = (int)((float)set_area.width * ratio_width);
2661                                         set_area.height = (int)((float)set_area.height * ratio_height);
2662
2663                                         if (set_area.width <= 0) {
2664                                                 set_area.width = 1;
2665                                         }
2666                                         if (set_area.height <= 0) {
2667                                                 set_area.height = 1;
2668                                         }
2669
2670                                         _mmcam_dbg_log("converted area %d,%d,%dx%d",
2671                                                        set_area.x, set_area.y, set_area.width, set_area.height);
2672                                 } else {
2673                                         _mmcam_dbg_warn("invalid preview size %dx%d, skip AF area converting",
2674                                                         info->preview_width, info->preview_height);
2675                                 }
2676                         }
2677
2678                         ret = gst_camera_control_get_auto_focus_area(control, &get_area);
2679                         if (!ret) {
2680                                 _mmcam_dbg_warn( "Failed to get AF area" );
2681                                 return FALSE;
2682                         }
2683
2684                         /* width and height are not supported now */
2685                         if (get_area.x == set_area.x && get_area.y == set_area.y) {
2686                                 _mmcam_dbg_log("No need to set AF area[x,y:%d,%d]",
2687                                                get_area.x, get_area.y);
2688                                 return TRUE;
2689                         }
2690
2691                         ret = gst_camera_control_set_auto_focus_area(control, set_area);
2692                         if (ret) {
2693                                 _mmcam_dbg_log("Succeed to set AF area[%d,%d,%dx%d]",
2694                                                set_area.x, set_area.y, set_area.width, set_area.height);
2695                                 return TRUE;
2696                         } else {
2697                                 _mmcam_dbg_warn("Failed to set AF area[%d,%d,%dx%d]",
2698                                                 set_area.x, set_area.y, set_area.width, set_area.height);
2699                         }
2700                 }
2701         } else {
2702                 _mmcam_dbg_log("pointer of video src is null");
2703         }
2704
2705         return FALSE;
2706 }
2707
2708
2709 bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2710 {
2711         GstCameraControl *control = NULL;
2712         int ivalue = value->value.i_val;
2713         int mslVal1 = 0, mslVal2 = 0;
2714         int newVal1 = 0, newVal2 = 0;
2715         int exposure_type = 0;
2716         int current_state = MM_CAMCORDER_STATE_NONE;
2717         _MMCamcorderSubContext *sc = NULL;
2718
2719         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
2720         gboolean check_scene_mode = FALSE;
2721
2722         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2723         if (!sc)
2724                 return TRUE;
2725
2726         /* check whether set or not */
2727         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2728                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2729                 return TRUE;
2730         }
2731
2732         current_state = _mmcamcorder_get_state( handle);
2733         if (current_state < MM_CAMCORDER_STATE_READY) {
2734                 return TRUE;
2735         }
2736
2737         if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
2738                 exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
2739                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2740                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2741         } else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
2742                 exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
2743                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2744                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2745         } else if (attr_idx == MM_CAM_CAMERA_ISO) {
2746                 exposure_type = GST_CAMERA_CONTROL_ISO;
2747                 mslVal1 = ivalue;
2748                 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2749                 check_scene_mode = TRUE;
2750         } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_MODE) {
2751                 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_MODE;
2752                 mslVal1 = ivalue;
2753                 newVal1 =  _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2754                 check_scene_mode = TRUE;
2755         } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
2756                 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
2757                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2758                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2759         }
2760
2761         if (check_scene_mode) {
2762                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
2763                 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
2764                         _mmcam_dbg_warn("can not set [%d] when scene mode is NOT normal.", attr_idx);
2765                         return FALSE;
2766                 }
2767         }
2768
2769         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2770                 int ret = 0;
2771
2772                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2773                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2774                         return TRUE;
2775                 }
2776
2777                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2778                 if (control == NULL) {
2779                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2780                         return FALSE;
2781                 }
2782
2783                 ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
2784                 if (ret) {
2785                         _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2786                         return TRUE;
2787                 } else {
2788                         _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2789                 }
2790         } else {
2791                 _mmcam_dbg_log("pointer of video src is null");
2792         }
2793
2794         return FALSE;
2795 }
2796
2797
2798 bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2799 {
2800         GstCameraControl *control = NULL;
2801         int mslVal = 0;
2802         int newVal = 0;
2803         int cur_value = 0;
2804         _MMCamcorderSubContext *sc = NULL;
2805         int current_state = MM_CAMCORDER_STATE_NONE;
2806
2807         mmf_return_val_if_fail(handle && value, FALSE);
2808
2809         /* check whether set or not */
2810         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2811                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2812                 return TRUE;
2813         }
2814
2815         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2816         if (!sc) {
2817                 return TRUE;
2818         }
2819
2820         /* check current state */
2821         current_state = _mmcamcorder_get_state( handle);
2822         if (current_state < MM_CAMCORDER_STATE_READY) {
2823                 _mmcam_dbg_log("will be applied when preview starts");
2824                 return TRUE;
2825         } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2826                 _mmcam_dbg_warn("Can not set while CAPTURING");
2827                 return FALSE;
2828         }
2829
2830         mslVal = value->value.i_val;
2831         newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_WDR, mslVal);
2832
2833         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2834                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2835                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2836                         return TRUE;
2837                 }
2838
2839                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2840                 if (control == NULL) {
2841                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
2842                         return FALSE;
2843                 }
2844
2845                 if (gst_camera_control_get_wdr(control, &cur_value)) {
2846                         if (newVal != cur_value) {
2847                                 if (gst_camera_control_set_wdr(control, newVal)) {
2848                                         _mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
2849                                         return TRUE;
2850                                 } else {
2851                                         _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
2852                                 }
2853                         } else {
2854                                 _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
2855                                 return TRUE;
2856                         }
2857                 } else {
2858                         _mmcam_dbg_warn( "Failed to get WDR." );
2859                 }
2860         } else {
2861                 _mmcam_dbg_log("pointer of video src is null");
2862         }
2863
2864         return FALSE;
2865 }
2866
2867
2868 bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2869 {
2870         int current_state = MM_CAMCORDER_STATE_NONE;
2871
2872         /* check whether set or not */
2873         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2874                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2875                 return TRUE;
2876         }
2877
2878         current_state = _mmcamcorder_get_state(handle);
2879         if (current_state < MM_CAMCORDER_STATE_READY) {
2880                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2881                 return TRUE;
2882         } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2883                 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2884                 return FALSE;
2885         }
2886
2887         return _mmcamcorder_set_videosrc_anti_shake(handle, value->value.i_val);
2888 }
2889
2890
2891 bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2892 {
2893         int current_state = MM_CAMCORDER_STATE_NONE;
2894
2895         current_state = _mmcamcorder_get_state(handle);
2896         if (current_state < MM_CAMCORDER_STATE_READY) {
2897                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2898                 return TRUE;
2899         } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2900                 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2901                 return FALSE;
2902         }
2903
2904         return _mmcamcorder_set_videosrc_stabilization(handle, value->value.i_val);
2905 }
2906
2907
2908 bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2909 {
2910         int current_state = MM_CAMCORDER_STATE_NONE;
2911
2912         _mmcam_dbg_log("rotate(%d)", value->value.i_val);
2913
2914         current_state = _mmcamcorder_get_state(handle);
2915
2916         if (current_state > MM_CAMCORDER_STATE_READY) {
2917                 _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
2918                 return FALSE;
2919         } else {
2920                 return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val);
2921         }
2922 }
2923
2924
2925 bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2926 {
2927         int current_state = MM_CAMCORDER_STATE_NONE;
2928
2929         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2930         _MMCamcorderSubContext *sc = NULL;
2931
2932         mmf_return_val_if_fail(handle, FALSE);
2933
2934         /* check type */
2935         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
2936                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
2937                 return FALSE;
2938         }
2939
2940         /* check current state */
2941         current_state = _mmcamcorder_get_state(handle);
2942         if (current_state < MM_CAMCORDER_STATE_READY) {
2943                 _mmcam_dbg_log("NOT initialized. this will be applied later");
2944                 return TRUE;
2945         }
2946
2947         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2948
2949         _mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
2950
2951         if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2952                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
2953                 return TRUE;
2954         } else {
2955                 _mmcam_dbg_err("invalid state %d", current_state);
2956                 return FALSE;
2957         }
2958 }
2959
2960
2961 bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2962 {
2963         _MMCamcorderSubContext *sc = NULL;
2964         const char * filename = NULL;
2965         int size = 0;
2966
2967         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2968         if (!sc) {
2969                 return TRUE;
2970         }
2971
2972         /* get string */
2973         filename = mmf_value_get_string(value, &size);
2974         if (filename == NULL) {
2975                 _mmcam_dbg_err("NULL filename");
2976                 return FALSE;
2977         }
2978
2979         if (sc->info_video) {
2980                 SAFE_G_FREE(sc->info_video->filename);
2981                 sc->info_video->filename = g_strdup(filename);
2982                 if (sc->info_video->filename == NULL) {
2983                         _mmcam_dbg_err("failed to strdup filename [%s]", filename);
2984                         return FALSE;
2985                 }
2986         }
2987
2988         if (sc->encode_element && sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst) {
2989                 _mmcam_dbg_log("new file location set.[%s] filesink %p", filename, sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst);
2990                 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->encode_element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename);
2991                 _mmcam_dbg_log("new file location set.(%s)", filename);
2992         } else {
2993                 _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename);
2994         }
2995
2996         return TRUE;
2997 }
2998
2999
3000
3001
3002 bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3003 {
3004         GstColorBalance *balance = NULL;
3005         GstColorBalanceChannel *Colorchannel = NULL;
3006         const GList *controls = NULL;
3007         const GList *item = NULL;
3008         int newVal = 0;
3009         int mslNewVal = 0;
3010         int current_state = MM_CAMCORDER_STATE_NONE;
3011         const char *control_label = NULL;
3012         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3013         _MMCamcorderSubContext *sc = NULL;
3014
3015         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
3016         gboolean check_scene_mode = FALSE;
3017
3018         if (hcamcorder == NULL) {
3019                 _mmcam_dbg_log("handle is NULL");
3020                 return FALSE;
3021         }
3022
3023         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3024         if (!sc)
3025                 return TRUE;
3026
3027         /* check whether set or not */
3028         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3029                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3030                 return TRUE;
3031         }
3032
3033         current_state = _mmcamcorder_get_state(handle);
3034         if (current_state < MM_CAMCORDER_STATE_READY) {
3035                 _mmcam_dbg_log("will be applied when preview starts");
3036                 return TRUE;
3037         } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3038                 _mmcam_dbg_warn("Can not set while CAPTURING");
3039                 return FALSE;
3040         }
3041
3042         if (value->type != MM_ATTRS_TYPE_INT) {
3043                 _mmcam_dbg_warn("Mismatched value type (%d)", value->type);
3044                 return FALSE;
3045         } else {
3046                 mslNewVal = value->value.i_val;
3047         }
3048
3049         switch (attr_idx) {
3050         case MM_CAM_FILTER_BRIGHTNESS:
3051                 control_label = "brightness";
3052                 check_scene_mode = TRUE;
3053                 break;
3054
3055         case MM_CAM_FILTER_CONTRAST:
3056                 control_label = "contrast";
3057                 break;
3058
3059         case MM_CAM_FILTER_WB:
3060                 control_label = "white balance";
3061                 check_scene_mode = TRUE;
3062                 break;
3063
3064         case MM_CAM_FILTER_COLOR_TONE:
3065                 control_label = "color tone";
3066                 break;
3067
3068         case MM_CAM_FILTER_SATURATION:
3069                 control_label = "saturation";
3070                 check_scene_mode = TRUE;
3071                 break;
3072
3073         case MM_CAM_FILTER_HUE:
3074                 control_label = "hue";
3075                 break;
3076
3077         case MM_CAM_FILTER_SHARPNESS:
3078                 control_label = "sharpness";
3079                 check_scene_mode = TRUE;
3080                 break;
3081         default:
3082                 _mmcam_dbg_err("unknown attribute index %d", attr_idx);
3083                 return FALSE;
3084         }
3085
3086         if (check_scene_mode) {
3087                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
3088                 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
3089                         _mmcam_dbg_warn("can not set %s when scene mode is NOT normal.", control_label);
3090                         return FALSE;
3091                 }
3092         }
3093
3094         newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
3095         if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE) {
3096                 return FALSE;
3097         }
3098
3099         /*_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);*/
3100
3101         if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3102                 _mmcam_dbg_log("Can't cast Video source into color balance.");
3103                 return TRUE;
3104         }
3105
3106         balance = GST_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3107         if (balance == NULL) {
3108                 _mmcam_dbg_err("cast COLOR_BALANCE failed");
3109                 return FALSE;
3110         }
3111
3112         controls = gst_color_balance_list_channels(balance);
3113         if (controls == NULL) {
3114                 _mmcam_dbg_log("There is no list of colorbalance controls");
3115                 return FALSE;
3116         }
3117
3118         for (item = controls ; item && item->data ; item = item->next) {
3119                 Colorchannel = item->data;
3120                 //_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);
3121
3122                 if (!strcmp(Colorchannel->label, control_label)) {
3123                         gst_color_balance_set_value (balance, Colorchannel, newVal);
3124                         _mmcam_dbg_log("Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
3125                         break;
3126                 }
3127         }
3128
3129         if (item == NULL) {
3130                 _mmcam_dbg_err("failed to find color channel item");
3131                 return FALSE;
3132         }
3133
3134         return TRUE;
3135 }
3136
3137
3138 bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3139 {
3140         GstCameraControl *control = NULL;
3141         int mslVal = value->value.i_val;
3142         int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
3143         _MMCamcorderSubContext *sc = NULL;
3144         int current_state = MM_CAMCORDER_STATE_NONE;
3145
3146         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3147         if (!sc)
3148                 return TRUE;
3149
3150         /* check whether set or not */
3151         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3152                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3153                 return TRUE;
3154         }
3155
3156         current_state = _mmcamcorder_get_state(handle);
3157         if (current_state < MM_CAMCORDER_STATE_READY) {
3158                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3159                 return TRUE;
3160         }
3161
3162         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
3163                 int ret = 0;
3164
3165                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3166                         _mmcam_dbg_log("Can't cast Video source into camera control.");
3167                         return TRUE;
3168                 }
3169
3170                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3171                 if (control == NULL) {
3172                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3173                         return FALSE;
3174                 }
3175
3176                 ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
3177                 if (ret) {
3178                         _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
3179
3180                         if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
3181                                 unsigned int i = 0;
3182                                 int attr_idxs[] = {
3183                                         MM_CAM_CAMERA_ISO
3184                                         , MM_CAM_FILTER_BRIGHTNESS
3185                                         , MM_CAM_FILTER_WB
3186                                         , MM_CAM_FILTER_SATURATION
3187                                         , MM_CAM_FILTER_SHARPNESS
3188                                         , MM_CAM_FILTER_COLOR_TONE
3189                                         , MM_CAM_CAMERA_EXPOSURE_MODE
3190                                 };
3191                                 mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
3192
3193                                 for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
3194                                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
3195                                                 mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
3196                                         }
3197                                 }
3198                         }
3199
3200                         return TRUE;
3201                 } else {
3202                         _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
3203                 }
3204         } else {
3205                 _mmcam_dbg_warn("pointer of video src is null");
3206         }
3207
3208         return FALSE;
3209 }
3210
3211
3212 bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3213 {
3214         _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
3215         return TRUE;
3216 }
3217
3218
3219 bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3220 {
3221         _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
3222
3223         return TRUE;
3224 }
3225
3226
3227 bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3228 {
3229         int current_state = MM_CAMCORDER_STATE_NONE;
3230
3231         current_state = _mmcamcorder_get_state(handle);
3232         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3233                 _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
3234                 return FALSE;
3235         } else {
3236                 _mmcam_dbg_log("Disable AUDIO when Recording");
3237                 return TRUE;
3238         }
3239 }
3240
3241
3242 bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3243 {
3244         int current_state = MM_CAMCORDER_STATE_NONE;
3245         const char *videosink_name = NULL;
3246         void *p_handle = NULL;
3247
3248         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3249         _MMCamcorderSubContext *sc = NULL;
3250
3251         mmf_return_val_if_fail(handle, FALSE);
3252
3253         /* check type */
3254         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3255                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3256                 return FALSE;
3257         }
3258
3259         /* check current state */
3260         current_state = _mmcamcorder_get_state(handle);
3261         if (current_state < MM_CAMCORDER_STATE_READY) {
3262                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3263                 return TRUE;
3264         }
3265
3266         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3267
3268         p_handle = value->value.p_val;
3269         if (p_handle) {
3270                 /* get videosink name */
3271                 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3272                 if (videosink_name == NULL) {
3273                         _mmcam_dbg_err("Please check videosink element in configuration file");
3274                         return FALSE;
3275                 }
3276
3277                 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3278
3279                 if (!strcmp(videosink_name, "xvimagesink") ||
3280                     !strcmp(videosink_name, "ximagesink")) {
3281                         _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
3282                         gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
3283                 } else if (!strcmp(videosink_name, "evasimagesink") ||
3284                            !strcmp(videosink_name, "evaspixmapsink")) {
3285                         _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
3286                         MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
3287 #ifdef HAVE_WAYLAND
3288                 } else if (!strcmp(videosink_name, "waylandsink")) {
3289                         MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)p_handle;
3290
3291                         _mmcam_dbg_log("wayland global surface id : %d", wl_info->global_surface_id);
3292
3293                         gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), (guintptr)wl_info->global_surface_id);
3294                         gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst),
3295                                 wl_info->window_x, wl_info->window_y, wl_info->window_width, wl_info->window_height);
3296 #endif /* HAVE_WAYLAND */
3297                 } else {
3298                         _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
3299                         return FALSE;
3300                 }
3301         } else {
3302                 _mmcam_dbg_warn("Display handle is NULL");
3303                 return FALSE;
3304         }
3305
3306         return TRUE;
3307 }
3308
3309
3310 bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3311 {
3312         int current_state = MM_CAMCORDER_STATE_NONE;
3313         const char *videosink_name = NULL;
3314
3315         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3316         _MMCamcorderSubContext *sc = NULL;
3317
3318         mmf_return_val_if_fail(handle, FALSE);
3319
3320         /* check type */
3321         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3322                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3323                 return FALSE;
3324         }
3325
3326         /* check current state */
3327         current_state = _mmcamcorder_get_state(handle);
3328         if (current_state < MM_CAMCORDER_STATE_READY) {
3329                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3330                 return TRUE;
3331         }
3332
3333         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3334
3335         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3336         if (videosink_name == NULL) {
3337                 _mmcam_dbg_err("Please check videosink element in configuration file");
3338                 return FALSE;
3339         }
3340
3341         _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3342
3343         if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink")) {
3344                 _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
3345                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
3346                 return TRUE;
3347         } else {
3348                 _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name);
3349                 return FALSE;
3350         }
3351 }
3352
3353
3354 bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3355 {
3356         int current_state = MM_CAMCORDER_STATE_NONE;
3357
3358         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3359
3360         mmf_return_val_if_fail(handle, FALSE);
3361
3362         /* check type */
3363         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3364                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3365                 return FALSE;
3366         }
3367
3368         /* check current state */
3369         current_state = _mmcamcorder_get_state(handle);
3370         if (current_state < MM_CAMCORDER_STATE_READY) {
3371                 _mmcam_dbg_log("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
3372                 return TRUE;
3373         }
3374
3375         return _mmcamcorder_set_display_rotation(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK);
3376 }
3377
3378
3379 bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3380 {
3381         int current_state = MM_CAMCORDER_STATE_NONE;
3382
3383         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3384
3385         mmf_return_val_if_fail(handle, FALSE);
3386
3387         /* check type */
3388         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3389                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3390                 return FALSE;
3391         }
3392
3393         /* check current state */
3394         current_state = _mmcamcorder_get_state(handle);
3395         if (current_state < MM_CAMCORDER_STATE_READY) {
3396                 _mmcam_dbg_log("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
3397                 return TRUE;
3398         }
3399
3400         return _mmcamcorder_set_display_flip(handle, value->value.i_val, _MMCAMCORDER_VIDEOSINK_SINK);
3401 }
3402
3403
3404 bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3405 {
3406         int current_state = MM_CAMCORDER_STATE_NONE;
3407         const char *videosink_name = NULL;
3408
3409         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3410         _MMCamcorderSubContext *sc = NULL;
3411
3412         mmf_return_val_if_fail(handle, FALSE);
3413
3414         /* check type */
3415         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3416                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3417                 return FALSE;
3418         }
3419
3420         /* check current state */
3421         current_state = _mmcamcorder_get_state(handle);
3422         if (current_state < MM_CAMCORDER_STATE_READY) {
3423                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3424                 return TRUE;
3425         }
3426
3427         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3428
3429         /* Get videosink name */
3430         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3431         if (videosink_name == NULL) {
3432                 _mmcam_dbg_err("Please check videosink element in configuration file");
3433                 return FALSE;
3434         }
3435
3436         if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
3437             !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
3438                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
3439                 _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
3440                 return TRUE;
3441         } else {
3442                 _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name);
3443                 return FALSE;
3444         }
3445 }
3446
3447
3448 bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3449 {
3450         int method = 0;
3451         int current_state = MM_CAMCORDER_STATE_NONE;
3452         const char *videosink_name = NULL;
3453
3454         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3455         _MMCamcorderSubContext *sc = NULL;
3456
3457         mmf_return_val_if_fail(handle, FALSE);
3458
3459         /* check type */
3460         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3461                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3462                 return FALSE;
3463         }
3464
3465         /* check current state */
3466         current_state = _mmcamcorder_get_state(handle);
3467         if (current_state < MM_CAMCORDER_STATE_READY) {
3468                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3469                 return TRUE;
3470         }
3471
3472         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3473
3474         /* Get videosink name */
3475         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3476         if (videosink_name == NULL) {
3477                 _mmcam_dbg_err("Please check videosink element in configuration file");
3478                 return FALSE;
3479         }
3480
3481         if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
3482             !strcmp(videosink_name, "evaspixmapsink") || !strcmp(videosink_name, "evasimagesink")) {
3483                 method = value->value.i_val;
3484                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
3485                 return TRUE;
3486         } else {
3487                 _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name);
3488                 return FALSE;
3489         }
3490 }
3491
3492
3493 bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3494 {
3495         int current_state = MM_CAMCORDER_STATE_NONE;
3496         int method = 0;
3497         const char *videosink_name = NULL;
3498
3499         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3500         _MMCamcorderSubContext *sc = NULL;
3501
3502         mmf_return_val_if_fail(handle, FALSE);
3503
3504         /* check type */
3505         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3506                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3507                 return FALSE;
3508         }
3509
3510         /* check current state */
3511         current_state = _mmcamcorder_get_state(handle);
3512         if (current_state < MM_CAMCORDER_STATE_READY) {
3513                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3514                 return TRUE;
3515         }
3516
3517         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3518
3519         /* check current method */
3520         mm_camcorder_get_attributes(handle, NULL,
3521                                     MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
3522                                     NULL);
3523         if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
3524                 _mmcam_dbg_log("current method[%d] is not supported rect", method);
3525                 return FALSE;
3526         }
3527
3528         /* Get videosink name */
3529         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3530         if (videosink_name == NULL) {
3531                 _mmcam_dbg_err("Please check videosink element in configuration file");
3532                 return FALSE;
3533         }
3534
3535         if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink") ||
3536             !strcmp(videosink_name, "evaspixmapsink")) {
3537                 int rect_x = 0;
3538                 int rect_y = 0;
3539                 int rect_width = 0;
3540                 int rect_height = 0;
3541                 int flags = MM_ATTRS_FLAG_NONE;
3542                 MMCamAttrsInfo info;
3543
3544                 mm_camcorder_get_attributes(handle, NULL,
3545                                             MMCAM_DISPLAY_RECT_X, &rect_x,
3546                                             MMCAM_DISPLAY_RECT_Y, &rect_y,
3547                                             MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
3548                                             MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
3549                                             NULL);
3550                 switch (attr_idx) {
3551                 case MM_CAM_DISPLAY_RECT_X:
3552                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
3553                         flags |= info.flag;
3554                         memset(&info, 0x00, sizeof(info));
3555                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3556                         flags |= info.flag;
3557                         memset(&info, 0x00, sizeof(info));
3558                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3559                         flags |= info.flag;
3560
3561                         rect_x = value->value.i_val;
3562                         break;
3563                 case MM_CAM_DISPLAY_RECT_Y:
3564                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3565                         flags |= info.flag;
3566                         memset(&info, 0x00, sizeof(info));
3567                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3568                         flags |= info.flag;
3569
3570                         rect_y = value->value.i_val;
3571                         break;
3572                 case MM_CAM_DISPLAY_RECT_WIDTH:
3573                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3574                         flags |= info.flag;
3575
3576                         rect_width = value->value.i_val;
3577                         break;
3578                 case MM_CAM_DISPLAY_RECT_HEIGHT:
3579                         rect_height = value->value.i_val;
3580                         break;
3581                 default:
3582                         _mmcam_dbg_err("Wrong attr_idx!");
3583                         return FALSE;
3584                 }
3585
3586                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
3587                         _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)",
3588                                        rect_x, rect_y, rect_width, rect_height);
3589                         g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
3590                                      "dst-roi-x", rect_x,
3591                                      "dst-roi-y", rect_y,
3592                                      "dst-roi-w", rect_width,
3593                                      "dst-roi-h", rect_height,
3594                                      NULL);
3595                 }
3596
3597                 return TRUE;
3598         } else {
3599                 _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name);
3600                 return FALSE;
3601         }
3602 }
3603
3604
3605 bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3606 {
3607         int zoom = 0;
3608         int current_state = MM_CAMCORDER_STATE_NONE;
3609         const char *videosink_name = NULL;
3610         GstElement *vs_element = NULL;
3611
3612         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3613         _MMCamcorderSubContext *sc = NULL;
3614
3615         mmf_return_val_if_fail(handle, FALSE);
3616
3617         /* check type */
3618         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3619                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3620                 return FALSE;
3621         }
3622
3623         /* check current state */
3624         current_state = _mmcamcorder_get_state(handle);
3625         if (current_state < MM_CAMCORDER_STATE_READY) {
3626                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3627                 return TRUE;
3628         }
3629
3630         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3631
3632         /* Get videosink name */
3633         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3634         if (videosink_name == NULL) {
3635                 _mmcam_dbg_err("Please check videosink element in configuration file");
3636                 return FALSE;
3637         }
3638
3639         zoom = value->value.i_val;
3640         if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "waylandsink")) {
3641                 vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
3642
3643                 MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1));
3644                 _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
3645
3646                 return TRUE;
3647         } else {
3648                 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3649                 return FALSE;
3650         }
3651 }
3652
3653
3654 bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3655 {
3656         int current_state = MM_CAMCORDER_STATE_NONE;
3657         int do_scaling = 0;
3658         const char *videosink_name = NULL;
3659
3660         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
3661         _MMCamcorderSubContext *sc = NULL;
3662
3663         mmf_return_val_if_fail(handle, FALSE);
3664
3665         /* check type */
3666         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3667                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3668                 return FALSE;
3669         }
3670
3671         /* check current state */
3672         current_state = _mmcamcorder_get_state(handle);
3673         if (current_state < MM_CAMCORDER_STATE_READY) {
3674                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3675                 return TRUE;
3676         }
3677
3678         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3679
3680         do_scaling = value->value.i_val;
3681
3682         /* Get videosink name */
3683         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3684         if (videosink_name == NULL) {
3685                 _mmcam_dbg_err("Please check videosink element in configuration file");
3686                 return FALSE;
3687         }
3688
3689         if (!strcmp(videosink_name, "evaspixmapsink")) {
3690                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
3691                 _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
3692                 return TRUE;
3693         } else {
3694                 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3695                 return FALSE;
3696         }
3697 }
3698
3699
3700 bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3701 {
3702         bool bret = FALSE;
3703         _MMCamcorderSubContext *sc = NULL;
3704         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3705         int strobe_type, mslVal, newVal, cur_value;
3706         int current_state = MM_CAMCORDER_STATE_NONE;
3707
3708         if (hcamcorder == NULL) {
3709                 _mmcam_dbg_err("NULL handle");
3710                 return FALSE;
3711         }
3712
3713         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3714         if (!sc)
3715                 return TRUE;
3716
3717         /*_mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );*/
3718
3719         mslVal = value->value.i_val;
3720
3721         /* check flash state */
3722         if (attr_idx == MM_CAM_STROBE_MODE) {
3723                 int flash_brightness = 0;
3724
3725                 /* get current flash brightness */
3726                 if (_mmcamcorder_get_device_flash_brightness(hcamcorder->gdbus_conn, &flash_brightness) != MM_ERROR_NONE) {
3727                         _mmcam_dbg_err("_mmcamcorder_get_device_flash_brightness failed");
3728                         hcamcorder->error_code = MM_ERROR_COMMON_INVALID_PERMISSION;
3729                         return FALSE;
3730                 }
3731
3732                 _mmcam_dbg_log("flash brightness %d", flash_brightness);
3733
3734                 if (flash_brightness > 0 &&
3735                     mslVal != MM_CAMCORDER_STROBE_MODE_OFF) {
3736                         /* other module already turned on flash */
3737                         hcamcorder->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
3738                         _mmcam_dbg_err("other module already turned on flash. avoid to set flash mode here.");
3739                         return FALSE;
3740                 } else {
3741                         _mmcam_dbg_log("keep going");
3742                 }
3743         }
3744
3745         /* check state */
3746         current_state = _mmcamcorder_get_state(handle);
3747         if (current_state < MM_CAMCORDER_STATE_READY) {
3748                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3749                 return TRUE;
3750         } else if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
3751                 _mmcam_dbg_warn("invalid state[capturing]");
3752                 hcamcorder->error_code = MM_ERROR_CAMCORDER_INVALID_STATE;
3753                 return FALSE;
3754         }
3755
3756         switch (attr_idx) {
3757         case MM_CAM_STROBE_CONTROL:
3758                 strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
3759                 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_CONTROL, mslVal);
3760                 break;
3761         case MM_CAM_STROBE_CAPABILITIES:
3762                 strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
3763                 newVal = mslVal;
3764                 break;
3765         case MM_CAM_STROBE_MODE:
3766                 /* check whether set or not */
3767                 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3768                         _mmcam_dbg_log("skip set value %d", mslVal);
3769                         return TRUE;
3770                 }
3771
3772                 strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
3773                 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
3774                 break;
3775         default:
3776                 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3777                 return FALSE;
3778         }
3779
3780         GstCameraControl *control = NULL;
3781         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3782                 _mmcam_dbg_err("Can't cast Video source into camera control.");
3783                 bret = FALSE;
3784         } else {
3785                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3786                 if (control == NULL) {
3787                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3788                         return FALSE;
3789                 }
3790
3791                 if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
3792                         if (newVal != cur_value) {
3793                                 if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
3794                                         _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
3795                                         bret = TRUE;
3796                                 } else {
3797                                         _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
3798                                         bret = FALSE;
3799                                 }
3800                         } else {
3801                                 _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
3802                                 bret = TRUE;
3803                         }
3804                 } else {
3805                         _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
3806                         bret = FALSE;
3807                 }
3808         }
3809
3810         return bret;
3811 }
3812
3813
3814 bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3815 {
3816         int ret = 0;
3817         int current_state = MM_CAMCORDER_STATE_NONE;
3818
3819         if ((void *)handle == NULL) {
3820                 _mmcam_dbg_warn("handle is NULL");
3821                 return FALSE;
3822         }
3823
3824         _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
3825
3826         /* state check */
3827         current_state = _mmcamcorder_get_state(handle);
3828         if (current_state > MM_CAMCORDER_STATE_READY) {
3829                 _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
3830                 return FALSE;
3831         } else if (current_state < MM_CAMCORDER_STATE_READY) {
3832                 _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
3833                 return TRUE;
3834         }
3835
3836         ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
3837
3838         _mmcam_dbg_log("ret %d", ret);
3839
3840         return ret;
3841 }
3842
3843
3844 bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3845 {
3846         int set_hdr_mode = MM_CAMCORDER_HDR_OFF;
3847         int current_state = MM_CAMCORDER_STATE_NONE;
3848         _MMCamcorderSubContext *sc = NULL;
3849
3850         if ((void *)handle == NULL) {
3851                 _mmcam_dbg_warn("handle is NULL");
3852                 return FALSE;
3853         }
3854
3855         /*_mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);*/
3856
3857         /* check whether set or not */
3858         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3859                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3860                 return TRUE;
3861         }
3862
3863         /* state check */
3864         current_state = _mmcamcorder_get_state(handle);
3865         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3866                 _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
3867                 return FALSE;
3868         }
3869
3870         if (current_state >= MM_CAMCORDER_STATE_READY) {
3871                 int current_value = 0;
3872
3873                 set_hdr_mode = value->value.i_val;
3874                 mm_camcorder_get_attributes(handle, NULL,
3875                                             MMCAM_CAMERA_HDR_CAPTURE, &current_value,
3876                                             NULL);
3877
3878                 if (set_hdr_mode == current_value) {
3879                         _mmcam_dbg_log("same HDR value : %d, do nothing", set_hdr_mode);
3880                         return TRUE;
3881                 }
3882
3883                 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3884                 if (sc) {
3885                         if (current_state == MM_CAMCORDER_STATE_PREPARE) {
3886                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", TRUE);
3887                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
3888
3889                                 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
3890
3891                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
3892                                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "empty-buffers", FALSE);
3893                         }
3894
3895                         set_hdr_mode = value->value.i_val;
3896                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", set_hdr_mode);
3897                         sc->info_image->hdr_capture_mode = set_hdr_mode;
3898                         _mmcam_dbg_log("set HDR mode : %d", set_hdr_mode);
3899
3900                         if (current_state == MM_CAMCORDER_STATE_PREPARE) {
3901                                 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
3902                         }
3903                 } else {
3904                         _mmcam_dbg_err("sc is NULL. can not set HDR capture");
3905                         return FALSE;
3906                 }
3907         }
3908
3909         return TRUE;
3910 }
3911
3912
3913 bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3914 {
3915         bool bret = FALSE;
3916         _MMCamcorderSubContext *sc = NULL;
3917         int detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3918         int set_value = 0;
3919         int current_value = 0;
3920         int current_state = MM_CAMCORDER_STATE_NONE;
3921         GstCameraControl *control = NULL;
3922
3923         if ((void *)handle == NULL) {
3924                 _mmcam_dbg_warn("handle is NULL");
3925                 return FALSE;
3926         }
3927
3928         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3929         if (!sc) {
3930                 return TRUE;
3931         }
3932
3933         /*_mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);*/
3934
3935         /* state check */
3936         current_state = _mmcamcorder_get_state( handle);
3937         if (current_state < MM_CAMCORDER_STATE_READY) {
3938                 _mmcam_dbg_log("will be applied when preview starts");
3939                 return TRUE;
3940         }
3941
3942         set_value = value->value.i_val;
3943
3944         switch (attr_idx) {
3945         case MM_CAM_DETECT_MODE:
3946                 /* check whether set or not */
3947                 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3948                         _mmcam_dbg_log("skip set value %d", set_value);
3949                         return TRUE;
3950                 }
3951
3952                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3953                 break;
3954         case MM_CAM_DETECT_NUMBER:
3955                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
3956                 break;
3957         case MM_CAM_DETECT_FOCUS_SELECT:
3958                 detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
3959                 break;
3960         case MM_CAM_DETECT_SELECT_NUMBER:
3961                 detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
3962                 break;
3963         case MM_CAM_DETECT_STATUS:
3964                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
3965                 break;
3966         default:
3967                 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3968                 return FALSE;
3969         }
3970
3971         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3972                 _mmcam_dbg_err("Can't cast Video source into camera control.");
3973                 bret = FALSE;
3974         } else {
3975                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3976                 if (control == NULL) {
3977                         _mmcam_dbg_err("cast CAMERA_CONTROL failed");
3978                         return FALSE;
3979                 }
3980
3981                 if (gst_camera_control_get_detect(control, detect_type, &current_value)) {
3982                         if (current_value == set_value) {
3983                                 _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
3984                                 bret = TRUE;
3985                         } else {
3986                                 if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
3987                                         _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
3988                                                         detect_type, set_value);
3989                                         bret = FALSE;
3990                                 } else {
3991                                         _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
3992                                                        detect_type, set_value);
3993                                         bret = TRUE;
3994                                 }
3995                         }
3996                 } else {
3997                         _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
3998                         bret = FALSE;
3999                 }
4000         }
4001
4002         return bret;
4003 }
4004
4005
4006 bool _mmcamcorder_commit_encoded_preview_bitrate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4007 {
4008         int current_state = MM_CAMCORDER_STATE_NONE;
4009         int preview_format = MM_PIXEL_FORMAT_NV12;
4010
4011         if ((void *)handle == NULL) {
4012                 _mmcam_dbg_warn("handle is NULL");
4013                 return FALSE;
4014         }
4015
4016         _mmcam_dbg_log("Commit : encoded preview bitrate - %d", value->value.i_val);
4017
4018         /* check preview format */
4019         mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
4020         if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
4021                 _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
4022                 return FALSE;
4023         }
4024
4025         /* check state */
4026         current_state = _mmcamcorder_get_state(handle);
4027         if (current_state < MM_CAMCORDER_STATE_READY) {
4028                 _mmcam_dbg_log("will be applied when preview starts");
4029                 return TRUE;
4030         }
4031
4032         return _mmcamcorder_set_encoded_preview_bitrate(handle, value->value.i_val);
4033 }
4034
4035
4036 bool _mmcamcorder_commit_encoded_preview_gop_interval(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4037 {
4038         int current_state = MM_CAMCORDER_STATE_NONE;
4039         int preview_format = MM_PIXEL_FORMAT_NV12;
4040
4041         if ((void *)handle == NULL) {
4042                 _mmcam_dbg_warn("handle is NULL");
4043                 return FALSE;
4044         }
4045
4046         _mmcam_dbg_log("Commit : encoded preview I-frame interval - %d", value->value.i_val);
4047
4048         /* check preview format */
4049         mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
4050         if (preview_format != MM_PIXEL_FORMAT_ENCODED_H264) {
4051                 _mmcam_dbg_err("current preview format[%d] is not encoded format", preview_format);
4052                 return FALSE;
4053         }
4054
4055         /* check state */
4056         current_state = _mmcamcorder_get_state(handle);
4057         if (current_state < MM_CAMCORDER_STATE_READY) {
4058                 _mmcam_dbg_log("will be applied when preview starts");
4059                 return TRUE;
4060         }
4061
4062         return _mmcamcorder_set_encoded_preview_gop_interval(handle, value->value.i_val);
4063 }
4064
4065
4066 bool _mmcamcorder_commit_pid_for_sound_focus(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4067 {
4068         int new_pid = 0;
4069         int current_state = MM_CAMCORDER_STATE_NONE;
4070         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4071
4072         if (hcamcorder == NULL) {
4073                 _mmcam_dbg_warn("handle is NULL");
4074                 return FALSE;
4075         }
4076
4077         /* state check */
4078         current_state = _mmcamcorder_get_state( handle);
4079         if (current_state > MM_CAMCORDER_STATE_NULL) {
4080                 _mmcam_dbg_log("invalid state %d", current_state);
4081                 return FALSE;
4082         }
4083
4084         new_pid = value->value.i_val;
4085
4086         _mmcam_dbg_log("Commit : pid %d, current sound_focus_register %d, sound_focus_id %d",
4087                        new_pid, hcamcorder->sound_focus_register, hcamcorder->sound_focus_id);
4088
4089         /* unregister sound focus before set new one */
4090         if (hcamcorder->sound_focus_register && hcamcorder->sound_focus_id > 0) {
4091                 if (MM_ERROR_NONE != mm_sound_unregister_focus(hcamcorder->sound_focus_id)) {
4092                         _mmcam_dbg_err("mm_sound_unregister_focus[id %d] failed", hcamcorder->sound_focus_id);
4093                 } else {
4094                         _mmcam_dbg_log("mm_sound_unregister_focus[id %d] done", hcamcorder->sound_focus_id);
4095                 }
4096         } else {
4097                 _mmcam_dbg_log("no need to unregister sound focus");
4098         }
4099
4100         /* register sound focus */
4101         if (hcamcorder->sound_focus_register) {
4102                 hcamcorder->sound_focus_id = 0;
4103                 if (MM_ERROR_NONE != mm_sound_focus_get_id(&hcamcorder->sound_focus_id)) {
4104                         _mmcam_dbg_err("mm_sound_focus_get_uniq failed");
4105                         hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED;
4106                         return FALSE;
4107                 }
4108
4109                 if (MM_ERROR_NONE != mm_sound_register_focus_for_session(hcamcorder->sound_focus_id,
4110                                                                          new_pid,
4111                                                                          "media",
4112                                                                          _mmcamcorder_sound_focus_cb,
4113                                                                          hcamcorder)) {
4114                         _mmcam_dbg_err("mm_sound_register_focus failed");
4115                         hcamcorder->error_code = MM_ERROR_POLICY_BLOCKED;
4116                         return FALSE;
4117                 }
4118
4119                 _mmcam_dbg_log("mm_sound_register_focus done - id %d, session type %d, flags 0x%x",
4120                                hcamcorder->sound_focus_id, hcamcorder->session_type, hcamcorder->session_flags);
4121         } else {
4122                 _mmcam_dbg_log("no need to register sound focus");
4123         }
4124
4125         return TRUE;
4126 }
4127
4128
4129 bool _mmcamcorder_commit_sound_stream_info(MMHandleType handle, int attr_idx, const mmf_value_t *value)
4130 {
4131         char *stream_type = NULL;
4132         int stream_type_len = 0;
4133         _MMCamcorderSubContext *sc = NULL;
4134
4135         if ((void *)handle == NULL) {
4136                 _mmcam_dbg_warn("handle is NULL");
4137                 return FALSE;
4138         }
4139
4140         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4141         if (!sc || !sc->encode_element ||
4142             !sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst) {
4143                 _mmcam_dbg_log("audiosrc element is not initialized, it will be set later");
4144                 return TRUE;
4145         }
4146
4147         mm_camcorder_get_attributes(handle, NULL,
4148                 MMCAM_SOUND_STREAM_TYPE, &stream_type, &stream_type_len,
4149                 NULL);
4150
4151         if (stream_type == NULL) {
4152                 _mmcam_dbg_err("stream type is not set");
4153                 return FALSE;
4154         }
4155
4156         _mmcam_dbg_log("Commit : sound stream info - type %s", stream_type);
4157
4158         return _mmcamcorder_set_sound_stream_info(sc->encode_element[_MMCAMCORDER_AUDIOSRC_SRC].gst, stream_type, value->value.i_val);
4159 }
4160
4161
4162 static bool
4163 __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
4164 {
4165         mmf_attrs_t *attr = (mmf_attrs_t*)handle;
4166         int flag;
4167
4168         if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
4169                 if (flag == MM_ATTRS_FLAG_NONE) {
4170                         return FALSE;
4171                 }
4172         } else {
4173                 return FALSE;
4174         }
4175
4176         if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
4177                 int min, max;
4178                 mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max);
4179                 if (max < min) {
4180                         return FALSE;
4181                 }
4182         } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
4183                 int count;
4184                 int *array;
4185                 mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array);
4186                 if (count == 0) {
4187                         return FALSE;
4188                 }
4189         }
4190
4191         return TRUE;
4192 }
4193
4194
4195 bool
4196 _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
4197 {
4198         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
4199         mmf_attrs_t *attr = NULL;
4200
4201         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
4202
4203         unsigned int i = 0 ;
4204         int ret = TRUE;
4205         int attr_idxs_default[] = {
4206                 MM_CAM_CAMERA_DIGITAL_ZOOM
4207                 , MM_CAM_CAMERA_OPTICAL_ZOOM
4208                 , MM_CAM_CAMERA_WDR
4209                 , MM_CAM_FILTER_CONTRAST
4210                 , MM_CAM_FILTER_HUE
4211                 , MM_CAM_STROBE_MODE
4212                 , MM_CAM_DETECT_MODE
4213         };
4214
4215         int attr_idxs_extra[] = {
4216                 MM_CAM_CAMERA_ISO
4217                 , MM_CAM_FILTER_BRIGHTNESS
4218                 , MM_CAM_FILTER_WB
4219                 , MM_CAM_FILTER_SATURATION
4220                 , MM_CAM_FILTER_SHARPNESS
4221                 , MM_CAM_FILTER_COLOR_TONE
4222                 , MM_CAM_CAMERA_EXPOSURE_MODE
4223         };
4224
4225         mmf_return_val_if_fail(hcamcorder, FALSE);
4226
4227         _mmcam_dbg_log("Set all attribute again.");
4228
4229         attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
4230         if (attr == NULL) {
4231                 _mmcam_dbg_err("Get attribute handle failed.");
4232                 return FALSE;
4233         } else {
4234                 /* Get Scene mode */
4235                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
4236
4237                 _mmcam_dbg_log("attribute count(%d)", attr->count);
4238
4239                 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
4240                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) {
4241                                 mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
4242                         }
4243                 }
4244
4245                 /* Set extra if scene mode is NORMAL */
4246                 if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
4247                         for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
4248                                 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) {
4249                                         mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
4250                                 }
4251                         }
4252                 } else {
4253                         /* Set scene mode if scene mode is NOT NORMAL */
4254                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) {
4255                                 mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
4256                         }
4257                 }
4258
4259                 if (mmf_attrs_commit((MMHandleType)attr) == -1) {
4260                         ret = FALSE;
4261                 } else {
4262                         ret = TRUE;
4263                 }
4264         }
4265
4266         _mmcam_dbg_log("Done.");
4267
4268         return ret;
4269 }
4270
4271
4272 int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
4273 {
4274         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
4275         int table_size = 0;
4276         int i = 0;
4277         mmf_attrs_t *attr = NULL;
4278         int nerror = MM_ERROR_NONE ;
4279
4280         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
4281
4282         attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
4283         mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
4284
4285         _mmcam_dbg_log("");
4286
4287         table_size = ARRAY_SIZE(readonly_attributes);
4288         _mmcam_dbg_log("%d", table_size);
4289         for (i = 0; i < table_size; i++)
4290         {
4291                 int sCategory = readonly_attributes[i];
4292
4293                 mmf_attribute_set_readonly(&(attr->items[sCategory]));
4294         }
4295
4296         return nerror;
4297 }
4298
4299
4300 int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
4301 {
4302         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
4303         //int table_size = 0;
4304         int i = 0;
4305         mmf_attrs_t *attr = NULL;
4306         type_string_array * disabled_attr = NULL;
4307         int cnt_str = 0;
4308         int nerror = MM_ERROR_NONE ;
4309
4310         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
4311
4312         attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
4313         mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
4314
4315         _mmcam_dbg_log("");
4316
4317         /* add gst_param */
4318         _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
4319                                                  CONFIGURE_CATEGORY_MAIN_GENERAL,
4320                                                  "DisabledAttributes",
4321                                                  &disabled_attr);
4322         if (disabled_attr != NULL && disabled_attr->value) {
4323                 cnt_str = disabled_attr->count;
4324                 for (i = 0; i < cnt_str; i++) {
4325                         int idx = 0;
4326                         _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] );
4327                         nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
4328                         if (nerror == MM_ERROR_NONE) {
4329                                 mmf_attribute_set_disabled(&(attr->items[idx]));
4330                         } else {
4331                                 _mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i);
4332                         }
4333                 }
4334         }
4335
4336         return nerror;
4337 }
4338
4339
4340 /*---------------------------------------------------------------------------------------
4341 |    INTERNAL FUNCTION DEFINITIONS:                                                     |
4342 ---------------------------------------------------------------------------------------*/
4343 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height)
4344 {
4345         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4346         _MMCamcorderSubContext *sc = NULL;
4347         int current_state = MM_CAMCORDER_STATE_NULL;
4348
4349         mmf_return_val_if_fail(hcamcorder, FALSE);
4350
4351         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4352         if (!sc) {
4353                 return TRUE;
4354         }
4355
4356         current_state = _mmcamcorder_get_state(handle);
4357
4358         if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
4359                 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
4360                         _mmcam_dbg_log("set capture width and height [%dx%d] to camera plugin", width, height);
4361                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", width);
4362                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", height);
4363                 } else {
4364                         _mmcam_dbg_warn("invalid state[%d]", current_state);
4365                         return FALSE;
4366                 }
4367         } else {
4368                 _mmcam_dbg_log("element is not created yet");
4369         }
4370
4371         return TRUE;
4372 }
4373
4374
4375 static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
4376 {
4377         #define INIT_VALUE            -1
4378         #define CHECK_COUNT           3
4379
4380         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4381         MMHandleType attrs = 0;
4382
4383         int ret = MM_ERROR_NONE;
4384         int i = 0;
4385         int j = 0;
4386         const char *name = NULL;
4387         const char *check_pair_name[CHECK_COUNT][3] = {
4388                 {MMCAM_CAMERA_WIDTH,  MMCAM_CAMERA_HEIGHT,  "MMCAM_CAMERA_WIDTH and HEIGHT"},
4389                 {MMCAM_CAPTURE_WIDTH, MMCAM_CAPTURE_HEIGHT, "MMCAM_CAPTURE_WIDTH and HEIGHT"},
4390                 {MMCAM_VIDEO_WIDTH, MMCAM_VIDEO_HEIGHT, "MMCAM_VIDEO_WIDTH and HEIGHT"},
4391         };
4392
4393         int check_pair_value[CHECK_COUNT][2] = {
4394                 {INIT_VALUE, INIT_VALUE},
4395                 {INIT_VALUE, INIT_VALUE},
4396                 {INIT_VALUE, INIT_VALUE},
4397         };
4398
4399         if (hcamcorder == NULL || attribute_name == NULL) {
4400                 _mmcam_dbg_warn("handle[%p] or attribute_name[%p] is NULL.",
4401                                 hcamcorder, attribute_name );
4402                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4403         }
4404
4405         if (err_attr_name) {
4406                 *err_attr_name = NULL;
4407         }
4408
4409         //_mmcam_dbg_log( "ENTER" );
4410
4411         attrs = MMF_CAMCORDER_ATTRS(handle);
4412
4413         name = attribute_name;
4414
4415         while (name) {
4416                 int idx = -1;
4417                 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
4418
4419                 /*_mmcam_dbg_log("NAME : %s", name);*/
4420
4421                 /* attribute name check */
4422                 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE) {
4423                         if (err_attr_name) {
4424                                 *err_attr_name = strdup(name);
4425                         }
4426
4427                         if (ret == (int)MM_ERROR_COMMON_OUT_OF_ARRAY) { //to avoid confusing
4428                                 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
4429                         } else {
4430                                 return ret;
4431                         }
4432                 }
4433
4434                 /* type check */
4435                 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE) {
4436                         return ret;
4437                 }
4438
4439                 switch (attr_type) {
4440                 case MM_ATTRS_TYPE_INT:
4441                 {
4442                         gboolean matched = FALSE;
4443                         for (i = 0 ; i < CHECK_COUNT ; i++) {
4444                                 for (j = 0 ; j < 2 ; j++) {
4445                                         if (!strcmp(name, check_pair_name[i][j])) {
4446                                                 check_pair_value[i][j] = va_arg((var_args), int);
4447                                                 _mmcam_dbg_log("%s : %d", check_pair_name[i][j], check_pair_value[i][j]);
4448                                                 matched = TRUE;
4449                                                 break;
4450                                         }
4451                                 }
4452                                 if (matched) {
4453                                         break;
4454                                 }
4455                         }
4456                         if (matched == FALSE) {
4457                                 va_arg((var_args), int);
4458                         }
4459                         break;
4460                 }
4461                 case MM_ATTRS_TYPE_DOUBLE:
4462                         va_arg((var_args), double);
4463                         break;
4464                 case MM_ATTRS_TYPE_STRING:
4465                         va_arg((var_args), char*); /* string */
4466                         va_arg((var_args), int);   /* size */
4467                         break;
4468                 case MM_ATTRS_TYPE_DATA:
4469                         va_arg((var_args), void*); /* data */
4470                         va_arg((var_args), int);   /* size */
4471                         break;
4472                 case MM_ATTRS_TYPE_INVALID:
4473                 default:
4474                         _mmcam_dbg_err("Not supported attribute type(%d, name:%s)", attr_type, name);
4475                         if (err_attr_name) {
4476                                 *err_attr_name = strdup(name);
4477                         }
4478                         return  MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4479                 }
4480
4481                 /* next name */
4482                 name = va_arg(var_args, const char*);
4483         }
4484
4485         for (i = 0 ; i < CHECK_COUNT ; i++) {
4486                 if (check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE) {
4487                         gboolean check_result = FALSE;
4488                         char *err_name = NULL;
4489                         MMCamAttrsInfo attr_info_0, attr_info_1;
4490
4491                         if (check_pair_value[i][0] == INIT_VALUE) {
4492                                 mm_attrs_get_int_by_name(attrs, check_pair_name[i][0], &check_pair_value[i][0]);
4493                                 err_name = strdup(check_pair_name[i][1]);
4494                         } else if (check_pair_value[i][1] == INIT_VALUE) {
4495                                 mm_attrs_get_int_by_name(attrs, check_pair_name[i][1], &check_pair_value[i][1]);
4496                                 err_name = strdup(check_pair_name[i][0]);
4497                         } else {
4498                                 err_name = strdup(check_pair_name[i][2]);
4499                         }
4500
4501                         mm_camcorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
4502                         mm_camcorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
4503
4504                         check_result = FALSE;
4505
4506                         for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) {
4507                                 if (attr_info_0.int_array.array[j] == check_pair_value[i][0] &&
4508                                     attr_info_1.int_array.array[j] == check_pair_value[i][1]) {
4509                                         /*
4510                                         _mmcam_dbg_log("Valid Pair[%s,%s] existed %dx%d[index:%d]",
4511                                                        check_pair_name[i][0], check_pair_name[i][1],
4512                                                        check_pair_value[i][0], check_pair_value[i][1], i);
4513                                                                    */
4514                                         check_result = TRUE;
4515                                         break;
4516                                 }
4517                         }
4518
4519                         if (check_result == FALSE) {
4520                                 _mmcam_dbg_err("INVALID pair[%s,%s] %dx%d",
4521                                                check_pair_name[i][0], check_pair_name[i][1],
4522                                                check_pair_value[i][0], check_pair_value[i][1]);
4523                                 if (err_attr_name) {
4524                                         *err_attr_name = err_name;
4525                                 } else {
4526                                         if (err_name) {
4527                                                 free(err_name);
4528                                                 err_name = NULL;
4529                                         }
4530                                 }
4531
4532                                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4533                         }
4534
4535                         if (!strcmp(check_pair_name[i][0], MMCAM_CAMERA_WIDTH)) {
4536                                 int current_width = 0;
4537                                 int current_height = 0;
4538
4539                                 mm_camcorder_get_attributes(handle, NULL,
4540                                                             MMCAM_CAMERA_WIDTH, &current_width,
4541                                                             MMCAM_CAMERA_HEIGHT, &current_height,
4542                                                             NULL);
4543
4544                                 if (current_width != check_pair_value[i][0] ||
4545                                     current_height != check_pair_value[i][1]) {
4546                                         hcamcorder->resolution_changed = TRUE;
4547                                 } else {
4548                                         hcamcorder->resolution_changed = FALSE;
4549                                 }
4550
4551                                 _mmcam_dbg_log("resolution changed : %d", hcamcorder->resolution_changed);
4552                         }
4553
4554                         if (err_name) {
4555                                 free(err_name);
4556                                 err_name = NULL;
4557                         }
4558                 }
4559         }
4560
4561         /*_mmcam_dbg_log("DONE");*/
4562
4563         return MM_ERROR_NONE;
4564 }
4565
4566
4567 bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
4568 {
4569         MMAttrsInfo info;
4570
4571         if ((void *)handle == NULL) {
4572                 _mmcam_dbg_warn("handle %p is NULL", handle);
4573                 return FALSE;
4574         }
4575
4576         memset(&info, 0x0, sizeof(MMAttrsInfo));
4577
4578         mm_attrs_get_info(MMF_CAMCORDER_ATTRS(handle), attr_index, &info);
4579
4580         switch (info.validity_type) {
4581         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
4582                 /*
4583                 _mmcam_dbg_log("int array count %d", info.int_array.count);
4584                 */
4585                 if (info.int_array.count <= 1) {
4586                         return FALSE;
4587                 }
4588                 break;
4589         case MM_ATTRS_VALID_TYPE_INT_RANGE:
4590                 /*
4591                 _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
4592                 */
4593                 if (info.int_range.min >= info.int_range.max) {
4594                         return FALSE;
4595                 }
4596                 break;
4597         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
4598                 /*
4599                 _mmcam_dbg_log("double array count %d", info.double_array.count);
4600                 */
4601                 if (info.double_array.count <= 1) {
4602                         return FALSE;
4603                 }
4604                 break;
4605         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
4606                 /*
4607                 _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
4608                 */
4609                 if (info.double_range.min >= info.double_range.max) {
4610                         return FALSE;
4611                 }
4612                 break;
4613         default:
4614                 _mmcam_dbg_warn("invalid type %d", info.validity_type);
4615                 return FALSE;
4616         }
4617
4618         return TRUE;
4619 }