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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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_CAMERA,
 290                 MM_CAM_CAMERA_PAN_MECHA,
 291                 MM_CAMCORDER_ATTR_NONE,
 292                 "PanMecha",
 293                 MM_CAMCONVERT_TYPE_INT_RANGE,
 294                 NULL,
 295         },
 296         {
 297                 CONFIGURE_TYPE_CTRL,
 298                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 299                 MM_CAM_CAMERA_PAN_ELEC,
 300                 MM_CAMCORDER_ATTR_NONE,
 301                 "PanElec",
 302                 MM_CAMCONVERT_TYPE_INT_RANGE,
 303                 NULL,
 304         },
 305         {
 306                 CONFIGURE_TYPE_CTRL,
 307                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 308                 MM_CAM_CAMERA_TILT_MECHA,
 309                 MM_CAMCORDER_ATTR_NONE,
 310                 "TiltMecha",
 311                 MM_CAMCONVERT_TYPE_INT_RANGE,
 312                 NULL,
 313         },
 314         {
 315                 CONFIGURE_TYPE_CTRL,
 316                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 317                 MM_CAM_CAMERA_TILT_ELEC,
 318                 MM_CAMCORDER_ATTR_NONE,
 319                 "TiltElec",
 320                 MM_CAMCONVERT_TYPE_INT_RANGE,
 321                 NULL,
 322         },
 323         {
 324                 CONFIGURE_TYPE_CTRL,
 325                 CONFIGURE_CATEGORY_CTRL_CAMERA,
 326                 MM_CAM_CAMERA_PTZ_TYPE,
 327                 MM_CAMCORDER_ATTR_NONE,
 328                 "PtzType",
 329                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 330                 NULL,
 331         },
 332         {/* 10 */
 333                 CONFIGURE_TYPE_CTRL,
 334                 CONFIGURE_CATEGORY_CTRL_STROBE,
 335                 MM_CAM_STROBE_CONTROL,
 336                 MM_CAMCORDER_ATTR_NONE,
 337                 "StrobeControl",
 338                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 339                 &_mmcamcorder_enum_conv_strobe_ctrl,
 340         },
 341         {
 342                 CONFIGURE_TYPE_CTRL,
 343                 CONFIGURE_CATEGORY_CTRL_STROBE,
 344                 MM_CAM_STROBE_CAPABILITIES,
 345                 MM_CAMCORDER_ATTR_NONE,
 346                 "StrobeCapabilities",
 347                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 348                 NULL,
 349         },
 350         {
 351                 CONFIGURE_TYPE_CTRL,
 352                 CONFIGURE_CATEGORY_CTRL_STROBE,
 353                 MM_CAM_STROBE_MODE,
 354                 MM_CAMCORDER_ATTR_NONE,
 355                 "StrobeMode",
 356                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 357                 &_mmcamcorder_enum_conv_strobe_mode,
 358         },
 359         {
 360                 CONFIGURE_TYPE_CTRL,
 361                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 362                 MM_CAM_FILTER_BRIGHTNESS,
 363                 MM_CAMCORDER_ATTR_NONE,
 364                 "Brightness",
 365                 MM_CAMCONVERT_TYPE_INT_RANGE,
 366                 NULL,
 367         },
 368         {
 369                 CONFIGURE_TYPE_CTRL,
 370                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 371                 MM_CAM_FILTER_CONTRAST,
 372                 MM_CAMCORDER_ATTR_NONE,
 373                 "Contrast",
 374                 MM_CAMCONVERT_TYPE_INT_RANGE,
 375                 NULL,
 376         },
 377         {
 378                 CONFIGURE_TYPE_CTRL,
 379                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 380                 MM_CAM_FILTER_SATURATION,
 381                 MM_CAMCORDER_ATTR_NONE,
 382                 "Saturation",
 383                 MM_CAMCONVERT_TYPE_INT_RANGE,
 384                 NULL,
 385         },
 386         {
 387                 CONFIGURE_TYPE_CTRL,
 388                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 389                 MM_CAM_FILTER_HUE,
 390                 MM_CAMCORDER_ATTR_NONE,
 391                 "Hue",
 392                 MM_CAMCONVERT_TYPE_INT_RANGE,
 393                 NULL,
 394         },
 395         {
 396                 CONFIGURE_TYPE_CTRL,
 397                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 398                 MM_CAM_FILTER_SHARPNESS,
 399                 MM_CAMCORDER_ATTR_NONE,
 400                 "Sharpness",
 401                 MM_CAMCONVERT_TYPE_INT_RANGE,
 402                 NULL,
 403         },
 404         {
 405                 CONFIGURE_TYPE_CTRL,
 406                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 407                 MM_CAM_FILTER_WB,
 408                 MM_CAMCORDER_ATTR_NONE,
 409                 "WhiteBalance",
 410                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 411                 &_mmcamcorder_enum_conv_whitebalance,
 412         },
 413         {
 414                 CONFIGURE_TYPE_CTRL,
 415                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 416                 MM_CAM_FILTER_COLOR_TONE,
 417                 MM_CAMCORDER_ATTR_NONE,
 418                 "ColorTone",
 419                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 420                 &_mmcamcorder_enum_conv_colortone,
 421         },
 422         {/* 20 */
 423                 CONFIGURE_TYPE_CTRL,
 424                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 425                 MM_CAM_CAMERA_WDR,
 426                 MM_CAMCORDER_ATTR_NONE,
 427                 "WDR",
 428                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 429                 &_mmcamcorder_enum_conv_wdr_ctrl,
 430         },
 431         {
 432                 CONFIGURE_TYPE_CTRL,
 433                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 434                 MM_CAM_CAMERA_FLIP,
 435                 MM_CAMCORDER_ATTR_NONE,
 436                 "Flip",
 437                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 438                 &_mmcamcorder_enum_conv_flip_ctrl,
 439         },
 440         {
 441                 CONFIGURE_TYPE_CTRL,
 442                 CONFIGURE_CATEGORY_CTRL_EFFECT,
 443                 MM_CAM_CAMERA_ROTATION,
 444                 MM_CAMCORDER_ATTR_NONE,
 445                 "Rotation",
 446                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 447                 &_mmcamcorder_enum_conv_rotation_ctrl,
 448         },
 449         {
 450                 CONFIGURE_TYPE_CTRL,
 451                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 452                 MM_CAM_CAMERA_DIGITAL_ZOOM,
 453                 MM_CAMCORDER_ATTR_NONE,
 454                 "DigitalZoom",
 455                 MM_CAMCONVERT_TYPE_INT_RANGE,
 456                 NULL,
 457         },
 458         {
 459                 CONFIGURE_TYPE_CTRL,
 460                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 461                 MM_CAM_CAMERA_OPTICAL_ZOOM,
 462                 MM_CAMCORDER_ATTR_NONE,
 463                 "OpticalZoom",
 464                 MM_CAMCONVERT_TYPE_INT_RANGE,
 465                 NULL,
 466         },
 467         {
 468                 CONFIGURE_TYPE_CTRL,
 469                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 470                 MM_CAM_CAMERA_FOCUS_MODE,
 471                 MM_CAMCORDER_ATTR_NONE,
 472                 "FocusMode",
 473                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 474                 &_mmcamcorder_enum_conv_focus_mode,
 475         },
 476         {
 477                 CONFIGURE_TYPE_CTRL,
 478                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 479                 MM_CAM_CAMERA_AF_SCAN_RANGE,
 480                 MM_CAMCORDER_ATTR_NONE,
 481                 "AFType",
 482                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 483                 &_mmcamcorder_enum_conv_focus_type,
 484         },
 485         {
 486                 CONFIGURE_TYPE_CTRL,
 487                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 488                 MM_CAM_CAMERA_EXPOSURE_MODE,
 489                 MM_CAMCORDER_ATTR_NONE,
 490                 "AEType",
 491                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 492                 &_mmcamcorder_enum_conv_ae_type,
 493         },
 494         {
 495                 CONFIGURE_TYPE_CTRL,
 496                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 497                 MM_CAM_CAMERA_EXPOSURE_VALUE,
 498                 MM_CAMCORDER_ATTR_NONE,
 499                 "ExposureValue",
 500                 MM_CAMCONVERT_TYPE_INT_RANGE,
 501                 NULL,
 502         },
 503         {
 504                 CONFIGURE_TYPE_CTRL,
 505                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 506                 MM_CAM_CAMERA_F_NUMBER,
 507                 MM_CAMCORDER_ATTR_NONE,
 508                 "FNumber",
 509                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 510                 NULL,
 511         },
 512         {/* 30 */
 513                 CONFIGURE_TYPE_CTRL,
 514                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 515                 MM_CAM_CAMERA_SHUTTER_SPEED,
 516                 MM_CAMCORDER_ATTR_NONE,
 517                 "ShutterSpeed",
 518                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 519                 NULL,
 520         },
 521         {
 522                 CONFIGURE_TYPE_CTRL,
 523                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 524                 MM_CAM_CAMERA_ISO,
 525                 MM_CAMCORDER_ATTR_NONE,
 526                 "ISO",
 527                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 528                 &_mmcamcorder_enum_conv_iso,
 529         },
 530         {
 531                 CONFIGURE_TYPE_CTRL,
 532                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 533                 MM_CAM_FILTER_SCENE_MODE,
 534                 MM_CAMCORDER_ATTR_NONE,
 535                 "ProgramMode",
 536                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 537                 &_mmcamcorder_enum_conv_prgrm,
 538         },
 539         {
 540                 CONFIGURE_TYPE_CTRL,
 541                 CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
 542                 MM_CAM_CAMERA_ANTI_HANDSHAKE,
 543                 MM_CAMCORDER_ATTR_NONE,
 544                 "AntiHandshake",
 545                 MM_CAMCONVERT_TYPE_INT_ARRAY,
 546                 &_mmcamcorder_enum_conv_ahs,
 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
 658 /*---------------------------------------------------------------------------
 659 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
 660 ---------------------------------------------------------------------------*/
 661 /* STATIC INTERNAL FUNCTION */
 662 static int  __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default);
 663
 664 /*===========================================================================================
 665 |                                                                                                                                                                                       |
 666 |  FUNCTION DEFINITIONS                                                                                                                                         |
 667 |                                                                                                                                                                                       |
 668 ========================================================================================== */
 669 /*---------------------------------------------------------------------------
 670 |    GLOBAL FUNCTION DEFINITIONS:                                                                                       |
 671 ---------------------------------------------------------------------------*/
 672 /* convert MSL value to sensor value */
 673 int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
 674 {
 675         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 676         _MMCamcorderInfoConverting *info = NULL;
 677         int i = 0;
 678         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 679
 680         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 681
 682         /* _mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval); */
 683
 684         info = hcamcorder->caminfo_convert;
 685
 686         for (i = 0; i < size; i++) {
 687                 if (info[i].attr_idx == attr_idx) {
 688                         _MMCamcorderEnumConvert * enum_convert = NULL;
 689                         enum_convert = info[i].enum_convert;
 690
 691                         if (enum_convert == NULL) {
 692                                 /* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
 693                                 return mslval;
 694                         }
 695
 696                         if (enum_convert->enum_arr == NULL) {
 697                                 _mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 698                                 return mslval;
 699                         }
 700
 701                         if (enum_convert->total_enum_num > mslval && mslval >= 0) {
 702                                 /* _mmcam_dbg_log("original value(%d) -> converted value(%d)", mslval, enum_convert->enum_arr[mslval]); */
 703                                 return enum_convert->enum_arr[mslval];
 704                         } else {
 705                                 _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);
 706                                 return mslval;
 707                         }
 708                 }
 709         }
 710
 711         _mmcam_dbg_warn("There is no category to match. Just return the original value.");
 712
 713         return mslval;
 714 }
 715
 716 int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height,  MMCamAttrsInfo* fps_info)
 717 {
 718         MMCamAttrsInfo *infoW = NULL;
 719         MMCamAttrsInfo *infoH = NULL;
 720         int i = 0;
 721         char nameFps[10] = {0,};
 722         bool valid_check = false;
 723
 724         type_int_array *fps_array;
 725
 726         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 727
 728         /* _mmcam_dbg_log("prev resolution w:%d, h:%d", width, height); */
 729
 730         infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 731         if (infoW == NULL) {
 732                 _mmcam_dbg_err("failed to alloc infoW");
 733                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 734         }
 735
 736         infoH = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
 737         if (infoH == NULL) {
 738                 _mmcam_dbg_err("failed to alloc infoH");
 739
 740                 free(infoW);
 741                 infoW = NULL;
 742
 743                 return MM_ERROR_CAMCORDER_LOW_MEMORY;
 744         }
 745
 746         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
 747         mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
 748
 749         for (i = 0; i < infoW->int_array.count; i++) {
 750                 /* _mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]); */
 751                 if (infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
 752                         valid_check = true;
 753                         snprintf(nameFps, 10, "FPS%d", i);
 754                         _mmcam_dbg_log("nameFps : %s!!!", nameFps);
 755                         break;
 756                 }
 757         }
 758
 759         free(infoW);
 760         infoW = NULL;
 761         free(infoH);
 762         infoH = NULL;
 763
 764         if (!valid_check) {
 765                 _mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
 766                 return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
 767         }
 768
 769         if (!_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, nameFps, &fps_array)) {
 770                 _mmcam_dbg_err("FAILED : Can't find the valid FPS array.");
 771                 return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 772         }
 773
 774         fps_info->int_array.count = fps_array->count;
 775         fps_info->int_array.array = fps_array->value;
 776         fps_info->int_array.def = fps_array->default_value;
 777
 778         return MM_ERROR_NONE;
 779 }
 780
 781 /* convert sensor value to MSL value */
 782 int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
 783 {
 784         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 785         _MMCamcorderInfoConverting *info = NULL;
 786         int i = 0, j = 0;
 787         int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 788
 789         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 790
 791         info = hcamcorder->caminfo_convert;
 792
 793         for (i = 0 ; i < size ; i++) {
 794                 if (info[i].attr_idx == attr_idx) {
 795                         _MMCamcorderEnumConvert * enum_convert = NULL;
 796                         enum_convert = info[i].enum_convert;
 797
 798                         if (enum_convert == NULL) {
 799                                 /* _mmcam_dbg_log("enum_convert is NULL. Just return the original value."); */
 800                                 return sensval;
 801                         }
 802
 803                         if (enum_convert->enum_arr == NULL) {
 804                                 _mmcam_dbg_warn("Unexpected error. Array pointer of enum_convert is NULL. Just return the original value.");
 805                                 return sensval;
 806                         }
 807
 808                         for (j = 0 ; j < enum_convert->total_enum_num ; j++) {
 809                                 if (sensval == enum_convert->enum_arr[j]) {
 810                                         /* _mmcam_dbg_log("original value(%d) -> converted value(%d)", sensval, j); */
 811                                         return j;
 812                                 }
 813                         }
 814
 815                         _mmcam_dbg_warn("There is no sensor value matched with input param. Just return the original value.");
 816                         return sensval;
 817
 818                 }
 819         }
 820
 821         _mmcam_dbg_log("There is no category to match. Just return the original value.");
 822         return sensval;
 823 }
 824
 825 static int
 826 __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default)
 827 {
 828         int i = 0;
 829         int valid_count = 0;
 830         int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
 831
 832         for (i = 0; i < original_count; i++) {
 833                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
 834                         valid_count++;
 835         }
 836
 837         if (valid_count > 0) {
 838                 *valid_array = (int*)malloc(sizeof(int) * valid_count);
 839
 840                 if (*valid_array) {
 841                         valid_count = 0;
 842                         for (i = 0; i < original_count; i++) {
 843                                 if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
 844                                         (*valid_array)[valid_count++] = i;
 845                                         /*_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );*/
 846
 847                                         if (original_array[i] == *valid_default &&
 848                                             new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
 849                                                 new_default = i;
 850                                                 /*_mmcam_dbg_log( "converted MSL default[%d]", new_default );*/
 851                                         }
 852                                 }
 853                         }
 854                 } else {
 855                         valid_count = 0;
 856                 }
 857         }
 858
 859         if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE)
 860                 *valid_default = new_default;
 861
 862         return valid_count;
 863 }
 864
 865
 866 int _mmcamcorder_init_attr_from_configure(MMHandleType handle, MMCamConvertingCategory category)
 867 {
 868         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 869         _MMCamcorderInfoConverting *info = NULL;
 870
 871         int table_size = 0;
 872         int ret = MM_ERROR_NONE;
 873
 874         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 875
 876         _mmcam_dbg_log("category : %d", category);
 877
 878         if (category & MM_CAMCONVERT_CATEGORY_CAMERA) {
 879                 /* Initialize attribute related to camera control */
 880                 info = hcamcorder->caminfo_convert;
 881                 table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
 882                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 883                 if (ret != MM_ERROR_NONE) {
 884                         _mmcam_dbg_err("camera info set error : 0x%x", ret);
 885                         return ret;
 886                 }
 887         }
 888
 889         if (category & MM_CAMCONVERT_CATEGORY_DISPLAY) {
 890                 /* Initialize attribute related to display */
 891                 info = g_display_info;
 892                 table_size = sizeof(g_display_info) / sizeof(_MMCamcorderInfoConverting);
 893                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 894                 if (ret != MM_ERROR_NONE) {
 895                         _mmcam_dbg_err("display info set error : 0x%x", ret);
 896                         return ret;
 897                 }
 898         }
 899
 900         if (category & MM_CAMCONVERT_CATEGORY_AUDIO) {
 901                 /* Initialize attribute related to audio */
 902                 info = g_audio_info;
 903                 table_size = sizeof(g_audio_info) / sizeof(_MMCamcorderInfoConverting);
 904                 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
 905                 if (ret != MM_ERROR_NONE) {
 906                         _mmcam_dbg_err("audio info set error : 0x%x", ret);
 907                         return ret;
 908                 }
 909         }
 910
 911         _mmcam_dbg_log("done");
 912
 913         return ret;
 914 }
 915
 916
 917 int __mmcamcorder_set_info_to_attr(MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size)
 918 {
 919         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
 920         MMHandleType     attrs      = 0;
 921
 922         int i = 0;
 923         int ret = MM_ERROR_NONE;
 924
 925         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 926
 927         attrs = MMF_CAMCORDER_ATTRS(handle);
 928         mmf_return_val_if_fail(attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
 929
 930         camera_conf *conf_info = NULL;
 931
 932         for (i = 0; i < table_size; i++) {
 933                 /*
 934                 _mmcam_dbg_log("%d,%d,%d,%d,%s,%d",
 935                         info[i].type,
 936                         info[i].category,
 937                         info[i].attr_idx,
 938                         info[i].attr_idx_pair,
 939                         info[i].keyword,
 940                         info[i].conv_type);
 941                 */
 942
 943                 if (ret != MM_ERROR_NONE)
 944                         break;
 945
 946                 if (info[i].type == CONFIGURE_TYPE_MAIN) {
 947                         conf_info = hcamcorder->conf_main;
 948                         /*_mmcam_dbg_log("MAIN configure [%s]", info[i].keyword);*/
 949                 } else {
 950                         conf_info = hcamcorder->conf_ctrl;
 951                         /*_mmcam_dbg_log("CTRL configure [%s]", info[i].keyword);*/
 952                 }
 953
 954                 switch (info[i].conv_type) {
 955                 case MM_CAMCONVERT_TYPE_INT:
 956                 {
 957                         int ivalue = 0;
 958
 959                         if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue)) {
 960                                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
 961                                 break; /* skip to set */
 962                         }
 963
 964                         ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
 965                         break;
 966                 }
 967                 case MM_CAMCONVERT_TYPE_INT_ARRAY:
 968                 {
 969                         int *iarray = NULL;
 970                         int iarray_size = 0;
 971                         int idefault = 0;
 972                         type_int_array *tarray = NULL;
 973
 974                         if (!_mmcamcorder_conf_get_value_int_array(conf_info, info[i].category, info[i].keyword, &tarray))
 975                                 break; /* skip to set, but not error */
 976
 977                         if (tarray) {
 978                                 idefault = tarray->default_value;
 979
 980                                 if (info[i].enum_convert) {
 981                                         iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
 982                                 } else {
 983                                         iarray = tarray->value;
 984                                         iarray_size = tarray->count;
 985                                 }
 986
 987                                 if (iarray_size > 0) {
 988                                         /*
 989                                         _mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
 990                                                 info[i].attr_idx, iarray, iarray_size, idefault);
 991                                         */
 992
 993                                         /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
 994                                         /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
 995                                         mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
 996
 997                                         ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
 998                                 }
 999                         }
1000
1001                         if (iarray && iarray != tarray->value)
1002                                 free(iarray);
1003
1004                         break;
1005                 }
1006                 case MM_CAMCONVERT_TYPE_INT_RANGE:
1007                 {
1008                         type_int_range *irange = NULL;
1009
1010                         if (!_mmcamcorder_conf_get_value_int_range(conf_info, info[i].category, info[i].keyword, &irange))
1011                                 break; /* skip to set, but not error */
1012
1013                         if (irange) {
1014                                 /* _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); */
1015                                 /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1016                                 /* mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE); */
1017                                 mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
1018
1019                                 ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
1020                         }
1021
1022                         break;
1023                 }
1024                 case MM_CAMCONVERT_TYPE_STRING:
1025                 {
1026                         const char *cString = NULL;
1027                         unsigned int iString_len = 0;
1028
1029                         if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString)) {
1030                                 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1031                                 break; /* skip to set */
1032                         }
1033
1034                         /* _mmcam_dbg_log("String. m:%d, s:%d, cString=%s", info[i].main_key, info[i].sub_key1, cString); */
1035                         /* strlen makes a crash when null pointer is passed. */
1036                         if (cString)
1037                                 iString_len = strlen(cString);
1038                         else
1039                                 iString_len = 0;
1040
1041                         ret = mm_attrs_set_string(attrs, info[i].attr_idx, cString, iString_len);
1042                         break;
1043                 }
1044                 case MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY:
1045                 {
1046                         type_int_pair_array *pair_array = NULL;
1047
1048                         /*_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);*/
1049
1050                         if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
1051                                 break; /* skip to set, but not error */
1052
1053                         if (pair_array && pair_array->count > 0) {
1054                                 /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1055                                 /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
1056                                 mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
1057                                         pair_array->value[0],
1058                                         pair_array->count,
1059                                         pair_array->default_value[0]);
1060                                 /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
1061                                 /* mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY); */
1062                                 mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
1063                                         pair_array->value[1],
1064                                         pair_array->count,
1065                                         pair_array->default_value[1]);
1066
1067                                 mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
1068                                 mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
1069                         }
1070                         break;
1071                 }
1072
1073                 case MM_CAMCONVERT_TYPE_USER:
1074                 default:
1075                         _mmcam_dbg_log("default : s:%d", info[i].attr_idx);
1076                         break;
1077                 }
1078         }
1079
1080         if (ret != MM_ERROR_NONE || mmf_attrs_commit(attrs) == -1)
1081                 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1082         else
1083                 return MM_ERROR_NONE;
1084 }
1085
1086
1087 int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConvert * convert)
1088 {
1089         mmf_camcorder_t* hcamcorder = MMF_CAMCORDER(handle);
1090         type_int_array *array = NULL;
1091
1092         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1093
1094         _mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, convert->category, convert->keyword, &array);
1095
1096         if (array)
1097                 convert->enum_arr = array->value;
1098
1099         return MM_ERROR_NONE;
1100 }
1101
1102
1103 int _mmcamcorder_init_convert_table(MMHandleType handle)
1104 {
1105         mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1106         int enum_conv_size = sizeof(_MMCamcorderEnumConvert);
1107         int caminfo_conv_size = sizeof(g_caminfo_convert);
1108         int caminfo_conv_length = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
1109         int i = 0;
1110
1111         mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1112
1113         /* copy default conv data into memory of handle */
1114         memcpy(&(hcamcorder->caminfo_convert), &g_caminfo_convert, caminfo_conv_size);
1115         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]), &_mmcamcorder_enum_conv_whitebalance, enum_conv_size);
1116         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]), &_mmcamcorder_enum_conv_colortone, enum_conv_size);
1117         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ISO]), &_mmcamcorder_enum_conv_iso, enum_conv_size);
1118         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]), &_mmcamcorder_enum_conv_prgrm, enum_conv_size);
1119         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]), &_mmcamcorder_enum_conv_focus_mode, enum_conv_size);
1120         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]), &_mmcamcorder_enum_conv_focus_type, enum_conv_size);
1121         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]), &_mmcamcorder_enum_conv_ae_type, enum_conv_size);
1122         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]), &_mmcamcorder_enum_conv_strobe_mode, enum_conv_size);
1123         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WDR]), &_mmcamcorder_enum_conv_wdr_ctrl, enum_conv_size);
1124         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]), &_mmcamcorder_enum_conv_flip_ctrl, enum_conv_size);
1125         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]), &_mmcamcorder_enum_conv_rotation_ctrl, enum_conv_size);
1126         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]), &_mmcamcorder_enum_conv_ahs, enum_conv_size);
1127         memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]), &_mmcamcorder_enum_conv_video_stabilization, enum_conv_size);
1128
1129         /* set ini info to conv data */
1130         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]));
1131         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]));
1132         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]));
1133         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]));
1134         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]));
1135         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]));
1136         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]));
1137         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]));
1138         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]));
1139         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]));
1140         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]));
1141         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]));
1142         _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]));
1143
1144         /* set modified conv data to handle */
1145         for (i = 0 ; i < caminfo_conv_length ; i++) {
1146                 if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
1147                         switch (hcamcorder->caminfo_convert[i].category) {
1148                         case CONFIGURE_CATEGORY_CTRL_STROBE:
1149                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode"))
1150                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
1151                                 break;
1152                         case CONFIGURE_CATEGORY_CTRL_EFFECT:
1153                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance"))
1154                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
1155                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone"))
1156                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
1157                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR"))
1158                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
1159                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip"))
1160                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]);
1161                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation"))
1162                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]);
1163                                 break;
1164                         case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
1165                                 if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode"))
1166                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
1167                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType"))
1168                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
1169                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType"))
1170                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
1171                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO"))
1172                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
1173                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode"))
1174                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
1175                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake"))
1176                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
1177                                 else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization"))
1178                                         hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
1179                                 break;
1180                         default:
1181                                 break;
1182                         }
1183                 }
1184         }
1185
1186         return MM_ERROR_NONE;
1187 }
1188
1189
1190 double _mmcamcorder_convert_volume(int mslVal)
1191 {
1192         double newVal = -1;
1193         switch (mslVal) {
1194         case 0:
1195                 newVal = 0;
1196                 break;
1197         case 1:
1198                 newVal = 1;
1199                 break;
1200         default:
1201                 _mmcam_dbg_warn("out of range");
1202                 break;
1203         }
1204
1205         return newVal;
1206 }
1207