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