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 };
1465
1466
1467 /*-----------------------------------------------------------------------
1468 |    LOCAL VARIABLE DEFINITIONS for internal                            |
1469 -----------------------------------------------------------------------*/
1470 /*      Readonly attributes list.
1471 *       If you want to make some attributes read only, write down here.
1472 *       It will make them read only after composing whole attributes.
1473 */
1474
1475 static int readonly_attributes[] = {
1476         MM_CAM_CAMERA_DEVICE_COUNT,
1477         MM_CAM_CAMERA_DEVICE_NAME,
1478         MM_CAM_CAMERA_FACING_DIRECTION,
1479         MM_CAM_CAMERA_SHUTTER_SPEED,
1480         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
1481         MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
1482         MM_CAM_CAPTURED_SCREENNAIL,
1483         MM_CAM_RECOMMEND_DISPLAY_ROTATION,
1484 };
1485
1486 /*-----------------------------------------------------------------------
1487 |    LOCAL FUNCTION PROTOTYPES:                                         |
1488 -----------------------------------------------------------------------*/
1489 /* STATIC INTERNAL FUNCTION */
1490 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height);
1491 static bool __mmcamcorder_set_camera_resolution(MMHandleType handle, int width, int height);
1492 static int  __mmcamcorder_set_conf_to_valid_info(MMHandleType handle);
1493 static int  __mmcamcorder_release_conf_valid_info(MMHandleType handle);
1494 static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx);
1495 static int  __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args);
1496
1497 /*=======================================================================
1498 |  FUNCTION DEFINITIONS                                                 |
1499 =======================================================================*/
1500 /*-----------------------------------------------------------------------
1501 |    GLOBAL FUNCTION DEFINITIONS:                                       |
1502 -----------------------------------------------------------------------*/
1503 MMHandleType
1504 _mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
1505 {
1506         _mmcam_dbg_log( "" );
1507
1508         MMHandleType attrs = 0;
1509         mmf_attrs_construct_info_t *attrs_const_info = NULL;
1510         int attr_count = 0;
1511         int idx;
1512
1513         /* Create attribute constructor */
1514         _mmcam_dbg_log("start");
1515
1516         /* alloc 'mmf_attrs_construct_info_t' */
1517         attr_count = ARRAY_SIZE(cam_attrs_const_info);
1518         attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
1519
1520         if (!attrs_const_info) {
1521                 _mmcam_dbg_err("Fail to alloc constructor.");
1522                 return 0;
1523         }
1524
1525         for (idx = 0 ; idx < attr_count ; idx++) {
1526                 /* attribute order check. This should be same. */
1527                 if (idx != cam_attrs_const_info[idx].attrid) {
1528                         _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
1529                         return 0;
1530                 }
1531
1532                 attrs_const_info[idx].name = cam_attrs_const_info[idx].name;
1533                 attrs_const_info[idx].value_type = cam_attrs_const_info[idx].value_type;
1534                 attrs_const_info[idx].flags = cam_attrs_const_info[idx].flags;
1535                 attrs_const_info[idx].default_value = cam_attrs_const_info[idx].default_value.value_void;
1536         }
1537
1538         /* Camcorder Attributes */
1539         _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
1540
1541         attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
1542                                         attrs_const_info,
1543                                         attr_count,
1544                                         _mmcamcorder_commit_camcorder_attrs,
1545                                         (void *)handle);
1546
1547         free(attrs_const_info);
1548         attrs_const_info = NULL;
1549
1550         if (attrs == 0) {
1551                 _mmcam_dbg_err("Fail to alloc attribute handle");
1552                 return 0;
1553         }
1554
1555         __mmcamcorder_set_conf_to_valid_info(handle);
1556
1557         for (idx = 0; idx < attr_count; idx++)
1558         {
1559 /*              _mmcam_dbg_log("Valid type [%s:%d, %d, %d]", cam_attrs_const_info[idx].name, cam_attrs_const_info[idx].validity_type
1560                         , cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
1561 */
1562                 mmf_attrs_set_valid_type (attrs, idx, cam_attrs_const_info[idx].validity_type);
1563
1564                 switch (cam_attrs_const_info[idx].validity_type)
1565                 {
1566                         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1567                                 if (cam_attrs_const_info[idx].validity_value1 &&
1568                                     cam_attrs_const_info[idx].validity_value2 > 0) {
1569                                         mmf_attrs_set_valid_array(attrs, idx,
1570                                                                   (const int *)(cam_attrs_const_info[idx].validity_value1),
1571                                                                   cam_attrs_const_info[idx].validity_value2,
1572                                                                   (int)(cam_attrs_const_info[idx].default_value.value_int));
1573                                 }
1574                         break;
1575                         case MM_ATTRS_VALID_TYPE_INT_RANGE:
1576                                 mmf_attrs_set_valid_range(attrs, idx,
1577                                                           cam_attrs_const_info[idx].validity_value1,
1578                                                           cam_attrs_const_info[idx].validity_value2,
1579                                                           (int)(cam_attrs_const_info[idx].default_value.value_int));
1580                         break;
1581                         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1582                                 if (cam_attrs_const_info[idx].validity_value1 &&
1583                                     cam_attrs_const_info[idx].validity_value2 > 0) {
1584                                         mmf_attrs_set_valid_double_array(attrs, idx,
1585                                                                          (const double *)(cam_attrs_const_info[idx].validity_value1),
1586                                                                          cam_attrs_const_info[idx].validity_value2,
1587                                                                          (double)(cam_attrs_const_info[idx].default_value.value_double));
1588                                 }
1589                         break;
1590                         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1591                                 mmf_attrs_set_valid_double_range(attrs, idx,
1592                                                                  (double)(cam_attrs_const_info[idx].validity_value1),
1593                                                                  (double)(cam_attrs_const_info[idx].validity_value2),
1594                                                                  (double)(cam_attrs_const_info[idx].default_value.value_double));
1595                         break;
1596                         case MM_ATTRS_VALID_TYPE_NONE:
1597                         break;
1598                         case MM_ATTRS_VALID_TYPE_INVALID:
1599                         default:
1600                                 _mmcam_dbg_err("Valid type error.");
1601                         break;
1602                 }
1603         }
1604
1605         __mmcamcorder_release_conf_valid_info(handle);
1606
1607         return attrs;
1608 }
1609
1610
1611 void
1612 _mmcamcorder_dealloc_attribute(MMHandleType attrs)
1613 {
1614         _mmcam_dbg_log("");
1615
1616         if (attrs)
1617         {
1618                 mmf_attrs_free(attrs);
1619
1620                 _mmcam_dbg_log("released attribute");
1621         }
1622 }
1623
1624
1625 int
1626 _mmcamcorder_get_attributes(MMHandleType handle,  char **err_attr_name, const char *attribute_name, va_list var_args)
1627 {
1628         MMHandleType attrs = 0;
1629         int ret = MM_ERROR_NONE;
1630
1631         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1632 //      mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1633
1634         attrs = MMF_CAMCORDER_ATTRS(handle);
1635         mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
1636
1637         ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
1638
1639         return ret;
1640 }
1641
1642
1643 int
1644 _mmcamcorder_set_attributes(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args)
1645 {
1646         MMHandleType attrs = 0;
1647         int ret = MM_ERROR_NONE;
1648
1649         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1650 //      mmf_return_val_if_fail( err_attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1651
1652         attrs = MMF_CAMCORDER_ATTRS(handle);
1653         mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
1654
1655         __ta__( "__mmcamcorder_check_valid_pair",
1656         ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
1657         );
1658
1659         if (ret == MM_ERROR_NONE) {
1660                 ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
1661         }
1662
1663         return ret;
1664 }
1665
1666
1667 int
1668 _mmcamcorder_get_attribute_info(MMHandleType handle, const char *attr_name, MMCamAttrsInfo *info)
1669 {
1670         MMHandleType attrs = 0;
1671         MMAttrsInfo attrinfo;
1672         int ret = MM_ERROR_NONE;
1673
1674         mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1675         mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1676         mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
1677
1678         attrs = MMF_CAMCORDER_ATTRS(handle);
1679         mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1680
1681         ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
1682
1683         if (ret == MM_ERROR_NONE)
1684         {
1685                 memset(info, 0x00, sizeof(MMCamAttrsInfo));
1686                 info->type = attrinfo.type;
1687                 info->flag = attrinfo.flag;
1688                 info->validity_type= attrinfo.validity_type;
1689
1690                 switch(attrinfo.validity_type)
1691                 {
1692                         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1693                                 info->int_array.array = attrinfo.int_array.array;
1694                                 info->int_array.count = attrinfo.int_array.count;
1695                                 info->int_array.def = attrinfo.int_array.dval;
1696                         break;
1697                         case MM_ATTRS_VALID_TYPE_INT_RANGE:
1698                                 info->int_range.min = attrinfo.int_range.min;
1699                                 info->int_range.max = attrinfo.int_range.max;
1700                                 info->int_range.def = attrinfo.int_range.dval;
1701                         break;
1702                         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1703                                 info->double_array.array = attrinfo.double_array.array;
1704                                 info->double_array.count = attrinfo.double_array.count;
1705                                 info->double_array.def = attrinfo.double_array.dval;
1706                         break;
1707                         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1708                                 info->double_range.min = attrinfo.double_range.min;
1709                                 info->double_range.max = attrinfo.double_range.max;
1710                                 info->double_range.def = attrinfo.double_range.dval;
1711                         break;
1712                         case MM_ATTRS_VALID_TYPE_NONE:
1713                         break;
1714                         case MM_ATTRS_VALID_TYPE_INVALID:
1715                         default:
1716                         break;
1717                 }
1718         }
1719
1720         return ret;
1721 }
1722
1723
1724 //attribute commiter
1725 void
1726 __mmcamcorder_print_attrs (const char *attr_name, const mmf_value_t *value, char* cmt_way)
1727 {
1728         switch(value->type)
1729         {
1730                 case MMF_VALUE_TYPE_INT:
1731                         _mmcam_dbg_log("%s :(%s:%d)", cmt_way, attr_name, value->value.i_val);
1732                 break;
1733                 case MMF_VALUE_TYPE_DOUBLE:
1734                         _mmcam_dbg_log("%s :(%s:%f)", cmt_way, attr_name, value->value.d_val);
1735                 break;
1736                 case MMF_VALUE_TYPE_STRING:
1737                         _mmcam_dbg_log("%s :(%s:%s)", cmt_way, attr_name, value->value.s_val);
1738                 break;
1739                 case MMF_VALUE_TYPE_DATA:
1740                         _mmcam_dbg_log("%s :(%s:%p)", cmt_way, attr_name, value->value.p_val);
1741                 break;
1742         }
1743
1744         return;
1745 }
1746
1747 bool
1748 _mmcamcorder_commit_camcorder_attrs (int attr_idx, const char *attr_name, const mmf_value_t *value, void *commit_param)
1749 {
1750         bool bret = FALSE;
1751
1752         mmf_return_val_if_fail(commit_param, FALSE);
1753         mmf_return_val_if_fail(attr_idx >= 0, FALSE);
1754         mmf_return_val_if_fail(attr_name, FALSE);
1755         mmf_return_val_if_fail(value, FALSE);
1756
1757         if (cam_attrs_const_info[attr_idx].attr_commit)
1758         {
1759 //              _mmcam_dbg_log("Dynamic commit:(%s)", attr_name);
1760                 __mmcamcorder_print_attrs(attr_name, value, "Dynamic");
1761                 bret = cam_attrs_const_info[attr_idx].attr_commit((MMHandleType)commit_param, attr_idx, value);
1762         }
1763         else
1764         {
1765 //              _mmcam_dbg_log("Static commit:(%s)", attr_name);
1766                 __mmcamcorder_print_attrs(attr_name, value, "Static");
1767                 bret = TRUE;
1768         }
1769
1770         return bret;
1771 }
1772
1773
1774 int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
1775 {
1776         int *format = NULL;
1777         int total_count = 0;
1778
1779         /* Audio encoder */
1780         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_AUDIO_ENCODER, &format);
1781         cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value1 = (int)format;
1782         cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value2 = (int)total_count;
1783
1784         /* Video encoder */
1785         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_VIDEO_ENCODER, &format);
1786         cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value1 = (int)format;
1787         cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value2 = (int)total_count;
1788
1789         /* Image encoder */
1790         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_IMAGE_ENCODER, &format);
1791         cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value1 = (int)format;
1792         cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value2 = (int)total_count;
1793
1794         /* File format */
1795         total_count = _mmcamcorder_get_available_format(handle, CONFIGURE_CATEGORY_MAIN_MUX, &format);
1796         cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value1 = (int)format;
1797         cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value2 = (int)total_count;
1798
1799         return MM_ERROR_NONE;
1800 }
1801
1802
1803 int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
1804 {
1805         int *allocated_memory = NULL;
1806
1807         _mmcam_dbg_log("START");
1808
1809         /* Audio encoder info */
1810         allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value1);
1811         if (allocated_memory) {
1812                 free(allocated_memory);
1813                 cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value1 = (int)NULL;
1814                 cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value2 = (int)0;
1815         }
1816
1817         /* Video encoder info */
1818         allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value1);
1819         if (allocated_memory) {
1820                 free(allocated_memory);
1821                 cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value1 = (int)NULL;
1822                 cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value2 = (int)0;
1823         }
1824
1825         /* Image encoder info */
1826         allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value1);
1827         if (allocated_memory) {
1828                 free(allocated_memory);
1829                 cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value1 = (int)NULL;
1830                 cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value2 = (int)0;
1831         }
1832
1833         /* File format info */
1834         allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value1);
1835         if (allocated_memory) {
1836                 free(allocated_memory);
1837                 cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value1 = (int)NULL;
1838                 cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value2 = (int)0;
1839         }
1840
1841         _mmcam_dbg_log("DONE");
1842
1843         return MM_ERROR_NONE;
1844 }
1845
1846
1847 bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1848 {
1849         MMHandleType attr = 0;
1850         int current_state = MM_CAMCORDER_STATE_NONE;
1851
1852         attr = MMF_CAMCORDER_ATTRS(handle);
1853         mmf_return_val_if_fail(attr, FALSE);
1854
1855         _mmcam_dbg_log("(%d)", attr_idx);
1856
1857         current_state = _mmcamcorder_get_state(handle);
1858         if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1859                 int flags = MM_ATTRS_FLAG_NONE;
1860                 int capture_width, capture_height;
1861                 MMCamAttrsInfo info;
1862
1863                 mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
1864                 flags = info.flag;
1865
1866                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
1867                         mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &capture_height, NULL);
1868                         capture_width = value->value.i_val;
1869
1870                         /* Check whether they are valid pair */
1871                         return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1872                 }
1873
1874                 return TRUE;
1875         } else {
1876                 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1877                 return FALSE;
1878         }
1879 }
1880
1881
1882 bool _mmcamcorder_commit_capture_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1883 {
1884         int current_state = MM_CAMCORDER_STATE_NONE;
1885
1886         current_state = _mmcamcorder_get_state(handle);
1887
1888         if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
1889                 int capture_width, capture_height;
1890
1891                 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &capture_width, NULL);
1892                 capture_height = value->value.i_val;
1893
1894                 return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
1895         } else {
1896                 _mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
1897
1898                 return FALSE;
1899         }
1900 }
1901
1902
1903 bool _mmcamcorder_commit_capture_break_cont_shot (MMHandleType handle, int attr_idx, const mmf_value_t *value)
1904 {
1905         int current_state = _mmcamcorder_get_state( handle);
1906         int ivalue = value->value.i_val;
1907
1908         mmf_camcorder_t        *hcamcorder = MMF_CAMCORDER(handle);
1909         _MMCamcorderSubContext *sc = NULL;
1910         GstCameraControl       *control = NULL;
1911         type_element           *VideosrcElement = NULL;
1912
1913         char* videosrc_name = NULL;
1914
1915         _mmcamcorder_conf_get_element(hcamcorder->conf_main,
1916                                       CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
1917                                       "VideosrcElement",
1918                                       &VideosrcElement );
1919         _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
1920
1921         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1922         if (!sc)
1923                 return TRUE;
1924
1925         if( ivalue && current_state == MM_CAMCORDER_STATE_CAPTURING )
1926         {
1927                 if( !strcmp( videosrc_name, "avsysvideosrc" ) || !strcmp( videosrc_name, "camerasrc" ) )
1928                 {
1929                         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
1930                         {
1931                                 _mmcam_dbg_err("Can't cast Video source into camera control.");
1932                                 return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
1933                         }
1934
1935                         control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
1936
1937                         gst_camera_control_set_capture_command( control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT );
1938
1939                         _mmcam_dbg_warn( "Commit Break continuous shot : Set command OK. current state[%d]", current_state );
1940                 }
1941                 else
1942                 {
1943                         _mmcam_dbg_warn( "Another videosrc plugin[%s] is not supported yet.", videosrc_name );
1944                 }
1945         }
1946         else
1947         {
1948                 _mmcam_dbg_warn( "Commit Break continuous shot : No effect. value[%d],current state[%d]", ivalue, current_state );
1949         }
1950
1951         return TRUE;
1952 }
1953
1954
1955 bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1956 {
1957         int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
1958         int current_state = MM_CAMCORDER_STATE_NONE;
1959
1960         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1961
1962         mmf_return_val_if_fail(hcamcorder, FALSE);
1963
1964         current_state = _mmcamcorder_get_state(handle);
1965         mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
1966
1967         _mmcam_dbg_log("current state %d, mode %d, set count %d",
1968                        current_state, mode, value->value.i_val);
1969
1970         if (mode != MM_CAMCORDER_MODE_AUDIO &&
1971             current_state != MM_CAMCORDER_STATE_CAPTURING) {
1972                 return TRUE;
1973         } else {
1974                 _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
1975                 return FALSE;
1976         }
1977 }
1978
1979
1980 bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
1981 {
1982         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1983
1984         mmf_return_val_if_fail(hcamcorder, FALSE);
1985
1986         _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
1987
1988         /* return error when disable shutter sound if policy is TRUE */
1989         if (!value->value.i_val &&
1990             hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
1991                 _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
1992                 return FALSE;
1993         } else {
1994                 _mmcam_dbg_log("set value [%d] success", value->value.i_val);
1995                 return TRUE;
1996         }
1997 }
1998
1999
2000 bool _mmcamcorder_commit_audio_volume (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2001 {
2002         int current_state = MM_CAMCORDER_STATE_NONE;
2003         _MMCamcorderSubContext *sc = NULL;
2004         bool bret = FALSE;
2005
2006         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2007         if (!sc)
2008                 return TRUE;
2009
2010         current_state = _mmcamcorder_get_state( handle);
2011
2012         if ((current_state == MM_CAMCORDER_STATE_RECORDING)||(current_state == MM_CAMCORDER_STATE_PAUSED))
2013         {
2014                 double mslNewVal = 0;
2015                 mslNewVal = value->value.d_val;
2016
2017                 if (sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst)
2018                 {
2019                         if(mslNewVal == 0.0)
2020                         {
2021                                 //Because data probe of audio src do the same job, it doesn't need to set mute here. Already null raw data.
2022 //                              MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "mute", TRUE);
2023                                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", 1.0);
2024                         }
2025                         else
2026                         {
2027                                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "mute", FALSE);
2028                                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", mslNewVal);
2029                         }
2030                 }
2031
2032                 _mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
2033                 bret = TRUE;
2034         }
2035         else
2036         {
2037                 _mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
2038                 bret = TRUE;
2039         }
2040
2041         return bret;
2042 }
2043
2044
2045 bool _mmcamcorder_commit_camera_fps (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2046 {
2047         _mmcam_dbg_log("FPS(%d)", value->value.i_val);
2048         return TRUE;
2049 }
2050
2051
2052 bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2053 {
2054         int current_state = MM_CAMCORDER_STATE_NONE;
2055         _MMCamcorderSubContext *sc = NULL;
2056
2057         mmf_return_val_if_fail(handle, TRUE);
2058
2059         current_state = _mmcamcorder_get_state(handle);
2060
2061         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2062                 _mmcam_dbg_warn("invalid state %d", current_state);
2063                 return FALSE;
2064         }
2065
2066         /* Verify recording motion rate */
2067         if (value->value.d_val > 0.0) {
2068                 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2069                 mmf_return_val_if_fail(sc, TRUE);
2070
2071                 /* set is_slow flag */
2072                 if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
2073                         sc->is_modified_rate = TRUE;
2074                 } else {
2075                         sc->is_modified_rate = FALSE;
2076                 }
2077
2078                 _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
2079                 return TRUE;
2080         } else {
2081                 _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
2082                 return FALSE;
2083         }
2084 }
2085
2086
2087 bool _mmcamcorder_commit_camera_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2088 {
2089         MMHandleType attr = 0;
2090         int current_state = MM_CAMCORDER_STATE_NONE;
2091         int width, height;
2092
2093         attr = MMF_CAMCORDER_ATTRS(handle);
2094         mmf_return_val_if_fail(attr, FALSE);
2095
2096         _mmcam_dbg_log("Width(%d)", value->value.i_val);
2097
2098         current_state = _mmcamcorder_get_state(handle);
2099
2100         if (current_state > MM_CAMCORDER_STATE_READY) {
2101                 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2102                 return FALSE;
2103         } else {
2104                 int flags = MM_ATTRS_FLAG_NONE;
2105                 MMCamAttrsInfo info;
2106                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, &info);
2107                 flags = info.flag;
2108
2109                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
2110                         mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_HEIGHT, &height, NULL);
2111                         width = value->value.i_val;
2112                         //This means that width is changed while height isn't changed. So call _mmcamcorder_commit_camera_height forcely.
2113                         _mmcam_dbg_log("Call _mmcamcorder_commit_camera_height");
2114                         return __mmcamcorder_set_camera_resolution(handle, width, height);
2115                 }
2116                 return TRUE;
2117         }
2118 }
2119
2120
2121 bool _mmcamcorder_commit_camera_height (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2122 {
2123         int width, height;
2124         int current_state = MM_CAMCORDER_STATE_NONE;
2125         MMHandleType attr = 0;
2126
2127         attr = MMF_CAMCORDER_ATTRS(handle);
2128         mmf_return_val_if_fail(attr, FALSE);
2129
2130         _mmcam_dbg_log("Height(%d)", value->value.i_val);
2131         current_state = _mmcamcorder_get_state( handle);
2132
2133         if (current_state > MM_CAMCORDER_STATE_READY) {
2134                 _mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
2135                 return FALSE;
2136         } else {
2137                 height = value->value.i_val;
2138                 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_WIDTH, &width, NULL);
2139                 return __mmcamcorder_set_camera_resolution(handle, width, height);
2140         }
2141 }
2142
2143
2144 bool _mmcamcorder_commit_camera_zoom (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2145 {
2146         _MMCamcorderSubContext *sc = NULL;
2147         int current_state = MM_CAMCORDER_STATE_NONE;
2148         GstCameraControl *control = NULL;
2149         int zoom_level = value->value.i_val;
2150         int zoom_type;
2151
2152         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2153         mmf_return_val_if_fail(sc, TRUE);
2154
2155         _mmcam_dbg_log("(%d)", attr_idx);
2156
2157         current_state = _mmcamcorder_get_state(handle);
2158
2159         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2160                 return TRUE;
2161         }
2162
2163         if (attr_idx == MM_CAM_CAMERA_OPTICAL_ZOOM) {
2164                 zoom_type = GST_CAMERA_CONTROL_OPTICAL_ZOOM;
2165         } else {
2166                 zoom_type = GST_CAMERA_CONTROL_DIGITAL_ZOOM;
2167         }
2168
2169         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2170                 int ret = FALSE;
2171
2172                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2173                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2174                         return TRUE;
2175                 }
2176
2177                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2178
2179                 __ta__("                gst_camera_control_set_zoom",
2180                 ret = gst_camera_control_set_zoom(control, zoom_type, zoom_level);
2181                 );
2182
2183                 if (ret) {
2184                         _mmcam_dbg_log("Succeed in operating Zoom[%d].", zoom_level);
2185                         return TRUE;
2186                 } else {
2187                         _mmcam_dbg_warn("Failed to operate Zoom. Type[%d],Level[%d]", zoom_type, zoom_level);
2188                 }
2189         } else {
2190                 _mmcam_dbg_log("pointer of video src is null");
2191         }
2192
2193         return FALSE;
2194 }
2195
2196
2197 bool _mmcamcorder_commit_camera_focus_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2198 {
2199         MMHandleType attr = 0;
2200         int current_state = MM_CAMCORDER_STATE_NONE;
2201         _MMCamcorderSubContext *sc = NULL;
2202         GstCameraControl *control = NULL;
2203         int mslVal;
2204         int mode, cur_focus_mode, cur_focus_range;
2205
2206         attr = MMF_CAMCORDER_ATTRS(handle);
2207         mmf_return_val_if_fail(attr, FALSE);
2208
2209         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2210         if (!sc)
2211                 return TRUE;
2212
2213         _mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
2214
2215         /* check whether set or not */
2216         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2217                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2218                 return TRUE;
2219         }
2220
2221         current_state = _mmcamcorder_get_state(handle);
2222         if (current_state < MM_CAMCORDER_STATE_NULL) {
2223                 _mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
2224                 return TRUE;
2225         }
2226
2227         if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst )
2228         {
2229                 int flags = MM_ATTRS_FLAG_NONE;
2230                 MMCamAttrsInfo info;
2231
2232                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
2233                 {
2234                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2235                         return TRUE;
2236                 }
2237
2238                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2239
2240                 mslVal = value->value.i_val;
2241                 mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
2242
2243                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
2244                 flags = info.flag;
2245
2246                 if (!(flags & MM_ATTRS_FLAG_MODIFIED))
2247                 {
2248                         if( gst_camera_control_get_focus( control, &cur_focus_mode, &cur_focus_range ) )
2249                         {
2250                                 if( mode != cur_focus_mode )
2251                                 {
2252                                         MMTA_ACUM_ITEM_BEGIN("                gst_camera_control_set_focus", 0);
2253                                         if( gst_camera_control_set_focus( control, mode, cur_focus_range ) )
2254                                         {
2255                                                 MMTA_ACUM_ITEM_END("                gst_camera_control_set_focus", 0);
2256                                                 _mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
2257                                                 return TRUE;
2258                                         }
2259                                         else
2260                                         {
2261                                                 _mmcam_dbg_warn( "Failed to set AF mode[%d]", mslVal );
2262                                         }
2263                                         MMTA_ACUM_ITEM_END("                gst_camera_control_set_focus", 0);
2264                                 }
2265                                 else
2266                                 {
2267                                         _mmcam_dbg_log( "No need to set AF mode. Current[%d]", mslVal );
2268                                         return TRUE;
2269                                 }
2270                         }
2271                         else
2272                         {
2273                                 _mmcam_dbg_warn( "Failed to get AF mode, so do not set new AF mode[%d]", mslVal );
2274                         }
2275                 }
2276         }
2277         else
2278         {
2279                 _mmcam_dbg_log("pointer of video src is null");
2280         }
2281         return TRUE;
2282 }
2283
2284
2285 bool _mmcamcorder_commit_camera_af_scan_range (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2286 {
2287         _MMCamcorderSubContext *sc = NULL;
2288         GstCameraControl *control = NULL;
2289         int current_state = MM_CAMCORDER_STATE_NONE;
2290         int mslVal, newVal;
2291         int cur_focus_mode = 0;
2292         int cur_focus_range = 0;
2293         int msl_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2294         int converted_mode = 0;
2295
2296         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2297         if (!sc)
2298                 return TRUE;
2299
2300         _mmcam_dbg_log("(%d)", attr_idx);
2301
2302         /* check whether set or not */
2303         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2304                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2305                 return TRUE;
2306         }
2307
2308         mslVal = value->value.i_val;
2309         newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
2310
2311         current_state = _mmcamcorder_get_state(handle);
2312         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2313                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2314                 return TRUE;
2315         }
2316
2317         if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst )
2318         {
2319                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
2320                 {
2321                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2322                         return TRUE;
2323                 }
2324
2325                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2326
2327                 mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
2328                 converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
2329
2330                 if( gst_camera_control_get_focus( control, &cur_focus_mode, &cur_focus_range ) )
2331                 {
2332
2333                         if (( newVal != cur_focus_range ) || ( converted_mode != cur_focus_mode ))
2334                         {
2335                                 MMTA_ACUM_ITEM_BEGIN("                gst_camera_control_set_focus", 0);
2336                                 if( gst_camera_control_set_focus( control, converted_mode, newVal ) )
2337                                 {
2338                                         MMTA_ACUM_ITEM_END("                gst_camera_control_set_focus", 0);
2339                                         //_mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
2340                                         return TRUE;
2341                                 }
2342                                 else
2343                                 {
2344                                         MMTA_ACUM_ITEM_END("                gst_camera_control_set_focus", 0);
2345                                         _mmcam_dbg_warn( "Failed to set AF mode[%d]", mslVal );
2346                                 }
2347                         }
2348                         else
2349                         {
2350                                 //_mmcam_dbg_log( "No need to set AF mode. Current[%d]", mslVal );
2351                                 return TRUE;
2352                         }
2353                 }
2354                 else
2355                 {
2356                         _mmcam_dbg_warn( "Failed to get AF mode, so do not set new AF mode[%d]", mslVal );
2357                 }
2358         }
2359         else
2360         {
2361                 _mmcam_dbg_log("pointer of video src is null");
2362         }
2363         return FALSE;
2364 }
2365
2366 bool _mmcamcorder_commit_camera_af_touch_area (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2367 {
2368         _MMCamcorderSubContext *sc = NULL;
2369         GstCameraControl *control = NULL;
2370         GstCameraControlRectType set_area = { 0, 0, 0, 0 }, get_area = { 0, 0, 0, 0 };
2371
2372         int current_state = MM_CAMCORDER_STATE_NONE;
2373         int ret = FALSE;
2374         int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
2375
2376         gboolean do_set = FALSE;
2377
2378         MMCamAttrsInfo info_y, info_w, info_h;
2379
2380         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2381         if (!sc)
2382                 return TRUE;
2383
2384         _mmcam_dbg_log("(%d)", attr_idx);
2385
2386         current_state = _mmcamcorder_get_state( handle);
2387
2388         if( current_state < MM_CAMCORDER_STATE_PREPARE )
2389         {
2390                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2391                 return TRUE;
2392         }
2393
2394         ret = mm_camcorder_get_attributes(handle, NULL,
2395                                 MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
2396                                 NULL);
2397         if( ret != MM_ERROR_NONE )
2398         {
2399                 _mmcam_dbg_warn( "Failed to get FOCUS MODE.[%x]", ret );
2400                 return FALSE;
2401         }
2402
2403         if ((focus_mode != MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO ) && (focus_mode != MM_CAMCORDER_FOCUS_MODE_CONTINUOUS))
2404         {
2405                 _mmcam_dbg_warn( "Focus mode is NOT TOUCH AUTO or CONTINUOUS(current[%d]). return FALSE", focus_mode );
2406                 return FALSE;
2407         }
2408
2409         if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst )
2410         {
2411                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
2412                 {
2413                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2414                         return TRUE;
2415                 }
2416
2417                 switch( attr_idx )
2418                 {
2419                         case MM_CAM_CAMERA_AF_TOUCH_X:
2420                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_Y, &info_y);
2421                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2422                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2423                                 if( !( (info_y.flag|info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED) )
2424                                 {
2425                                         set_area.x = value->value.i_val;
2426                                         mm_camcorder_get_attributes(handle, NULL,
2427                                                         MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2428                                                         MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2429                                                         MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2430                                                         NULL);
2431                                         do_set = TRUE;
2432                                 }
2433                                 else
2434                                 {
2435                                         _mmcam_dbg_log( "Just store AF area[x:%d]", value->value.i_val );
2436                                         return TRUE;
2437                                 }
2438                                 break;
2439                         case MM_CAM_CAMERA_AF_TOUCH_Y:
2440                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_WIDTH, &info_w);
2441                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2442                                 if( !( (info_w.flag|info_h.flag) & MM_ATTRS_FLAG_MODIFIED) )
2443                                 {
2444                                         set_area.y = value->value.i_val;
2445                                         mm_camcorder_get_attributes(handle, NULL,
2446                                                         MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2447                                                         MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2448                                                         MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2449                                                         NULL);
2450                                         do_set = TRUE;
2451                                 }
2452                                 else
2453                                 {
2454                                         _mmcam_dbg_log( "Just store AF area[y:%d]", value->value.i_val );
2455                                         return TRUE;
2456                                 }
2457                                 break;
2458                         case MM_CAM_CAMERA_AF_TOUCH_WIDTH:
2459                                 mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_TOUCH_HEIGHT, &info_h);
2460                                 if( !( info_h.flag & MM_ATTRS_FLAG_MODIFIED) )
2461                                 {
2462                                         set_area.width = value->value.i_val;
2463                                         mm_camcorder_get_attributes(handle, NULL,
2464                                                         MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2465                                                         MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2466                                                         MMCAM_CAMERA_AF_TOUCH_HEIGHT, &set_area.height,
2467                                                         NULL);
2468                                         do_set = TRUE;
2469                                 }
2470                                 else
2471                                 {
2472                                         _mmcam_dbg_log( "Just store AF area[width:%d]", value->value.i_val );
2473                                         return TRUE;
2474                                 }
2475                                 break;
2476                         case MM_CAM_CAMERA_AF_TOUCH_HEIGHT:
2477                                 set_area.height = value->value.i_val;
2478                                 mm_camcorder_get_attributes(handle, NULL,
2479                                                 MMCAM_CAMERA_AF_TOUCH_X, &set_area.x,
2480                                                 MMCAM_CAMERA_AF_TOUCH_Y, &set_area.y,
2481                                                 MMCAM_CAMERA_AF_TOUCH_WIDTH, &set_area.width,
2482                                                 NULL);
2483                                 do_set = TRUE;
2484                                 break;
2485                         default:
2486                                 break;
2487                 }
2488
2489                 if( do_set )
2490                 {
2491                         control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2492
2493                         __ta__( "                gst_camera_control_get_focus_area",
2494                         ret = gst_camera_control_get_auto_focus_area( control, &get_area );
2495                         );
2496                         if( !ret )
2497                         {
2498                                 _mmcam_dbg_warn( "Failed to get AF area" );
2499                                 return FALSE;
2500                         }
2501
2502                         if( get_area.x == set_area.x && get_area.y == set_area.y )
2503                         // width and height are not supported now.
2504                         // get_area.width == set_area.width && get_area.height == set_area.height
2505                         {
2506                                 _mmcam_dbg_log( "No need to set AF area[x,y:%d,%d]", get_area.x, get_area.y );
2507                                 return TRUE;
2508                         }
2509
2510                         __ta__( "                gst_camera_control_set_focus_area",
2511                         ret = gst_camera_control_set_auto_focus_area( control, set_area );
2512                         );
2513                         if( ret )
2514                         {
2515                                 _mmcam_dbg_log( "Succeed to set AF area[%d,%d,%dx%d]", set_area.x, set_area.y, set_area.width, set_area.height );
2516                                 return TRUE;
2517                         }
2518                         else
2519                         {
2520                                 _mmcam_dbg_warn( "Failed to set AF area[%d,%d,%dx%d]", set_area.x, set_area.y, set_area.width, set_area.height );
2521                         }
2522                 }
2523         }
2524         else
2525         {
2526                 _mmcam_dbg_log("pointer of video src is null");
2527         }
2528
2529         return FALSE;
2530 }
2531
2532
2533 bool _mmcamcorder_commit_camera_capture_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2534 {
2535         GstCameraControl *control = NULL;
2536         int ivalue = value->value.i_val;
2537         int mslVal1 = 0, mslVal2 = 0;
2538         int newVal1 = 0, newVal2 = 0;
2539         int exposure_type = 0;
2540         int current_state = MM_CAMCORDER_STATE_NONE;
2541         _MMCamcorderSubContext *sc = NULL;
2542
2543         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
2544         gboolean check_scene_mode = FALSE;
2545
2546         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2547         if (!sc)
2548                 return TRUE;
2549
2550         /* check whether set or not */
2551         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2552                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2553                 return TRUE;
2554         }
2555
2556         current_state = _mmcamcorder_get_state( handle);
2557         if (current_state < MM_CAMCORDER_STATE_READY) {
2558                 return TRUE;
2559         }
2560
2561         if (attr_idx == MM_CAM_CAMERA_F_NUMBER) {
2562                 exposure_type = GST_CAMERA_CONTROL_F_NUMBER;
2563                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2564                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2565         } else if (attr_idx == MM_CAM_CAMERA_SHUTTER_SPEED) {
2566                 exposure_type = GST_CAMERA_CONTROL_SHUTTER_SPEED;
2567                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2568                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2569         } else if (attr_idx == MM_CAM_CAMERA_ISO) {
2570                 exposure_type = GST_CAMERA_CONTROL_ISO;
2571                 mslVal1 = ivalue;
2572                 newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2573                 check_scene_mode = TRUE;
2574         } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_MODE) {
2575                 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_MODE;
2576                 mslVal1 = ivalue;
2577                 newVal1 =  _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
2578                 check_scene_mode = TRUE;
2579         } else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
2580                 exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
2581                 mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
2582                 mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
2583         }
2584
2585         if (check_scene_mode) {
2586                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
2587                 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
2588                         _mmcam_dbg_warn("can not set [%d] when scene mode is NOT normal.", attr_idx);
2589                         return FALSE;
2590                 }
2591         }
2592
2593         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2594                 int ret = 0;
2595
2596                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2597                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2598                         return TRUE;
2599                 }
2600
2601                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2602
2603                 __ta__("                gst_camera_control_set_exposure",
2604                 ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
2605                 );
2606                 if (ret) {
2607                         _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2608                         return TRUE;
2609                 } else {
2610                         _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
2611                 }
2612         } else {
2613                 _mmcam_dbg_log("pointer of video src is null");
2614         }
2615
2616         return FALSE;
2617 }
2618
2619
2620 bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2621 {
2622         GstCameraControl *control = NULL;
2623         int mslVal = 0;
2624         int newVal = 0;
2625         int cur_value = 0;
2626         _MMCamcorderSubContext *sc = NULL;
2627         int current_state = MM_CAMCORDER_STATE_NONE;
2628
2629         mmf_return_val_if_fail(handle && value, FALSE);
2630
2631         /* check whether set or not */
2632         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2633                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2634                 return TRUE;
2635         }
2636
2637         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2638         mmf_return_val_if_fail(sc, TRUE);
2639
2640         /* check current state */
2641         current_state = _mmcamcorder_get_state( handle);
2642         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2643                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2644                 return TRUE;
2645         }
2646
2647         if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
2648                 _mmcam_dbg_warn("Can not set WDR while CAPTURING");
2649                 return FALSE;
2650         }
2651
2652         mslVal = value->value.i_val;
2653         newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_WDR, mslVal);
2654
2655         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2656                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2657                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2658                         return TRUE;
2659                 }
2660
2661                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2662                 if (gst_camera_control_get_wdr(control, &cur_value)) {
2663                         if (newVal != cur_value) {
2664                                 if (gst_camera_control_set_wdr(control, newVal)) {
2665                                         _mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
2666                                         return TRUE;
2667                                 } else {
2668                                         _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
2669                                 }
2670                         } else {
2671                                 _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
2672                                 return TRUE;
2673                         }
2674                 } else {
2675                         _mmcam_dbg_warn( "Failed to get WDR." );
2676                 }
2677         } else {
2678                 _mmcam_dbg_log("pointer of video src is null");
2679         }
2680
2681         return FALSE;
2682 }
2683
2684
2685 bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2686 {
2687         int current_state = MM_CAMCORDER_STATE_NONE;
2688
2689         /* check whether set or not */
2690         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2691                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2692                 return TRUE;
2693         }
2694
2695         current_state = _mmcamcorder_get_state(handle);
2696         if (current_state < MM_CAMCORDER_STATE_READY) {
2697                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2698                 return TRUE;
2699         } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2700                 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2701                 return FALSE;
2702         }
2703
2704         return _mmcamcorder_set_videosrc_anti_shake(handle, value->value.i_val);
2705 }
2706
2707
2708 bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2709 {
2710         int current_state = MM_CAMCORDER_STATE_NONE;
2711
2712         current_state = _mmcamcorder_get_state(handle);
2713         if (current_state < MM_CAMCORDER_STATE_READY) {
2714                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2715                 return TRUE;
2716         } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
2717                 _mmcam_dbg_err("Invaild state (state %d)", current_state);
2718                 return FALSE;
2719         }
2720
2721         return _mmcamcorder_set_videosrc_stabilization(handle, value->value.i_val);
2722 }
2723
2724
2725 bool _mmcamcorder_commit_camera_hold_af_after_capturing (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2726 {
2727         _MMCamcorderSubContext *sc = NULL;
2728         int current_state = MM_CAMCORDER_STATE_NONE;
2729
2730         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2731         if (!sc)
2732                 return TRUE;
2733
2734         current_state = _mmcamcorder_get_state(handle);
2735
2736         if( current_state < MM_CAMCORDER_STATE_READY )
2737         {
2738                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2739                 return TRUE;
2740         }
2741
2742         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)
2743         {
2744                 _mmcam_dbg_log("Commit : value of Hold af after capturing is %d", value->value.i_val);
2745                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hold-af-after-capturing", value->value.i_val);
2746         }
2747         else
2748                 _mmcam_dbg_warn("Commit : Hold af after capturing cannot be set");
2749
2750         return TRUE;
2751 }
2752
2753
2754 bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2755 {
2756         int current_state = MM_CAMCORDER_STATE_NONE;
2757
2758         _mmcam_dbg_log("rotate(%d)", value->value.i_val);
2759
2760         current_state = _mmcamcorder_get_state(handle);
2761
2762         if (current_state > MM_CAMCORDER_STATE_READY) {
2763                 _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
2764                 return FALSE;
2765         } else {
2766                 return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val);
2767         }
2768 }
2769
2770
2771 bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2772 {
2773         int current_state = MM_CAMCORDER_STATE_NONE;
2774
2775         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
2776         _MMCamcorderSubContext *sc = NULL;
2777
2778         mmf_return_val_if_fail(handle, FALSE);
2779
2780         /* check type */
2781         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
2782                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
2783                 return FALSE;
2784         }
2785
2786         /* check current state */
2787         current_state = _mmcamcorder_get_state(handle);
2788         if (current_state < MM_CAMCORDER_STATE_READY) {
2789                 _mmcam_dbg_log("NOT initialized. this will be applied later");
2790                 return TRUE;
2791         }
2792
2793         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2794
2795         _mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
2796
2797         if (current_state == MM_CAMCORDER_STATE_PREPARE) {
2798                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
2799                 return TRUE;
2800         } else {
2801                 _mmcam_dbg_err("invalid state %d", current_state);
2802                 return FALSE;
2803         }
2804 }
2805
2806
2807 bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value)
2808 {
2809         _MMCamcorderSubContext *sc = NULL;
2810         char * filename = NULL;
2811         int size = 0;
2812
2813         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2814         if (!sc)
2815                 return TRUE;
2816
2817         /* get string */
2818         filename = (char *)mmf_value_get_string(value, &size);
2819
2820         if (sc->element && sc->element[_MMCAMCORDER_ENCSINK_SINK].gst) {
2821                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename);
2822                 _mmcam_dbg_log("new file location set.(%s)", filename);
2823         } else {
2824                 _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename);
2825         }
2826
2827         return TRUE;
2828 }
2829
2830
2831
2832
2833 bool _mmcamcorder_commit_filter (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2834 {
2835         GstColorBalance *balance = NULL;
2836         GstColorBalanceChannel *Colorchannel = NULL;
2837         const GList *controls = NULL;
2838         const GList *item = NULL;
2839         int newVal = 0;
2840         int mslNewVal = 0;
2841         int current_state = MM_CAMCORDER_STATE_NONE;
2842         gchar * control_label = NULL;
2843         _MMCamcorderSubContext *sc = NULL;
2844
2845         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
2846         gboolean check_scene_mode = FALSE;
2847
2848         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2849         if (!sc)
2850                 return TRUE;
2851
2852         /* check whether set or not */
2853         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2854                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2855                 return TRUE;
2856         }
2857
2858         current_state = _mmcamcorder_get_state(handle);
2859         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2860                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2861                 return TRUE;
2862         }
2863
2864         if (value->type != MM_ATTRS_TYPE_INT) {
2865                 _mmcam_dbg_warn("Mismatched value type (%d)", value->type);
2866                 return FALSE;
2867         } else {
2868                 mslNewVal = value->value.i_val;
2869         }
2870
2871         switch (attr_idx) {
2872         case MM_CAM_FILTER_BRIGHTNESS:
2873                 control_label = "brightness";
2874                 check_scene_mode = TRUE;
2875                 break;
2876
2877         case MM_CAM_FILTER_CONTRAST:
2878                 control_label = "contrast";
2879                 break;
2880
2881         case MM_CAM_FILTER_WB:
2882                 control_label = "white balance";
2883                 check_scene_mode = TRUE;
2884                 break;
2885
2886         case MM_CAM_FILTER_COLOR_TONE:
2887                 control_label = "color tone";
2888                 break;
2889
2890         case MM_CAM_FILTER_SATURATION:
2891                 control_label = "saturation";
2892                 check_scene_mode = TRUE;
2893                 break;
2894
2895         case MM_CAM_FILTER_HUE:
2896                 control_label = "hue";
2897                 break;
2898
2899         case MM_CAM_FILTER_SHARPNESS:
2900                 control_label = "sharpness";
2901                 check_scene_mode = TRUE;
2902                 break;
2903         }
2904
2905         if (check_scene_mode) {
2906                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
2907                 if (scene_mode != MM_CAMCORDER_SCENE_MODE_NORMAL) {
2908                         _mmcam_dbg_warn("can not set %s when scene mode is NOT normal.", control_label);
2909                         return FALSE;
2910                 }
2911         }
2912
2913         newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
2914         if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
2915                 return FALSE;
2916
2917         _mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);
2918
2919         if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2920                 _mmcam_dbg_log("Can't cast Video source into color balance.");
2921                 return TRUE;
2922         }
2923
2924         balance = GST_COLOR_BALANCE (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2925
2926         controls = gst_color_balance_list_channels (balance);
2927         if (controls == NULL) {
2928                 _mmcam_dbg_log("There is no list of colorbalance controls");
2929                 return FALSE;
2930         }
2931
2932         for (item = controls ; item != NULL ; item = item->next) {
2933                 if (item) {
2934                         if (item->data) {
2935                                 Colorchannel = item->data;
2936                                 /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
2937
2938                                 if (!strcmp(Colorchannel->label, control_label)) {
2939                                         break;
2940                                 } else {
2941                                         Colorchannel = NULL;
2942                                 }
2943                         }
2944                 }
2945         }
2946
2947         if (Colorchannel== NULL) {
2948                 _mmcam_dbg_log("There is no data in the colorbalance controls(%d)", attr_idx);
2949                 return FALSE;
2950         }
2951
2952         __ta__("                gst_color_balance_set_value",
2953         gst_color_balance_set_value (balance, Colorchannel, newVal);
2954         );
2955
2956         _mmcam_dbg_log( "Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
2957
2958         return TRUE;
2959 }
2960
2961
2962 bool _mmcamcorder_commit_filter_scene_mode (MMHandleType handle, int attr_idx, const mmf_value_t *value)
2963 {
2964         GstCameraControl *control = NULL;
2965         int mslVal = value->value.i_val;
2966         int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
2967         _MMCamcorderSubContext *sc = NULL;
2968         int current_state = MM_CAMCORDER_STATE_NONE;
2969
2970         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
2971         if (!sc)
2972                 return TRUE;
2973
2974         /* check whether set or not */
2975         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
2976                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
2977                 return TRUE;
2978         }
2979
2980         current_state = _mmcamcorder_get_state(handle);
2981         if (current_state < MM_CAMCORDER_STATE_PREPARE) {
2982                 _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
2983                 return TRUE;
2984         }
2985
2986         if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
2987                 int ret = 0;
2988
2989                 if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
2990                         _mmcam_dbg_log("Can't cast Video source into camera control.");
2991                         return TRUE;
2992                 }
2993
2994                 control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
2995                 __ta__("                gst_camera_control_set_exposure:GST_CAMERA_CONTROL_PROGRAM_MODE",
2996                 ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
2997                 );
2998                 if (ret) {
2999                         _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
3000
3001                         if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
3002                                 int i = 0;
3003                                 int attr_idxs[] = {
3004                                         MM_CAM_CAMERA_ISO
3005                                         , MM_CAM_FILTER_BRIGHTNESS
3006                                         , MM_CAM_FILTER_WB
3007                                         , MM_CAM_FILTER_SATURATION
3008                                         , MM_CAM_FILTER_SHARPNESS
3009                                         , MM_CAM_FILTER_COLOR_TONE
3010                                         , MM_CAM_CAMERA_EXPOSURE_MODE
3011                                 };
3012                                 mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
3013
3014                                 for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
3015                                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
3016                                                 mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
3017                                         }
3018                                 }
3019                         }
3020
3021                         return TRUE;
3022                 } else {
3023                         _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
3024                 }
3025         } else {
3026                 _mmcam_dbg_warn("pointer of video src is null");
3027         }
3028
3029         return FALSE;
3030 }
3031
3032
3033 bool _mmcamcorder_commit_filter_flip (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3034 {
3035         _mmcam_dbg_warn("Filter Flip(%d)", value->value.i_val);
3036         return TRUE;
3037 }
3038
3039
3040 bool _mmcamcorder_commit_camera_face_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3041 {
3042         int ret = 0;
3043         int current_state = MM_CAMCORDER_STATE_NONE;
3044
3045         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3046         GstCameraControl *control = NULL;
3047         _MMCamcorderSubContext *sc = NULL;
3048
3049         mmf_return_val_if_fail(hcamcorder, FALSE);
3050
3051         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3052         mmf_return_val_if_fail(sc, TRUE);
3053
3054         /* these are only available after camera preview is started */
3055         current_state = _mmcamcorder_get_state(handle);
3056         if (current_state >= MM_CAMCORDER_STATE_PREPARE &&
3057             hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
3058                 int x = 0;
3059                 int y = 0;
3060                 int zoom_level = 0;
3061                 int preview_width = 0;
3062                 int preview_height = 0;
3063
3064                 switch (attr_idx) {
3065                 case MM_CAM_CAMERA_FACE_ZOOM_X:
3066                         /* check x coordinate of face zoom */
3067                         mm_camcorder_get_attributes(handle, NULL,
3068                                                     MMCAM_CAMERA_WIDTH, &preview_width,
3069                                                     NULL);
3070                         /* x coordinate should be smaller than width of preview */
3071                         if (value->value.i_val < preview_width) {
3072                                 _mmcam_dbg_log("set face zoom x %d done", value->value.i_val);
3073                                 ret = TRUE;
3074                         } else {
3075                                 _mmcam_dbg_err("invalid face zoom x %d", value->value.i_val);
3076                                 ret = FALSE;
3077                         }
3078                         break;
3079                 case MM_CAM_CAMERA_FACE_ZOOM_Y:
3080                         /* check y coordinate of face zoom */
3081                         mm_camcorder_get_attributes(handle, NULL,
3082                                                     MMCAM_CAMERA_WIDTH, &preview_height,
3083                                                     NULL);
3084                         /* y coordinate should be smaller than height of preview */
3085                         if (value->value.i_val < preview_height) {
3086                                 _mmcam_dbg_log("set face zoom y %d done", value->value.i_val);
3087                                 ret = TRUE;
3088                         } else {
3089                                 _mmcam_dbg_err("invalid face zoom y %d", value->value.i_val);
3090                                 ret = FALSE;
3091                         }
3092                         break;
3093                 case MM_CAM_CAMERA_FACE_ZOOM_MODE:
3094                         if (value->value.i_val == MM_CAMCORDER_FACE_ZOOM_MODE_ON) {
3095                                 int face_detect_mode = MM_CAMCORDER_DETECT_MODE_OFF;
3096
3097                                 /* start face zoom */
3098                                 /* get x,y coordinate and zoom level */
3099                                 mm_camcorder_get_attributes(handle, NULL,
3100                                                             MMCAM_CAMERA_FACE_ZOOM_X, &x,
3101                                                             MMCAM_CAMERA_FACE_ZOOM_Y, &y,
3102                                                             MMCAM_CAMERA_FACE_ZOOM_LEVEL, &zoom_level,
3103                                                             MMCAM_DETECT_MODE, &face_detect_mode,
3104                                                             NULL);
3105
3106                                 if (face_detect_mode == MM_CAMCORDER_DETECT_MODE_ON) {
3107                                         control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
3108                                         __ta__("                gst_camera_control_start_face_zoom",
3109                                         ret = gst_camera_control_start_face_zoom(control, x, y, zoom_level);
3110                                         );
3111                                 } else {
3112                                         _mmcam_dbg_err("face detect is OFF... could not start face zoom");
3113                                         ret = FALSE;
3114                                 }
3115                         } else if (value->value.i_val == MM_CAMCORDER_FACE_ZOOM_MODE_OFF) {
3116                                 /* stop face zoom */
3117                                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
3118                                 __ta__("                gst_camera_control_stop_face_zoom",
3119                                 ret = gst_camera_control_stop_face_zoom(control);
3120                                 );
3121                         } else {
3122                                 /* should not be reached here */
3123                                 _mmcam_dbg_err("unknown command [%d]", value->value.i_val);
3124                                 ret = FALSE;
3125                         }
3126
3127                         if (!ret) {
3128                                 _mmcam_dbg_err("face zoom[%d] failed", value->value.i_val);
3129                                 ret = FALSE;
3130                         } else {
3131                                 _mmcam_dbg_log("");
3132                                 ret = TRUE;
3133                         }
3134                         break;
3135                 default:
3136                         _mmcam_dbg_warn("should not be reached here. attr_idx %d", attr_idx);
3137                         break;
3138                 }
3139         } else {
3140                 _mmcam_dbg_err("invalid state[%d] or mode[%d]", current_state, hcamcorder->type);
3141                 ret = FALSE;
3142         }
3143
3144         return ret;
3145 }
3146
3147
3148 bool _mmcamcorder_commit_audio_input_route (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3149 {
3150         _mmcam_dbg_log("Commit : Do nothing. this attr will be removed soon.");
3151
3152         return TRUE;
3153 }
3154
3155
3156 bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3157 {
3158         int current_state = MM_CAMCORDER_STATE_NONE;
3159
3160         current_state = _mmcamcorder_get_state(handle);
3161         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3162                 _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
3163                 return FALSE;
3164         } else {
3165                 _mmcam_dbg_log("Disable AUDIO when Recording");
3166                 return TRUE;
3167         }
3168 }
3169
3170
3171 bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3172 {
3173         int current_state = MM_CAMCORDER_STATE_NONE;
3174         char *videosink_name = NULL;
3175         void *p_handle = NULL;
3176
3177         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3178         _MMCamcorderSubContext *sc = NULL;
3179
3180         mmf_return_val_if_fail(handle, FALSE);
3181
3182         /* check type */
3183         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3184                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3185                 return FALSE;
3186         }
3187
3188         /* check current state */
3189         current_state = _mmcamcorder_get_state(handle);
3190         if (current_state < MM_CAMCORDER_STATE_READY) {
3191                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3192                 return TRUE;
3193         }
3194
3195         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3196
3197         p_handle = value->value.p_val;
3198         if (p_handle) {
3199                 /* get videosink name */
3200                 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3201                 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3202
3203                 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
3204                         _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
3205                         gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
3206                 } else if (!strcmp(videosink_name, "evasimagesink") ||
3207                            !strcmp(videosink_name, "evaspixmapsink")) {
3208                         _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
3209                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
3210                 } else {
3211                         _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
3212                         return FALSE;
3213                 }
3214         } else {
3215                 _mmcam_dbg_warn("Display handle is NULL");
3216                 return FALSE;
3217         }
3218
3219         return TRUE;
3220 }
3221
3222
3223 bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3224 {
3225         int current_state = MM_CAMCORDER_STATE_NONE;
3226         char *videosink_name = NULL;
3227
3228         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3229         _MMCamcorderSubContext *sc = NULL;
3230
3231         mmf_return_val_if_fail(handle, FALSE);
3232
3233         /* check type */
3234         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3235                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3236                 return FALSE;
3237         }
3238
3239         /* check current state */
3240         current_state = _mmcamcorder_get_state(handle);
3241         if (current_state < MM_CAMCORDER_STATE_READY) {
3242                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3243                 return TRUE;
3244         }
3245
3246         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3247
3248         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3249         _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
3250
3251         if (!strcmp(videosink_name, "xvimagesink")) {
3252                 _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
3253                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
3254                 return TRUE;
3255         } else {
3256                 _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name);
3257                 return FALSE;
3258         }
3259 }
3260
3261
3262 bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3263 {
3264         int current_state = MM_CAMCORDER_STATE_NONE;
3265
3266         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3267
3268         mmf_return_val_if_fail(handle, FALSE);
3269
3270         /* check type */
3271         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3272                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3273                 return FALSE;
3274         }
3275
3276         /* check current state */
3277         current_state = _mmcamcorder_get_state(handle);
3278         if (current_state < MM_CAMCORDER_STATE_READY) {
3279                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3280                 return TRUE;
3281         }
3282
3283         return _mmcamcorder_set_display_rotation(handle, value->value.i_val);
3284 }
3285
3286
3287 bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3288 {
3289         int current_state = MM_CAMCORDER_STATE_NONE;
3290
3291         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3292
3293         mmf_return_val_if_fail(handle, FALSE);
3294
3295         /* check type */
3296         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3297                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3298                 return FALSE;
3299         }
3300
3301         /* check current state */
3302         current_state = _mmcamcorder_get_state(handle);
3303         if (current_state < MM_CAMCORDER_STATE_READY) {
3304                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3305                 return TRUE;
3306         }
3307
3308         return _mmcamcorder_set_display_flip(handle, value->value.i_val);
3309 }
3310
3311
3312 bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3313 {
3314         int current_state = MM_CAMCORDER_STATE_NONE;
3315         char *videosink_name = NULL;
3316
3317         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3318         _MMCamcorderSubContext *sc = NULL;
3319
3320         mmf_return_val_if_fail(handle, FALSE);
3321
3322         /* check type */
3323         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3324                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3325                 return FALSE;
3326         }
3327
3328         /* check current state */
3329         current_state = _mmcamcorder_get_state(handle);
3330         if (current_state < MM_CAMCORDER_STATE_READY) {
3331                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3332                 return TRUE;
3333         }
3334
3335         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3336
3337         /* Get videosink name */
3338         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3339         if (!strcmp(videosink_name, "xvimagesink") ||
3340             !strcmp(videosink_name, "evaspixmapsink")) {
3341                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
3342                 _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
3343                 return TRUE;
3344         } else {
3345                 _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name);
3346                 return FALSE;
3347         }
3348 }
3349
3350
3351 bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3352 {
3353         int method = 0;
3354         int current_state = MM_CAMCORDER_STATE_NONE;
3355         char *videosink_name = NULL;
3356
3357         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3358         _MMCamcorderSubContext *sc = NULL;
3359
3360         mmf_return_val_if_fail(handle, FALSE);
3361
3362         /* check type */
3363         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3364                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3365                 return FALSE;
3366         }
3367
3368         /* check current state */
3369         current_state = _mmcamcorder_get_state(handle);
3370         if (current_state < MM_CAMCORDER_STATE_READY) {
3371                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3372                 return TRUE;
3373         }
3374
3375         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3376
3377         /* Get videosink name */
3378         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3379         if (!strcmp(videosink_name, "xvimagesink") ||
3380             !strcmp(videosink_name, "evaspixmapsink")) {
3381                 method = value->value.i_val;
3382                 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
3383                 return TRUE;
3384         } else {
3385                 _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name);
3386                 return FALSE;
3387         }
3388 }
3389
3390
3391 bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3392 {
3393         int current_state = MM_CAMCORDER_STATE_NONE;
3394         int method = 0;
3395         char *videosink_name = NULL;
3396
3397         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3398         _MMCamcorderSubContext *sc = NULL;
3399
3400         mmf_return_val_if_fail(handle, FALSE);
3401
3402         /* check type */
3403         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3404                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3405                 return FALSE;
3406         }
3407
3408         /* check current state */
3409         current_state = _mmcamcorder_get_state(handle);
3410         if (current_state < MM_CAMCORDER_STATE_READY) {
3411                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3412                 return TRUE;
3413         }
3414
3415         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3416
3417         /* check current method */
3418         mm_camcorder_get_attributes(handle, NULL,
3419                                     MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
3420                                     NULL);
3421         if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
3422                 _mmcam_dbg_log("current method[%d] is not supported rect", method);
3423                 return FALSE;
3424         }
3425
3426         /* Get videosink name */
3427         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3428         if (!strcmp(videosink_name, "xvimagesink") ||
3429             !strcmp(videosink_name, "evaspixmapsink")) {
3430                 int rect_x = 0;
3431                 int rect_y = 0;
3432                 int rect_width = 0;
3433                 int rect_height = 0;
3434                 int flags = MM_ATTRS_FLAG_NONE;
3435                 MMCamAttrsInfo info;
3436
3437                 mm_camcorder_get_attributes(handle, NULL,
3438                                             MMCAM_DISPLAY_RECT_X, &rect_x,
3439                                             MMCAM_DISPLAY_RECT_Y, &rect_y,
3440                                             MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
3441                                             MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
3442                                             NULL);
3443                 switch (attr_idx) {
3444                 case MM_CAM_DISPLAY_RECT_X:
3445                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
3446                         flags |= info.flag;
3447                         memset(&info, 0x00, sizeof(info));
3448                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3449                         flags |= info.flag;
3450                         memset(&info, 0x00, sizeof(info));
3451                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3452                         flags |= info.flag;
3453
3454                         rect_x = value->value.i_val;
3455                         break;
3456                 case MM_CAM_DISPLAY_RECT_Y:
3457                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
3458                         flags |= info.flag;
3459                         memset(&info, 0x00, sizeof(info));
3460                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3461                         flags |= info.flag;
3462
3463                         rect_y = value->value.i_val;
3464                         break;
3465                 case MM_CAM_DISPLAY_RECT_WIDTH:
3466                         mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
3467                         flags |= info.flag;
3468
3469                         rect_width = value->value.i_val;
3470                         break;
3471                 case MM_CAM_DISPLAY_RECT_HEIGHT:
3472                         rect_height = value->value.i_val;
3473                         break;
3474                 default:
3475                         _mmcam_dbg_err("Wrong attr_idx!");
3476                         return FALSE;
3477                 }
3478
3479                 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
3480                         _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)",
3481                                        rect_x, rect_y, rect_width, rect_height);
3482                         g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
3483                                      "dst-roi-x", rect_x,
3484                                      "dst-roi-y", rect_y,
3485                                      "dst-roi-w", rect_width,
3486                                      "dst-roi-h", rect_height,
3487                                      NULL);
3488                 }
3489
3490                 return TRUE;
3491         } else {
3492                 _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name);
3493                 return FALSE;
3494         }
3495 }
3496
3497
3498 bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3499 {
3500         int zoom = 0;
3501         int current_state = MM_CAMCORDER_STATE_NONE;
3502         char *videosink_name = NULL;
3503         GstElement *vs_element = NULL;
3504
3505         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3506         _MMCamcorderSubContext *sc = NULL;
3507
3508         mmf_return_val_if_fail(handle, FALSE);
3509
3510         /* check type */
3511         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3512                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3513                 return FALSE;
3514         }
3515
3516         /* check current state */
3517         current_state = _mmcamcorder_get_state(handle);
3518         if (current_state < MM_CAMCORDER_STATE_READY) {
3519                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3520                 return TRUE;
3521         }
3522
3523         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3524
3525         /* Get videosink name */
3526         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3527         zoom = value->value.i_val;
3528         if (!strcmp(videosink_name, "xvimagesink")) {
3529                 vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
3530
3531                 MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", zoom + 1);
3532                 _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
3533
3534                 return TRUE;
3535         } else {
3536                 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3537                 return FALSE;
3538         }
3539 }
3540
3541
3542 bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3543 {
3544         int current_state = MM_CAMCORDER_STATE_NONE;
3545         int do_scaling = 0;
3546         char *videosink_name = NULL;
3547
3548         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
3549         _MMCamcorderSubContext *sc = NULL;
3550
3551         mmf_return_val_if_fail(handle, FALSE);
3552
3553         /* check type */
3554         if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
3555                 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
3556                 return FALSE;
3557         }
3558
3559         /* check current state */
3560         current_state = _mmcamcorder_get_state(handle);
3561         if (current_state < MM_CAMCORDER_STATE_READY) {
3562                 _mmcam_dbg_log("NOT initialized. this will be applied later");
3563                 return TRUE;
3564         }
3565
3566         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3567
3568         do_scaling = value->value.i_val;
3569
3570         /* Get videosink name */
3571         _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
3572         if (!strcmp(videosink_name, "evaspixmapsink")) {
3573                 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
3574                 _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
3575                 return TRUE;
3576         } else {
3577                 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
3578                 return FALSE;
3579         }
3580 }
3581
3582
3583 bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
3584 {
3585         bool bret = FALSE;
3586         _MMCamcorderSubContext *sc = NULL;
3587         int strobe_type, mslVal, newVal, cur_value;
3588         int current_state = MM_CAMCORDER_STATE_NONE;
3589
3590         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3591         if (!sc)
3592                 return TRUE;
3593
3594         _mmcam_dbg_log( "Commit : strobe attribute(%d)", attr_idx );
3595
3596         //status check
3597         current_state = _mmcamcorder_get_state( handle);
3598
3599         if (current_state < MM_CAMCORDER_STATE_PREPARE ||
3600             current_state == MM_CAMCORDER_STATE_CAPTURING) {
3601                 //_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3602                 return TRUE;
3603         }
3604
3605         mslVal = value->value.i_val;
3606
3607         switch (attr_idx) {
3608         case MM_CAM_STROBE_CONTROL:
3609                 strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
3610                 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_CONTROL, mslVal);
3611                 break;
3612         case MM_CAM_STROBE_CAPABILITIES:
3613                 strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
3614                 newVal = mslVal;
3615                 break;
3616         case MM_CAM_STROBE_MODE:
3617                 /* check whether set or not */
3618                 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3619                         _mmcam_dbg_log("skip set value %d", mslVal);
3620                         return TRUE;
3621                 }
3622
3623                 strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
3624                 newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
3625                 break;
3626         default:
3627                 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3628                 return FALSE;
3629         }
3630
3631         GstCameraControl *control = NULL;
3632         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3633                 _mmcam_dbg_err("Can't cast Video source into camera control.");
3634                 bret = FALSE;
3635         } else {
3636                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3637
3638                 if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
3639                         if (newVal != cur_value) {
3640                                 if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
3641                                         _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
3642                                         bret = TRUE;
3643                                 } else {
3644                                         _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
3645                                         bret = FALSE;
3646                                 }
3647                         } else {
3648                                 _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
3649                                 bret = TRUE;
3650                         }
3651                 } else {
3652                         _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
3653                         bret = FALSE;
3654                 }
3655         }
3656
3657         return bret;
3658 }
3659
3660
3661 bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3662 {
3663         int ret = 0;
3664         int current_state = MM_CAMCORDER_STATE_NONE;
3665
3666         if ((void *)handle == NULL) {
3667                 _mmcam_dbg_warn("handle is NULL");
3668                 return FALSE;
3669         }
3670
3671         _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
3672
3673         /* state check */
3674         current_state = _mmcamcorder_get_state(handle);
3675         if (current_state > MM_CAMCORDER_STATE_READY) {
3676                 _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
3677                 return FALSE;
3678         } else if (current_state < MM_CAMCORDER_STATE_READY) {
3679                 _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
3680                 return TRUE;
3681         }
3682
3683         ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
3684
3685         _mmcam_dbg_log("ret %d", ret);
3686
3687         return ret;
3688 }
3689
3690
3691 bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3692 {
3693         int current_state = MM_CAMCORDER_STATE_NONE;
3694
3695         if ((void *)handle == NULL) {
3696                 _mmcam_dbg_warn("handle is NULL");
3697                 return FALSE;
3698         }
3699
3700         _mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);
3701
3702         /* check whether set or not */
3703         if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3704                 _mmcam_dbg_log("skip set value %d", value->value.i_val);
3705                 return TRUE;
3706         }
3707
3708         /* state check */
3709         current_state = _mmcamcorder_get_state(handle);
3710         if (current_state > MM_CAMCORDER_STATE_PREPARE) {
3711                 _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
3712                 return FALSE;
3713         }
3714
3715         return TRUE;
3716 }
3717
3718
3719 bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
3720 {
3721         bool bret = FALSE;
3722         _MMCamcorderSubContext *sc = NULL;
3723         int detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3724         int set_value = 0;
3725         int current_value = 0;
3726         int current_state = MM_CAMCORDER_STATE_NONE;
3727         GstCameraControl *control = NULL;
3728
3729         if ((void *)handle == NULL) {
3730                 _mmcam_dbg_warn("handle is NULL");
3731                 return FALSE;
3732         }
3733
3734         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
3735         if (!sc) {
3736                 return TRUE;
3737         }
3738
3739         _mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);
3740
3741         /* state check */
3742         current_state = _mmcamcorder_get_state( handle);
3743         if (current_state < MM_CAMCORDER_STATE_READY) {
3744                 //_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
3745                 return TRUE;
3746         }
3747
3748         set_value = value->value.i_val;
3749
3750         switch (attr_idx) {
3751         case MM_CAM_DETECT_MODE:
3752                 /* check whether set or not */
3753                 if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
3754                         _mmcam_dbg_log("skip set value %d", set_value);
3755                         return TRUE;
3756                 }
3757
3758                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
3759                 break;
3760         case MM_CAM_DETECT_NUMBER:
3761                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
3762                 break;
3763         case MM_CAM_DETECT_FOCUS_SELECT:
3764                 detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
3765                 break;
3766         case MM_CAM_DETECT_SELECT_NUMBER:
3767                 detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
3768                 break;
3769         case MM_CAM_DETECT_STATUS:
3770                 detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
3771                 break;
3772         default:
3773                 _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
3774                 return FALSE;
3775         }
3776
3777         if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
3778                 _mmcam_dbg_err("Can't cast Video source into camera control.");
3779                 bret = FALSE;
3780         } else {
3781                 control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
3782
3783                 if (gst_camera_control_get_detect(control, detect_type, &current_value)) {
3784                         if (current_value == set_value) {
3785                                 _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
3786                                 bret = TRUE;
3787                         } else {
3788                                 if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
3789                                         _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
3790                                                         detect_type, set_value);
3791                                         bret = FALSE;
3792                                 } else {
3793                                         _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
3794                                                        detect_type, set_value);
3795                                         bret = TRUE;
3796                                 }
3797                         }
3798                 } else {
3799                         _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
3800                         bret = FALSE;
3801                 }
3802         }
3803
3804         return bret;
3805 }
3806
3807
3808 static bool
3809 __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx)
3810 {
3811         mmf_attrs_t *attr = (mmf_attrs_t*)handle;
3812         int flag;
3813
3814         if (mm_attrs_get_flags(handle, idx, &flag) == MM_ERROR_NONE) {
3815                 if (flag == MM_ATTRS_FLAG_NONE) {
3816                         return FALSE;
3817                 }
3818         } else {
3819                 return FALSE;
3820         }
3821
3822         if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_RANGE) {
3823                 int min, max;
3824                 mm_attrs_get_valid_range((MMHandleType)attr, idx, &min, &max);
3825                 if (max < min) {
3826                         return FALSE;
3827                 }
3828         } else if (attr->items[idx].value_spec.type == MM_ATTRS_VALID_TYPE_INT_ARRAY) {
3829                 int count;
3830                 int *array;
3831                 mm_attrs_get_valid_array((MMHandleType)attr, idx, &count, &array);
3832                 if (count == 0) {
3833                         return FALSE;
3834                 }
3835         }
3836
3837         return TRUE;
3838 }
3839
3840
3841 bool
3842 _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle)
3843 {
3844         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3845         mmf_attrs_t *attr = NULL;
3846
3847         int scene_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
3848
3849         int i = 0 ;
3850         int ret = TRUE;
3851         int attr_idxs_default[] = {
3852                 MM_CAM_CAMERA_DIGITAL_ZOOM
3853                 , MM_CAM_CAMERA_OPTICAL_ZOOM
3854                 , MM_CAM_CAMERA_WDR
3855                 , MM_CAM_CAMERA_HOLD_AF_AFTER_CAPTURING
3856                 , MM_CAM_FILTER_CONTRAST
3857                 , MM_CAM_FILTER_HUE
3858                 , MM_CAM_STROBE_MODE
3859                 , MM_CAM_DETECT_MODE
3860         };
3861
3862         int attr_idxs_extra[] = {
3863                 MM_CAM_CAMERA_ISO
3864                 , MM_CAM_FILTER_BRIGHTNESS
3865                 , MM_CAM_FILTER_WB
3866                 , MM_CAM_FILTER_SATURATION
3867                 , MM_CAM_FILTER_SHARPNESS
3868                 , MM_CAM_FILTER_COLOR_TONE
3869                 , MM_CAM_CAMERA_EXPOSURE_MODE
3870         };
3871
3872         mmf_return_val_if_fail(hcamcorder, FALSE);
3873
3874         _mmcam_dbg_log("Set all attribute again.");
3875
3876         MMTA_ACUM_ITEM_BEGIN("                _mmcamcorder_set_attribute_to_camsensor", 0);
3877
3878         attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
3879         if (attr == NULL) {
3880                 _mmcam_dbg_err("Get attribute handle failed.");
3881                 return FALSE;
3882         } else {
3883                 /* Get Scene mode */
3884                 mm_camcorder_get_attributes(handle, NULL, MMCAM_FILTER_SCENE_MODE, &scene_mode, NULL);
3885
3886                 _mmcam_dbg_log("attribute count(%d)", attr->count);
3887
3888                 for (i = 0 ; i < ARRAY_SIZE(attr_idxs_default) ; i++) {
3889                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_default[i])) {
3890                                 mmf_attribute_set_modified(&(attr->items[attr_idxs_default[i]]));
3891                         }
3892                 }
3893
3894                 /* Set extra if scene mode is NORMAL */
3895                 if (scene_mode == MM_CAMCORDER_SCENE_MODE_NORMAL) {
3896                         for (i = 0 ; i < ARRAY_SIZE(attr_idxs_extra) ; i++) {
3897                                 if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs_extra[i])) {
3898                                         mmf_attribute_set_modified(&(attr->items[attr_idxs_extra[i]]));
3899                                 }
3900                         }
3901                 } else {
3902                         /* Set scene mode if scene mode is NOT NORMAL */
3903                         if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, MM_CAM_FILTER_SCENE_MODE)) {
3904                                 mmf_attribute_set_modified(&(attr->items[MM_CAM_FILTER_SCENE_MODE]));
3905                         }
3906                 }
3907
3908                 if (mmf_attrs_commit((MMHandleType)attr) == -1) {
3909                         ret = FALSE;
3910                 } else {
3911                         ret = TRUE;
3912                 }
3913         }
3914
3915         MMTA_ACUM_ITEM_END("                _mmcamcorder_set_attribute_to_camsensor", 0);
3916
3917         _mmcam_dbg_log("Done.");
3918
3919         return ret;
3920 }
3921
3922
3923 int _mmcamcorder_lock_readonly_attributes(MMHandleType handle)
3924 {
3925         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3926         int table_size = 0;
3927         int i = 0;
3928         mmf_attrs_t *attr = NULL;
3929         int nerror = MM_ERROR_NONE ;
3930
3931         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
3932
3933         attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
3934         mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3935
3936         _mmcam_dbg_log("");
3937
3938         table_size = ARRAY_SIZE(readonly_attributes);
3939         _mmcam_dbg_log("%d", table_size);
3940         for (i = 0; i < table_size; i++)
3941         {
3942                 int sCategory = readonly_attributes[i];
3943
3944                 mmf_attribute_set_readonly(&(attr->items[sCategory]));
3945         }
3946
3947         return nerror;
3948 }
3949
3950
3951 int _mmcamcorder_set_disabled_attributes(MMHandleType handle)
3952 {
3953         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
3954         //int table_size = 0;
3955         int i = 0;
3956         mmf_attrs_t *attr = NULL;
3957         type_string_array * disabled_attr = NULL;
3958         int cnt_str = 0;
3959         int nerror = MM_ERROR_NONE ;
3960
3961         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
3962
3963         attr = (mmf_attrs_t*) MMF_CAMCORDER_ATTRS(handle);
3964         mmf_return_val_if_fail(attr, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
3965
3966         _mmcam_dbg_log("");
3967
3968         /* add gst_param */
3969         _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
3970                                                  CONFIGURE_CATEGORY_MAIN_GENERAL,
3971                                                  "DisabledAttributes",
3972                                                  &disabled_attr);
3973         if (disabled_attr != NULL && disabled_attr->value) {
3974                 cnt_str = disabled_attr->count;
3975                 for (i = 0; i < cnt_str; i++) {
3976                         int idx = 0;
3977                         _mmcam_dbg_log("[%d]%s", i, disabled_attr->value[i] );
3978                         nerror = mm_attrs_get_index((MMHandleType)attr, disabled_attr->value[i], &idx);
3979                         if (nerror == MM_ERROR_NONE) {
3980                                 mmf_attribute_set_disabled(&(attr->items[idx]));
3981                         } else {
3982                                 _mmcam_dbg_warn("No ATTR named %s[%d]",disabled_attr->value[i], i);
3983                         }
3984                 }
3985         }
3986
3987         return nerror;
3988 }
3989
3990
3991 /*---------------------------------------------------------------------------------------
3992 |    INTERNAL FUNCTION DEFINITIONS:                                                     |
3993 ---------------------------------------------------------------------------------------*/
3994 static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height)
3995 {
3996         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
3997         _MMCamcorderSubContext *sc = NULL;
3998         int current_state = MM_CAMCORDER_STATE_NULL;
3999
4000         mmf_return_val_if_fail(hcamcorder, FALSE);
4001
4002         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4003         mmf_return_val_if_fail(sc, TRUE);
4004
4005         current_state = _mmcamcorder_get_state(handle);
4006
4007         if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
4008                 if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
4009                         _mmcam_dbg_log("set capture width and height [%dx%d] to camera plugin", width, height);
4010                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", width);
4011                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", height);
4012                 } else {
4013                         _mmcam_dbg_warn("invalid state[%d]", current_state);
4014                         return FALSE;
4015                 }
4016         } else {
4017                 _mmcam_dbg_log("element is not created yet");
4018         }
4019
4020         return TRUE;
4021 }
4022
4023
4024 static bool __mmcamcorder_set_camera_resolution(MMHandleType handle, int width, int height)
4025 {
4026         int fps = 0;
4027         double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
4028
4029         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
4030         _MMCamcorderSubContext *sc = NULL;
4031         GstCaps *caps = NULL;
4032
4033         mmf_return_val_if_fail(hcamcorder, FALSE);
4034
4035         sc = MMF_CAMCORDER_SUBCONTEXT(handle);
4036         mmf_return_val_if_fail(sc, TRUE);
4037
4038         mm_camcorder_get_attributes(handle, NULL,
4039                                     MMCAM_CAMERA_FPS, &fps,
4040                                     MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
4041                                     NULL);
4042
4043         if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
4044                 if(motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
4045                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
4046                 } else {
4047                         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
4048                 }
4049         }
4050
4051         caps = gst_caps_new_simple("video/x-raw-yuv",
4052                                    "format", GST_TYPE_FOURCC, sc->fourcc,
4053                                    "width", G_TYPE_INT, width,
4054                                    "height", G_TYPE_INT, height,
4055                                    "framerate", GST_TYPE_FRACTION, fps, 1,
4056                                    NULL);
4057         MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
4058         gst_caps_unref(caps);
4059
4060         return TRUE;
4061 }
4062
4063 static int
4064 __mmcamcorder_check_valid_pair( MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args )
4065 {
4066         #define INIT_VALUE            -1
4067         #define CHECK_COUNT           2
4068         #define CAMERA_RESOLUTION     0
4069         #define CAPTURE_RESOLUTION    1
4070
4071         mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
4072         MMHandleType attrs = 0;
4073
4074         int ret = MM_ERROR_NONE;
4075         int  i = 0, j = 0;
4076         char *name = NULL;
4077         char *check_pair_name[2][3] = {
4078                 { MMCAM_CAMERA_WIDTH,  MMCAM_CAMERA_HEIGHT,  "MMCAM_CAMERA_WIDTH and HEIGHT" },
4079                 { MMCAM_CAPTURE_WIDTH, MMCAM_CAPTURE_HEIGHT, "MMCAM_CAPTURE_WIDTH and HEIGHT" },
4080         };
4081
4082         int check_pair_value[2][2] = {
4083                 { INIT_VALUE, INIT_VALUE },
4084                 { INIT_VALUE, INIT_VALUE },
4085         };
4086
4087         if( hcamcorder == NULL || attribute_name == NULL )
4088         {
4089                 _mmcam_dbg_warn( "handle[%p] or attribute_name[%p] is NULL.",
4090                                  hcamcorder, attribute_name );
4091                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4092         }
4093
4094         if( err_attr_name )
4095                 *err_attr_name = NULL;
4096
4097         //_mmcam_dbg_log( "ENTER" );
4098
4099         attrs = MMF_CAMCORDER_ATTRS(handle);
4100
4101         name = (char*)attribute_name;
4102
4103         while( name )
4104         {
4105                 int idx = -1;
4106                 MMAttrsType attr_type = MM_ATTRS_TYPE_INVALID;
4107
4108                 /*_mmcam_dbg_log( "NAME : %s", name );*/
4109
4110                 /* attribute name check */
4111                 if ((ret = mm_attrs_get_index(attrs, name, &idx)) != MM_ERROR_NONE)
4112                 {
4113                         if (err_attr_name)
4114                                 *err_attr_name = strdup(name);
4115
4116                         if (ret == MM_ERROR_COMMON_OUT_OF_ARRAY)        //to avoid confusing
4117                                 return MM_ERROR_COMMON_ATTR_NOT_EXIST;
4118                         else
4119                                 return ret;
4120                 }
4121
4122                 /* type check */
4123                 if ((ret = mm_attrs_get_type(attrs, idx, &attr_type)) != MM_ERROR_NONE)
4124                         return ret;
4125
4126                 switch (attr_type)
4127                 {
4128                         case MM_ATTRS_TYPE_INT:
4129                         {
4130                                 gboolean matched = FALSE;
4131                                 for( i = 0 ; i < CHECK_COUNT ; i++ ) {
4132                                         for( j = 0 ; j < 2 ; j++ ) {
4133                                                 if( !strcmp( name, check_pair_name[i][j] ) )
4134                                                 {
4135                                                         check_pair_value[i][j] = va_arg( (var_args), int );
4136                                                         _mmcam_dbg_log( "%s : %d", check_pair_name[i][j], check_pair_value[i][j] );
4137                                                         matched = TRUE;
4138                                                         break;
4139                                                 }
4140                                         }
4141                                         if( matched )
4142                                                 break;
4143                                 }
4144                                 if( matched == FALSE )
4145                                 {
4146                                         va_arg ((var_args), int);
4147                                 }
4148                                 break;
4149                         }
4150                         case MM_ATTRS_TYPE_DOUBLE:
4151                                 va_arg ((var_args), double);
4152                                 break;
4153                         case MM_ATTRS_TYPE_STRING:
4154                                 va_arg ((var_args), char*); /* string */
4155                                 va_arg ((var_args), int);   /* size */
4156                                 break;
4157                         case MM_ATTRS_TYPE_DATA:
4158                                 va_arg ((var_args), void*); /* data */
4159                                 va_arg ((var_args), int);   /* size */
4160                                 break;
4161                         case MM_ATTRS_TYPE_INVALID:
4162                         default:
4163                                 _mmcam_dbg_err( "Not supported attribute type(%d, name:%s)", attr_type, name);
4164                                 if (err_attr_name)
4165                                         *err_attr_name = strdup(name);
4166                                 return  MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4167                 }
4168
4169                 /* next name */
4170                 name = va_arg (var_args, char*);
4171         }
4172
4173         for( i = 0 ; i < CHECK_COUNT ; i++ )
4174         {
4175                 if( check_pair_value[i][0] != INIT_VALUE || check_pair_value[i][1] != INIT_VALUE )
4176                 {
4177                         gboolean check_result = FALSE;
4178                         char *err_name = NULL;
4179                         MMCamAttrsInfo attr_info_0, attr_info_1;
4180
4181                         if( check_pair_value[i][0] == INIT_VALUE )
4182                         {
4183                                 mm_attrs_get_int_by_name( attrs, check_pair_name[i][0], &check_pair_value[i][0] );
4184                                 err_name = strdup(check_pair_name[i][1]);
4185                         }
4186                         else if( check_pair_value[i][1] == INIT_VALUE )
4187                         {
4188                                 mm_attrs_get_int_by_name( attrs, check_pair_name[i][1], &check_pair_value[i][1] );
4189                                 err_name = strdup(check_pair_name[i][0]);
4190                         }
4191                         else
4192                         {
4193                                 err_name = strdup(check_pair_name[i][2]);
4194                         }
4195
4196                         mm_camcorder_get_attribute_info(handle, check_pair_name[i][0], &attr_info_0);
4197                         mm_camcorder_get_attribute_info(handle, check_pair_name[i][1], &attr_info_1);
4198
4199                         check_result = FALSE;
4200
4201                         for( j = 0 ; j < attr_info_0.int_array.count ; j++ ) {
4202                                 if( attr_info_0.int_array.array[j] == check_pair_value[i][0]
4203                                  && attr_info_1.int_array.array[j] == check_pair_value[i][1] )
4204                                 {
4205                                         _mmcam_dbg_log( "Valid Pair[%s,%s] existed %dx%d[index:%d]",
4206                                                         check_pair_name[i][0], check_pair_name[i][1],
4207                                                         check_pair_value[i][0], check_pair_value[i][1], i );
4208                                         check_result = TRUE;
4209                                         break;
4210                                 }
4211                         }
4212
4213                         if( check_result == FALSE )
4214                         {
4215                                 _mmcam_dbg_err( "INVALID pair[%s,%s] %dx%d",
4216                                                 check_pair_name[i][0], check_pair_name[i][1],
4217                                                 check_pair_value[i][0], check_pair_value[i][1] );
4218                                 if (err_attr_name)
4219                                         *err_attr_name = err_name;
4220
4221                                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
4222                         }
4223
4224                         if (err_name) {
4225                                 free(err_name);
4226                                 err_name = NULL;
4227                         }
4228                 }
4229         }
4230
4231         /*_mmcam_dbg_log("DONE");*/
4232
4233         return MM_ERROR_NONE;
4234 }
4235
4236
4237 bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
4238 {
4239         MMAttrsInfo info;
4240
4241         if ((void *)handle == NULL) {
4242                 _mmcam_dbg_warn("handle %p is NULL", handle);
4243                 return FALSE;
4244         }
4245
4246         memset(&info, 0x0, sizeof(MMAttrsInfo));
4247
4248         mm_attrs_get_info(MMF_CAMCORDER_ATTRS(handle), attr_index, &info);
4249
4250         switch (info.validity_type) {
4251         case MM_ATTRS_VALID_TYPE_INT_ARRAY:
4252                 _mmcam_dbg_log("int array count %d", info.int_array.count)
4253                 if (info.int_array.count <= 1) {
4254                         return FALSE;
4255                 }
4256                 break;
4257         case MM_ATTRS_VALID_TYPE_INT_RANGE:
4258                 _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
4259                 if (info.int_range.min >= info.int_range.max) {
4260                         return FALSE;
4261                 }
4262                 break;
4263         case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
4264                 _mmcam_dbg_log("double array count %d", info.double_array.count)
4265                 if (info.double_array.count <= 1) {
4266                         return FALSE;
4267                 }
4268                 break;
4269         case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
4270                 _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
4271                 if (info.double_range.min >= info.double_range.max) {
4272                         return FALSE;
4273                 }
4274                 break;
4275         default:
4276                 _mmcam_dbg_warn("invalid type %d", info.validity_type);
4277                 return FALSE;
4278         }
4279
4280         return TRUE;
4281 }