blob: da2f04934fb316481f50c24d8d5b03a3a3bb7465 [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/*
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
Nipun Kwatra0de0c492010-07-30 13:40:14 -070025struct 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080040class CameraParameters
41{
42public:
43 CameraParameters();
44 CameraParameters(const String8 &params) { unflatten(params); }
45 ~CameraParameters();
46
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080047 String8 flatten() const;
48 void unflatten(const String8 &params);
49
50 void set(const char *key, const char *value);
51 void set(const char *key, int value);
Wu-cheng Li7eae31c2010-01-31 14:19:38 +080052 void setFloat(const char *key, float value);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080053 const char *get(const char *key) const;
54 int getInt(const char *key) const;
Wu-cheng Li7eae31c2010-01-31 14:19:38 +080055 float getFloat(const char *key) const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080056
Wu-cheng Li78624e42010-05-11 12:11:56 +080057 void remove(const char *key);
58
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080059 void setPreviewSize(int width, int height);
60 void getPreviewSize(int *width, int *height) const;
Nipun Kwatra6c008b82010-08-04 14:04:07 -070061 void getSupportedPreviewSizes(Vector<Size> &sizes) const;
James Dong4fd446f2010-09-30 10:50:51 -070062
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;
James Dong4ddca9b2010-11-29 16:51:55 -080082 // 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;
James Dong4fd446f2010-09-30 10:50:51 -070090
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080091 void setPreviewFrameRate(int fps);
92 int getPreviewFrameRate() const;
Wu-cheng Li454630f2010-08-11 16:48:05 -070093 void getPreviewFpsRange(int *min_fps, int *max_fps) const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080094 void setPreviewFormat(const char *format);
95 const char *getPreviewFormat() const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080096 void setPictureSize(int width, int height);
97 void getPictureSize(int *width, int *height) const;
Nipun Kwatra0de0c492010-07-30 13:40:14 -070098 void getSupportedPictureSizes(Vector<Size> &sizes) const;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080099 void setPictureFormat(const char *format);
100 const char *getPictureFormat() const;
101
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800102 void dump() const;
103 status_t dump(int fd, const Vector<String16>& args) const;
104
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700105 // 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[];
Wu-cheng Li454630f2010-08-11 16:48:05 -0700115 // 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[];
Wu-cheng Lid2c29292010-05-28 17:32:41 +0800129 // The image format for preview frames. See CAMERA_MSG_PREVIEW_FRAME in
130 // frameworks/base/include/camera/Camera.h.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700131 // 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[];
Wu-cheng Lid2c29292010-05-28 17:32:41 +0800136 // Number of preview frames per second. This is the target frame rate. The
137 // actual frame rate depends on the driver.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700138 // 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[];
Wu-cheng Lid2c29292010-05-28 17:32:41 +0800149 // The image format for captured pictures. See CAMERA_MSG_COMPRESSED_IMAGE
150 // in frameworks/base/include/camera/Camera.h.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700151 // 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[];
Wu-cheng Liacf77032010-01-25 15:18:18 +0800162 // 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[];
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700166 // 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[];
Wu-cheng Li99a3f3e2010-11-19 15:56:16 +0800174 // 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 //
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700191 // Example value: "0" or "90" or "180" or "270". Write only.
192 static const char KEY_ROTATION[];
Wu-cheng Libd329dd2010-05-21 17:52:42 +0800193 // GPS latitude coordinate. GPSLatitude and GPSLatitudeRef will be stored in
194 // JPEG EXIF header.
195 // Example value: "25.032146" or "-33.462809". Write only.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700196 static const char KEY_GPS_LATITUDE[];
Wu-cheng Libd329dd2010-05-21 17:52:42 +0800197 // GPS longitude coordinate. GPSLongitude and GPSLongitudeRef will be stored
198 // in JPEG EXIF header.
199 // Example value: "121.564448" or "-70.660286". Write only.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700200 static const char KEY_GPS_LONGITUDE[];
Wu-cheng Libd329dd2010-05-21 17:52:42 +0800201 // GPS altitude. GPSAltitude and GPSAltitudeRef will be stored in JPEG EXIF
202 // header.
203 // Example value: "21.0" or "-5". Write only.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700204 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[];
Ray Chen055c9862010-02-23 10:45:42 +0800209 // GPS Processing Method
210 // Example value: "GPS" or "NETWORK". Write only.
211 static const char KEY_GPS_PROCESSING_METHOD[];
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700212 // 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[];
Wu-cheng Li699fe932010-08-05 11:50:25 -0700242 // 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.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700245 // 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[];
Wu-cheng Li6c8d2762010-01-27 22:55:14 +0800250 // Focal length in millimeter.
251 // Example value: "4.31". Read only.
252 static const char KEY_FOCAL_LENGTH[];
253 // Horizontal angle of view in degrees.
254 // Example value: "54.8". Read only.
255 static const char KEY_HORIZONTAL_VIEW_ANGLE[];
256 // Vertical angle of view in degrees.
257 // Example value: "42.5". Read only.
258 static const char KEY_VERTICAL_VIEW_ANGLE[];
Wu-cheng Li24b326a2010-02-20 17:47:04 +0800259 // Exposure compensation index. 0 means exposure is not adjusted.
260 // Example value: "0" or "5". Read/write.
Wu-cheng Liff723b62010-02-09 13:38:19 +0800261 static const char KEY_EXPOSURE_COMPENSATION[];
Wu-cheng Li24b326a2010-02-20 17:47:04 +0800262 // The maximum exposure compensation index (>=0).
263 // Example value: "6". Read only.
264 static const char KEY_MAX_EXPOSURE_COMPENSATION[];
265 // The minimum exposure compensation index (<=0).
266 // Example value: "-6". Read only.
267 static const char KEY_MIN_EXPOSURE_COMPENSATION[];
268 // The exposure compensation step. Exposure compensation index multiply by
269 // step eqals to EV. Ex: if exposure compensation index is 6 and step is
270 // 0.3333, EV is -2.
271 // Example value: "0.333333333" or "0.5". Read only.
272 static const char KEY_EXPOSURE_COMPENSATION_STEP[];
Wu-cheng Li8cbb8f52010-02-28 23:19:55 -0800273 // Current zoom value.
274 // Example value: "0" or "6". Read/write.
275 static const char KEY_ZOOM[];
276 // Maximum zoom value.
277 // Example value: "6". Read only.
278 static const char KEY_MAX_ZOOM[];
279 // The zoom ratios of all zoom values. The zoom ratio is in 1/100
280 // increments. Ex: a zoom of 3.2x is returned as 320. The number of list
281 // elements is KEY_MAX_ZOOM + 1. The first element is always 100. The last
282 // element is the zoom ratio of zoom value KEY_MAX_ZOOM.
283 // Example value: "100,150,200,250,300,350,400". Read only.
284 static const char KEY_ZOOM_RATIOS[];
285 // Whether zoom is supported. Zoom is supported if the value is "true". Zoom
286 // is not supported if the value is not "true" or the key does not exist.
287 // Example value: "true". Read only.
288 static const char KEY_ZOOM_SUPPORTED[];
289 // Whether if smooth zoom is supported. Smooth zoom is supported if the
290 // value is "true". It is not supported if the value is not "true" or the
291 // key does not exist.
292 // See CAMERA_CMD_START_SMOOTH_ZOOM, CAMERA_CMD_STOP_SMOOTH_ZOOM, and
293 // CAMERA_MSG_ZOOM in frameworks/base/include/camera/Camera.h.
294 // Example value: "true". Read only.
295 static const char KEY_SMOOTH_ZOOM_SUPPORTED[];
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700296
Wu-cheng Lie339c5e2010-05-13 19:31:02 +0800297 // The distances (in meters) from the camera to where an object appears to
298 // be in focus. The object is sharpest at the optimal focus distance. The
299 // depth of field is the far focus distance minus near focus distance.
300 //
Wu-cheng Li699fe932010-08-05 11:50:25 -0700301 // Focus distances may change after starting auto focus, canceling auto
302 // focus, or starting the preview. Applications can read this anytime to get
303 // the latest focus distances. If the focus mode is FOCUS_MODE_CONTINUOUS,
304 // focus distances may change from time to time.
305 //
306 // This is intended to estimate the distance between the camera and the
307 // subject. After autofocus, the subject distance may be within near and far
308 // focus distance. However, the precision depends on the camera hardware,
309 // autofocus algorithm, the focus area, and the scene. The error can be
310 // large and it should be only used as a reference.
Wu-cheng Lie339c5e2010-05-13 19:31:02 +0800311 //
312 // Far focus distance > optimal focus distance > near focus distance. If
313 // the far focus distance is infinity, the value should be "Infinity" (case
314 // sensitive). The format is three float values separated by commas. The
315 // first is near focus distance. The second is optimal focus distance. The
316 // third is far focus distance.
317 // Example value: "0.95,1.9,Infinity" or "0.049,0.05,0.051". Read only.
318 static const char KEY_FOCUS_DISTANCES[];
319
James Dong4fd446f2010-09-30 10:50:51 -0700320 // The current dimensions in pixels (width x height) for video frames.
321 // The width and height must be one of the supported sizes retrieved
322 // via KEY_SUPPORTED_VIDEO_SIZES.
323 // Example value: "1280x720". Read/write.
324 static const char KEY_VIDEO_SIZE[];
325 // A list of the supported dimensions in pixels (width x height)
326 // for video frames. See CAMERA_MSG_VIDEO_FRAME for details in
327 // frameworks/base/include/camera/Camera.h.
328 // Example: "176x144,1280x720". Read only.
329 static const char KEY_SUPPORTED_VIDEO_SIZES[];
James Dong4ddca9b2010-11-29 16:51:55 -0800330
331 // Preferred preview frame size in pixels for video recording.
332 // The width and height must be one of the supported sizes retrieved
333 // via KEY_SUPPORTED_PREVIEW_SIZES. This key can be used only when
334 // getSupportedVideoSizes() does not return an empty Vector of Size.
335 // Camcorder applications are recommended to set the preview size
336 // to a value that is not larger than the preferred preview size.
337 // In other words, the product of the width and height of the
338 // preview size should not be larger than that of the preferred
339 // preview size. In addition, we recommend to choos a preview size
340 // that has the same aspect ratio as the resolution of video to be
341 // recorded.
342 // Example value: "800x600". Read only.
343 static const char KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[];
344
Wu-cheng Lid2c29292010-05-28 17:32:41 +0800345 // The image format for video frames. See CAMERA_MSG_VIDEO_FRAME in
346 // frameworks/base/include/camera/Camera.h.
347 // Example value: "yuv420sp" or PIXEL_FORMAT_XXX constants. Read only.
348 static const char KEY_VIDEO_FRAME_FORMAT[];
349
Wu-cheng Lid9ef5d72010-03-08 15:28:48 -0800350 // Value for KEY_ZOOM_SUPPORTED or KEY_SMOOTH_ZOOM_SUPPORTED.
351 static const char TRUE[];
352
Wu-cheng Lie339c5e2010-05-13 19:31:02 +0800353 // Value for KEY_FOCUS_DISTANCES.
Wu-cheng Liae7ca4c2010-05-15 13:05:04 +0800354 static const char FOCUS_DISTANCE_INFINITY[];
Wu-cheng Lie339c5e2010-05-13 19:31:02 +0800355
Wu-cheng Li24b326a2010-02-20 17:47:04 +0800356 // Values for white balance settings.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700357 static const char WHITE_BALANCE_AUTO[];
358 static const char WHITE_BALANCE_INCANDESCENT[];
359 static const char WHITE_BALANCE_FLUORESCENT[];
360 static const char WHITE_BALANCE_WARM_FLUORESCENT[];
361 static const char WHITE_BALANCE_DAYLIGHT[];
362 static const char WHITE_BALANCE_CLOUDY_DAYLIGHT[];
363 static const char WHITE_BALANCE_TWILIGHT[];
364 static const char WHITE_BALANCE_SHADE[];
365
366 // Values for effect settings.
367 static const char EFFECT_NONE[];
368 static const char EFFECT_MONO[];
369 static const char EFFECT_NEGATIVE[];
370 static const char EFFECT_SOLARIZE[];
371 static const char EFFECT_SEPIA[];
372 static const char EFFECT_POSTERIZE[];
373 static const char EFFECT_WHITEBOARD[];
374 static const char EFFECT_BLACKBOARD[];
375 static const char EFFECT_AQUA[];
376
377 // Values for antibanding settings.
378 static const char ANTIBANDING_AUTO[];
379 static const char ANTIBANDING_50HZ[];
380 static const char ANTIBANDING_60HZ[];
381 static const char ANTIBANDING_OFF[];
382
383 // Values for flash mode settings.
384 // Flash will not be fired.
385 static const char FLASH_MODE_OFF[];
Wu-cheng Life1a86d2009-09-28 13:51:12 -0700386 // Flash will be fired automatically when required. The flash may be fired
387 // during preview, auto-focus, or snapshot depending on the driver.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700388 static const char FLASH_MODE_AUTO[];
Wu-cheng Life1a86d2009-09-28 13:51:12 -0700389 // Flash will always be fired during snapshot. The flash may also be
390 // fired during preview or auto-focus depending on the driver.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700391 static const char FLASH_MODE_ON[];
392 // Flash will be fired in red-eye reduction mode.
393 static const char FLASH_MODE_RED_EYE[];
Wu-cheng Life1a86d2009-09-28 13:51:12 -0700394 // Constant emission of light during preview, auto-focus and snapshot.
395 // This can also be used for video recording.
396 static const char FLASH_MODE_TORCH[];
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700397
398 // Values for scene mode settings.
399 static const char SCENE_MODE_AUTO[];
400 static const char SCENE_MODE_ACTION[];
401 static const char SCENE_MODE_PORTRAIT[];
402 static const char SCENE_MODE_LANDSCAPE[];
403 static const char SCENE_MODE_NIGHT[];
404 static const char SCENE_MODE_NIGHT_PORTRAIT[];
405 static const char SCENE_MODE_THEATRE[];
406 static const char SCENE_MODE_BEACH[];
407 static const char SCENE_MODE_SNOW[];
408 static const char SCENE_MODE_SUNSET[];
409 static const char SCENE_MODE_STEADYPHOTO[];
410 static const char SCENE_MODE_FIREWORKS[];
411 static const char SCENE_MODE_SPORTS[];
412 static const char SCENE_MODE_PARTY[];
413 static const char SCENE_MODE_CANDLELIGHT[];
Wu-cheng Lic58b4232010-03-29 17:21:28 +0800414 // Applications are looking for a barcode. Camera driver will be optimized
415 // for barcode reading.
416 static const char SCENE_MODE_BARCODE[];
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700417
James Dong9b61dc52010-09-15 16:52:51 -0700418 // Pixel color formats for KEY_PREVIEW_FORMAT, KEY_PICTURE_FORMAT,
419 // and KEY_VIDEO_FRAME_FORMAT
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700420 static const char PIXEL_FORMAT_YUV422SP[];
421 static const char PIXEL_FORMAT_YUV420SP[]; // NV21
422 static const char PIXEL_FORMAT_YUV422I[]; // YUY2
Wu-cheng Li10a1b302011-02-22 15:49:25 +0800423 static const char PIXEL_FORMAT_YUV420P[]; // YV12
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700424 static const char PIXEL_FORMAT_RGB565[];
425 static const char PIXEL_FORMAT_JPEG[];
426
427 // Values for focus mode settings.
Wu-cheng Lif008f3e2010-08-17 13:44:35 -0700428 // Auto-focus mode. Applications should call
429 // CameraHardwareInterface.autoFocus to start the focus in this mode.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700430 static const char FOCUS_MODE_AUTO[];
431 // Focus is set at infinity. Applications should not call
432 // CameraHardwareInterface.autoFocus in this mode.
433 static const char FOCUS_MODE_INFINITY[];
Wu-cheng Lif008f3e2010-08-17 13:44:35 -0700434 // Macro (close-up) focus mode. Applications should call
435 // CameraHardwareInterface.autoFocus to start the focus in this mode.
Wu-cheng Li8de57d82009-09-23 14:37:52 -0700436 static const char FOCUS_MODE_MACRO[];
437 // Focus is fixed. The camera is always in this mode if the focus is not
438 // adjustable. If the camera has auto-focus, this mode can fix the
439 // focus, which is usually at hyperfocal distance. Applications should
440 // not call CameraHardwareInterface.autoFocus in this mode.
441 static const char FOCUS_MODE_FIXED[];
Wu-cheng Lic58b4232010-03-29 17:21:28 +0800442 // Extended depth of field (EDOF). Focusing is done digitally and
443 // continuously. Applications should not call
444 // CameraHardwareInterface.autoFocus in this mode.
445 static const char FOCUS_MODE_EDOF[];
Wu-cheng Lid45cb722010-09-20 16:15:32 -0700446 // Continuous auto focus mode intended for video recording. The camera
447 // continuously tries to focus. This is ideal for shooting video.
448 // Applications still can call CameraHardwareInterface.takePicture in this
449 // mode but the subject may not be in focus. Auto focus starts when the
450 // parameter is set. Applications should not call
451 // CameraHardwareInterface.autoFocus in this mode. To stop continuous focus,
452 // applications should change the focus mode to other modes.
453 static const char FOCUS_MODE_CONTINUOUS_VIDEO[];
Wu-cheng Lica099612010-05-06 16:47:30 +0800454
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800455private:
456 DefaultKeyedVector<String8,String8> mMap;
457};
458
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800459}; // namespace android
460
461#endif