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