3 * Copyright 2012 Samsung Electronics Co., Ltd
\r
5 * Licensed under the Flora License, Version 1.0 (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
9 * http://floralicense.org/license/
\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
22 #include "CamDeviceCapacity.h"
\r
23 #include "cam_capacity_type.h"
\r
28 #include "cam_debug.h"
\r
31 #define CAM_ATTR_NOT_SUPPORTED (1)
\r
32 #define CAM_CP_FUNC_UNMARKED (0)
\r
33 CCamDeviceCapacity* CCamDeviceCapacity::m_pInstance = NULL;
\r
35 /////////////////////////////////////////////////////////////////////////////
\r
36 // Construction/Destruction
\r
37 /////////////////////////////////////////////////////////////////////////////
\r
38 CCamDeviceCapacity::CCamDeviceCapacity()
\r
43 CCamDeviceCapacity::~CCamDeviceCapacity()
\r
49 CCamDeviceCapacity::ResetCaps()
\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
67 m_WDR.bChecked = FALSE;
\r
68 m_AntiShake.bChecked = FALSE;
\r
69 m_RecAntiShake.bChecked = FALSE;
\r
70 m_Outdoorvisibility.bChecked = FALSE;
\r
77 CCamDeviceCapacity::GetInstance()
\r
79 if(m_pInstance == NULL)
\r
80 m_pInstance = new CCamDeviceCapacity;
\r
85 CCamDeviceCapacity::Destroy()
\r
95 CCamDeviceCapacity::GetCamDevFuncCaps(unsigned int *uCapacity, void *user_data)
\r
97 unsigned int uSearchCaps = CAM_CP_FUNC_BURST_SHOT_MODE;
\r
98 unsigned int uCaps = 0;
\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
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
113 cam_debug(LOG_CAM, "i[%d] uSearchCaps [0x%x]", i, uSearchCaps);
\r
116 m_uFuncCaps = uCaps;
\r
119 *uCapacity = m_uFuncCaps;
\r
124 CCamDeviceCapacity::GetCamDevSceneModeCaps(unsigned int* uCapacity, void *user_data)
\r
126 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
128 unsigned int uCaps = 0;
\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
137 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
138 m_Scene.bSupported = TRUE;
\r
140 m_Scene.bSupported = FALSE;
\r
142 m_Scene.bChecked = TRUE;
\r
143 m_Scene.unCaps = uCaps;
\r
147 *uCapacity = m_Scene.unCaps;
\r
152 CCamDeviceCapacity::GetCamDevWBCaps(unsigned int* uCapacity, void *user_data)
\r
154 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
156 unsigned int uCaps = 0;
\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
165 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
166 m_WB.bSupported = TRUE;
\r
168 m_WB.bSupported = FALSE;
\r
170 m_WB.bChecked = TRUE;
\r
171 m_WB.unCaps = uCaps;
\r
175 *uCapacity = m_WB.unCaps;
\r
181 CCamDeviceCapacity::GetCamDevEffectCaps(unsigned int* uCapacity, void *user_data)
\r
183 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
185 unsigned int uCaps = 0;
\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
194 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
195 m_Effect.bSupported = TRUE;
\r
197 m_Effect.bSupported = FALSE;
\r
199 m_Effect.bChecked = TRUE;
\r
200 m_Effect.unCaps = uCaps;
\r
203 *uCapacity = m_Effect.unCaps;
\r
208 CCamDeviceCapacity::GetCamDevFocusCaps(unsigned int* uCapacity, void *user_data)
\r
210 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
212 unsigned int uCaps = 0;
\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
221 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
222 m_Focus.bSupported = TRUE;
\r
224 m_Focus.bSupported = FALSE;
\r
226 if (cam_mm_is_supported_face_detection())
\r
227 uCaps |= CAM_CP_FOCUS_FACE_DETECTION;
\r
229 m_Focus.bChecked = TRUE;
\r
230 m_Focus.unCaps = uCaps;
\r
233 *uCapacity = m_Focus.unCaps;
\r
239 CCamDeviceCapacity::GetCamDevShotModeCaps(unsigned int *uCapacity, void *user_data)
\r
241 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
244 m_Shot.bSupported = FALSE;
\r
245 m_Shot.bChecked = TRUE;
\r
251 CCamDeviceCapacity::GetCamDevRecModeCaps(unsigned int *uCapacity, void *user_data)
\r
253 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
256 #ifdef CAMERA_MACHINE_I686
\r
257 m_RecMode.bSupported = FALSE;
\r
258 m_RecMode.bChecked = TRUE;
\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
268 m_RecMode.bSupported = TRUE;
\r
269 m_RecMode.bChecked = TRUE;
\r
272 *uCapacity = m_RecMode.unCaps;
\r
278 CCamDeviceCapacity::GetCamDevCamResolutionCaps(unsigned int* uCapacity, void *user_data)
\r
280 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
282 unsigned int uCaps = 0;
\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
291 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
292 m_CamRes.bSupported = TRUE;
\r
294 m_CamRes.bSupported = FALSE;
\r
296 m_CamRes.bSupported = TRUE;
\r
297 m_CamRes.bChecked = TRUE;
\r
298 m_CamRes.unCaps = uCaps;
\r
301 *uCapacity = m_CamRes.unCaps;
\r
306 CCamDeviceCapacity::GetCamDevISOCaps(unsigned int* uCapacity, void *user_data)
\r
308 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
310 unsigned int uCaps = 0;
\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
319 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
320 m_ISO.bSupported = TRUE;
\r
322 m_ISO.bSupported = FALSE;
\r
324 m_ISO.bChecked = TRUE;
\r
325 m_ISO.unCaps = uCaps;
\r
328 *uCapacity = m_ISO.unCaps;
\r
333 CCamDeviceCapacity::GetCamDevMeteringCaps(unsigned int* uCapacity, void *user_data)
\r
335 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
337 unsigned int uCaps = 0;
\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
346 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
347 m_Metering.bSupported = TRUE;
\r
349 m_Metering.bSupported = FALSE;
\r
351 m_Metering.bChecked = TRUE;
\r
352 m_Metering.unCaps = uCaps;
\r
355 *uCapacity = m_Metering.unCaps;
\r
360 CCamDeviceCapacity::GetCamDevFlashCaps(unsigned int* uCapacity, void *user_data)
\r
362 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
364 unsigned int uCaps = 0;
\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
373 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
374 m_Flash.bSupported = TRUE;
\r
376 m_Flash.bSupported = FALSE;
\r
378 m_Flash.bChecked = TRUE;
\r
379 m_Flash.unCaps = uCaps;
\r
382 *uCapacity = m_Flash.unCaps;
\r
387 CCamDeviceCapacity::GetCamDevRecResolutionCaps(unsigned int* uCapacity, void *user_data)
\r
389 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
391 unsigned int uCaps = 0;
\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
400 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
401 m_RecRes.bSupported = TRUE;
\r
403 m_RecRes.bSupported = FALSE;
\r
405 m_RecRes.bChecked = TRUE;
\r
406 m_RecRes.unCaps = uCaps;
\r
409 *uCapacity = m_RecRes.unCaps;
\r
416 CCamDeviceCapacity::GetCamDevFpsCaps(unsigned int *uCapacity, void *user_data)
\r
418 cam_retvm_if(uCapacity == NULL, FALSE, "input param is NULL");
\r
420 unsigned int uCaps = 0;
\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
429 if (cam_mm_get_caps_cb_cnt() > CAM_ATTR_NOT_SUPPORTED)
\r
430 m_Fps.bSupported = TRUE;
\r
432 m_Fps.bSupported = FALSE;
\r
434 m_Fps.bChecked = TRUE;
\r
435 m_Fps.bChecked = TRUE;
\r
436 m_Fps.unCaps = uCaps;
\r
439 *uCapacity = m_Fps.unCaps;
\r
445 CCamDeviceCapacity::GetCamDevZoomCaps(int *min, int *max)
\r
447 cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");
\r
449 int nMin, nMax = 0;
\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
457 if ((nMin == 0) && (nMax == 0))
\r
458 m_Zoom.bSupported = FALSE;
\r
460 m_Zoom.bSupported = TRUE;
\r
462 m_Zoom.bChecked = TRUE;
\r
463 m_Zoom.nMin = nMin;
\r
464 m_Zoom.nMax = nMax;
\r
467 *min = m_Zoom.nMin;
\r
468 *max = m_Zoom.nMax;
\r
473 CCamDeviceCapacity::GetCamDevEvCaps(int *min, int *max)
\r
475 cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");
\r
477 int nMin, nMax = 0;
\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
485 if ((nMin == 0) && (nMax == 0))
\r
486 m_Ev.bSupported = FALSE;
\r
488 m_Ev.bSupported = TRUE;
\r
490 m_Ev.bChecked = TRUE;
\r
501 CCamDeviceCapacity::GetCamDevBrCaps(int *min, int *max)
\r
503 cam_retvm_if((min == NULL || max == NULL), FALSE, "input parameter is NULL");
\r
505 int nMin, nMax = 0;
\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
513 if ((nMin == 0) && (nMax == 0))
\r
514 m_Br.bSupported = FALSE;
\r
516 m_Br.bSupported = TRUE;
\r
518 m_Br.bChecked = TRUE;
\r
531 CCamDeviceCapacity::IsSupported(unsigned int type, CamDeviceType deviceType, void *user_data)
\r
534 unsigned int uCaps = 0;
\r
538 case CAM_CP_FUNC_FPS:
\r
540 if (GetCamDevFpsCaps(&uCaps, user_data))
\r
541 ret = m_Fps.bSupported;
\r
544 case CAM_CP_FUNC_CAM_RESOLUTION:
\r
546 if (GetCamDevCamResolutionCaps(&uCaps, user_data))
\r
547 ret = m_CamRes.bSupported;
\r
550 case CAM_CP_FUNC_REC_RESOLUTION:
\r
552 if (GetCamDevRecResolutionCaps(&uCaps, user_data))
\r
553 ret = m_RecRes.bSupported;
\r
556 case CAM_CP_FUNC_FLASH_MODE:
\r
558 if (GetCamDevFlashCaps(&uCaps, user_data))
\r
559 ret = m_Flash.bSupported;
\r
563 case CAM_CP_FUNC_SHOT_MODE:
\r
565 if (GetCamDevShotModeCaps(&uCaps, user_data))
\r
566 ret = m_Shot.bSupported;
\r
570 case CAM_CP_FUNC_REC_MODE:
\r
572 if (GetCamDevRecModeCaps(&uCaps, user_data)) {
\r
573 ret = m_RecMode.bSupported;
\r
574 DEBUG_TRACE("ret:%d", ret);
\r
579 case CAM_CP_FUNC_SCENE_MODE:
\r
581 if (GetCamDevSceneModeCaps(&uCaps, user_data))
\r
582 ret = m_Scene.bSupported;
\r
586 case CAM_CP_FUNC_FOCUS_MODE:
\r
588 if (GetCamDevFocusCaps(&uCaps, user_data))
\r
589 ret = m_Focus.bSupported;
\r
593 case CAM_CP_FUNC_EFFECT_MODE:
\r
595 if (GetCamDevEffectCaps(&uCaps, user_data))
\r
596 ret = m_Effect.bSupported;
\r
600 case CAM_CP_FUNC_WHITE_BALANCE:
\r
602 if (GetCamDevWBCaps(&uCaps, user_data))
\r
603 ret = m_WB.bSupported;
\r
607 case CAM_CP_FUNC_ISO:
\r
609 if (GetCamDevISOCaps(&uCaps, user_data))
\r
610 ret = m_ISO.bSupported;
\r
614 case CAM_CP_FUNC_METERING:
\r
616 if (GetCamDevMeteringCaps(&uCaps, user_data))
\r
617 ret = m_Metering.bSupported;
\r
621 case CAM_CP_FUNC_OUTDOOR:
\r
623 if (cam_mm_is_supported_outdoor_visibility())
\r
624 m_Outdoorvisibility.bSupported = TRUE;
\r
626 m_Outdoorvisibility.bSupported = FALSE;
\r
628 ret = m_Outdoorvisibility.bSupported;
\r
632 case CAM_CP_FUNC_AUTO_CONTRAST: // not supported mmfw
\r
634 #ifdef CAMERA_MACHINE_I686
\r
637 if (deviceType == CAM_DEVICE_MEGA)
\r
638 m_WDR.bSupported = TRUE;
\r
640 m_WDR.bSupported = FALSE;
\r
641 ret = m_WDR.bSupported;
\r
646 case CAM_CP_FUNC_ZOOM:
\r
648 if (GetCamDevZoomCaps(&min, &max))
\r
649 ret = m_Zoom.bSupported;
\r
653 case CAM_CP_FUNC_BRIGHTNESS:
\r
655 if (GetCamDevBrCaps(&min, &max))
\r
656 ret = m_Br.bSupported;
\r
660 case CAM_CP_FUNC_EXPOSURE:
\r
662 if (GetCamDevEvCaps(&min, &max))
\r
663 ret = m_Ev.bSupported;
\r
667 case CAM_CP_FUNC_CAM_ANS:
\r
669 if (cam_mm_is_support_anti_hand_shake())
\r
673 case CAM_CP_FUNC_REC_ANS: // not supported mmfw
\r
676 case CAM_CP_FUNC_SELF_MODE:
\r
678 #ifdef CAMERA_MACHINE_I686
\r
681 if (cam_mm_is_support_front_camera())
\r
688 case CAM_CP_FUNC_GPS:
\r
689 case CAM_CP_FUNC_STORAGE:
\r
691 #ifdef CAMERA_MACHINE_I686
\r
698 case CAM_CP_FUNC_BURST_SHOT_MODE:
\r
701 case CAM_CP_FUNC_CAPTURE_VOICE:
\r
704 case CAM_CP_FUNC_SAVE_AS_FLIP:
\r