src/CamDeviceCapacity.cpp

   1 \r
   2 /*\r
   3  * Copyright 2012  Samsung Electronics Co., Ltd\r
   4  *\r
   5  * Licensed under the Flora License, Version 1.1 (the "License");\r
   6  * you may not use this file except in compliance with the License.\r
   7  * You may obtain a copy of the License at\r
   8  *\r
   9  *        http://floralicense.org/license/\r
  10  *\r
  11  * Unless required by applicable law or agreed to in writing, software\r
  12  * distributed under the License is distributed on an "AS IS" BASIS,\r
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14  * See the License for the specific language governing permissions and\r
  15  * limitations under the License.\r
  16  */\r
  17 \r
  18 \r
  19 #include <stdlib.h>\r
  20 #include <stdio.h>\r
  21 \r
  22 #include "CamDeviceCapacity.h"\r
  23 #include "cam_capacity_type.h"\r
  24 \r
  25 \r
  26 extern "C" {\r
  27 #include "cam_mm.h"\r
  28 #include "cam_debug.h"\r
  29 }\r
  30 \r
  31 #define CAM_ATTR_NOT_SUPPORTED (1)\r
  32 #define CAM_CP_FUNC_UNMARKED (0)\r
  33 CCamDeviceCapacity* CCamDeviceCapacity::m_pInstance = NULL;\r
  34 \r
  35 /////////////////////////////////////////////////////////////////////////////\r
  36 // Construction/Destruction\r
  37 /////////////////////////////////////////////////////////////////////////////\r
  38 CCamDeviceCapacity::CCamDeviceCapacity()\r
  39 {\r
  40         ResetCaps();\r
  41 }\r
  42 \r
  43 CCamDeviceCapacity::~CCamDeviceCapacity()\r
  44 {\r
  45         Destroy();\r
  46 }\r
  47 \r
  48 void\r
  49 CCamDeviceCapacity::ResetCaps()\r
  50 {\r
  51         m_CamRes.bChecked = FALSE;\r
  52         m_RecRes.bChecked = FALSE;\r
  53         m_Focus.bChecked = FALSE;\r
  54         m_Effect.bChecked = FALSE;\r
  55         m_WB.bChecked = FALSE;\r
  56         m_Scene.bChecked = FALSE;\r
  57         m_Metering.bChecked = FALSE;\r
  58         m_ISO.bChecked = FALSE;\r
  59         m_Flash.bChecked = FALSE;\r
  60         m_Fps.bChecked = FALSE;\r
  61         m_Shot.bChecked = FALSE;\r
  62         m_Zoom.bChecked = FALSE;\r
  63         m_Ev.bChecked = FALSE;\r
  64         m_Br.bChecked = FALSE;\r
  65         m_RecMode.bChecked = FALSE;\r
  66 \r
  67         m_WDR.bChecked = FALSE;\r
  68         m_AntiShake.bChecked = FALSE;\r
  69         m_RecAntiShake.bChecked = FALSE;\r
  70         m_Outdoorvisibility.bChecked = FALSE;\r
  71 \r
  72         m_uFuncCaps = 0;\r
  73 \r
  74 }\r
  75 \r
  76 CCamDeviceCapacity*\r
  77 CCamDeviceCapacity::GetInstance()\r
  78 {\r
  79         if(m_pInstance == NULL)\r
  80                 m_pInstance = new CCamDeviceCapacity;\r
  81         return m_pInstance;\r
  82 }\r
  83 \r
  84 void\r
  85 CCamDeviceCapacity::Destroy()\r
  86 {\r
  87         if(m_pInstance)\r
  88         {\r
  89                 delete m_pInstance;\r
  90                 m_pInstance = NULL;\r
  91         }\r
  92 }\r
  93 \r
  94 void\r
  95 CCamDeviceCapacity::GetCamDevFuncCaps(unsigned int *uCapacity, void *user_data)\r
  96 {\r
  97         unsigned int uSearchCaps = CAM_CP_FUNC_BURST_SHOT_MODE;\r
  98         unsigned int uCaps = 0;\r
  99 \r
 100         int deviceType = 0;\r
 101         if (!cam_mm_get_video_device(&deviceType)) {\r
 102                 cam_debug(LOG_CAM, "cam_mm_get_video_device() fail");\r
 103                 *uCapacity = 0;\r
 104                 return;\r
 105         }\r
 106 \r
 107         if (m_uFuncCaps == CAM_CP_FUNC_UNMARKED) {\r
 108                 for(int i = 0; i < CAM_CP_FUNC_COUNT; i++) {\r
 109                         if (IsSupported(uSearchCaps, (CamDeviceType)deviceType, user_data))\r
 110                                 uCaps |= uSearchCaps;\r
 111 \r
 112                         uSearchCaps *= 2;\r
 113                         cam_debug(LOG_CAM, "i[%d] uSearchCaps [0x%x]", i, uSearchCaps);\r
 114                 }\r
 115 \r
 116                 m_uFuncCaps = uCaps;\r
 117         }\r
 118 \r
 119         *uCapacity = m_uFuncCaps;\r
 120 }\r
 121 \r
 122 \r
 123 bool\r
 124 CCamDeviceCapacity::GetCamDevSceneModeCaps(unsigned int* uCapacity, void *user_data)\r
 125 {\r
 126         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 127 \r
 128         unsigned int uCaps = 0;\r
 129         *uCapacity = 0;\r
 130 \r
 131         if (!m_Scene.bChecked) {\r
 132                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_SCENE_MODE, &uCaps, user_data)) {\r
 133                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 134                         return FALSE;\r
 135                 }\r
 136 \r
 137                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 138                         m_Scene.bSupported = TRUE;\r
 139                 else\r
 140                         m_Scene.bSupported = FALSE;\r
 141 \r
 142                 m_Scene.bChecked = TRUE;\r
 143                 m_Scene.unCaps = uCaps;\r
 144 \r
 145         }\r
 146 \r
 147         *uCapacity = m_Scene.unCaps;\r
 148         return TRUE;\r
 149 }\r
 150 \r
 151 bool\r
 152 CCamDeviceCapacity::GetCamDevWBCaps(unsigned int* uCapacity, void *user_data)\r
 153 {\r
 154         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 155 \r
 156         unsigned int uCaps = 0;\r
 157         *uCapacity = 0;\r
 158 \r
 159         if (!m_WB.bChecked) {\r
 160                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_WHITE_BALANCE, &uCaps, user_data)) {\r
 161                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 162                         return FALSE;\r
 163                 }\r
 164 \r
 165                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 166                         m_WB.bSupported = TRUE;\r
 167                 else\r
 168                         m_WB.bSupported = FALSE;\r
 169 \r
 170                 m_WB.bChecked = TRUE;\r
 171                 m_WB.unCaps = uCaps;\r
 172 \r
 173         }\r
 174 \r
 175         *uCapacity = m_WB.unCaps;\r
 176         return TRUE;\r
 177 }\r
 178 \r
 179 \r
 180 bool\r
 181 CCamDeviceCapacity::GetCamDevEffectCaps(unsigned int* uCapacity, void *user_data)\r
 182 {\r
 183         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 184 \r
 185         unsigned int uCaps = 0;\r
 186         *uCapacity = 0;\r
 187 \r
 188         if (!m_Effect.bChecked) {\r
 189                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_EFFECT_MODE, &uCaps, user_data)) {\r
 190                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 191                         return FALSE;\r
 192                 }\r
 193 \r
 194                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 195                         m_Effect.bSupported = TRUE;\r
 196                 else\r
 197                         m_Effect.bSupported = FALSE;\r
 198 \r
 199                 m_Effect.bChecked = TRUE;\r
 200                 m_Effect.unCaps = uCaps;\r
 201         }\r
 202 \r
 203         *uCapacity = m_Effect.unCaps;\r
 204         return TRUE;\r
 205 }\r
 206 \r
 207 bool\r
 208 CCamDeviceCapacity::GetCamDevFocusCaps(unsigned int* uCapacity, void *user_data)\r
 209 {\r
 210         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 211 \r
 212         unsigned int uCaps = 0;\r
 213         *uCapacity = 0;\r
 214 \r
 215         if (!m_Focus.bChecked) {\r
 216                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_FOCUS_MODE, &uCaps, user_data)) {\r
 217                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 218                         return FALSE;\r
 219                 }\r
 220 \r
 221                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 222                         m_Focus.bSupported = TRUE;\r
 223                 else\r
 224                         m_Focus.bSupported = FALSE;\r
 225 \r
 226                 if (cam_mm_is_supported_face_detection())\r
 227                         uCaps |= CAM_CP_FOCUS_FACE_DETECTION;\r
 228 \r
 229                 m_Focus.bChecked = TRUE;\r
 230                 m_Focus.unCaps = uCaps;\r
 231         }\r
 232 \r
 233         *uCapacity = m_Focus.unCaps;\r
 234         return TRUE;\r
 235 }\r
 236 \r
 237 \r
 238 bool\r
 239 CCamDeviceCapacity::GetCamDevShotModeCaps(unsigned int *uCapacity, void *user_data)\r
 240 {\r
 241         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 242 \r
 243         *uCapacity = 0;\r
 244         m_Shot.bSupported = FALSE;\r
 245         m_Shot.bChecked = TRUE;\r
 246 \r
 247         return TRUE;\r
 248 }\r
 249 \r
 250 bool\r
 251 CCamDeviceCapacity::GetCamDevRecModeCaps(unsigned int *uCapacity, void *user_data)\r
 252 {\r
 253         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 254 \r
 255         *uCapacity = 0;\r
 256 #ifdef CAMERA_MACHINE_I686\r
 257                         m_RecMode.bSupported = FALSE;\r
 258                         m_RecMode.bChecked = TRUE;\r
 259 \r
 260 #else\r
 261         if (!m_RecMode.bChecked) {\r
 262                 m_RecMode.unCaps = 0;\r
 263                 m_RecMode.unCaps |= CAM_CP_REC_MODE_NORMAL;\r
 264                 m_RecMode.unCaps |= CAM_CP_REC_MODE_MMS;\r
 265                 m_RecMode.unCaps |= CAM_CP_REC_MODE_SLOW_MOTION;\r
 266                 m_RecMode.unCaps |= CAM_CP_REC_MODE_FAST_MOTION;\r
 267 \r
 268                 m_RecMode.bSupported = TRUE;\r
 269                 m_RecMode.bChecked = TRUE;\r
 270         }\r
 271 \r
 272         *uCapacity = m_RecMode.unCaps;\r
 273 #endif\r
 274         return TRUE;\r
 275 }\r
 276 \r
 277 bool\r
 278 CCamDeviceCapacity::GetCamDevCamResolutionCaps(unsigned int* uCapacity, void *user_data)\r
 279 {\r
 280         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 281 \r
 282         unsigned int uCaps = 0;\r
 283         *uCapacity = 0;\r
 284 \r
 285         if (!m_CamRes.bChecked) {\r
 286                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_CAM_RESOLUTION, &uCaps, user_data)) {\r
 287                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 288                         return FALSE;\r
 289                 }\r
 290 \r
 291                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 292                         m_CamRes.bSupported = TRUE;\r
 293                 else\r
 294                         m_CamRes.bSupported = FALSE;\r
 295 \r
 296                 m_CamRes.bSupported = TRUE;\r
 297                 m_CamRes.bChecked = TRUE;\r
 298                 m_CamRes.unCaps = uCaps;\r
 299         }\r
 300 \r
 301         *uCapacity = m_CamRes.unCaps;\r
 302         return TRUE;\r
 303 }\r
 304 \r
 305 bool\r
 306 CCamDeviceCapacity::GetCamDevISOCaps(unsigned int* uCapacity, void *user_data)\r
 307 {\r
 308         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 309 \r
 310         unsigned int uCaps = 0;\r
 311         *uCapacity = 0;\r
 312 \r
 313         if (!m_ISO.bChecked) {\r
 314                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_ISO, &uCaps, user_data)) {\r
 315                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 316                         return FALSE;\r
 317                 }\r
 318 \r
 319                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 320                         m_ISO.bSupported = TRUE;\r
 321                 else\r
 322                         m_ISO.bSupported = FALSE;\r
 323 \r
 324                 m_ISO.bChecked = TRUE;\r
 325                 m_ISO.unCaps = uCaps;\r
 326         }\r
 327 \r
 328         *uCapacity = m_ISO.unCaps;\r
 329         return TRUE;\r
 330 }\r
 331 \r
 332 bool\r
 333 CCamDeviceCapacity::GetCamDevMeteringCaps(unsigned int* uCapacity, void *user_data)\r
 334 {\r
 335         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 336 \r
 337         unsigned int uCaps = 0;\r
 338         *uCapacity = 0;\r
 339 \r
 340         if (!m_Metering.bChecked) {\r
 341                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_METERING, &uCaps, user_data)) {\r
 342                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 343                         return FALSE;\r
 344                 }\r
 345 \r
 346                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 347                         m_Metering.bSupported = TRUE;\r
 348                 else\r
 349                         m_Metering.bSupported = FALSE;\r
 350 \r
 351                 m_Metering.bChecked = TRUE;\r
 352                 m_Metering.unCaps = uCaps;\r
 353         }\r
 354 \r
 355         *uCapacity = m_Metering.unCaps;\r
 356         return TRUE;\r
 357 }\r
 358 \r
 359 bool\r
 360 CCamDeviceCapacity::GetCamDevFlashCaps(unsigned int* uCapacity, void *user_data)\r
 361 {\r
 362         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 363 \r
 364         unsigned int uCaps = 0;\r
 365         *uCapacity = 0;\r
 366 \r
 367         if (!m_Flash.bChecked) {\r
 368                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_FLASH_MODE, &uCaps, user_data)) {\r
 369                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 370                         return FALSE;\r
 371                 }\r
 372 \r
 373                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 374                         m_Flash.bSupported = TRUE;\r
 375                 else\r
 376                         m_Flash.bSupported = FALSE;\r
 377 \r
 378                 m_Flash.bChecked = TRUE;\r
 379                 m_Flash.unCaps = uCaps;\r
 380         }\r
 381 \r
 382         *uCapacity = m_Flash.unCaps;\r
 383         return TRUE;\r
 384 }\r
 385 \r
 386 bool\r
 387 CCamDeviceCapacity::GetCamDevRecResolutionCaps(unsigned int* uCapacity, void *user_data)\r
 388 {\r
 389         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 390 \r
 391         unsigned int uCaps = 0;\r
 392         *uCapacity = 0;\r
 393 \r
 394         if (!m_RecRes.bChecked) {\r
 395                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_REC_RESOLUTION, &uCaps, user_data)) {\r
 396                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 397                         return FALSE;\r
 398                 }\r
 399 \r
 400                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 401                         m_RecRes.bSupported = TRUE;\r
 402                 else\r
 403                         m_RecRes.bSupported = FALSE;\r
 404 \r
 405                 m_RecRes.bChecked = TRUE;\r
 406                 m_RecRes.unCaps = uCaps;\r
 407         }\r
 408 \r
 409         *uCapacity = m_RecRes.unCaps;\r
 410         return TRUE;\r
 411 \r
 412 }\r
 413 \r
 414 \r
 415 bool\r
 416 CCamDeviceCapacity::GetCamDevFpsCaps(unsigned int *uCapacity, void *user_data)\r
 417 {\r
 418         cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");\r
 419 \r
 420         unsigned int uCaps = 0;\r
 421         *uCapacity = 0;\r
 422 \r
 423         if (!m_Fps.bChecked) {\r
 424                 if (!cam_mm_get_caps_range(CAM_CP_FUNC_FPS, &uCaps, user_data)) {\r
 425                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 426                         return FALSE;\r
 427                 }\r
 428 \r
 429                 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)\r
 430                         m_Fps.bSupported = TRUE;\r
 431                 else\r
 432                         m_Fps.bSupported = FALSE;\r
 433 \r
 434                 m_Fps.bChecked = TRUE;\r
 435                 m_Fps.bChecked = TRUE;\r
 436                 m_Fps.unCaps = uCaps;\r
 437         }\r
 438 \r
 439         *uCapacity = m_Fps.unCaps;\r
 440         return TRUE;\r
 441 }\r
 442 \r
 443 \r
 444 bool\r
 445 CCamDeviceCapacity::GetCamDevZoomCaps(int *min, int *max)\r
 446 {\r
 447         cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");\r
 448 \r
 449         int nMin, nMax = 0;\r
 450 \r
 451         if (!m_Zoom.bChecked) {\r
 452                 if (!cam_mm_get_caps_minmax(CAM_CP_FUNC_ZOOM, &nMin, &nMax)) {\r
 453                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 454                         return FALSE;\r
 455                 }\r
 456 \r
 457                 if ((nMin == 0) && (nMax == 0))\r
 458                         m_Zoom.bSupported = FALSE;\r
 459                 else\r
 460                         m_Zoom.bSupported = TRUE;\r
 461 \r
 462                 m_Zoom.bChecked = TRUE;\r
 463                 m_Zoom.nMin = nMin;\r
 464                 m_Zoom.nMax = nMax;\r
 465         }\r
 466 \r
 467         *min = m_Zoom.nMin;\r
 468         *max = m_Zoom.nMax;\r
 469         return TRUE;\r
 470 }\r
 471 \r
 472 bool\r
 473 CCamDeviceCapacity::GetCamDevEvCaps(int *min, int *max)\r
 474 {\r
 475         cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");\r
 476 \r
 477         int nMin, nMax = 0;\r
 478 \r
 479         if (!m_Ev.bChecked) {\r
 480                 if (!cam_mm_get_caps_minmax(CAM_CP_FUNC_EXPOSURE, &nMin, &nMax)) {\r
 481                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 482                         return FALSE;\r
 483                 }\r
 484 \r
 485                 if ((nMin == 0) && (nMax == 0))\r
 486                         m_Ev.bSupported = FALSE;\r
 487                 else\r
 488                         m_Ev.bSupported = TRUE;\r
 489 \r
 490                 m_Ev.bChecked = TRUE;\r
 491                 m_Ev.nMin = nMin;\r
 492                 m_Ev.nMax = nMax;\r
 493         }\r
 494 \r
 495         *min = m_Ev.nMin;\r
 496         *max = m_Ev.nMax;\r
 497         return TRUE;\r
 498 }\r
 499 \r
 500 bool\r
 501 CCamDeviceCapacity::GetCamDevBrCaps(int *min, int *max)\r
 502 {\r
 503         cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");\r
 504 \r
 505         int nMin, nMax = 0;\r
 506 \r
 507         if (!m_Br.bChecked) {\r
 508                 if (!cam_mm_get_caps_minmax(CAM_CP_FUNC_BRIGHTNESS, &nMin, &nMax)) {\r
 509                         cam_debug(LOG_CAM, "cam_mm_get_caps_range() fail");\r
 510                         return FALSE;\r
 511                 }\r
 512 \r
 513                 if ((nMin == 0) && (nMax == 0))\r
 514                         m_Br.bSupported = FALSE;\r
 515                 else\r
 516                         m_Br.bSupported = TRUE;\r
 517 \r
 518                 m_Br.bChecked = TRUE;\r
 519                 m_Br.nMin = nMin;\r
 520                 m_Br.nMax = nMax;\r
 521         }\r
 522 \r
 523         *min = m_Br.nMin;\r
 524         *max = m_Br.nMax;\r
 525         return TRUE;\r
 526 }\r
 527 \r
 528 \r
 529 // private\r
 530 bool\r
 531 CCamDeviceCapacity::IsSupported(unsigned int type, CamDeviceType deviceType, void *user_data)\r
 532 {\r
 533         bool ret = FALSE;\r
 534         unsigned int uCaps = 0;\r
 535         int min, max = 0;\r
 536 \r
 537         switch(type) {\r
 538         case CAM_CP_FUNC_FPS:\r
 539                 {\r
 540                         if (GetCamDevFpsCaps(&uCaps, user_data))\r
 541                                 ret = m_Fps.bSupported;\r
 542                 }\r
 543                 break;\r
 544         case CAM_CP_FUNC_CAM_RESOLUTION:\r
 545                 {\r
 546                         if (GetCamDevCamResolutionCaps(&uCaps, user_data))\r
 547                                 ret = m_CamRes.bSupported;\r
 548                 }\r
 549                 break;\r
 550         case CAM_CP_FUNC_REC_RESOLUTION:\r
 551                 {\r
 552                         if (GetCamDevRecResolutionCaps(&uCaps, user_data))\r
 553                                 ret = m_RecRes.bSupported;\r
 554                 }\r
 555                 break;\r
 556         case CAM_CP_FUNC_FLASH_MODE:\r
 557                 {\r
 558                         if (GetCamDevFlashCaps(&uCaps, user_data))\r
 559                                 ret = m_Flash.bSupported;\r
 560                 }\r
 561                 break;\r
 562 \r
 563         case CAM_CP_FUNC_SHOT_MODE:\r
 564                 {\r
 565                         if (GetCamDevShotModeCaps(&uCaps, user_data))\r
 566                                 ret = m_Shot.bSupported;\r
 567                 }\r
 568                 break;\r
 569 \r
 570         case CAM_CP_FUNC_REC_MODE:\r
 571                 {\r
 572                         if (GetCamDevRecModeCaps(&uCaps, user_data)) {\r
 573                                 ret = m_RecMode.bSupported;\r
 574                                 DEBUG_TRACE("ret:%d", ret);\r
 575                         }\r
 576                 }\r
 577                 break;\r
 578 \r
 579         case CAM_CP_FUNC_SCENE_MODE:\r
 580                 {\r
 581                         if (GetCamDevSceneModeCaps(&uCaps, user_data))\r
 582                                 ret = m_Scene.bSupported;\r
 583                 }\r
 584                 break;\r
 585 \r
 586         case CAM_CP_FUNC_FOCUS_MODE:\r
 587                 {\r
 588                         if (GetCamDevFocusCaps(&uCaps, user_data))\r
 589                                 ret = m_Focus.bSupported;\r
 590                 }\r
 591                 break;\r
 592 \r
 593         case CAM_CP_FUNC_EFFECT_MODE:\r
 594                 {\r
 595                         if (GetCamDevEffectCaps(&uCaps, user_data))\r
 596                                 ret = m_Effect.bSupported;\r
 597                 }\r
 598                 break;\r
 599 \r
 600         case CAM_CP_FUNC_WHITE_BALANCE:\r
 601                 {\r
 602                         if (GetCamDevWBCaps(&uCaps, user_data))\r
 603                                 ret = m_WB.bSupported;\r
 604                 }\r
 605                 break;\r
 606 \r
 607         case CAM_CP_FUNC_ISO:\r
 608                 {\r
 609                         if (GetCamDevISOCaps(&uCaps, user_data))\r
 610                                 ret = m_ISO.bSupported;\r
 611                 }\r
 612                 break;\r
 613 \r
 614         case CAM_CP_FUNC_METERING:\r
 615                 {\r
 616                         if (GetCamDevMeteringCaps(&uCaps, user_data))\r
 617                                 ret = m_Metering.bSupported;\r
 618                 }\r
 619                 break;\r
 620 \r
 621         case CAM_CP_FUNC_OUTDOOR:\r
 622                 {\r
 623                         if (cam_mm_is_supported_outdoor_visibility())\r
 624                                 m_Outdoorvisibility.bSupported = TRUE;\r
 625                         else\r
 626                                 m_Outdoorvisibility.bSupported = FALSE;\r
 627 \r
 628                         ret = m_Outdoorvisibility.bSupported;\r
 629                 }\r
 630                 break;\r
 631 \r
 632         case CAM_CP_FUNC_AUTO_CONTRAST:         // not supported mmfw\r
 633                 {\r
 634                 #ifdef CAMERA_MACHINE_I686\r
 635                         ret = FALSE;\r
 636                 #else\r
 637                         if (deviceType == CAM_DEVICE_MEGA)\r
 638                                 m_WDR.bSupported = TRUE;\r
 639                         else\r
 640                                 m_WDR.bSupported = FALSE;\r
 641                                 ret = m_WDR.bSupported;\r
 642                 #endif\r
 643                 }\r
 644                 break;\r
 645 \r
 646         case CAM_CP_FUNC_ZOOM:\r
 647                 {\r
 648                         if (GetCamDevZoomCaps(&min, &max))\r
 649                                 ret = m_Zoom.bSupported;\r
 650                 }\r
 651                 break;\r
 652 \r
 653         case CAM_CP_FUNC_BRIGHTNESS:\r
 654                 {\r
 655                         if (GetCamDevBrCaps(&min, &max))\r
 656                                 ret = m_Br.bSupported;\r
 657                 }\r
 658                 break;\r
 659 \r
 660         case CAM_CP_FUNC_EXPOSURE:\r
 661                 {\r
 662                         if (GetCamDevEvCaps(&min, &max))\r
 663                                 ret = m_Ev.bSupported;\r
 664                 }\r
 665                 break;\r
 666 \r
 667         case CAM_CP_FUNC_CAM_ANS:\r
 668                 {\r
 669                         if (cam_mm_is_support_anti_hand_shake())\r
 670                                 ret = TRUE;\r
 671                 }\r
 672                 break;\r
 673         case CAM_CP_FUNC_REC_ANS:               // not supported mmfw\r
 674                 ret = FALSE;\r
 675                 break;\r
 676         case CAM_CP_FUNC_SELF_MODE:\r
 677                 {\r
 678                 #ifdef CAMERA_MACHINE_I686\r
 679                         ret = FALSE;\r
 680                 #else\r
 681                         if (cam_mm_is_support_front_camera())\r
 682                                 ret = TRUE;\r
 683                         else\r
 684                                 ret = FALSE;\r
 685                 #endif\r
 686                 }\r
 687                 break;\r
 688         case CAM_CP_FUNC_GPS:\r
 689         case CAM_CP_FUNC_STORAGE:\r
 690                 {\r
 691                 #ifdef CAMERA_MACHINE_I686\r
 692                         ret = FALSE;\r
 693                 #else\r
 694                         ret = TRUE;\r
 695                 #endif\r
 696                 }\r
 697                 break;\r
 698         case CAM_CP_FUNC_BURST_SHOT_MODE:\r
 699                 ret = TRUE;\r
 700                 break;\r
 701         case CAM_CP_FUNC_CAPTURE_VOICE:\r
 702                 ret = FALSE;\r
 703                 break;\r
 704         case CAM_CP_FUNC_SAVE_AS_FLIP:\r
 705                 {\r
 706                         ret = FALSE;\r
 707                 }\r
 708                 break;\r
 709         default:\r
 710                 break;\r
 711         }\r
 712 \r
 713         return ret;\r
 714 }\r
 715 \r