src/mm_camcorder_platform.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 ========================================================================================== */
  27 #include "mm_camcorder_internal.h"
  28 #include "mm_camcorder_platform.h"
  29 #include "mm_camcorder_configure.h"
  30
  31 /*---------------------------------------------------------------------------
  32 |    GLOBAL VARIABLE DEFINITIONS for internal                                                           |
  33 ---------------------------------------------------------------------------*/
  34
  35 /*---------------------------------------------------------------------------
  36 |    LOCAL VARIABLE DEFINITIONS for internal                                                            |
  37 ---------------------------------------------------------------------------*/
  38
  39
  40 // Rule 1. 1:1 match except NONE.
  41 // Rule 2. MSL should be Superset.
  42 // Rule 3. sensor value should not be same as _MMCAMCORDER_SENSOR_ENUM_NONE.
  43
  44 static int __enum_conv_whitebalance[MM_CAMCORDER_WHITE_BALANCE_NUM] ;
  45
  46 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_whitebalance =
  47 {
  48         MM_CAMCORDER_WHITE_BALANCE_NUM,
  49         __enum_conv_whitebalance,
  50         CONFIGURE_CATEGORY_CTRL_EFFECT,
  51         "WhiteBalance"
  52 };
  53
  54
  55 static int __enum_conv_colortone[MM_CAMCORDER_COLOR_TONE_NUM];
  56
  57 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_colortone =
  58 {
  59         MM_CAMCORDER_COLOR_TONE_NUM,
  60         __enum_conv_colortone,
  61         CONFIGURE_CATEGORY_CTRL_EFFECT,
  62         "ColorTone"
  63 };
  64
  65
  66 static int __enum_conv_iso[MM_CAMCORDER_ISO_NUM];
  67
  68 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_iso =
  69 {
  70         MM_CAMCORDER_ISO_NUM,
  71         __enum_conv_iso,
  72         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
  73         "ISO"
  74 };
  75
  76
  77 static int __enum_conv_prgrm[MM_CAMCORDER_SCENE_MODE_NUM];
  78
  79 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_prgrm =
  80 {
  81         MM_CAMCORDER_SCENE_MODE_NUM,
  82         __enum_conv_prgrm,
  83         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
  84         "ProgramMode"
  85 };
  86
  87
  88 static int __enum_conv_focus_mode[MM_CAMCORDER_FOCUS_MODE_NUM];
  89
  90 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_mode =
  91 {
  92         MM_CAMCORDER_FOCUS_MODE_NUM,
  93         __enum_conv_focus_mode,
  94         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
  95         "FocusMode"
  96 };
  97
  98
  99 static int __enum_conv_focus_type[MM_CAMCORDER_AUTO_FOCUS_NUM];
 100
 101 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_focus_type =
 102 {
 103         MM_CAMCORDER_AUTO_FOCUS_NUM,
 104         __enum_conv_focus_type,
 105         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 106         "AFType"
 107 };
 108
 109
 110 static int __enum_conv_ae_type[MM_CAMCORDER_AUTO_EXPOSURE_NUM];
 111
 112 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_ae_type =
 113 {
 114         MM_CAMCORDER_AUTO_EXPOSURE_NUM,
 115         __enum_conv_ae_type,
 116         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 117         "AEType"
 118 };
 119
 120
 121 static int __enum_conv_strobe_ctrl[MM_CAMCORDER_STROBE_CONTROL_NUM];
 122
 123 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_ctrl =
 124 {
 125         MM_CAMCORDER_STROBE_CONTROL_NUM,
 126         __enum_conv_strobe_ctrl,
 127         CONFIGURE_CATEGORY_CTRL_STROBE,
 128         "StrobeControl"
 129 };
 130
 131
 132 static int __enum_conv_strobe_mode[MM_CAMCORDER_STROBE_MODE_NUM];
 133
 134 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_strobe_mode =
 135 {
 136         MM_CAMCORDER_STROBE_MODE_NUM,
 137         __enum_conv_strobe_mode,
 138         CONFIGURE_CATEGORY_CTRL_STROBE,
 139         "StrobeMode"
 140 };
 141
 142
 143 static int __enum_conv_wdr_ctrl[MM_CAMCORDER_WDR_NUM];
 144
 145 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_wdr_ctrl =
 146 {
 147         MM_CAMCORDER_WDR_NUM,
 148         __enum_conv_wdr_ctrl,
 149         CONFIGURE_CATEGORY_CTRL_EFFECT,
 150         "WDR"
 151 };
 152
 153 static int __enum_conv_flip_ctrl[MM_CAMCORDER_FLIP_NUM];
 154
 155 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl =
 156 {
 157         MM_CAMCORDER_FLIP_NUM,
 158         __enum_conv_flip_ctrl,
 159         CONFIGURE_CATEGORY_CTRL_EFFECT,
 160         "Flip"
 161 };
 162
 163 static int __enum_conv_rotation_ctrl[MM_CAMCORDER_ROTATION_NUM];
 164
 165 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl =
 166 {
 167         MM_CAMCORDER_ROTATION_NUM,
 168         __enum_conv_rotation_ctrl,
 169         CONFIGURE_CATEGORY_CTRL_EFFECT,
 170         "Rotation"
 171 };
 172
 173
 174 static int __enum_conv_ahs[MM_CAMCORDER_AHS_NUM];
 175
 176 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_ahs =
 177 {
 178         MM_CAMCORDER_AHS_NUM,
 179         __enum_conv_ahs,
 180         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 181         "AntiHandshake"
 182 };
 183
 184
 185 static int __enum_conv_video_stabilization[MM_CAMCORDER_VIDEO_STABILIZATION_NUM];
 186
 187 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
 188 {
 189         MM_CAMCORDER_VIDEO_STABILIZATION_NUM,
 190         __enum_conv_video_stabilization,
 191         CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 192         "VideoStabilization"
 193 };
 194
 195
 196 static int __enum_conv_hdr_capture[MM_CAMCORDER_HDR_CAPTURE_NUM];
 197
 198 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
 199 {
 200         MM_CAMCORDER_HDR_CAPTURE_NUM,
 201         __enum_conv_hdr_capture,
 202         CONFIGURE_CATEGORY_CTRL_CAPTURE,
 203         "SupportHDR"
 204 };
 205
 206 static int __enum_conv_detect_mode[MM_CAMCORDER_DETECT_MODE_NUM];
 207
 208 _MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode =
 209 {
 210         MM_CAMCORDER_DETECT_MODE_NUM,
 211         __enum_conv_detect_mode,
 212         CONFIGURE_CATEGORY_CTRL_DETECT,
 213         "DetectMode"
 214 };
 215
 216
 217 /**
 218  * Matching table of caminfo index with category enum of attribute.
 219  * If predefined item is changed, this static variables should be changed.
 220  * For detail information, refer below documents.
 221  *
 222  */
 223 static _MMCamcorderInfoConverting       g_audio_info[] = {
 224         {
 225                 CONFIGURE_TYPE_MAIN,
 226                 CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
 227                 MM_CAM_AUDIO_DEVICE,
 228                 MM_CAMCORDER_ATTR_NONE,
 229                 "AudioDevice",
 230                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 231                 NULL,
 232         }
 233 };
 234
 235 static _MMCamcorderInfoConverting       g_display_info[] = {
 236         {
 237                 CONFIGURE_TYPE_MAIN,
 238                 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
 239                 MM_CAM_DISPLAY_DEVICE,
 240                 MM_CAMCORDER_ATTR_NONE,
 241                 "DisplayDevice",
 242                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 243                 NULL,
 244         },
 245         {
 246                 CONFIGURE_TYPE_MAIN,
 247                 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
 248                 MM_CAM_DISPLAY_MODE,
 249                 MM_CAMCORDER_ATTR_NONE,
 250                 "DisplayMode",
 251                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 252                 NULL,
 253         },
 254         {
 255                 CONFIGURE_TYPE_MAIN,
 256                 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
 257                 MM_CAM_DISPLAY_SURFACE,
 258                 MM_CAMCORDER_ATTR_NONE,
 259                 "Videosink",
 260                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 261                 NULL,
 262         },
 263 };
 264
 265 static _MMCamcorderInfoConverting       g_caminfo_convert[CAMINFO_CONVERT_NUM] = {
 266         {
 267                 CONFIGURE_TYPE_CTRL,
 268                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 269                 MM_CAM_CAMERA_DEVICE_NAME,
 270                 MM_CAMCORDER_ATTR_NONE,
 271                 "DeviceName",
 272                 MM_CAMCONVERT_TYPE_STRING,
 273                 NULL,
 274         },
 275         {
 276                 CONFIGURE_TYPE_CTRL,
 277                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 278                 MM_CAM_CAMERA_WIDTH,
 279                 MM_CAM_CAMERA_HEIGHT,
 280                 "PreviewResolution",
 281                 MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
 282                 NULL,
 283         },
 284         {
 285                 CONFIGURE_TYPE_CTRL,
 286                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 287                 MM_CAM_CAPTURE_WIDTH,
 288                 MM_CAM_CAPTURE_HEIGHT,
 289                 "CaptureResolution",
 290                 MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
 291                 NULL,
 292         },
 293         {
 294                 CONFIGURE_TYPE_CTRL,
 295                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 296                 MM_CAM_CAMERA_FORMAT,
 297                 MM_CAMCORDER_ATTR_NONE,
 298                 "PictureFormat",
 299                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 300                 NULL,
 301         },
 302         {
 303                 CONFIGURE_TYPE_CTRL,
 304                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 305                 MM_CAM_CAMERA_PAN_MECHA,
 306                 MM_CAMCORDER_ATTR_NONE,
 307                 "PanMecha",
 308                 MM_CAMCONVERT_TYPE_INT_RANGE,
 309                 NULL,
 310         },
 311         {
 312                 CONFIGURE_TYPE_CTRL,
 313                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 314                 MM_CAM_CAMERA_PAN_ELEC,
 315                 MM_CAMCORDER_ATTR_NONE,
 316                 "PanElec",
 317                 MM_CAMCONVERT_TYPE_INT_RANGE,
 318                 NULL,
 319         },
 320         {
 321                 CONFIGURE_TYPE_CTRL,
 322                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 323                 MM_CAM_CAMERA_TILT_MECHA,
 324                 MM_CAMCORDER_ATTR_NONE,
 325                 "TiltMecha",
 326                 MM_CAMCONVERT_TYPE_INT_RANGE,
 327                 NULL,
 328         },
 329         {
 330                 CONFIGURE_TYPE_CTRL,
 331                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 332                 MM_CAM_CAMERA_TILT_ELEC,
 333                 MM_CAMCORDER_ATTR_NONE,
 334                 "TiltElec",
 335                 MM_CAMCONVERT_TYPE_INT_RANGE,
 336                 NULL,
 337         },
 338         {
 339                 CONFIGURE_TYPE_CTRL,
 340                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 341                 MM_CAM_CAMERA_PTZ_TYPE,
 342                 MM_CAMCORDER_ATTR_NONE,
 343                 "PtzType",
 344                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 345                 NULL,
 346         },
 347         {/* 10 */
 348                 CONFIGURE_TYPE_CTRL,
 349                 CONFIGURE_CATEGORY_CTRL_STROBE,
 350                 MM_CAM_STROBE_CONTROL,
 351                 MM_CAMCORDER_ATTR_NONE,
 352                 "StrobeControl",
 353                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 354                 &_mmcamcorder_enum_conv_strobe_ctrl,
 355         },
 356         {
 357                 CONFIGURE_TYPE_CTRL,
 358                 CONFIGURE_CATEGORY_CTRL_STROBE,
 359                 MM_CAM_STROBE_CAPABILITIES,
 360                 MM_CAMCORDER_ATTR_NONE,
 361                 "StrobeCapabilities",
 362                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 363                 NULL,
 364         },
 365         {
 366                 CONFIGURE_TYPE_CTRL,
 367                 CONFIGURE_CATEGORY_CTRL_STROBE,
 368                 MM_CAM_STROBE_MODE,
 369                 MM_CAMCORDER_ATTR_NONE,
 370                 "StrobeMode",
 371                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 372                 &_mmcamcorder_enum_conv_strobe_mode,
 373         },
 374         {
 375                 CONFIGURE_TYPE_CTRL,
 376                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 377                 MM_CAM_FILTER_BRIGHTNESS,
 378                 MM_CAMCORDER_ATTR_NONE,
 379                 "Brightness",
 380                 MM_CAMCONVERT_TYPE_INT_RANGE,
 381                 NULL,
 382         },
 383         {
 384                 CONFIGURE_TYPE_CTRL,
 385                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 386                 MM_CAM_FILTER_CONTRAST,
 387                 MM_CAMCORDER_ATTR_NONE,
 388                 "Contrast",
 389                 MM_CAMCONVERT_TYPE_INT_RANGE,
 390                 NULL,
 391         },
 392         {
 393                 CONFIGURE_TYPE_CTRL,
 394                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 395                 MM_CAM_FILTER_SATURATION,
 396                 MM_CAMCORDER_ATTR_NONE,
 397                 "Saturation",
 398                 MM_CAMCONVERT_TYPE_INT_RANGE,
 399                 NULL,
 400         },
 401         {
 402                 CONFIGURE_TYPE_CTRL,
 403                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 404                 MM_CAM_FILTER_HUE,
 405                 MM_CAMCORDER_ATTR_NONE,
 406                 "Hue",
 407                 MM_CAMCONVERT_TYPE_INT_RANGE,
 408                 NULL,
 409         },
 410         {
 411                 CONFIGURE_TYPE_CTRL,
 412                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 413                 MM_CAM_FILTER_SHARPNESS,
 414                 MM_CAMCORDER_ATTR_NONE,
 415                 "Sharpness",
 416                 MM_CAMCONVERT_TYPE_INT_RANGE,
 417                 NULL,
 418         },
 419         {
 420                 CONFIGURE_TYPE_CTRL,
 421                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 422                 MM_CAM_FILTER_WB,
 423                 MM_CAMCORDER_ATTR_NONE,
 424                 "WhiteBalance",
 425                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 426                 &_mmcamcorder_enum_conv_whitebalance,
 427         },
 428         {
 429                 CONFIGURE_TYPE_CTRL,
 430                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 431                 MM_CAM_FILTER_COLOR_TONE,
 432                 MM_CAMCORDER_ATTR_NONE,
 433                 "ColorTone",
 434                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 435                 &_mmcamcorder_enum_conv_colortone,
 436         },
 437         {/* 20 */
 438                 CONFIGURE_TYPE_CTRL,
 439                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 440                 MM_CAM_CAMERA_WDR,
 441                 MM_CAMCORDER_ATTR_NONE,
 442                 "WDR",
 443                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 444                 &_mmcamcorder_enum_conv_wdr_ctrl,
 445         },
 446         {
 447                 CONFIGURE_TYPE_CTRL,
 448                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 449                 MM_CAM_CAMERA_FLIP,
 450                 MM_CAMCORDER_ATTR_NONE,
 451                 "Flip",
 452                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 453                 &_mmcamcorder_enum_conv_flip_ctrl,
 454         },
 455         {
 456                 CONFIGURE_TYPE_CTRL,
 457                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 458                 MM_CAM_CAMERA_ROTATION,
 459                 MM_CAMCORDER_ATTR_NONE,
 460                 "Rotation",
 461                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 462                 &_mmcamcorder_enum_conv_rotation_ctrl,
 463         },
 464         {
 465                 CONFIGURE_TYPE_CTRL,
 466                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 467                 MM_CAM_CAMERA_DIGITAL_ZOOM,
 468                 MM_CAMCORDER_ATTR_NONE,
 469                 "DigitalZoom",
 470                 MM_CAMCONVERT_TYPE_INT_RANGE,
 471                 NULL,
 472         },
 473         {
 474                 CONFIGURE_TYPE_CTRL,
 475                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 476                 MM_CAM_CAMERA_OPTICAL_ZOOM,
 477                 MM_CAMCORDER_ATTR_NONE,
 478                 "OpticalZoom",
 479                 MM_CAMCONVERT_TYPE_INT_RANGE,
 480                 NULL,
 481         },
 482         {
 483                 CONFIGURE_TYPE_CTRL,
 484                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 485                 MM_CAM_CAMERA_FOCUS_MODE,
 486                 MM_CAMCORDER_ATTR_NONE,
 487                 "FocusMode",
 488                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 489                 &_mmcamcorder_enum_conv_focus_mode,
 490         },
 491         {
 492                 CONFIGURE_TYPE_CTRL,
 493                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 494                 MM_CAM_CAMERA_AF_SCAN_RANGE,
 495                 MM_CAMCORDER_ATTR_NONE,
 496                 "AFType",
 497                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 498                 &_mmcamcorder_enum_conv_focus_type,
 499         },
 500         {
 501                 CONFIGURE_TYPE_CTRL,
 502                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 503                 MM_CAM_CAMERA_EXPOSURE_MODE,
 504                 MM_CAMCORDER_ATTR_NONE,
 505                 "AEType",
 506                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 507                 &_mmcamcorder_enum_conv_ae_type,
 508         },
 509         {
 510                 CONFIGURE_TYPE_CTRL,
 511                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 512                 MM_CAM_CAMERA_EXPOSURE_VALUE,
 513                 MM_CAMCORDER_ATTR_NONE,
 514                 "ExposureValue",
 515                 MM_CAMCONVERT_TYPE_INT_RANGE,
 516                 NULL,
 517         },
 518         {
 519                 CONFIGURE_TYPE_CTRL,
 520                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 521                 MM_CAM_CAMERA_F_NUMBER,
 522                 MM_CAMCORDER_ATTR_NONE,
 523                 "FNumber",
 524                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 525                 NULL,
 526         },
 527         {/* 30 */
 528                 CONFIGURE_TYPE_CTRL,
 529                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 530                 MM_CAM_CAMERA_SHUTTER_SPEED,
 531                 MM_CAMCORDER_ATTR_NONE,
 532                 "ShutterSpeed",
 533                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 534                 NULL,
 535         },
 536         {
 537                 CONFIGURE_TYPE_CTRL,
 538                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 539                 MM_CAM_CAMERA_ISO,
 540                 MM_CAMCORDER_ATTR_NONE,
 541                 "ISO",
 542                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 543                 &_mmcamcorder_enum_conv_iso,
 544         },
 545         {
 546                 CONFIGURE_TYPE_CTRL,
 547                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 548                 MM_CAM_FILTER_SCENE_MODE,
 549                 MM_CAMCORDER_ATTR_NONE,
 550                 "ProgramMode",
 551                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 552                 &_mmcamcorder_enum_conv_prgrm,
 553         },
 554         {
 555                 CONFIGURE_TYPE_CTRL,
 556                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 557                 MM_CAM_CAMERA_ANTI_HANDSHAKE,
 558                 MM_CAMCORDER_ATTR_NONE,
 559                 "AntiHandshake",
 560                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 561                 &_mmcamcorder_enum_conv_ahs,
 562         },
 563         {
 564                 CONFIGURE_TYPE_CTRL,
 565                 CONFIGURE_CATEGORY_CTRL_CAPTURE,
 566                 MM_CAM_CAPTURE_FORMAT,
 567                 MM_CAMCORDER_ATTR_NONE,
 568                 "OutputMode",
 569                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 570                 NULL,
 571         },
 572         {
 573                 CONFIGURE_TYPE_CTRL,
 574                 CONFIGURE_CATEGORY_CTRL_CAPTURE,
 575                 MM_CAM_IMAGE_ENCODER_QUALITY,
 576                 MM_CAMCORDER_ATTR_NONE,
 577                 "JpegQuality",
 578                 MM_CAMCONVERT_TYPE_INT_RANGE,
 579                 NULL,
 580         },
 581         {
 582                 CONFIGURE_TYPE_CTRL,
 583                 CONFIGURE_CATEGORY_CTRL_CAPTURE,
 584                 MM_CAM_CAPTURE_COUNT,
 585                 MM_CAMCORDER_ATTR_NONE,
 586                 "MultishotNumber",
 587                 MM_CAMCONVERT_TYPE_INT_RANGE,
 588                 NULL,
 589         },
 590         {
 591                 CONFIGURE_TYPE_CTRL,
 592                 CONFIGURE_CATEGORY_CTRL_CAPTURE,
 593                 MM_CAM_CAMERA_HDR_CAPTURE,
 594                 MM_CAMCORDER_ATTR_NONE,
 595                 "SupportHDR",
 596                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 597                 &_mmcamcorder_enum_conv_hdr_capture,
 598         },
 599         {
 600                 CONFIGURE_TYPE_CTRL,
 601                 CONFIGURE_CATEGORY_CTRL_DETECT,
 602                 MM_CAM_DETECT_MODE,
 603                 MM_CAMCORDER_ATTR_NONE,
 604                 "DetectMode",
 605                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 606                 &_mmcamcorder_enum_conv_detect_mode,
 607         },
 608         {
 609                 CONFIGURE_TYPE_CTRL,
 610                 CONFIGURE_CATEGORY_CTRL_DETECT,
 611                 MM_CAM_DETECT_NUMBER,
 612                 MM_CAMCORDER_ATTR_NONE,
 613                 "DetectNumber",
 614                 MM_CAMCONVERT_TYPE_INT_RANGE,
 615                 NULL,
 616         },
 617         {/* 40 */
 618                 CONFIGURE_TYPE_CTRL,
 619                 CONFIGURE_CATEGORY_CTRL_DETECT,
 620                 MM_CAM_DETECT_FOCUS_SELECT,
 621                 MM_CAMCORDER_ATTR_NONE,
 622                 "DetectFocusSelect",
 623                 MM_CAMCONVERT_TYPE_INT_RANGE,
 624                 NULL,
 625         },
 626         {
 627                 CONFIGURE_TYPE_CTRL,
 628                 CONFIGURE_CATEGORY_CTRL_DETECT,
 629                 MM_CAM_DETECT_SELECT_NUMBER,
 630                 MM_CAMCORDER_ATTR_NONE,
 631                 "DetectSelectNumber",
 632                 MM_CAMCONVERT_TYPE_INT_RANGE,
 633                 NULL,
 634         },
 635         {
 636                 CONFIGURE_TYPE_CTRL,
 637                 CONFIGURE_CATEGORY_CTRL_DETECT,
 638                 MM_CAM_DETECT_STATUS,
 639                 MM_CAMCORDER_ATTR_NONE,
 640                 "DetectStatus",
 641                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 642                 NULL,
 643         },
 644         {
 645                 CONFIGURE_TYPE_CTRL,
 646                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 647                 MM_CAM_RECOMMEND_CAMERA_WIDTH,
 648                 MM_CAM_RECOMMEND_CAMERA_HEIGHT,
 649                 "RecommendPreviewResolution",
 650                 MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
 651                 NULL,
 652         },
 653         {
 654                 CONFIGURE_TYPE_CTRL,
 655                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 656                 MM_CAM_CAMERA_VIDEO_STABILIZATION,
 657                 MM_CAMCORDER_ATTR_NONE,
 658                 "VideoStabilization",
 659                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 660                 &_mmcamcorder_enum_conv_video_stabilization,
 661         },
 662         {
 663                 CONFIGURE_TYPE_CTRL,
 664                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 665                 MM_CAM_VIDEO_WIDTH,
 666                 MM_CAM_VIDEO_HEIGHT,
 667                 "VideoResolution",
 668                 MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
 669                 NULL,
 670         }
 671 };
 672
 673 /*---------------------------------------------------------------------------
 674 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
 675 ---------------------------------------------------------------------------*/
 676 /* STATIC INTERNAL FUNCTION */
 677 static int  __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default );
 678
 679 /*===========================================================================================
 680 |                                                                                                                                                                                       |
 681 |  FUNCTION DEFINITIONS                                                                                                                                         |
 682 |                                                                                                                                                                                       |
 683 ========================================================================================== */
 684 /*---------------------------------------------------------------------------
 685 |    GLOBAL FUNCTION DEFINITIONS:                                                                                       |
 686 ---------------------------------------------------------------------------*/
 687 //convert MSL value to sensor value
 688 int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
 689 {
 690         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 691         _MMCamcorderInfoConverting *info = NULL;
 692         int i =0;
 693         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 694
 695         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 696
 697         //_mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval);
 698
 699         info = hcamcorder->caminfo_convert;
 700
 701         for (i = 0; i < size; i++)
 702         {
 703                 if (info[i].attr_idx == attr_idx)
 704                 {
 705                         _MMCamcorderEnumConvert * enum_convert = NULL;
 706                         enum_convert = info[i].enum_convert;
 707
 708                         if (enum_convert == NULL)
 709                         {
 710                                 //_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
 711                                 return mslval;
 712                         }
 713
 714                         if (enum_convert->enum_arr == NULL)
 715                         {
 716                                 _mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 717                                 return mslval;
 718                         }
 719
 720                         if( enum_convert->total_enum_num > mslval && mslval >= 0 )
 721                         {
 722                                 //_mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]);
 723                                 return enum_convert->enum_arr[mslval];
 724                         }
 725                         else
 726                         {
 727                                 _mmcam_dbg_warn( "Input mslval[%d] is invalid(out of array[idx:%d,size:%d]), so can not convert. Just return the original value.", mslval, attr_idx, enum_convert->total_enum_num );
 728                                 return mslval;
 729                         }
 730                 }
 731         }
 732
 733         _mmcam_dbg_warn("There is no category to match. Just return the original value.");
 734
 735         return mslval;
 736 }
 737
 738 int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height,  MMCamAttrsInfo* fps_info)
 739 {
 740         MMCamAttrsInfo *infoW = NULL;
 741         MMCamAttrsInfo *infoH = NULL;
 742         int i = 0;
 743         char nameFps[10] = {0,};
 744         bool valid_check = false;
 745
 746         type_int_array *fps_array;
 747
 748         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 749
 750         //_mmcam_dbg_log("prev resolution w:%d, h:%d", width, height);
 751
 752         infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 753         if (infoW == NULL) {
 754                 _mmcam_dbg_err("failed to alloc infoW");
 755                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 756         }
 757
 758         infoH = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 759         if (infoH == NULL) {
 760                 _mmcam_dbg_err("failed to alloc infoH");
 761
 762                 free(infoW);
 763                 infoW = NULL;
 764
 765                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 766         }
 767
 768         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
 769         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
 770
 771         for(i=0; i < infoW->int_array.count; i++) {
 772                 //_mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]);
 773                 if(infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
 774                         valid_check = true;
 775                         snprintf(nameFps, 10, "FPS%d", i);
 776                         _mmcam_dbg_log("nameFps : %s!!!", nameFps);
 777                         break;
 778                 }
 779         }
 780
 781         free(infoW);
 782         infoW = NULL;
 783         free(infoH);
 784         infoH = NULL;
 785
 786         if(!valid_check) {
 787                 _mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
 788                 return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 789         }
 790
 791         if (!_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, nameFps, &fps_array)) {
 792                 _mmcam_dbg_err("FAILED : Can't find the valid FPS array.");
 793                 return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 794         }
 795
 796         fps_info->int_array.count = fps_array->count;
 797         fps_info->int_array.array = fps_array->value;
 798         fps_info->int_array.def = fps_array->default_value;
 799
 800         return MM_ERROR_NONE;
 801 }
 802
 803 //convert sensor value to MSL value
 804 int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
 805 {
 806         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 807         _MMCamcorderInfoConverting *info = NULL;
 808         int i = 0, j = 0;
 809         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 810
 811         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 812
 813         info = hcamcorder->caminfo_convert;
 814
 815         for( i = 0 ; i < size ; i++ )
 816         {
 817                 if( info[i].attr_idx == attr_idx )
 818                 {
 819                         _MMCamcorderEnumConvert * enum_convert = NULL;
 820                         enum_convert = info[i].enum_convert;
 821
 822                         if( enum_convert == NULL )
 823                         {
 824                                 //_mmcam_dbg_log("enum_convert is NULL. Just return the original value.");
 825                                 return sensval;
 826                         }
 827
 828                         if( enum_convert->enum_arr == NULL )
 829                         {
 830                                 _mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 831                                 return sensval;
 832                         }
 833
 834                         for( j = 0 ; j < enum_convert->total_enum_num ; j++ )
 835                         {
 836                                 if( sensval == enum_convert->enum_arr[j] )
 837                                 {
 838                                         //_mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j);
 839                                         return j;
 840                                 }
 841                         }
 842
 843                         _mmcam_dbg_warn("There is no sensor value matched with input param. Just return the original value.");
 844                         return sensval;
 845
 846                 }
 847         }
 848
 849         _mmcam_dbg_log("There is no category to match. Just return the original value.");
 850         return sensval;
 851 }
 852
 853 static int
 854 __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default )
 855 {
 856         int i = 0;
 857         int valid_count = 0;
 858         int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
 859
 860         for (i = 0; i < original_count; i++) {
 861                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
 862                         valid_count++;
 863                 }
 864         }
 865
 866         if (valid_count > 0) {
 867                 *valid_array = (int*)malloc(sizeof(int) * valid_count);
 868
 869                 if (*valid_array) {
 870                         valid_count = 0;
 871                         for (i = 0; i < original_count; i++) {
 872                                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
 873                                         (*valid_array)[valid_count++] = i;
 874                                         /*_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );*/
 875
 876                                         if (original_array[i] == *valid_default &&
 877                                             new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
 878                                                 new_default = i;
 879                                                 /*_mmcam_dbg_log( "converted MSL default[%d]", new_default );*/
 880                                         }
 881                                 }
 882                         }
 883                 }
 884                 else {
 885                         valid_count = 0;
 886                 }
 887         }
 888
 889         if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE) {
 890                 *valid_default = new_default;
 891         }
 892
 893         return valid_count;
 894 }
 895
 896
 897 int _mmcamcorder_init_attr_from_configure(MMHandleType handle, MMCamConvertingCategory category)
 898 {
 899         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 900         _MMCamcorderInfoConverting *info = NULL;
 901
 902         int table_size = 0;
 903         int ret = MM_ERROR_NONE;
 904
 905         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 906
 907         _mmcam_dbg_log("category : %d", category);
 908
 909         if (category & MM_CAMCONVERT_CATEGORY_CAMERA) {
 910                 /* Initialize attribute related to camera control */
 911                 info = hcamcorder->caminfo_convert;
 912                 table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 913                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 914                 if (ret != MM_ERROR_NONE) {
 915                         _mmcam_dbg_err("camera info set error : 0x%x", ret);
 916                         return ret;
 917                 }
 918         }
 919
 920         if (category & MM_CAMCONVERT_CATEGORY_DISPLAY) {
 921                 /* Initialize attribute related to display */
 922                 info = g_display_info;
 923                 table_size = sizeof(g_display_info) / sizeof(_MMCamcorderInfoConverting);
 924                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 925                 if (ret != MM_ERROR_NONE) {
 926                         _mmcam_dbg_err("display info set error : 0x%x", ret);
 927                         return ret;
 928                 }
 929         }
 930
 931         if (category & MM_CAMCONVERT_CATEGORY_AUDIO) {
 932                 /* Initialize attribute related to audio */
 933                 info = g_audio_info;
 934                 table_size = sizeof(g_audio_info) / sizeof(_MMCamcorderInfoConverting);
 935                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 936                 if (ret != MM_ERROR_NONE) {
 937                         _mmcam_dbg_err("audio info set error : 0x%x", ret);
 938                         return ret;
 939                 }
 940         }
 941
 942         _mmcam_dbg_log("done");
 943
 944         return ret;
 945 }
 946
 947
 948 int __mmcamcorder_set_info_to_attr(MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size)
 949 {
 950         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 951         MMHandleType     attrs      = 0;
 952
 953         int i = 0;
 954         int ret = MM_ERROR_NONE;
 955
 956         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 957
 958         attrs = MMF_CAMCORDER_ATTRS (handle);
 959         mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 960
 961         camera_conf *conf_info = NULL;
 962
 963         for (i = 0; i < table_size ; i++ )
 964         {
 965                 /*
 966                 _mmcam_dbg_log( "%d,%d,%d,%d,%s,%d",
 967                                 info[i].type,
 968                                 info[i].category,
 969                                 info[i].attr_idx,
 970                                 info[i].attr_idx_pair,
 971                                 info[i].keyword,
 972                                 info[i].conv_type );
 973                 */
 974
 975                 if( info[i].type == CONFIGURE_TYPE_MAIN )
 976                 {
 977                         conf_info = hcamcorder->conf_main;
 978                         /*_mmcam_dbg_log( "MAIN configure [%s]", info[i].keyword );*/
 979                 }
 980                 else
 981                 {
 982                         conf_info = hcamcorder->conf_ctrl;
 983                         /*_mmcam_dbg_log( "CTRL configure [%s]", info[i].keyword );*/
 984                 }
 985
 986                 switch(info[i].conv_type)
 987                 {
 988                         case MM_CAMCONVERT_TYPE_INT:
 989                         {
 990                                 int ivalue = 0;
 991
 992                                 if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue))
 993                                 {
 994                                         ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 995                                         break;          //skip to set
 996                                 }
 997
 998                                 ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
 999                                 break;
1000                         }
1001                         case MM_CAMCONVERT_TYPE_INT_ARRAY:
1002                         {
1003                                 int *iarray = NULL;
1004                                 int iarray_size = 0;
1005                                 int idefault = 0;
1006                                 type_int_array *tarray = NULL;
1007
1008                                 if (!_mmcamcorder_conf_get_value_int_array( conf_info, info[i].category, info[i].keyword, &tarray ))
1009                                 {
1010                                         ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1011                                         break;          //skip to set
1012                                 }
1013
1014                                 if( tarray )
1015                                 {
1016                                         idefault = tarray->default_value;
1017
1018                                         if( info[i].enum_convert )
1019                                         {
1020                                                 iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
1021                                         }
1022                                         else
1023                                         {
1024                                                 iarray = tarray->value;
1025                                                 iarray_size = tarray->count;
1026                                         }
1027
1028                                         if( iarray_size > 0 )
1029                                         {
1030                                                 /*
1031                                                 _mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
1032                                                                info[i].attr_idx, iarray, iarray_size, idefault);
1033                                                 */
1034
1035                                                 /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1036                                                 //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
1037                                                 mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
1038
1039                                                 ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
1040                                         }
1041                                 }
1042
1043                                 if (iarray && iarray != tarray->value )
1044                                         free(iarray);
1045
1046                                 break;
1047                         }
1048                         case MM_CAMCONVERT_TYPE_INT_RANGE:
1049                         {
1050                                 type_int_range *irange = NULL;
1051
1052                                 if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange))
1053                                 {
1054                                         ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1055                                         break;          //skip to set
1056                                 }
1057
1058                                 if( irange )
1059                                 {
1060                                         //_mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max);
1061                                         /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1062                                         //mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
1063                                         mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
1064
1065                                         ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
1066                                 }
1067
1068                                 break;
1069                         }
1070                         case MM_CAMCONVERT_TYPE_STRING:
1071                         {
1072                                 const char *cString = NULL;
1073                                 unsigned int iString_len = 0;
1074
1075                                 if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString ))
1076                                 {
1077                                         ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1078                                         break;          //skip to set
1079                                 }
1080
1081                                 //_mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString);
1082                                 //strlen makes a crash when null pointer is passed.
1083                                 if (cString)
1084                                         iString_len = strlen(cString);
1085                                 else
1086                                         iString_len = 0;
1087
1088                                 ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
1089                                 break;
1090                         }
1091                         case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
1092                         {
1093                                 type_int_pair_array *pair_array = NULL;
1094
1095                                 /*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
1096
1097                                 if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
1098                                 {
1099                                         ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1100                                         break;          //skip to set
1101                                 }
1102
1103                                 if( pair_array && pair_array->count > 0 )
1104                                 {
1105                                         /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1106                                         //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
1107                                         mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
1108                                                                   pair_array->value[0],
1109                                                                   pair_array->count,
1110                                                                   pair_array->default_value[0]);
1111                                         /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1112                                         //mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
1113                                         mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
1114                                                                   pair_array->value[1],
1115                                                                   pair_array->count,
1116                                                                   pair_array->default_value[1]);
1117
1118                                         mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
1119                                         mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
1120                                 }
1121                                 break;
1122                         }
1123
1124                         case MM_CAMCONVERT_TYPE_USER:
1125                         default:
1126                                 _mmcam_dbg_log("default : s:%d", info[i].attr_idx);
1127                                 break;
1128                 }
1129         }
1130
1131         if (ret != MM_ERROR_NONE || mmf_attrs_commit(attrs) == -1)
1132                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1133         else
1134                 return MM_ERROR_NONE;
1135 }
1136
1137
1138 int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConvert * convert)
1139 {
1140         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1141         type_int_array *array = NULL;
1142
1143         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1144
1145         _mmcamcorder_conf_get_value_int_array( hcamcorder->conf_ctrl, convert->category, convert->keyword, &array );
1146
1147         if( array )
1148         {
1149                 convert->enum_arr = array->value;
1150         }
1151
1152         return MM_ERROR_NONE;
1153 }
1154
1155
1156 int _mmcamcorder_init_convert_table(MMHandleType handle)
1157 {
1158         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1159         int enum_conv_size = sizeof(_MMCamcorderEnumConvert);
1160         int caminfo_conv_size = sizeof(g_caminfo_convert);
1161         int caminfo_conv_length = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
1162         int i = 0;
1163
1164         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1165
1166         /* copy default conv data into memory of handle */
1167         memcpy(&(hcamcorder->caminfo_convert), &g_caminfo_convert, caminfo_conv_size);
1168         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]), &_mmcamcorder_enum_conv_whitebalance, enum_conv_size);
1169         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]), &_mmcamcorder_enum_conv_colortone, enum_conv_size);
1170         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ISO]), &_mmcamcorder_enum_conv_iso, enum_conv_size);
1171         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]), &_mmcamcorder_enum_conv_prgrm, enum_conv_size);
1172         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]), &_mmcamcorder_enum_conv_focus_mode, enum_conv_size);
1173         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]), &_mmcamcorder_enum_conv_focus_type, enum_conv_size);
1174         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]), &_mmcamcorder_enum_conv_ae_type, enum_conv_size);
1175         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]), &_mmcamcorder_enum_conv_strobe_mode, enum_conv_size);
1176         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WDR]), &_mmcamcorder_enum_conv_wdr_ctrl, enum_conv_size);
1177         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]), &_mmcamcorder_enum_conv_flip_ctrl, enum_conv_size);
1178         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]), &_mmcamcorder_enum_conv_rotation_ctrl, enum_conv_size);
1179         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]), &_mmcamcorder_enum_conv_ahs, enum_conv_size);
1180         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]), &_mmcamcorder_enum_conv_video_stabilization, enum_conv_size);
1181
1182         /* set ini info to conv data */
1183         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]));
1184         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]));
1185         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]));
1186         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]));
1187         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]));
1188         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]));
1189         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]));
1190         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]));
1191         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]));
1192         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]));
1193         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]));
1194         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]));
1195         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]));
1196
1197         /* set modified conv data to handle */
1198         for (i = 0 ; i < caminfo_conv_length ; i++) {
1199                 if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
1200                         switch (hcamcorder->caminfo_convert[i].category) {
1201                         case CONFIGURE_CATEGORY_CTRL_STROBE:
1202                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode")) {
1203                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
1204                                 }
1205                                 break;
1206                         case CONFIGURE_CATEGORY_CTRL_EFFECT:
1207                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance")) {
1208                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
1209                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone")) {
1210                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
1211                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR")) {
1212                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
1213                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip")) {
1214                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]);
1215                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation")) {
1216                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]);
1217                                 }
1218                                 break;
1219                         case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
1220                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode")) {
1221                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
1222                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType")) {
1223                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
1224                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType")) {
1225                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
1226                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO")) {
1227                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
1228                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode")) {
1229                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
1230                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake")) {
1231                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
1232                                 } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization")) {
1233                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
1234                                 }
1235                                 break;
1236                         default:
1237                                 break;
1238                         }
1239                 }
1240         }
1241
1242         return MM_ERROR_NONE;
1243 }
1244
1245
1246 double _mmcamcorder_convert_volume(int mslVal)
1247 {
1248         double newVal = -1;
1249         switch (mslVal)
1250         {
1251                 case 0:
1252                         newVal = 0;
1253                         break;
1254                 case 1:
1255                         newVal = 1;
1256                         break;
1257                 default:
1258                         _mmcam_dbg_warn("out of range");
1259                         break;
1260         }
1261
1262         return newVal;
1263 }
1264
1265
1266