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