src/mm_camcorder_platform.c

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