CameraParameters.h revision ca1d5399c5d6d23d16554be7c702fdf5232e55bd
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_HARDWARE_CAMERA_PARAMETERS_H 18#define ANDROID_HARDWARE_CAMERA_PARAMETERS_H 19 20#include <utils/KeyedVector.h> 21#include <utils/String8.h> 22 23namespace android { 24 25struct Size { 26 int width; 27 int height; 28 29 Size() { 30 width = 0; 31 height = 0; 32 } 33 34 Size(int w, int h) { 35 width = w; 36 height = h; 37 } 38}; 39 40class CameraParameters 41{ 42public: 43 CameraParameters(); 44 CameraParameters(const String8 ¶ms) { unflatten(params); } 45 ~CameraParameters(); 46 47 String8 flatten() const; 48 void unflatten(const String8 ¶ms); 49 50 void set(const char *key, const char *value); 51 void set(const char *key, int value); 52 void setFloat(const char *key, float value); 53 const char *get(const char *key) const; 54 int getInt(const char *key) const; 55 float getFloat(const char *key) const; 56 57 void remove(const char *key); 58 59 void setPreviewSize(int width, int height); 60 void getPreviewSize(int *width, int *height) const; 61 void getSupportedPreviewSizes(Vector<Size> &sizes) const; 62 63 // Set the dimensions in pixels to the given width and height 64 // for video frames. The given width and height must be one 65 // of the supported dimensions returned from 66 // getSupportedVideoSizes(). Must not be called if 67 // getSupportedVideoSizes() returns an empty Vector of Size. 68 void setVideoSize(int width, int height); 69 // Retrieve the current dimensions (width and height) 70 // in pixels for video frames, which must be one of the 71 // supported dimensions returned from getSupportedVideoSizes(). 72 // Must not be called if getSupportedVideoSizes() returns an 73 // empty Vector of Size. 74 void getVideoSize(int *width, int *height) const; 75 // Retrieve a Vector of supported dimensions (width and height) 76 // in pixels for video frames. If sizes returned from the method 77 // is empty, the camera does not support calls to setVideoSize() 78 // or getVideoSize(). In adddition, it also indicates that 79 // the camera only has a single output, and does not have 80 // separate output for video frames and preview frame. 81 void getSupportedVideoSizes(Vector<Size> &sizes) const; 82 // Retrieve the preferred preview size (width and height) in pixels 83 // for video recording. The given width and height must be one of 84 // supported preview sizes returned from getSupportedPreviewSizes(). 85 // Must not be called if getSupportedVideoSizes() returns an empty 86 // Vector of Size. If getSupportedVideoSizes() returns an empty 87 // Vector of Size, the width and height returned from this method 88 // is invalid, and is "-1x-1". 89 void getPreferredPreviewSizeForVideo(int *width, int *height) const; 90 91 void setPreviewFrameRate(int fps); 92 int getPreviewFrameRate() const; 93 void getPreviewFpsRange(int *min_fps, int *max_fps) const; 94 void setPreviewFormat(const char *format); 95 const char *getPreviewFormat() const; 96 void setPictureSize(int width, int height); 97 void getPictureSize(int *width, int *height) const; 98 void getSupportedPictureSizes(Vector<Size> &sizes) const; 99 void setPictureFormat(const char *format); 100 const char *getPictureFormat() const; 101 102 void dump() const; 103 status_t dump(int fd, const Vector<String16>& args) const; 104 105 // Parameter keys to communicate between camera application and driver. 106 // The access (read/write, read only, or write only) is viewed from the 107 // perspective of applications, not driver. 108 109 // Preview frame size in pixels (width x height). 110 // Example value: "480x320". Read/Write. 111 static const char KEY_PREVIEW_SIZE[]; 112 // Supported preview frame sizes in pixels. 113 // Example value: "800x600,480x320". Read only. 114 static const char KEY_SUPPORTED_PREVIEW_SIZES[]; 115 // The current minimum and maximum preview fps. This controls the rate of 116 // preview frames received (CAMERA_MSG_PREVIEW_FRAME). The minimum and 117 // maximum fps must be one of the elements from 118 // KEY_SUPPORTED_PREVIEW_FPS_RANGE parameter. 119 // Example value: "10500,26623" 120 static const char KEY_PREVIEW_FPS_RANGE[]; 121 // The supported preview fps (frame-per-second) ranges. Each range contains 122 // a minimum fps and maximum fps. If minimum fps equals to maximum fps, the 123 // camera outputs frames in fixed frame rate. If not, the camera outputs 124 // frames in auto frame rate. The actual frame rate fluctuates between the 125 // minimum and the maximum. The list has at least one element. The list is 126 // sorted from small to large (first by maximum fps and then minimum fps). 127 // Example value: "(10500,26623),(15000,26623),(30000,30000)" 128 static const char KEY_SUPPORTED_PREVIEW_FPS_RANGE[]; 129 // The image format for preview frames. See CAMERA_MSG_PREVIEW_FRAME in 130 // frameworks/base/include/camera/Camera.h. 131 // Example value: "yuv420sp" or PIXEL_FORMAT_XXX constants. Read/write. 132 static const char KEY_PREVIEW_FORMAT[]; 133 // Supported image formats for preview frames. 134 // Example value: "yuv420sp,yuv422i-yuyv". Read only. 135 static const char KEY_SUPPORTED_PREVIEW_FORMATS[]; 136 // Number of preview frames per second. This is the target frame rate. The 137 // actual frame rate depends on the driver. 138 // Example value: "15". Read/write. 139 static const char KEY_PREVIEW_FRAME_RATE[]; 140 // Supported number of preview frames per second. 141 // Example value: "24,15,10". Read. 142 static const char KEY_SUPPORTED_PREVIEW_FRAME_RATES[]; 143 // The dimensions for captured pictures in pixels (width x height). 144 // Example value: "1024x768". Read/write. 145 static const char KEY_PICTURE_SIZE[]; 146 // Supported dimensions for captured pictures in pixels. 147 // Example value: "2048x1536,1024x768". Read only. 148 static const char KEY_SUPPORTED_PICTURE_SIZES[]; 149 // The image format for captured pictures. See CAMERA_MSG_COMPRESSED_IMAGE 150 // in frameworks/base/include/camera/Camera.h. 151 // Example value: "jpeg" or PIXEL_FORMAT_XXX constants. Read/write. 152 static const char KEY_PICTURE_FORMAT[]; 153 // Supported image formats for captured pictures. 154 // Example value: "jpeg,rgb565". Read only. 155 static const char KEY_SUPPORTED_PICTURE_FORMATS[]; 156 // The width (in pixels) of EXIF thumbnail in Jpeg picture. 157 // Example value: "512". Read/write. 158 static const char KEY_JPEG_THUMBNAIL_WIDTH[]; 159 // The height (in pixels) of EXIF thumbnail in Jpeg picture. 160 // Example value: "384". Read/write. 161 static const char KEY_JPEG_THUMBNAIL_HEIGHT[]; 162 // Supported EXIF thumbnail sizes (width x height). 0x0 means not thumbnail 163 // in EXIF. 164 // Example value: "512x384,320x240,0x0". Read only. 165 static const char KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES[]; 166 // The quality of the EXIF thumbnail in Jpeg picture. The range is 1 to 100, 167 // with 100 being the best. 168 // Example value: "90". Read/write. 169 static const char KEY_JPEG_THUMBNAIL_QUALITY[]; 170 // Jpeg quality of captured picture. The range is 1 to 100, with 100 being 171 // the best. 172 // Example value: "90". Read/write. 173 static const char KEY_JPEG_QUALITY[]; 174 // The rotation angle in degrees relative to the orientation of the camera. 175 // This affects the pictures returned from CAMERA_MSG_COMPRESSED_IMAGE. The 176 // camera driver may set orientation in the EXIF header without rotating the 177 // picture. Or the driver may rotate the picture and the EXIF thumbnail. If 178 // the Jpeg picture is rotated, the orientation in the EXIF header will be 179 // missing or 1 (row #0 is top and column #0 is left side). 180 // 181 // Note that the JPEG pictures of front-facing cameras are not mirrored 182 // as in preview display. 183 // 184 // For example, suppose the natural orientation of the device is portrait. 185 // The device is rotated 270 degrees clockwise, so the device orientation is 186 // 270. Suppose a back-facing camera sensor is mounted in landscape and the 187 // top side of the camera sensor is aligned with the right edge of the 188 // display in natural orientation. So the camera orientation is 90. The 189 // rotation should be set to 0 (270 + 90). 190 // 191 // Example value: "0" or "90" or "180" or "270". Write only. 192 static const char KEY_ROTATION[]; 193 // GPS latitude coordinate. GPSLatitude and GPSLatitudeRef will be stored in 194 // JPEG EXIF header. 195 // Example value: "25.032146" or "-33.462809". Write only. 196 static const char KEY_GPS_LATITUDE[]; 197 // GPS longitude coordinate. GPSLongitude and GPSLongitudeRef will be stored 198 // in JPEG EXIF header. 199 // Example value: "121.564448" or "-70.660286". Write only. 200 static const char KEY_GPS_LONGITUDE[]; 201 // GPS altitude. GPSAltitude and GPSAltitudeRef will be stored in JPEG EXIF 202 // header. 203 // Example value: "21.0" or "-5". Write only. 204 static const char KEY_GPS_ALTITUDE[]; 205 // GPS timestamp (UTC in seconds since January 1, 1970). This should be 206 // stored in JPEG EXIF header. 207 // Example value: "1251192757". Write only. 208 static const char KEY_GPS_TIMESTAMP[]; 209 // GPS Processing Method 210 // Example value: "GPS" or "NETWORK". Write only. 211 static const char KEY_GPS_PROCESSING_METHOD[]; 212 // Current white balance setting. 213 // Example value: "auto" or WHITE_BALANCE_XXX constants. Read/write. 214 static const char KEY_WHITE_BALANCE[]; 215 // Supported white balance settings. 216 // Example value: "auto,incandescent,daylight". Read only. 217 static const char KEY_SUPPORTED_WHITE_BALANCE[]; 218 // Current color effect setting. 219 // Example value: "none" or EFFECT_XXX constants. Read/write. 220 static const char KEY_EFFECT[]; 221 // Supported color effect settings. 222 // Example value: "none,mono,sepia". Read only. 223 static const char KEY_SUPPORTED_EFFECTS[]; 224 // Current antibanding setting. 225 // Example value: "auto" or ANTIBANDING_XXX constants. Read/write. 226 static const char KEY_ANTIBANDING[]; 227 // Supported antibanding settings. 228 // Example value: "auto,50hz,60hz,off". Read only. 229 static const char KEY_SUPPORTED_ANTIBANDING[]; 230 // Current scene mode. 231 // Example value: "auto" or SCENE_MODE_XXX constants. Read/write. 232 static const char KEY_SCENE_MODE[]; 233 // Supported scene mode settings. 234 // Example value: "auto,night,fireworks". Read only. 235 static const char KEY_SUPPORTED_SCENE_MODES[]; 236 // Current flash mode. 237 // Example value: "auto" or FLASH_MODE_XXX constants. Read/write. 238 static const char KEY_FLASH_MODE[]; 239 // Supported flash modes. 240 // Example value: "auto,on,off". Read only. 241 static const char KEY_SUPPORTED_FLASH_MODES[]; 242 // Current focus mode. This will not be empty. Applications should call 243 // CameraHardwareInterface.autoFocus to start the focus if focus mode is 244 // FOCUS_MODE_AUTO or FOCUS_MODE_MACRO. 245 // Example value: "auto" or FOCUS_MODE_XXX constants. Read/write. 246 static const char KEY_FOCUS_MODE[]; 247 // Supported focus modes. 248 // Example value: "auto,macro,fixed". Read only. 249 static const char KEY_SUPPORTED_FOCUS_MODES[]; 250 // The maximum number of focus areas supported. This is the maximum length 251 // of KEY_FOCUS_AREAS. 252 // Example value: "0" or "2". Read only. 253 static const char KEY_MAX_NUM_FOCUS_AREAS[]; 254 // Current focus areas. 255 // 256 // Before accessing this parameter, apps should check 257 // KEY_MAX_NUM_FOCUS_AREAS first to know the maximum number of focus areas 258 // first. If the value is 0, focus area is not supported. 259 // 260 // Each focus area is a five-element int array. The first four elements are 261 // the rectangle of the area (left, top, right, bottom). The direction is 262 // relative to the sensor orientation, that is, what the sensor sees. The 263 // direction is not affected by the rotation or mirroring of 264 // CAMERA_CMD_SET_DISPLAY_ORIENTATION. Coordinates range from -1000 to 1000. 265 // (-1000,-1000) is the upper left point. (1000, 1000) is the lower right 266 // point. The width and height of focus areas cannot be 0 or negative. 267 // 268 // The fifth element is the weight. Values for weight must range from 1 to 269 // 1000. The weight should be interpreted as a per-pixel weight - all 270 // pixels in the area have the specified weight. This means a small area 271 // with the same weight as a larger area will have less influence on the 272 // focusing than the larger area. Focus areas can partially overlap and the 273 // driver will add the weights in the overlap region. 274 // 275 // A special case of single focus area (0,0,0,0,0) means driver to decide 276 // the focus area. For example, the driver may use more signals to decide 277 // focus areas and change them dynamically. Apps can set (0,0,0,0,0) if they 278 // want the driver to decide focus areas. 279 // 280 // Focus areas are relative to the current field of view (KEY_ZOOM). No 281 // matter what the zoom level is, (-1000,-1000) represents the top of the 282 // currently visible camera frame. The focus area cannot be set to be 283 // outside the current field of view, even when using zoom. 284 // 285 // Focus area only has effect if the current focus mode is FOCUS_MODE_AUTO, 286 // FOCUS_MODE_MACRO, or FOCUS_MODE_CONTINOUS_VIDEO. 287 // Example value: "(-10,-10,0,0,300),(0,0,10,10,700)". Read/write. 288 static const char KEY_FOCUS_AREAS[]; 289 // Focal length in millimeter. 290 // Example value: "4.31". Read only. 291 static const char KEY_FOCAL_LENGTH[]; 292 // Horizontal angle of view in degrees. 293 // Example value: "54.8". Read only. 294 static const char KEY_HORIZONTAL_VIEW_ANGLE[]; 295 // Vertical angle of view in degrees. 296 // Example value: "42.5". Read only. 297 static const char KEY_VERTICAL_VIEW_ANGLE[]; 298 // Exposure compensation index. 0 means exposure is not adjusted. 299 // Example value: "0" or "5". Read/write. 300 static const char KEY_EXPOSURE_COMPENSATION[]; 301 // The maximum exposure compensation index (>=0). 302 // Example value: "6". Read only. 303 static const char KEY_MAX_EXPOSURE_COMPENSATION[]; 304 // The minimum exposure compensation index (<=0). 305 // Example value: "-6". Read only. 306 static const char KEY_MIN_EXPOSURE_COMPENSATION[]; 307 // The exposure compensation step. Exposure compensation index multiply by 308 // step eqals to EV. Ex: if exposure compensation index is 6 and step is 309 // 0.3333, EV is -2. 310 // Example value: "0.333333333" or "0.5". Read only. 311 static const char KEY_EXPOSURE_COMPENSATION_STEP[]; 312 // The state of the auto-exposure lock. "true" means that 313 // auto-exposure is locked to its current value and will not 314 // change. "false" means the auto-exposure routine is free to 315 // change exposure values. If auto-exposure is already locked, 316 // setting this to true again has no effect (the driver will not 317 // recalculate exposure values). Changing exposure compensation 318 // settings will still affect the exposure settings while 319 // auto-exposure is locked. Stopping preview or taking a still 320 // image will not change the lock. In conjunction with 321 // exposure compensation, this allows for capturing multi-exposure 322 // brackets with known relative exposure values. Locking 323 // auto-exposure after open but before the first call to 324 // startPreview may result in severely over- or under-exposed 325 // images. The driver will not change the AE lock after 326 // auto-focus completes. 327 static const char KEY_AUTO_EXPOSURE_LOCK[]; 328 // Whether locking the auto-exposure is supported. "true" means it is, and 329 // "false" or this key not existing means it is not supported. 330 static const char KEY_AUTO_EXPOSURE_LOCK_SUPPORTED[]; 331 // The state of the auto-white balance lock. "true" means that 332 // auto-white balance is locked to its current value and will not 333 // change. "false" means the auto-white balance routine is free to 334 // change white balance values. If auto-white balance is already 335 // locked, setting this to true again has no effect (the driver 336 // will not recalculate white balance values). Stopping preview or 337 // taking a still image will not change the lock. In conjunction 338 // with exposure compensation, this allows for capturing 339 // multi-exposure brackets with fixed white balance. Locking 340 // auto-white balance after open but before the first call to 341 // startPreview may result in severely incorrect color. The 342 // driver will not change the AWB lock after auto-focus 343 // completes. 344 static const char KEY_AUTO_WHITEBALANCE_LOCK[]; 345 // Whether locking the auto-white balance is supported. "true" 346 // means it is, and "false" or this key not existing means it is 347 // not supported. 348 static const char KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED[]; 349 350 // The maximum number of metering areas supported. This is the maximum 351 // length of KEY_METERING_AREAS. 352 // Example value: "0" or "2". Read only. 353 static const char KEY_MAX_NUM_METERING_AREAS[]; 354 // Current metering areas. Camera driver uses these areas to decide 355 // exposure. 356 // 357 // Before accessing this parameter, apps should check 358 // KEY_MAX_NUM_METERING_AREAS first to know the maximum number of metering 359 // areas first. If the value is 0, metering area is not supported. 360 // 361 // Each metering area is a rectangle with specified weight. The direction is 362 // relative to the sensor orientation, that is, what the sensor sees. The 363 // direction is not affected by the rotation or mirroring of 364 // CAMERA_CMD_SET_DISPLAY_ORIENTATION. Coordinates of the rectangle range 365 // from -1000 to 1000. (-1000, -1000) is the upper left point. (1000, 1000) 366 // is the lower right point. The width and height of metering areas cannot 367 // be 0 or negative. 368 // 369 // The fifth element is the weight. Values for weight must range from 1 to 370 // 1000. The weight should be interpreted as a per-pixel weight - all 371 // pixels in the area have the specified weight. This means a small area 372 // with the same weight as a larger area will have less influence on the 373 // metering than the larger area. Metering areas can partially overlap and 374 // the driver will add the weights in the overlap region. 375 // 376 // A special case of all-zero single metering area means driver to decide 377 // the metering area. For example, the driver may use more signals to decide 378 // metering areas and change them dynamically. Apps can set all-zero if they 379 // want the driver to decide metering areas. 380 // 381 // Metering areas are relative to the current field of view (KEY_ZOOM). 382 // No matter what the zoom level is, (-1000,-1000) represents the top of the 383 // currently visible camera frame. The metering area cannot be set to be 384 // outside the current field of view, even when using zoom. 385 // 386 // No matter what metering areas are, the final exposure are compensated 387 // by KEY_EXPOSURE_COMPENSATION. 388 // Example value: "(-10,-10,0,0,300),(0,0,10,10,700)". Read/write. 389 static const char KEY_METERING_AREAS[]; 390 // Current zoom value. 391 // Example value: "0" or "6". Read/write. 392 static const char KEY_ZOOM[]; 393 // Maximum zoom value. 394 // Example value: "6". Read only. 395 static const char KEY_MAX_ZOOM[]; 396 // The zoom ratios of all zoom values. The zoom ratio is in 1/100 397 // increments. Ex: a zoom of 3.2x is returned as 320. The number of list 398 // elements is KEY_MAX_ZOOM + 1. The first element is always 100. The last 399 // element is the zoom ratio of zoom value KEY_MAX_ZOOM. 400 // Example value: "100,150,200,250,300,350,400". Read only. 401 static const char KEY_ZOOM_RATIOS[]; 402 // Whether zoom is supported. Zoom is supported if the value is "true". Zoom 403 // is not supported if the value is not "true" or the key does not exist. 404 // Example value: "true". Read only. 405 static const char KEY_ZOOM_SUPPORTED[]; 406 // Whether if smooth zoom is supported. Smooth zoom is supported if the 407 // value is "true". It is not supported if the value is not "true" or the 408 // key does not exist. 409 // See CAMERA_CMD_START_SMOOTH_ZOOM, CAMERA_CMD_STOP_SMOOTH_ZOOM, and 410 // CAMERA_MSG_ZOOM in frameworks/base/include/camera/Camera.h. 411 // Example value: "true". Read only. 412 static const char KEY_SMOOTH_ZOOM_SUPPORTED[]; 413 414 // The distances (in meters) from the camera to where an object appears to 415 // be in focus. The object is sharpest at the optimal focus distance. The 416 // depth of field is the far focus distance minus near focus distance. 417 // 418 // Focus distances may change after starting auto focus, canceling auto 419 // focus, or starting the preview. Applications can read this anytime to get 420 // the latest focus distances. If the focus mode is FOCUS_MODE_CONTINUOUS, 421 // focus distances may change from time to time. 422 // 423 // This is intended to estimate the distance between the camera and the 424 // subject. After autofocus, the subject distance may be within near and far 425 // focus distance. However, the precision depends on the camera hardware, 426 // autofocus algorithm, the focus area, and the scene. The error can be 427 // large and it should be only used as a reference. 428 // 429 // Far focus distance > optimal focus distance > near focus distance. If 430 // the far focus distance is infinity, the value should be "Infinity" (case 431 // sensitive). The format is three float values separated by commas. The 432 // first is near focus distance. The second is optimal focus distance. The 433 // third is far focus distance. 434 // Example value: "0.95,1.9,Infinity" or "0.049,0.05,0.051". Read only. 435 static const char KEY_FOCUS_DISTANCES[]; 436 437 // The current dimensions in pixels (width x height) for video frames. 438 // The width and height must be one of the supported sizes retrieved 439 // via KEY_SUPPORTED_VIDEO_SIZES. 440 // Example value: "1280x720". Read/write. 441 static const char KEY_VIDEO_SIZE[]; 442 // A list of the supported dimensions in pixels (width x height) 443 // for video frames. See CAMERA_MSG_VIDEO_FRAME for details in 444 // frameworks/base/include/camera/Camera.h. 445 // Example: "176x144,1280x720". Read only. 446 static const char KEY_SUPPORTED_VIDEO_SIZES[]; 447 448 // The maximum number of detected faces supported by hardware face 449 // detection. If the value is 0, hardware face detection is not supported. 450 // Example: "5". Read only 451 static const char KEY_MAX_NUM_DETECTED_FACES_HW[]; 452 453 // The maximum number of detected faces supported by software face 454 // detection. If the value is 0, software face detection is not supported. 455 // Example: "5". Read only 456 static const char KEY_MAX_NUM_DETECTED_FACES_SW[]; 457 458 // Preferred preview frame size in pixels for video recording. 459 // The width and height must be one of the supported sizes retrieved 460 // via KEY_SUPPORTED_PREVIEW_SIZES. This key can be used only when 461 // getSupportedVideoSizes() does not return an empty Vector of Size. 462 // Camcorder applications are recommended to set the preview size 463 // to a value that is not larger than the preferred preview size. 464 // In other words, the product of the width and height of the 465 // preview size should not be larger than that of the preferred 466 // preview size. In addition, we recommend to choos a preview size 467 // that has the same aspect ratio as the resolution of video to be 468 // recorded. 469 // Example value: "800x600". Read only. 470 static const char KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[]; 471 472 // The image format for video frames. See CAMERA_MSG_VIDEO_FRAME in 473 // frameworks/base/include/camera/Camera.h. 474 // Example value: "yuv420sp" or PIXEL_FORMAT_XXX constants. Read only. 475 static const char KEY_VIDEO_FRAME_FORMAT[]; 476 477 // Sets the hint of the recording mode. If this is true, MediaRecorder.start 478 // may be faster or has less glitches. This should be called before starting 479 // the preview for the best result. But it is allowed to change the hint 480 // while the preview is active. The default value is false. 481 // 482 // The apps can still call Camera.takePicture when the hint is true. The 483 // apps can call MediaRecorder.start when the hint is false. But the 484 // performance may be worse. 485 // Example value: "true" or "false". Read/write. 486 static const char KEY_RECORDING_HINT[]; 487 488 // Returns true if video snapshot is supported. That is, applications 489 // can call Camera.takePicture during recording. Applications do not need to 490 // call Camera.startPreview after taking a picture. The preview will be 491 // still active. Other than that, taking a picture during recording is 492 // identical to taking a picture normally. All settings and methods related 493 // to takePicture work identically. Ex: KEY_PICTURE_SIZE, 494 // KEY_SUPPORTED_PICTURE_SIZES, KEY_JPEG_QUALITY, KEY_ROTATION, and etc. 495 // The picture will have an EXIF header. FLASH_MODE_AUTO and FLASH_MODE_ON 496 // also still work, but the video will record the flash. 497 // 498 // Applications can set shutter callback as null to avoid the shutter 499 // sound. It is also recommended to set raw picture and post view callbacks 500 // to null to avoid the interrupt of preview display. 501 // 502 // Field-of-view of the recorded video may be different from that of the 503 // captured pictures. 504 // Example value: "true" or "false". Read only. 505 static const char KEY_VIDEO_SNAPSHOT_SUPPORTED[]; 506 507 // Value for KEY_ZOOM_SUPPORTED or KEY_SMOOTH_ZOOM_SUPPORTED. 508 static const char TRUE[]; 509 static const char FALSE[]; 510 511 // Value for KEY_FOCUS_DISTANCES. 512 static const char FOCUS_DISTANCE_INFINITY[]; 513 514 // Values for white balance settings. 515 static const char WHITE_BALANCE_AUTO[]; 516 static const char WHITE_BALANCE_INCANDESCENT[]; 517 static const char WHITE_BALANCE_FLUORESCENT[]; 518 static const char WHITE_BALANCE_WARM_FLUORESCENT[]; 519 static const char WHITE_BALANCE_DAYLIGHT[]; 520 static const char WHITE_BALANCE_CLOUDY_DAYLIGHT[]; 521 static const char WHITE_BALANCE_TWILIGHT[]; 522 static const char WHITE_BALANCE_SHADE[]; 523 524 // Values for effect settings. 525 static const char EFFECT_NONE[]; 526 static const char EFFECT_MONO[]; 527 static const char EFFECT_NEGATIVE[]; 528 static const char EFFECT_SOLARIZE[]; 529 static const char EFFECT_SEPIA[]; 530 static const char EFFECT_POSTERIZE[]; 531 static const char EFFECT_WHITEBOARD[]; 532 static const char EFFECT_BLACKBOARD[]; 533 static const char EFFECT_AQUA[]; 534 535 // Values for antibanding settings. 536 static const char ANTIBANDING_AUTO[]; 537 static const char ANTIBANDING_50HZ[]; 538 static const char ANTIBANDING_60HZ[]; 539 static const char ANTIBANDING_OFF[]; 540 541 // Values for flash mode settings. 542 // Flash will not be fired. 543 static const char FLASH_MODE_OFF[]; 544 // Flash will be fired automatically when required. The flash may be fired 545 // during preview, auto-focus, or snapshot depending on the driver. 546 static const char FLASH_MODE_AUTO[]; 547 // Flash will always be fired during snapshot. The flash may also be 548 // fired during preview or auto-focus depending on the driver. 549 static const char FLASH_MODE_ON[]; 550 // Flash will be fired in red-eye reduction mode. 551 static const char FLASH_MODE_RED_EYE[]; 552 // Constant emission of light during preview, auto-focus and snapshot. 553 // This can also be used for video recording. 554 static const char FLASH_MODE_TORCH[]; 555 556 // Values for scene mode settings. 557 static const char SCENE_MODE_AUTO[]; 558 static const char SCENE_MODE_ACTION[]; 559 static const char SCENE_MODE_PORTRAIT[]; 560 static const char SCENE_MODE_LANDSCAPE[]; 561 static const char SCENE_MODE_NIGHT[]; 562 static const char SCENE_MODE_NIGHT_PORTRAIT[]; 563 static const char SCENE_MODE_THEATRE[]; 564 static const char SCENE_MODE_BEACH[]; 565 static const char SCENE_MODE_SNOW[]; 566 static const char SCENE_MODE_SUNSET[]; 567 static const char SCENE_MODE_STEADYPHOTO[]; 568 static const char SCENE_MODE_FIREWORKS[]; 569 static const char SCENE_MODE_SPORTS[]; 570 static const char SCENE_MODE_PARTY[]; 571 static const char SCENE_MODE_CANDLELIGHT[]; 572 // Applications are looking for a barcode. Camera driver will be optimized 573 // for barcode reading. 574 static const char SCENE_MODE_BARCODE[]; 575 576 // Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT, 577 // and KEY_VIDEO_FRAME_FORMAT 578 static const char PIXEL_FORMAT_YUV422SP[]; 579 static const char PIXEL_FORMAT_YUV420SP[]; // NV21 580 static const char PIXEL_FORMAT_YUV422I[]; // YUY2 581 static const char PIXEL_FORMAT_YUV420P[]; // YV12 582 static const char PIXEL_FORMAT_RGB565[]; 583 static const char PIXEL_FORMAT_RGBA8888[]; 584 static const char PIXEL_FORMAT_JPEG[]; 585 // Raw bayer format used for images, which is 10 bit precision samples 586 // stored in 16 bit words. The filter pattern is RGGB. 587 static const char PIXEL_FORMAT_BAYER_RGGB[]; 588 589 // Values for focus mode settings. 590 // Auto-focus mode. Applications should call 591 // CameraHardwareInterface.autoFocus to start the focus in this mode. 592 static const char FOCUS_MODE_AUTO[]; 593 // Focus is set at infinity. Applications should not call 594 // CameraHardwareInterface.autoFocus in this mode. 595 static const char FOCUS_MODE_INFINITY[]; 596 // Macro (close-up) focus mode. Applications should call 597 // CameraHardwareInterface.autoFocus to start the focus in this mode. 598 static const char FOCUS_MODE_MACRO[]; 599 // Focus is fixed. The camera is always in this mode if the focus is not 600 // adjustable. If the camera has auto-focus, this mode can fix the 601 // focus, which is usually at hyperfocal distance. Applications should 602 // not call CameraHardwareInterface.autoFocus in this mode. 603 static const char FOCUS_MODE_FIXED[]; 604 // Extended depth of field (EDOF). Focusing is done digitally and 605 // continuously. Applications should not call 606 // CameraHardwareInterface.autoFocus in this mode. 607 static const char FOCUS_MODE_EDOF[]; 608 // Continuous auto focus mode intended for video recording. The camera 609 // continuously tries to focus. This is the best choice for video 610 // recording because the focus changes smoothly . Applications still can 611 // call CameraHardwareInterface.takePicture in this mode but the subject may 612 // not be in focus. Auto focus starts when the parameter is set. 613 // Applications should not call CameraHardwareInterface.autoFocus in this 614 // mode. To stop continuous focus, applications should change the focus mode 615 // to other modes. 616 static const char FOCUS_MODE_CONTINUOUS_VIDEO[]; 617 // Continuous auto focus mode intended for taking pictures. The camera 618 // continuously tries to focus. The speed of focus change is more aggressive 619 // than FOCUS_MODE_CONTINUOUS_VIDEO. Auto focus starts when the parameter is 620 // set. If applications call autoFocus in this mode, the focus callback will 621 // immediately return with a boolean that indicates the focus is sharp or 622 // not. The apps can then decide if they want to take a picture immediately 623 // or to change the focus mode to auto, and run a full autofocus cycle. To 624 // stop continuous focus, applications should change the focus mode to other 625 // modes. 626 static const char FOCUS_MODE_CONTINUOUS_PICTURE[]; 627 628private: 629 DefaultKeyedVector<String8,String8> mMap; 630}; 631 632}; // namespace android 633 634#endif 635