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