android-native-cam-properties.patch
| modules/highgui/include/opencv2/highgui/highgui_c.h (working copy) | ||
|---|---|---|
| 415 | 415 |
CV_CAP_PROP_XI_AEAG_LEVEL = 419, // Average intensity of output signal AEAG should achieve(in %) |
| 416 | 416 |
CV_CAP_PROP_XI_TIMEOUT = 420, // Image capture timeout in milliseconds |
| 417 | 417 |
|
| 418 |
// Properties for Android cameras |
|
| 419 |
CV_CAP_PROP_ANDROID_FLASH_MODE = 8001, |
|
| 420 |
CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002, |
|
| 421 |
CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003, |
|
| 422 |
CV_CAP_PROP_ANDROID_ANTIBANDING = 8004, |
|
| 423 |
CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005, |
|
| 424 |
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006, |
|
| 425 |
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007, |
|
| 426 |
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008, |
|
| 427 | ||
| 418 | 428 |
// Properties of cameras available through AVFOUNDATION interface |
| 419 | 429 |
CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001, |
| 420 | 430 |
CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002, |
| ... | ... | |
| 455 | 465 |
CV_CAP_ANDROID_COLOR_FRAME_RGBA = 4 |
| 456 | 466 |
}; |
| 457 | 467 | |
| 468 |
// supported Android camera flash modes |
|
| 469 |
enum {
|
|
| 470 |
CV_CAP_ANDROID_FLASH_MODE_AUTO = 0, |
|
| 471 |
CV_CAP_ANDROID_FLASH_MODE_OFF, |
|
| 472 |
CV_CAP_ANDROID_FLASH_MODE_ON, |
|
| 473 |
CV_CAP_ANDROID_FLASH_MODE_RED_EYE, |
|
| 474 |
CV_CAP_ANDROID_FLASH_MODE_TORCH |
|
| 475 |
}; |
|
| 476 | ||
| 477 |
// supported Android camera focus modes |
|
| 478 |
enum {
|
|
| 479 |
CV_CAP_ANDROID_FOCUS_MODE_AUTO = 0, |
|
| 480 |
CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO, |
|
| 481 |
CV_CAP_ANDROID_FOCUS_MODE_EDOF, |
|
| 482 |
CV_CAP_ANDROID_FOCUS_MODE_FIXED, |
|
| 483 |
CV_CAP_ANDROID_FOCUS_MODE_INFINITY, |
|
| 484 |
CV_CAP_ANDROID_FOCUS_MODE_MACRO |
|
| 485 |
}; |
|
| 486 | ||
| 487 |
// supported Android camera white balance modes |
|
| 488 |
enum {
|
|
| 489 |
CV_CAP_ANDROID_WHITE_BALANCE_AUTO = 0, |
|
| 490 |
CV_CAP_ANDROID_WHITE_BALANCE_CLOUDY_DAYLIGHT, |
|
| 491 |
CV_CAP_ANDROID_WHITE_BALANCE_DAYLIGHT, |
|
| 492 |
CV_CAP_ANDROID_WHITE_BALANCE_FLUORESCENT, |
|
| 493 |
CV_CAP_ANDROID_WHITE_BALANCE_INCANDESCENT, |
|
| 494 |
CV_CAP_ANDROID_WHITE_BALANCE_SHADE, |
|
| 495 |
CV_CAP_ANDROID_WHITE_BALANCE_TWILIGHT, |
|
| 496 |
CV_CAP_ANDROID_WHITE_BALANCE_WARM_FLUORESCENT |
|
| 497 |
}; |
|
| 498 | ||
| 499 |
// supported Android camera antibanding modes |
|
| 500 |
enum {
|
|
| 501 |
CV_CAP_ANDROID_ANTIBANDING_50HZ = 0, |
|
| 502 |
CV_CAP_ANDROID_ANTIBANDING_60HZ, |
|
| 503 |
CV_CAP_ANDROID_ANTIBANDING_AUTO, |
|
| 504 |
CV_CAP_ANDROID_ANTIBANDING_OFF |
|
| 505 |
}; |
|
| 506 | ||
| 458 | 507 |
/* retrieve or set capture properties */ |
| 459 | 508 |
CVAPI(double) cvGetCaptureProperty( CvCapture* capture, int property_id ); |
| 460 | 509 |
CVAPI(int) cvSetCaptureProperty( CvCapture* capture, int property_id, double value ); |
| modules/highgui/src/cap_android.cpp (working copy) | ||
|---|---|---|
| 41 | 41 | |
| 42 | 42 |
#include "precomp.hpp" |
| 43 | 43 | |
| 44 |
#define HAVE_ANDROID_NATIVE_CAMERA |
|
| 45 | ||
| 44 | 46 |
#ifdef HAVE_ANDROID_NATIVE_CAMERA |
| 45 | 47 | |
| 46 | 48 |
#include <opencv2/imgproc/imgproc.hpp> |
| ... | ... | |
| 263 | 265 |
return (double)m_activity->getFrameWidth(); |
| 264 | 266 |
case CV_CAP_PROP_FRAME_HEIGHT: |
| 265 | 267 |
return (double)m_activity->getFrameHeight(); |
| 266 | ||
| 267 | 268 |
case CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING: |
| 268 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING);
|
|
| 269 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING);
|
|
| 269 | 270 |
case CV_CAP_PROP_PREVIEW_FORMAT: |
| 270 | 271 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING); |
| 272 |
case CV_CAP_PROP_FPS: |
|
| 273 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FPS); |
|
| 274 |
case CV_CAP_PROP_EXPOSURE: |
|
| 275 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_EXPOSURE); |
|
| 276 |
case CV_CAP_PROP_ANDROID_FLASH_MODE: |
|
| 277 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FLASH_MODE); |
|
| 278 |
case CV_CAP_PROP_ANDROID_FOCUS_MODE: |
|
| 279 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FOCUS_MODE); |
|
| 280 |
case CV_CAP_PROP_ANDROID_WHITE_BALANCE: |
|
| 281 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_WHITE_BALANCE); |
|
| 282 |
case CV_CAP_PROP_ANDROID_ANTIBANDING: |
|
| 283 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_ANTIBANDING); |
|
| 284 |
case CV_CAP_PROP_ANDROID_FOCAL_LENGTH: |
|
| 285 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FOCAL_LENGTH); |
|
| 286 |
case CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR: |
|
| 287 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_NEAR); |
|
| 288 |
case CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL: |
|
| 289 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_OPTIMAL); |
|
| 290 |
case CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR: |
|
| 291 |
return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_FAR); |
|
| 271 | 292 |
default: |
| 272 | 293 |
CV_Error( CV_StsOutOfRange, "Failed attempt to GET unsupported camera property." ); |
| 273 | 294 |
break; |
| ... | ... | |
| 288 | 309 |
case CV_CAP_PROP_FRAME_HEIGHT: |
| 289 | 310 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT, propValue); |
| 290 | 311 |
break; |
| 291 | ||
| 292 | 312 |
case CV_CAP_PROP_AUTOGRAB: |
| 293 | 313 |
m_shouldAutoGrab=(propValue != 0); |
| 294 | 314 |
break; |
| 295 | ||
| 315 |
case CV_CAP_PROP_EXPOSURE: |
|
| 316 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_EXPOSURE, propValue); |
|
| 317 |
break; |
|
| 318 |
case CV_CAP_PROP_ANDROID_FLASH_MODE: |
|
| 319 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_FLASH_MODE, propValue); |
|
| 320 |
break; |
|
| 321 |
case CV_CAP_PROP_ANDROID_FOCUS_MODE: |
|
| 322 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_FOCUS_MODE, propValue); |
|
| 323 |
break; |
|
| 324 |
case CV_CAP_PROP_ANDROID_WHITE_BALANCE: |
|
| 325 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_WHITE_BALANCE, propValue); |
|
| 326 |
break; |
|
| 327 |
case CV_CAP_PROP_ANDROID_ANTIBANDING: |
|
| 328 |
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_ANTIBANDING, propValue); |
|
| 329 |
break; |
|
| 296 | 330 |
default: |
| 297 | 331 |
CV_Error( CV_StsOutOfRange, "Failed attempt to SET unsupported camera property." ); |
| 298 | 332 |
return false; |
| modules/androidcamera/include/camera_properties.h (working copy) | ||
|---|---|---|
| 5 | 5 |
ANDROID_CAMERA_PROPERTY_FRAMEWIDTH = 0, |
| 6 | 6 |
ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT = 1, |
| 7 | 7 |
ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING = 2, |
| 8 |
ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING = 3 |
|
| 8 |
ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING = 3, |
|
| 9 |
ANDROID_CAMERA_PROPERTY_FPS = 4, |
|
| 10 |
ANDROID_CAMERA_PROPERTY_EXPOSURE = 5, |
|
| 11 |
ANDROID_CAMERA_PROPERTY_FLASH_MODE = 101, |
|
| 12 |
ANDROID_CAMERA_PROPERTY_FOCUS_MODE = 102, |
|
| 13 |
ANDROID_CAMERA_PROPERTY_WHITE_BALANCE = 103, |
|
| 14 |
ANDROID_CAMERA_PROPERTY_ANTIBANDING = 104, |
|
| 15 |
ANDROID_CAMERA_PROPERTY_FOCAL_LENGTH = 105, |
|
| 16 |
ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_NEAR = 106, |
|
| 17 |
ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_OPTIMAL = 107, |
|
| 18 |
ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_FAR = 108 |
|
| 9 | 19 |
}; |
| 10 | 20 | |
| 21 | ||
| 22 |
enum {
|
|
| 23 |
ANDROID_CAMERA_FLASH_MODE_AUTO = 0, |
|
| 24 |
ANDROID_CAMERA_FLASH_MODE_OFF, |
|
| 25 |
ANDROID_CAMERA_FLASH_MODE_ON, |
|
| 26 |
ANDROID_CAMERA_FLASH_MODE_RED_EYE, |
|
| 27 |
ANDROID_CAMERA_FLASH_MODE_TORCH, |
|
| 28 |
ANDROID_CAMERA_FLASH_MODES_NUM |
|
| 29 |
}; |
|
| 30 | ||
| 31 |
enum {
|
|
| 32 |
ANDROID_CAMERA_FOCUS_MODE_AUTO = 0, |
|
| 33 |
ANDROID_CAMERA_FOCUS_MODE_CONTINUOUS_PICTURE, |
|
| 34 |
ANDROID_CAMERA_FOCUS_MODE_CONTINUOUS_VIDEO, |
|
| 35 |
ANDROID_CAMERA_FOCUS_MODE_EDOF, |
|
| 36 |
ANDROID_CAMERA_FOCUS_MODE_FIXED, |
|
| 37 |
ANDROID_CAMERA_FOCUS_MODE_INFINITY, |
|
| 38 |
ANDROID_CAMERA_FOCUS_MODE_MACRO, |
|
| 39 |
ANDROID_CAMERA_FOCUS_MODES_NUM |
|
| 40 |
}; |
|
| 41 | ||
| 42 |
enum {
|
|
| 43 |
ANDROID_CAMERA_WHITE_BALANCE_AUTO = 0, |
|
| 44 |
ANDROID_CAMERA_WHITE_BALANCE_CLOUDY_DAYLIGHT, |
|
| 45 |
ANDROID_CAMERA_WHITE_BALANCE_DAYLIGHT, |
|
| 46 |
ANDROID_CAMERA_WHITE_BALANCE_FLUORESCENT, |
|
| 47 |
ANDROID_CAMERA_WHITE_BALANCE_INCANDESCENT, |
|
| 48 |
ANDROID_CAMERA_WHITE_BALANCE_SHADE, |
|
| 49 |
ANDROID_CAMERA_WHITE_BALANCE_TWILIGHT, |
|
| 50 |
ANDROID_CAMERA_WHITE_BALANCE_WARM_FLUORESCENT, |
|
| 51 |
ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM |
|
| 52 |
}; |
|
| 53 | ||
| 54 |
enum {
|
|
| 55 |
ANDROID_CAMERA_ANTIBANDING_50HZ = 0, |
|
| 56 |
ANDROID_CAMERA_ANTIBANDING_60HZ, |
|
| 57 |
ANDROID_CAMERA_ANTIBANDING_AUTO, |
|
| 58 |
ANDROID_CAMERA_ANTIBANDING_OFF, |
|
| 59 |
ANDROID_CAMERA_ANTIBANDING_MODES_NUM |
|
| 60 |
}; |
|
| 61 | ||
| 62 |
enum {
|
|
| 63 |
ANDROID_CAMERA_FOCUS_DISTANCE_NEAR_INDEX = 0, |
|
| 64 |
ANDROID_CAMERA_FOCUS_DISTANCE_OPTIMAL_INDEX, |
|
| 65 |
ANDROID_CAMERA_FOCUS_DISTANCE_FAR_INDEX |
|
| 66 |
}; |
|
| 67 | ||
| 11 | 68 |
#endif // CAMERA_PROPERTIES_H |
| modules/androidcamera/src/camera_activity.cpp (working copy) | ||
|---|---|---|
| 3 | 3 |
#include <string> |
| 4 | 4 |
#include <vector> |
| 5 | 5 |
#include <algorithm> |
| 6 |
#include <ctype.h> |
|
| 6 | 7 |
#include "camera_activity.hpp" |
| 7 | 8 |
#include "camera_wrapper.h" |
| 8 | 9 | |
| modules/androidcamera/camera_wrapper/camera_wrapper.cpp (working copy) | ||
|---|---|---|
| 86 | 86 | |
| 87 | 87 |
int emptyCameraCallbackReported; |
| 88 | 88 | |
| 89 |
static const char* flashModesNames[ANDROID_CAMERA_FLASH_MODES_NUM]; |
|
| 90 |
static const char* focusModesNames[ANDROID_CAMERA_FOCUS_MODES_NUM]; |
|
| 91 |
static const char* whiteBalanceModesNames[ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM]; |
|
| 92 |
static const char* antibandingModesNames[ANDROID_CAMERA_ANTIBANDING_MODES_NUM]; |
|
| 93 | ||
| 89 | 94 |
void doCall(void* buffer, size_t bufferSize) |
| 90 | 95 |
{
|
| 91 | 96 |
if (cameraCallback == 0) |
| ... | ... | |
| 156 | 161 |
camera->releaseRecordingFrame(dataPtr); |
| 157 | 162 |
} |
| 158 | 163 | |
| 164 |
// Split list of floats, returns number of floats found |
|
| 165 |
static int split_float(const char *str, float* out, char delim, int max_elem_num, |
|
| 166 |
char **endptr = NULL) |
|
| 167 |
{
|
|
| 168 |
// Find the first float. |
|
| 169 |
char *end = const_cast<char*>(str); |
|
| 170 |
int elem_num = 0; |
|
| 171 |
for(; elem_num < max_elem_num; elem_num++ ){
|
|
| 172 |
char* curr_end; |
|
| 173 |
out[elem_num] = (float)strtof(end, &curr_end); |
|
| 174 |
// No other numbers found, finish the loop |
|
| 175 |
if(end == curr_end){
|
|
| 176 |
break; |
|
| 177 |
} |
|
| 178 |
if (*curr_end != delim) {
|
|
| 179 |
// When end of string, finish the loop |
|
| 180 |
if (*curr_end == 0){
|
|
| 181 |
elem_num++; |
|
| 182 |
break; |
|
| 183 |
} |
|
| 184 |
else {
|
|
| 185 |
LOGE("Cannot find delimeter (%c) in str=%s", delim, str);
|
|
| 186 |
return -1; |
|
| 187 |
} |
|
| 188 |
} |
|
| 189 |
// Skip the delimiter character |
|
| 190 |
end = curr_end + 1; |
|
| 191 |
} |
|
| 192 |
if (endptr) |
|
| 193 |
*endptr = end; |
|
| 194 |
return elem_num; |
|
| 195 |
} |
|
| 196 | ||
| 197 |
int is_supported(const char* supp_modes_key, const char* mode) |
|
| 198 |
{
|
|
| 199 |
const char* supported_modes = params.get(supp_modes_key); |
|
| 200 |
return strstr(supported_modes, mode) > 0; |
|
| 201 |
} |
|
| 202 | ||
| 203 |
float getFocusDistance(int focus_distance_type){
|
|
| 204 |
if (focus_distance_type >= 0 && focus_distance_type < 3) {
|
|
| 205 |
float focus_distances[3]; |
|
| 206 |
const char* output = params.get(CameraParameters::KEY_FOCUS_DISTANCES); |
|
| 207 |
int val_num = CameraHandler::split_float(output, focus_distances, ',', 3); |
|
| 208 |
if(val_num == 3){
|
|
| 209 |
return focus_distances[focus_distance_type]; |
|
| 210 |
} else {
|
|
| 211 |
LOGE("Invalid focus distances.");
|
|
| 212 |
} |
|
| 213 |
} |
|
| 214 |
return -1; |
|
| 215 |
} |
|
| 216 | ||
| 217 |
static int getModeNum(const char** modes, const int modes_num, const char* mode_name) |
|
| 218 |
{
|
|
| 219 |
for (int i = 0; i < modes_num; i++){
|
|
| 220 |
if(!strcmp(modes[i],mode_name)) |
|
| 221 |
return i; |
|
| 222 |
} |
|
| 223 |
return -1; |
|
| 224 |
} |
|
| 225 | ||
| 159 | 226 |
public: |
| 160 | 227 |
CameraHandler(CameraCallback callback = 0, void* _userData = 0): |
| 161 | 228 |
cameraId(0), |
| ... | ... | |
| 163 | 230 |
userData(_userData), |
| 164 | 231 |
emptyCameraCallbackReported(0) |
| 165 | 232 |
{
|
| 166 |
LOGD("Instantiated new CameraHandler (%p, %p)", callback, _userData);
|
|
| 233 |
LOGD("My camera wrapper: Instantiated new CameraHandler (%p, %p)", callback, _userData);
|
|
| 167 | 234 |
} |
| 168 | 235 | |
| 169 | 236 |
virtual ~CameraHandler() |
| ... | ... | |
| 220 | 287 |
std::string cameraPropertyPreviewFormatString; |
| 221 | 288 |
}; |
| 222 | 289 | |
| 290 |
const char* CameraHandler::flashModesNames[ANDROID_CAMERA_FLASH_MODES_NUM] = |
|
| 291 |
{
|
|
| 292 |
CameraParameters::FLASH_MODE_AUTO, |
|
| 293 |
CameraParameters::FLASH_MODE_OFF, |
|
| 294 |
CameraParameters::FLASH_MODE_ON, |
|
| 295 |
CameraParameters::FLASH_MODE_RED_EYE, |
|
| 296 |
CameraParameters::FLASH_MODE_TORCH |
|
| 297 |
}; |
|
| 223 | 298 | |
| 299 |
const char* CameraHandler::focusModesNames[ANDROID_CAMERA_FOCUS_MODES_NUM] = |
|
| 300 |
{
|
|
| 301 |
CameraParameters::FOCUS_MODE_AUTO, |
|
| 302 |
CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, |
|
| 303 |
CameraParameters::FOCUS_MODE_EDOF, |
|
| 304 |
CameraParameters::FOCUS_MODE_FIXED, |
|
| 305 |
CameraParameters::FOCUS_MODE_INFINITY |
|
| 306 |
}; |
|
| 307 | ||
| 308 |
const char* CameraHandler::whiteBalanceModesNames[ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM] = |
|
| 309 |
{
|
|
| 310 |
CameraParameters::WHITE_BALANCE_AUTO, |
|
| 311 |
CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, |
|
| 312 |
CameraParameters::WHITE_BALANCE_DAYLIGHT, |
|
| 313 |
CameraParameters::WHITE_BALANCE_FLUORESCENT, |
|
| 314 |
CameraParameters::WHITE_BALANCE_INCANDESCENT, |
|
| 315 |
CameraParameters::WHITE_BALANCE_SHADE, |
|
| 316 |
CameraParameters::WHITE_BALANCE_TWILIGHT |
|
| 317 |
}; |
|
| 318 | ||
| 319 | ||
| 320 |
const char* CameraHandler::antibandingModesNames[ANDROID_CAMERA_ANTIBANDING_MODES_NUM] = |
|
| 321 |
{
|
|
| 322 |
CameraParameters::ANTIBANDING_50HZ, |
|
| 323 |
CameraParameters::ANTIBANDING_60HZ, |
|
| 324 |
CameraParameters::ANTIBANDING_AUTO |
|
| 325 |
}; |
|
| 326 | ||
| 327 | ||
| 224 | 328 |
CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback, int cameraId, void* userData, CameraParameters* prevCameraParameters) |
| 225 | 329 |
{
|
| 226 | 330 |
LOGD("CameraHandler::initCameraConnect(%p, %d, %p, %p)", callback, cameraId, userData, prevCameraParameters);
|
| ... | ... | |
| 273 | 377 |
LOGD("Supported Antibanding Options: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
|
| 274 | 378 |
LOGD("Supported Flash Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
|
| 275 | 379 | |
| 276 | ||
| 277 | 380 |
//check if yuv420sp format available. Set this format as preview format. |
| 278 | 381 |
const char* available_formats = handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS); |
| 279 | 382 |
if (available_formats != 0) |
| ... | ... | |
| 435 | 538 |
u.str = cameraPropertyPreviewFormatString.c_str(); |
| 436 | 539 |
return u.res; |
| 437 | 540 |
} |
| 438 | ||
| 541 |
case ANDROID_CAMERA_PROPERTY_EXPOSURE: |
|
| 542 |
{
|
|
| 543 |
int exposure = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); |
|
| 544 |
return exposure; |
|
| 545 |
} |
|
| 546 |
case ANDROID_CAMERA_PROPERTY_FPS: |
|
| 547 |
{
|
|
| 548 |
return params.getPreviewFrameRate(); |
|
| 549 |
} |
|
| 550 |
case ANDROID_CAMERA_PROPERTY_FLASH_MODE: |
|
| 551 |
{
|
|
| 552 |
int flash_mode = getModeNum(CameraHandler::flashModesNames, |
|
| 553 |
ANDROID_CAMERA_FLASH_MODES_NUM, |
|
| 554 |
params.get(CameraParameters::KEY_FLASH_MODE)); |
|
| 555 |
return flash_mode; |
|
| 556 |
} |
|
| 557 |
case ANDROID_CAMERA_PROPERTY_FOCUS_MODE: |
|
| 558 |
{
|
|
| 559 |
int focus_mode = getModeNum(CameraHandler::focusModesNames, |
|
| 560 |
ANDROID_CAMERA_FOCUS_MODES_NUM, |
|
| 561 |
params.get(CameraParameters::KEY_FOCUS_MODE)); |
|
| 562 |
return focus_mode; |
|
| 563 |
} |
|
| 564 |
case ANDROID_CAMERA_PROPERTY_WHITE_BALANCE: |
|
| 565 |
{
|
|
| 566 |
int white_balance = getModeNum(CameraHandler::whiteBalanceModesNames, |
|
| 567 |
ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM, |
|
| 568 |
params.get(CameraParameters::KEY_WHITE_BALANCE)); |
|
| 569 |
return white_balance; |
|
| 570 |
} |
|
| 571 |
case ANDROID_CAMERA_PROPERTY_ANTIBANDING: |
|
| 572 |
{
|
|
| 573 |
int antibanding = getModeNum(CameraHandler::antibandingModesNames, |
|
| 574 |
ANDROID_CAMERA_ANTIBANDING_MODES_NUM, |
|
| 575 |
params.get(CameraParameters::KEY_ANTIBANDING)); |
|
| 576 |
return antibanding; |
|
| 577 |
} |
|
| 578 |
case ANDROID_CAMERA_PROPERTY_FOCAL_LENGTH: |
|
| 579 |
{
|
|
| 580 |
float focal_length = params.getFloat(CameraParameters::KEY_FOCAL_LENGTH); |
|
| 581 |
return focal_length; |
|
| 582 |
} |
|
| 583 |
case ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_NEAR: |
|
| 584 |
{
|
|
| 585 |
return getFocusDistance(ANDROID_CAMERA_FOCUS_DISTANCE_NEAR_INDEX); |
|
| 586 |
} |
|
| 587 |
case ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_OPTIMAL: |
|
| 588 |
{
|
|
| 589 |
return getFocusDistance(ANDROID_CAMERA_FOCUS_DISTANCE_OPTIMAL_INDEX); |
|
| 590 |
} |
|
| 591 |
case ANDROID_CAMERA_PROPERTY_FOCUS_DISTANCE_FAR: |
|
| 592 |
{
|
|
| 593 |
return getFocusDistance(ANDROID_CAMERA_FOCUS_DISTANCE_FAR_INDEX); |
|
| 594 |
} |
|
| 595 |
default: |
|
| 596 |
LOGW("CameraHandler::getProperty - Unsupported property.");
|
|
| 439 | 597 |
}; |
| 440 | 598 |
return -1; |
| 441 | 599 |
} |
| ... | ... | |
| 462 | 620 |
params.setPreviewSize(w, h); |
| 463 | 621 |
} |
| 464 | 622 |
break; |
| 623 |
case ANDROID_CAMERA_PROPERTY_EXPOSURE: |
|
| 624 |
{
|
|
| 625 |
int max_exposure = params.getInt("max-exposure-compensation");
|
|
| 626 |
int min_exposure = params.getInt("min-exposure-compensation");
|
|
| 627 |
if(max_exposure && min_exposure){
|
|
| 628 |
int exposure = (int)value; |
|
| 629 |
if(exposure >= min_exposure && exposure <= max_exposure){
|
|
| 630 |
params.set("exposure-compensation", exposure);
|
|
| 631 |
} else {
|
|
| 632 |
LOGE("Exposure compensation not in valid range (%i,%i).", min_exposure, max_exposure);
|
|
| 633 |
} |
|
| 634 |
} else {
|
|
| 635 |
LOGE("Exposure compensation adjust is not supported.");
|
|
| 636 |
} |
|
| 637 |
} |
|
| 638 |
break; |
|
| 639 |
case ANDROID_CAMERA_PROPERTY_FLASH_MODE: |
|
| 640 |
{
|
|
| 641 |
int new_val = (int)value; |
|
| 642 |
if(new_val >= 0 && new_val < ANDROID_CAMERA_FLASH_MODES_NUM){
|
|
| 643 |
const char* mode_name = flashModesNames[new_val]; |
|
| 644 |
if(is_supported(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mode_name)) |
|
| 645 |
params.set(CameraParameters::KEY_FLASH_MODE, mode_name); |
|
| 646 |
else |
|
| 647 |
LOGE("Flash mode %s is not supported.", mode_name);
|
|
| 648 |
} else {
|
|
| 649 |
LOGE("Flash mode value not in valid range.");
|
|
| 650 |
} |
|
| 651 |
} |
|
| 652 |
break; |
|
| 653 |
case ANDROID_CAMERA_PROPERTY_FOCUS_MODE: |
|
| 654 |
{
|
|
| 655 |
int new_val = (int)value; |
|
| 656 |
if(new_val >= 0 && new_val < ANDROID_CAMERA_FOCUS_MODES_NUM){
|
|
| 657 |
const char* mode_name = focusModesNames[new_val]; |
|
| 658 |
if(is_supported(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mode_name)) |
|
| 659 |
params.set(CameraParameters::KEY_FOCUS_MODE, mode_name); |
|
| 660 |
else |
|
| 661 |
LOGE("Focus mode %s is not supported.", mode_name);
|
|
| 662 |
} else {
|
|
| 663 |
LOGE("Focus mode value not in valid range.");
|
|
| 664 |
} |
|
| 665 |
} |
|
| 666 |
break; |
|
| 667 |
case ANDROID_CAMERA_PROPERTY_WHITE_BALANCE: |
|
| 668 |
{
|
|
| 669 |
int new_val = (int)value; |
|
| 670 |
if(new_val >= 0 && new_val < ANDROID_CAMERA_WHITE_BALANCE_MODES_NUM){
|
|
| 671 |
const char* mode_name = whiteBalanceModesNames[new_val]; |
|
| 672 |
if(is_supported(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mode_name)) |
|
| 673 |
params.set(CameraParameters::KEY_WHITE_BALANCE, mode_name); |
|
| 674 |
else |
|
| 675 |
LOGE("White balance mode %s is not supported.", mode_name);
|
|
| 676 |
} else {
|
|
| 677 |
LOGE("White balance mode value not in valid range.");
|
|
| 678 |
} |
|
| 679 |
} |
|
| 680 |
break; |
|
| 681 |
case ANDROID_CAMERA_PROPERTY_ANTIBANDING: |
|
| 682 |
{
|
|
| 683 |
int new_val = (int)value; |
|
| 684 |
if(new_val >= 0 && new_val < ANDROID_CAMERA_ANTIBANDING_MODES_NUM){
|
|
| 685 |
const char* mode_name = antibandingModesNames[new_val]; |
|
| 686 |
if(is_supported(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mode_name)) |
|
| 687 |
params.set(CameraParameters::KEY_ANTIBANDING, mode_name); |
|
| 688 |
else |
|
| 689 |
LOGE("Antibanding mode %s is not supported.", mode_name);
|
|
| 690 |
} else {
|
|
| 691 |
LOGE("Antibanding mode value not in valid range.");
|
|
| 692 |
} |
|
| 693 |
} |
|
| 694 |
break; |
|
| 695 |
default: |
|
| 696 |
LOGW("CameraHandler::setProperty - Unsupported property.");
|
|
| 465 | 697 |
}; |
| 466 | 698 |
} |
| 467 | 699 | |