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
 676 /*---------------------------------------------------------------------------
 677 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
 678 ---------------------------------------------------------------------------*/
 679 /* STATIC INTERNAL FUNCTION */
 680 static int  __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default);
 681
 682 /*===========================================================================================
 683 |                                                                                                                                                                                       |
 684 |  FUNCTION DEFINITIONS                                                                                                                                         |
 685 |                                                                                                                                                                                       |
 686 ========================================================================================== */
 687 /*---------------------------------------------------------------------------
 688 |    GLOBAL FUNCTION DEFINITIONS:                                                                                       |
 689 ---------------------------------------------------------------------------*/
 690 /* convert MSL value to sensor value */
 691 int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
 692 {
 693         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 694         _MMCamcorderInfoConverting *info = NULL;
 695         int i = 0;
 696         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 697
 698         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 699
 700         info = hcamcorder->caminfo_convert;
 701
 702         for (i = 0; i < size; i++) {
 703                 if (info[i].attr_idx == attr_idx) {
 704                         _MMCamcorderEnumConvert * enum_convert = NULL;
 705                         enum_convert = info[i].enum_convert;
 706
 707                         if (enum_convert == NULL) {
 708                                 MMCAM_LOG_VERBOSE("[attr:%d] NULL enum_convert, just return original[%d]",
 709                                         attr_idx, mslval);
 710                                 return mslval;
 711                         }
 712
 713                         if (enum_convert->enum_arr == NULL) {
 714                                 MMCAM_LOG_WARNING("[attr:%d] NULL array pointer, just return original[%d]",
 715                                         attr_idx, mslval);
 716                                 return mslval;
 717                         }
 718
 719                         if (enum_convert->total_enum_num > mslval && mslval >= 0) {
 720                                 MMCAM_LOG_VERBOSE("[attr:%d] original[%d] -> converted[%d]",
 721                                         attr_idx, mslval, enum_convert->enum_arr[mslval]);
 722                                 return enum_convert->enum_arr[mslval];
 723                         } else {
 724                                 MMCAM_LOG_WARNING("[attr:%d] invalid input mslval[%d][size:%d], just return original.",
 725                                         attr_idx, mslval, enum_convert->total_enum_num);
 726                                 return mslval;
 727                         }
 728                 }
 729         }
 730
 731         MMCAM_LOG_WARNING("[attr:%d] no category to match, just return original[%d]",
 732                 attr_idx, mslval);
 733
 734         return mslval;
 735 }
 736
 737 int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height,  MMCamAttrsInfo* fps_info)
 738 {
 739         MMCamAttrsInfo *infoW = NULL;
 740         MMCamAttrsInfo *infoH = NULL;
 741         int i = 0;
 742         char nameFps[16] = {0,};
 743         bool valid_check = false;
 744
 745         type_int_array *fps_array;
 746
 747         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 748
 749         MMCAM_LOG_DEBUG("resolution %dx%d", width, height);
 750
 751         infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 752         if (infoW == NULL) {
 753                 MMCAM_LOG_ERROR("failed to alloc infoW");
 754                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 755         }
 756
 757         infoH = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 758         if (infoH == NULL) {
 759                 MMCAM_LOG_ERROR("failed to alloc infoH");
 760
 761                 free(infoW);
 762                 infoW = NULL;
 763
 764                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 765         }
 766
 767         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
 768         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
 769
 770         for (i = 0; i < infoW->int_array.count; i++) {
 771                 MMCAM_LOG_VERBOSE("check resolution %dx%d", infoW->int_array.array[i], infoH->int_array.array[i]);
 772                 if (infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
 773                         valid_check = true;
 774                         snprintf(nameFps, sizeof(nameFps), "FPS%d", i);
 775                         MMCAM_LOG_INFO("nameFps[%s]", nameFps);
 776                         break;
 777                 }
 778         }
 779
 780         free(infoW);
 781         infoW = NULL;
 782         free(infoH);
 783         infoH = NULL;
 784
 785         if (!valid_check) {
 786                 MMCAM_LOG_ERROR("FAILED : Can't find the valid resolution from attribute.");
 787                 return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 788         }
 789
 790         if (!_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, nameFps, &fps_array)) {
 791                 MMCAM_LOG_ERROR("FAILED : Can't find the valid FPS array.");
 792                 return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 793         }
 794
 795         fps_info->int_array.count = fps_array->count;
 796         fps_info->int_array.array = fps_array->value;
 797         fps_info->int_array.def = fps_array->default_value;
 798
 799         return MM_ERROR_NONE;
 800 }
 801
 802 /* convert sensor value to MSL value */
 803 int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
 804 {
 805         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 806         _MMCamcorderInfoConverting *info = NULL;
 807         int i = 0, j = 0;
 808         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 809
 810         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 811
 812         info = hcamcorder->caminfo_convert;
 813
 814         for (i = 0 ; i < size ; i++) {
 815                 if (info[i].attr_idx == attr_idx) {
 816                         _MMCamcorderEnumConvert * enum_convert = NULL;
 817                         enum_convert = info[i].enum_convert;
 818
 819                         if (enum_convert == NULL) {
 820                                 MMCAM_LOG_VERBOSE("[attr:%d] NULL enum_convert, just return original[%d]",
 821                                         attr_idx, sensval);
 822                                 return sensval;
 823                         }
 824
 825                         if (enum_convert->enum_arr == NULL) {
 826                                 MMCAM_LOG_WARNING("[attr:%d] NULL array pointer, just return original[%d]",
 827                                         attr_idx, sensval);
 828                                 return sensval;
 829                         }
 830
 831                         for (j = 0 ; j < enum_convert->total_enum_num ; j++) {
 832                                 if (sensval == enum_convert->enum_arr[j]) {
 833                                         MMCAM_LOG_VERBOSE("[attr:%d] original[%d] -> converted[%d]",
 834                                                 attr_idx, sensval, j);
 835                                         return j;
 836                                 }
 837                         }
 838
 839                         MMCAM_LOG_WARNING("[attr:%d] no sensor value matched, just return original[%d]",
 840                                 attr_idx, sensval);
 841
 842                         return sensval;
 843
 844                 }
 845         }
 846
 847         MMCAM_LOG_INFO("[attr:%d] no category to match, just return original[%d]",
 848                 attr_idx, sensval);
 849
 850         return sensval;
 851 }
 852
 853 static int __mmcamcorder_get_valid_array(int *original_array, int original_count, int **valid_array, int *valid_default)
 854 {
 855         int i = 0;
 856         int valid_count = 0;
 857         int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
 858
 859         for (i = 0; i < original_count; i++) {
 860                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
 861                         valid_count++;
 862         }
 863
 864         if (valid_count > 0) {
 865                 *valid_array = (int*)malloc(sizeof(int) * valid_count);
 866
 867                 if (*valid_array) {
 868                         valid_count = 0;
 869                         for (i = 0; i < original_count; i++) {
 870                                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
 871                                         (*valid_array)[valid_count++] = i;
 872                                         MMCAM_LOG_VERBOSE("valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1]);
 873
 874                                         if (original_array[i] == *valid_default &&
 875                                             new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
 876                                                 new_default = i;
 877                                                 MMCAM_LOG_VERBOSE("converted MSL default[%d]", new_default);
 878                                         }
 879                                 }
 880                         }
 881                 } else {
 882                         valid_count = 0;
 883                 }
 884         }
 885
 886         if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE)
 887                 *valid_default = new_default;
 888
 889         return valid_count;
 890 }
 891
 892
 893 int _mmcamcorder_init_attr_from_configure(MMHandleType handle, MMCamConvertingCategory category)
 894 {
 895         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 896         _MMCamcorderInfoConverting *info = NULL;
 897
 898         int table_size = 0;
 899         int ret = MM_ERROR_NONE;
 900
 901         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 902
 903         MMCAM_LOG_INFO("category : %d", category);
 904
 905         if (category & MM_CAMCONVERT_CATEGORY_CAMERA) {
 906                 /* Initialize attribute related to camera control */
 907                 info = hcamcorder->caminfo_convert;
 908                 table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 909                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 910                 if (ret != MM_ERROR_NONE) {
 911                         MMCAM_LOG_ERROR("camera info set error : 0x%x", ret);
 912                         return ret;
 913                 }
 914         }
 915
 916         if (category & MM_CAMCONVERT_CATEGORY_DISPLAY) {
 917                 /* Initialize attribute related to display */
 918                 info = g_display_info;
 919                 table_size = sizeof(g_display_info) / sizeof(_MMCamcorderInfoConverting);
 920                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 921                 if (ret != MM_ERROR_NONE) {
 922                         MMCAM_LOG_ERROR("display info set error : 0x%x", ret);
 923                         return ret;
 924                 }
 925         }
 926
 927         if (category & MM_CAMCONVERT_CATEGORY_AUDIO) {
 928                 /* Initialize attribute related to audio */
 929                 info = g_audio_info;
 930                 table_size = sizeof(g_audio_info) / sizeof(_MMCamcorderInfoConverting);
 931                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 932                 if (ret != MM_ERROR_NONE) {
 933                         MMCAM_LOG_ERROR("audio info set error : 0x%x", ret);
 934                         return ret;
 935                 }
 936         }
 937
 938         MMCAM_LOG_INFO("done");
 939
 940         return ret;
 941 }
 942
 943
 944 int __mmcamcorder_set_info_to_attr(MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size)
 945 {
 946         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 947         MMHandleType     attrs      = 0;
 948
 949         int i = 0;
 950         int ret = MM_ERROR_NONE;
 951
 952         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 953
 954         attrs = MMF_CAMCORDER_ATTRS(handle);
 955         mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 956
 957         camera_conf *conf_info = NULL;
 958
 959         for (i = 0; i < table_size; i++) {
 960                 MMCAM_LOG_VERBOSE("[type:%d][cat:%d][attr:%d][attr_pair:%d][key:%s][ctype:%d]",
 961                         info[i].type,
 962                         info[i].category,
 963                         info[i].attr_idx,
 964                         info[i].attr_idx_pair,
 965                         info[i].keyword,
 966                         info[i].conv_type);
 967
 968                 if (ret != MM_ERROR_NONE)
 969                         break;
 970
 971                 if (info[i].type == CONFIGURE_TYPE_MAIN)
 972                         conf_info = hcamcorder->conf_main;
 973                 else
 974                         conf_info = hcamcorder->conf_ctrl;
 975
 976                 switch (info[i].conv_type) {
 977                 case MM_CAMCONVERT_TYPE_INT:
 978                 {
 979                         int ivalue = 0;
 980
 981                         if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue)) {
 982                                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 983                                 break; /* skip to set */
 984                         }
 985
 986                         ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
 987                         break;
 988                 }
 989                 case MM_CAMCONVERT_TYPE_INT_ARRAY:
 990                 {
 991                         int *iarray = NULL;
 992                         int iarray_size = 0;
 993                         int idefault = 0;
 994                         type_int_array *tarray = NULL;
 995
 996                         if (!_mmcamcorder_conf_get_value_int_array(conf_info, info[i].category, info[i].keyword, &tarray))
 997                                 break; /* skip to set, but not error */
 998
 999                         if (tarray) {
1000                                 idefault = tarray->default_value;
1001
1002                                 if (info[i].enum_convert) {
1003                                         iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
1004                                 } else {
1005                                         iarray = tarray->value;
1006                                         iarray_size = tarray->count;
1007                                 }
1008
1009                                 if (iarray_size > 0) {
1010                                         MMCAM_LOG_DEBUG("[%s] INT Array - size[%d], default[%d]",
1011                                                 info[i].keyword, iarray_size, idefault);
1012
1013                                         mm_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
1014                                         ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
1015                                 }
1016                         }
1017
1018                         if (iarray && iarray != tarray->value)
1019                                 free(iarray);
1020
1021                         break;
1022                 }
1023                 case MM_CAMCONVERT_TYPE_INT_RANGE:
1024                 {
1025                         type_int_range *irange = NULL;
1026
1027                         if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange))
1028                                 break; /* skip to set, but not error */
1029
1030                         if (irange) {
1031                                 MMCAM_LOG_DEBUG("[%s] INT Range - min[%d], max[%d]",
1032                                         info[i].keyword, irange->min, irange->max);
1033
1034                                 mm_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
1035                                 ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
1036                         }
1037
1038                         break;
1039                 }
1040                 case MM_CAMCONVERT_TYPE_STRING:
1041                 {
1042                         const char *cString = NULL;
1043
1044                         if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString)) {
1045                                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1046                                 break; /* skip to set */
1047                         }
1048
1049                         MMCAM_LOG_DEBUG("[%s] String - string[%s]", info[i].keyword, cString);
1050                         ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, cString ? strlen(cString) : 0);
1051                         break;
1052                 }
1053                 case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
1054                 {
1055                         type_int_pair_array *pair_array = NULL;
1056
1057                         if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
1058                                 break; /* skip to set, but not error */
1059
1060                         if (pair_array && pair_array->count > 0) {
1061                                 mm_attrs_set_valid_array(attrs, info[i].attr_idx,
1062                                         pair_array->value[0],
1063                                         pair_array->count,
1064                                         pair_array->default_value[0]);
1065                                 mm_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
1066                                         pair_array->value[1],
1067                                         pair_array->count,
1068                                         pair_array->default_value[1]);
1069
1070                                 MMCAM_LOG_DEBUG("[%s] INT PAIR Array - default[%d,%d]",
1071                                         info[i].keyword, pair_array->default_value[0], pair_array->default_value[1]);
1072
1073                                 mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
1074                                 mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
1075                         }
1076                         break;
1077                 }
1078
1079                 case MM_CAMCONVERT_TYPE_USER:
1080                 default:
1081                         MMCAM_LOG_WARNING("default - [attr:%d]", info[i].attr_idx);
1082                         break;
1083                 }
1084         }
1085
1086         if (ret != MM_ERROR_NONE || mm_attrs_commit_all(attrs) == -1)
1087                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1088         else
1089                 return MM_ERROR_NONE;
1090 }
1091
1092
1093 int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConvert * convert)
1094 {
1095         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1096         type_int_array *array = NULL;
1097
1098         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1099
1100         _mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, convert->category, convert->keyword, &array);
1101
1102         if (array)
1103                 convert->enum_arr = array->value;
1104
1105         return MM_ERROR_NONE;
1106 }
1107
1108
1109 int _mmcamcorder_init_convert_table(MMHandleType handle)
1110 {
1111         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1112         int enum_conv_size = sizeof(_MMCamcorderEnumConvert);
1113         int caminfo_conv_size = sizeof(g_caminfo_convert);
1114         int caminfo_conv_length = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
1115         int i = 0;
1116
1117         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1118
1119         /* copy default conv data into memory of handle */
1120         memcpy(&(hcamcorder->caminfo_convert), &g_caminfo_convert, caminfo_conv_size);
1121         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]), &_mmcamcorder_enum_conv_whitebalance, enum_conv_size);
1122         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]), &_mmcamcorder_enum_conv_colortone, enum_conv_size);
1123         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ISO]), &_mmcamcorder_enum_conv_iso, enum_conv_size);
1124         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]), &_mmcamcorder_enum_conv_prgrm, enum_conv_size);
1125         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]), &_mmcamcorder_enum_conv_focus_mode, enum_conv_size);
1126         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]), &_mmcamcorder_enum_conv_focus_type, enum_conv_size);
1127         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]), &_mmcamcorder_enum_conv_ae_type, enum_conv_size);
1128         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]), &_mmcamcorder_enum_conv_strobe_mode, enum_conv_size);
1129         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WDR]), &_mmcamcorder_enum_conv_wdr_ctrl, enum_conv_size);
1130         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]), &_mmcamcorder_enum_conv_flip_ctrl, enum_conv_size);
1131         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]), &_mmcamcorder_enum_conv_rotation_ctrl, enum_conv_size);
1132         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]), &_mmcamcorder_enum_conv_ahs, enum_conv_size);
1133         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]), &_mmcamcorder_enum_conv_video_stabilization, enum_conv_size);
1134
1135         /* set ini info to conv data */
1136         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]));
1137         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]));
1138         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]));
1139         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]));
1140         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]));
1141         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]));
1142         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]));
1143         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]));
1144         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]));
1145         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]));
1146         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]));
1147         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]));
1148         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]));
1149
1150         /* set modified conv data to handle */
1151         for (i = 0 ; i < caminfo_conv_length ; i++) {
1152                 if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
1153                         switch (hcamcorder->caminfo_convert[i].category) {
1154                         case CONFIGURE_CATEGORY_CTRL_STROBE:
1155                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode"))
1156                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
1157                                 break;
1158                         case CONFIGURE_CATEGORY_CTRL_EFFECT:
1159                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance"))
1160                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
1161                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone"))
1162                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
1163                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR"))
1164                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
1165                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip"))
1166                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]);
1167                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation"))
1168                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]);
1169                                 break;
1170                         case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
1171                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode"))
1172                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
1173                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType"))
1174                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
1175                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType"))
1176                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
1177                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO"))
1178                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
1179                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode"))
1180                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
1181                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake"))
1182                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
1183                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization"))
1184                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
1185                                 break;
1186                         default:
1187                                 break;
1188                         }
1189                 }
1190         }
1191
1192         return MM_ERROR_NONE;
1193 }
1194
1195
1196 double _mmcamcorder_convert_volume(int mslVal)
1197 {
1198         double newVal = -1;
1199         switch (mslVal) {
1200         case 0:
1201                 newVal = 0;
1202                 break;
1203         case 1:
1204                 newVal = 1;
1205                 break;
1206         default:
1207                 MMCAM_LOG_WARNING("out of range");
1208                 break;
1209         }
1210
1211         return newVal;
1212 }