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