blob: 1cea9066026d2eb2b828a2ea70041f5e9a1be2d6 [file] [log] [blame]
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001/*
2 * Copyright (C) 2012 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#define LOG_TAG "Camera2Client"
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070018#define ATRACE_TAG ATRACE_TAG_CAMERA
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070019//#define LOG_NDEBUG 0
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070020
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070021#include <utils/Log.h>
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070022#include <utils/Trace.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070023
24#include <cutils/properties.h>
25#include <gui/SurfaceTextureClient.h>
26#include <gui/Surface.h>
27
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070028#include <math.h>
29
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070030#include "Camera2Client.h"
31
32namespace android {
33
34#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
35#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
36
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070037static int getCallingPid() {
38 return IPCThreadState::self()->getCallingPid();
39}
40
41static int getCallingUid() {
42 return IPCThreadState::self()->getCallingUid();
43}
44
45// Interface used by CameraService
46
47Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
48 const sp<ICameraClient>& cameraClient,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070049 int cameraId,
50 int cameraFacing,
51 int clientPid):
52 Client(cameraService, cameraClient,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070053 cameraId, cameraFacing, clientPid),
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -070054 mState(NOT_INITIALIZED),
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -070055 mPreviewStreamId(NO_PREVIEW_STREAM),
56 mPreviewRequest(NULL)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070057{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070058 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070059
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070060 mDevice = new Camera2Device(cameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070061}
62
63status_t Camera2Client::initialize(camera_module_t *module)
64{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070065 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070066 status_t res;
67
68 res = mDevice->initialize(module);
69 if (res != OK) {
70 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
71 __FUNCTION__, mCameraId, strerror(-res), res);
72 return NO_INIT;
73 }
74
75 res = buildDefaultParameters();
76 if (res != OK) {
77 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
78 __FUNCTION__, mCameraId, strerror(-res), res);
79 return NO_INIT;
80 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070081
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070082 if (gLogLevel >= 1) {
83 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
84 mCameraId);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070085 ALOGD("%s", mParamsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070086 }
87
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -070088 mState = STOPPED;
89
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070090 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070091}
92
93Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070094 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070095 mDestructionStarted = true;
96
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070097 disconnect();
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070098
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070099}
100
101status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700102 String8 result;
103 result.appendFormat("Client2[%d] (%p) PID: %d:\n",
104 mCameraId,
105 getCameraClient()->asBinder().get(),
106 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700107 result.append(" State: ");
108#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
109
110 switch (mState) {
111 CASE_APPEND_ENUM(NOT_INITIALIZED)
112 CASE_APPEND_ENUM(STOPPED)
113 CASE_APPEND_ENUM(WAITING_FOR_PREVIEW_WINDOW)
114 CASE_APPEND_ENUM(PREVIEW)
115 CASE_APPEND_ENUM(RECORD)
116 CASE_APPEND_ENUM(STILL_CAPTURE)
117 default: result.append("UNKNOWN\n"); break;
118 }
119
120 result.append(" Current parameters:\n");
121 result.appendFormat(" Preview size: %d x %d\n",
122 mParameters.previewWidth, mParameters.previewHeight);
123 result.appendFormat(" Preview FPS range: %d - %d\n",
124 mParameters.previewFpsRangeMin, mParameters.previewFpsRangeMax);
125 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
126 mParameters.previewFormat);
127 result.appendFormat(" Picture size: %d x %d\n",
128 mParameters.pictureWidth, mParameters.pictureHeight);
129 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
130 mParameters.jpegThumbWidth, mParameters.jpegThumbHeight);
131 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
132 mParameters.jpegQuality, mParameters.jpegThumbQuality);
133 result.appendFormat(" Jpeg rotation: %d\n", mParameters.jpegRotation);
134 result.appendFormat(" GPS tags %s\n",
135 mParameters.gpsEnabled ? "enabled" : "disabled");
136 if (mParameters.gpsEnabled) {
137 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
138 mParameters.gpsLatitude, mParameters.gpsLongitude,
139 mParameters.gpsAltitude);
140 result.appendFormat(" GPS timestamp: %lld\n",
141 mParameters.gpsTimestamp);
142 result.appendFormat(" GPS processing method: %s\n",
143 mParameters.gpsProcessingMethod.string());
144 }
145
146 result.append(" White balance mode: ");
147 switch (mParameters.wbMode) {
148 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
149 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
150 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
151 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
152 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
153 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
154 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
155 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
156 default: result.append("UNKNOWN\n");
157 }
158
159 result.append(" Effect mode: ");
160 switch (mParameters.effectMode) {
161 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
162 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
163 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
164 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
165 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
166 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
167 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
168 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
169 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
170 default: result.append("UNKNOWN\n");
171 }
172
173 result.append(" Antibanding mode: ");
174 switch (mParameters.antibandingMode) {
175 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
176 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
177 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
178 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
179 default: result.append("UNKNOWN\n");
180 }
181
182 result.append(" Scene mode: ");
183 switch (mParameters.sceneMode) {
184 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
185 result.append("AUTO\n"); break;
186 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
187 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
188 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
189 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
190 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
191 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
192 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
193 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
194 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
195 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
196 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
197 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
198 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
199 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
200 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
201 default: result.append("UNKNOWN\n");
202 }
203
204 result.append(" Flash mode: ");
205 switch (mParameters.flashMode) {
206 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
207 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
208 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
209 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
210 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
211 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
212 default: result.append("UNKNOWN\n");
213 }
214
215 result.append(" Focus mode: ");
216 switch (mParameters.focusMode) {
217 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
218 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
219 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
220 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
221 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
222 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
223 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
224 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
225 default: result.append("UNKNOWN\n");
226 }
227
228 result.append(" Focusing areas:\n");
229 for (size_t i = 0; i < mParameters.focusingAreas.size(); i++) {
230 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
231 mParameters.focusingAreas[i].left,
232 mParameters.focusingAreas[i].top,
233 mParameters.focusingAreas[i].right,
234 mParameters.focusingAreas[i].bottom,
235 mParameters.focusingAreas[i].weight);
236 }
237
238 result.appendFormat(" Exposure compensation index: %d\n",
239 mParameters.exposureCompensation);
240
241 result.appendFormat(" AE lock %s, AWB lock %s\n",
242 mParameters.autoExposureLock ? "enabled" : "disabled",
243 mParameters.autoWhiteBalanceLock ? "enabled" : "disabled" );
244
245 result.appendFormat(" Metering areas:\n");
246 for (size_t i = 0; i < mParameters.meteringAreas.size(); i++) {
247 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
248 mParameters.meteringAreas[i].left,
249 mParameters.meteringAreas[i].top,
250 mParameters.meteringAreas[i].right,
251 mParameters.meteringAreas[i].bottom,
252 mParameters.meteringAreas[i].weight);
253 }
254
255 result.appendFormat(" Zoom index: %d\n", mParameters.zoom);
256 result.appendFormat(" Video size: %d x %d\n", mParameters.videoWidth,
257 mParameters.videoHeight);
258
259 result.appendFormat(" Recording hint is %s\n",
260 mParameters.recordingHint ? "set" : "not set");
261
262 result.appendFormat(" Video stabilization is %s\n",
263 mParameters.videoStabilization ? "enabled" : "disabled");
264
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700265 write(fd, result.string(), result.size());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700266
267 // TODO: Dump Camera2Device
268
269#undef CASE_APPEND_ENUM
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700270 return NO_ERROR;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700271}
272
273// ICamera interface
274
275void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700276 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700277 Mutex::Autolock icl(mICameraLock);
278
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700279 if (mDevice == 0) return;
280
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700281 stopPreviewLocked();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700282
283 if (mPreviewStreamId != NO_PREVIEW_STREAM) {
284 mDevice->deleteStream(mPreviewStreamId);
285 mPreviewStreamId = NO_PREVIEW_STREAM;
286 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700287
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700288 CameraService::Client::disconnect();
289}
290
291status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700292 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700293 Mutex::Autolock icl(mICameraLock);
294
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700295 return BAD_VALUE;
296}
297
298status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700299 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700300 Mutex::Autolock icl(mICameraLock);
301
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700302 return BAD_VALUE;
303}
304
305status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700306 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700307 Mutex::Autolock icl(mICameraLock);
308
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700309 return BAD_VALUE;
310}
311
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700312status_t Camera2Client::setPreviewDisplay(
313 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700314 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700315 Mutex::Autolock icl(mICameraLock);
316
317 if (mState >= PREVIEW) return INVALID_OPERATION;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700318
319 sp<IBinder> binder;
320 sp<ANativeWindow> window;
321 if (surface != 0) {
322 binder = surface->asBinder();
323 window = surface;
324 }
325
326 return setPreviewWindow(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700327}
328
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700329status_t Camera2Client::setPreviewTexture(
330 const sp<ISurfaceTexture>& surfaceTexture) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700331 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700332 Mutex::Autolock icl(mICameraLock);
333
334 if (mState >= PREVIEW) return INVALID_OPERATION;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700335
336 sp<IBinder> binder;
337 sp<ANativeWindow> window;
338 if (surfaceTexture != 0) {
339 binder = surfaceTexture->asBinder();
340 window = new SurfaceTextureClient(surfaceTexture);
341 }
342 return setPreviewWindow(binder, window);
343}
344
345status_t Camera2Client::setPreviewWindow(const sp<IBinder>& binder,
346 const sp<ANativeWindow>& window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700347 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700348 status_t res;
349
350 if (binder == mPreviewSurface) {
351 return NO_ERROR;
352 }
353
354 if (mPreviewStreamId != NO_PREVIEW_STREAM) {
355 res = mDevice->deleteStream(mPreviewStreamId);
356 if (res != OK) {
357 return res;
358 }
359 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700360 res = mDevice->createStream(window,
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700361 mParameters.previewWidth, mParameters.previewHeight,
362 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE,
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700363 &mPreviewStreamId);
364 if (res != OK) {
365 return res;
366 }
367
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700368 mPreviewSurface = binder;
369
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700370 if (mState == WAITING_FOR_PREVIEW_WINDOW) {
371 return startPreview();
372 }
373
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700374 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700375}
376
377void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700378 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700379 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700380}
381
382status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700383 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700384 Mutex::Autolock icl(mICameraLock);
385
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700386 status_t res;
387 if (mState == PREVIEW) return INVALID_OPERATION;
388
389 if (mPreviewStreamId == NO_PREVIEW_STREAM) {
390 mState = WAITING_FOR_PREVIEW_WINDOW;
391 return OK;
392 }
393
394 if (mPreviewRequest == NULL) {
395 updatePreviewRequest();
396 }
397
398 uint8_t outputStream = mPreviewStreamId;
399
400 camera_metadata_entry_t outputStreams;
401 res = find_camera_metadata_entry(mPreviewRequest,
402 ANDROID_REQUEST_OUTPUT_STREAMS,
403 &outputStreams);
404 if (res == NAME_NOT_FOUND) {
405 res = add_camera_metadata_entry(mPreviewRequest,
406 ANDROID_REQUEST_OUTPUT_STREAMS,
407 &outputStream, 1);
408 } else if (res == OK) {
409 res = update_camera_metadata_entry(mPreviewRequest,
410 outputStreams.index, &outputStream, 1, NULL);
411 }
412
413 if (res != OK) {
414 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
415 __FUNCTION__, mCameraId, strerror(-res), res);
416 mState = STOPPED;
417 return res;
418 }
419
420 res = mDevice->setStreamingRequest(mPreviewRequest);
421 if (res != OK) {
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700422 ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
423 "%s (%d)",
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700424 __FUNCTION__, mCameraId, strerror(-res), res);
425 mState = STOPPED;
426 return res;
427 }
428 mState = PREVIEW;
429
430 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700431}
432
433void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700434 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700435 Mutex::Autolock icl(mICameraLock);
436 stopPreviewLocked();
437}
438
439void Camera2Client::stopPreviewLocked() {
440 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700441 if (mState != PREVIEW) return;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700442
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700443 mDevice->setStreamingRequest(NULL);
444 mState = STOPPED;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700445}
446
447bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700448 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700449 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700450 return mState == PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700451}
452
453status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700454 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700455 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700456 return BAD_VALUE;
457}
458
459status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700460 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700461 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700462 return BAD_VALUE;
463}
464
465void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700466 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700467 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700468}
469
470bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700471 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700472 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700473 return BAD_VALUE;
474}
475
476void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700477 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700478 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700479}
480
481status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700482 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700483 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700484 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700485}
486
487status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700488 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700489 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700490 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700491}
492
493status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700494 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700495 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700496 return BAD_VALUE;
497}
498
499status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700500 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700501 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -0700502 Mutex::Autolock pl(mParamsLock);
503 status_t res;
504
505 CameraParameters newParams(params);
506
507 // TODO: Currently ignoring any changes to supposedly read-only
508 // parameters such as supported preview sizes, etc. Should probably
509 // produce an error if they're changed.
510
511 /** Extract and verify new parameters */
512
513 size_t i;
514
515 // PREVIEW_SIZE
516 int previewWidth, previewHeight;
517 newParams.getPreviewSize(&previewWidth, &previewHeight);
518
519 if (previewWidth != mParameters.previewWidth ||
520 previewHeight != mParameters.previewHeight) {
521 if (mState >= PREVIEW) {
522 ALOGE("%s: Preview size cannot be updated when preview "
523 "is active!", __FUNCTION__);
524 return BAD_VALUE;
525 }
526 camera_metadata_entry_t availablePreviewSizes =
527 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
528 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
529 if (availablePreviewSizes.data.i32[i] == previewWidth &&
530 availablePreviewSizes.data.i32[i+1] == previewHeight) break;
531 }
532 if (i == availablePreviewSizes.count) {
533 ALOGE("%s: Requested preview size %d x %d is not supported",
534 __FUNCTION__, previewWidth, previewHeight);
535 return BAD_VALUE;
536 }
537 }
538
539 // PREVIEW_FPS_RANGE
540 int previewFpsRangeMin, previewFpsRangeMax, previewFps = 0;
541 bool fpsRangeChanged = false;
542 newParams.getPreviewFpsRange(&previewFpsRangeMin, &previewFpsRangeMax);
543 if (previewFpsRangeMin != mParameters.previewFpsRangeMin ||
544 previewFpsRangeMax != mParameters.previewFpsRangeMax) {
545 fpsRangeChanged = true;
546 camera_metadata_entry_t availablePreviewFpsRanges =
547 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
548 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
549 if ((availablePreviewFpsRanges.data.i32[i] ==
550 previewFpsRangeMin) &&
551 (availablePreviewFpsRanges.data.i32[i+1] ==
552 previewFpsRangeMax) ) {
553 break;
554 }
555 }
556 if (i == availablePreviewFpsRanges.count) {
557 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
558 __FUNCTION__, previewFpsRangeMin, previewFpsRangeMax);
559 return BAD_VALUE;
560 }
561 previewFps = previewFpsRangeMin;
562 }
563
564 // PREVIEW_FORMAT
565 int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
566 if (previewFormat != mParameters.previewFormat) {
567 if (mState >= PREVIEW) {
568 ALOGE("%s: Preview format cannot be updated when preview "
569 "is active!", __FUNCTION__);
570 return BAD_VALUE;
571 }
572 camera_metadata_entry_t availableFormats =
573 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
574 for (i = 0; i < availableFormats.count; i++) {
575 if (availableFormats.data.i32[i] == previewFormat) break;
576 }
577 if (i == availableFormats.count) {
578 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
579 __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
580 return BAD_VALUE;
581 }
582 }
583
584 // PREVIEW_FRAME_RATE
585 // Deprecated, only use if the preview fps range is unchanged this time.
586 // The single-value FPS is the same as the minimum of the range.
587 if (!fpsRangeChanged) {
588 previewFps = newParams.getPreviewFrameRate();
589 if (previewFps != mParameters.previewFps) {
590 camera_metadata_entry_t availableFrameRates =
591 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
592 for (i = 0; i < availableFrameRates.count; i+=2) {
593 if (availableFrameRates.data.i32[i] == previewFps) break;
594 }
595 if (i == availableFrameRates.count) {
596 ALOGE("%s: Requested preview frame rate %d is not supported",
597 __FUNCTION__, previewFps);
598 return BAD_VALUE;
599 }
600 previewFpsRangeMin = availableFrameRates.data.i32[i];
601 previewFpsRangeMax = availableFrameRates.data.i32[i+1];
602 }
603 }
604
605 // PICTURE_SIZE
606 int pictureWidth, pictureHeight;
607 newParams.getPictureSize(&pictureWidth, &pictureHeight);
608 if (pictureWidth == mParameters.pictureWidth ||
609 pictureHeight == mParameters.pictureHeight) {
610 camera_metadata_entry_t availablePictureSizes =
611 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
612 for (i = 0; i < availablePictureSizes.count; i+=2) {
613 if (availablePictureSizes.data.i32[i] == pictureWidth &&
614 availablePictureSizes.data.i32[i+1] == pictureHeight) break;
615 }
616 if (i == availablePictureSizes.count) {
617 ALOGE("%s: Requested picture size %d x %d is not supported",
618 __FUNCTION__, pictureWidth, pictureHeight);
619 return BAD_VALUE;
620 }
621 }
622
623 // JPEG_THUMBNAIL_WIDTH/HEIGHT
624 int jpegThumbWidth, jpegThumbHeight;
625 jpegThumbWidth =
626 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
627 jpegThumbHeight =
628 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
629 if (jpegThumbWidth != mParameters.jpegThumbWidth ||
630 jpegThumbHeight != mParameters.jpegThumbHeight) {
631 camera_metadata_entry_t availableJpegThumbSizes =
632 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
633 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
634 if (availableJpegThumbSizes.data.i32[i] == jpegThumbWidth &&
635 availableJpegThumbSizes.data.i32[i+1] == jpegThumbHeight) {
636 break;
637 }
638 }
639 if (i == availableJpegThumbSizes.count) {
640 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
641 __FUNCTION__, jpegThumbWidth, jpegThumbHeight);
642 return BAD_VALUE;
643 }
644 }
645
646 // JPEG_THUMBNAIL_QUALITY
647 int jpegThumbQuality =
648 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
649 if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
650 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
651 __FUNCTION__, jpegThumbQuality);
652 return BAD_VALUE;
653 }
654
655 // JPEG_QUALITY
656 int jpegQuality =
657 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
658 if (jpegQuality < 0 || jpegQuality > 100) {
659 ALOGE("%s: Requested JPEG quality %d is not supported",
660 __FUNCTION__, jpegQuality);
661 return BAD_VALUE;
662 }
663
664 // ROTATION
665 int jpegRotation =
666 newParams.getInt(CameraParameters::KEY_ROTATION);
667 if (jpegRotation != 0 &&
668 jpegRotation != 90 &&
669 jpegRotation != 180 &&
670 jpegRotation != 270) {
671 ALOGE("%s: Requested picture rotation angle %d is not supported",
672 __FUNCTION__, jpegRotation);
673 return BAD_VALUE;
674 }
675
676 // GPS
677 bool gpsEnabled = false;
678 double gpsLatitude = 0, gpsLongitude = 0, gpsAltitude = 0;
679 int64_t gpsTimestamp = 0;
680 String8 gpsProcessingMethod;
681 const char *gpsLatStr =
682 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
683 if (gpsLatStr != NULL) {
684 const char *gpsLongStr =
685 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
686 const char *gpsAltitudeStr =
687 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
688 const char *gpsTimeStr =
689 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
690 const char *gpsProcMethodStr =
691 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
692 if (gpsLongStr == NULL ||
693 gpsAltitudeStr == NULL ||
694 gpsTimeStr == NULL ||
695 gpsProcMethodStr == NULL) {
696 ALOGE("%s: Incomplete set of GPS parameters provided",
697 __FUNCTION__);
698 return BAD_VALUE;
699 }
700 char *endPtr;
701 errno = 0;
702 gpsLatitude = strtod(gpsLatStr, &endPtr);
703 if (errno || endPtr == gpsLatStr) {
704 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
705 return BAD_VALUE;
706 }
707 errno = 0;
708 gpsLongitude = strtod(gpsLongStr, &endPtr);
709 if (errno || endPtr == gpsLongStr) {
710 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
711 return BAD_VALUE;
712 }
713 errno = 0;
714 gpsAltitude = strtod(gpsAltitudeStr, &endPtr);
715 if (errno || endPtr == gpsAltitudeStr) {
716 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
717 gpsAltitudeStr);
718 return BAD_VALUE;
719 }
720 errno = 0;
721 gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
722 if (errno || endPtr == gpsTimeStr) {
723 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
724 return BAD_VALUE;
725 }
726 gpsProcessingMethod = gpsProcMethodStr;
727
728 gpsEnabled = true;
729 }
730
731 // WHITE_BALANCE
732 int wbMode = wbModeStringToEnum(
733 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
734 if (wbMode != mParameters.wbMode) {
735 camera_metadata_entry_t availableWbModes =
736 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
737 for (i = 0; i < availableWbModes.count; i++) {
738 if (wbMode == availableWbModes.data.u8[i]) break;
739 }
740 if (i == availableWbModes.count) {
741 ALOGE("%s: Requested white balance mode %s is not supported",
742 __FUNCTION__,
743 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
744 return BAD_VALUE;
745 }
746 }
747
748 // EFFECT
749 int effectMode = effectModeStringToEnum(
750 newParams.get(CameraParameters::KEY_EFFECT) );
751 if (effectMode != mParameters.effectMode) {
752 camera_metadata_entry_t availableEffectModes =
753 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
754 for (i = 0; i < availableEffectModes.count; i++) {
755 if (effectMode == availableEffectModes.data.u8[i]) break;
756 }
757 if (i == availableEffectModes.count) {
758 ALOGE("%s: Requested effect mode \"%s\" is not supported",
759 __FUNCTION__,
760 newParams.get(CameraParameters::KEY_EFFECT) );
761 return BAD_VALUE;
762 }
763 }
764
765 // ANTIBANDING
766 int antibandingMode = abModeStringToEnum(
767 newParams.get(CameraParameters::KEY_ANTIBANDING) );
768 if (antibandingMode != mParameters.antibandingMode) {
769 camera_metadata_entry_t availableAbModes =
770 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
771 for (i = 0; i < availableAbModes.count; i++) {
772 if (antibandingMode == availableAbModes.data.u8[i]) break;
773 }
774 if (i == availableAbModes.count) {
775 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
776 __FUNCTION__,
777 newParams.get(CameraParameters::KEY_ANTIBANDING));
778 return BAD_VALUE;
779 }
780 }
781
782 // SCENE_MODE
783 int sceneMode = sceneModeStringToEnum(
784 newParams.get(CameraParameters::KEY_SCENE_MODE) );
785 if (sceneMode != mParameters.sceneMode) {
786 camera_metadata_entry_t availableSceneModes =
787 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
788 for (i = 0; i < availableSceneModes.count; i++) {
789 if (sceneMode == availableSceneModes.data.u8[i]) break;
790 }
791 if (i == availableSceneModes.count) {
792 ALOGE("%s: Requested scene mode \"%s\" is not supported",
793 __FUNCTION__,
794 newParams.get(CameraParameters::KEY_SCENE_MODE));
795 return BAD_VALUE;
796 }
797 }
798
799 // FLASH_MODE
800 Parameters::flashMode_t flashMode = flashModeStringToEnum(
801 newParams.get(CameraParameters::KEY_FLASH_MODE) );
802 if (flashMode != mParameters.flashMode) {
803 camera_metadata_entry_t flashAvailable =
804 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
805 if (!flashAvailable.data.u8[0] &&
806 flashMode != Parameters::FLASH_MODE_OFF) {
807 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
808 "No flash on device", __FUNCTION__,
809 newParams.get(CameraParameters::KEY_FLASH_MODE));
810 return BAD_VALUE;
811 } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
812 camera_metadata_entry_t availableAeModes =
813 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
814 for (i = 0; i < availableAeModes.count; i++) {
815 if (flashMode == availableAeModes.data.u8[i]) break;
816 }
817 if (i == availableAeModes.count) {
818 ALOGE("%s: Requested flash mode \"%s\" is not supported",
819 __FUNCTION__,
820 newParams.get(CameraParameters::KEY_FLASH_MODE));
821 return BAD_VALUE;
822 }
823 } else if (flashMode == -1) {
824 ALOGE("%s: Requested flash mode \"%s\" is unknown",
825 __FUNCTION__,
826 newParams.get(CameraParameters::KEY_FLASH_MODE));
827 return BAD_VALUE;
828 }
829 }
830
831 // FOCUS_MODE
832 Parameters::focusMode_t focusMode = focusModeStringToEnum(
833 newParams.get(CameraParameters::KEY_FOCUS_MODE));
834 if (focusMode != mParameters.focusMode) {
835 if (focusMode != Parameters::FOCUS_MODE_FIXED) {
836 camera_metadata_entry_t minFocusDistance =
837 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
838 if (minFocusDistance.data.f[0] == 0) {
839 ALOGE("%s: Requested focus mode \"%s\" is not available: "
840 "fixed focus lens",
841 __FUNCTION__,
842 newParams.get(CameraParameters::KEY_FOCUS_MODE));
843 return BAD_VALUE;
844 } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
845 camera_metadata_entry_t availableFocusModes =
846 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
847 for (i = 0; i < availableFocusModes.count; i++) {
848 if (focusMode == availableFocusModes.data.u8[i]) break;
849 }
850 if (i == availableFocusModes.count) {
851 ALOGE("%s: Requested focus mode \"%s\" is not supported",
852 __FUNCTION__,
853 newParams.get(CameraParameters::KEY_FOCUS_MODE));
854 return BAD_VALUE;
855 }
856 }
857 }
858 }
859
860 // FOCUS_AREAS
861 Vector<Parameters::Area> focusingAreas;
862 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
863 &focusingAreas);
864 size_t max3aRegions =
865 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
866 if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
867 if (res != OK) {
868 ALOGE("%s: Requested focus areas are malformed: %s",
869 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
870 return BAD_VALUE;
871 }
872
873 // EXPOSURE_COMPENSATION
874 int exposureCompensation =
875 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
876 camera_metadata_entry_t exposureCompensationRange =
877 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
878 if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
879 exposureCompensation > exposureCompensationRange.data.i32[1]) {
880 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
881 __FUNCTION__, exposureCompensation);
882 return BAD_VALUE;
883 }
884
885 // AUTO_EXPOSURE_LOCK (always supported)
886 bool autoExposureLock = boolFromString(
887 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
888
889 // AUTO_WHITEBALANCE_LOCK (always supported)
890 bool autoWhiteBalanceLock = boolFromString(
891 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
892
893 // METERING_AREAS
894 Vector<Parameters::Area> meteringAreas;
895 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
896 &meteringAreas);
897 if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
898 if (res != OK) {
899 ALOGE("%s: Requested metering areas are malformed: %s",
900 __FUNCTION__,
901 newParams.get(CameraParameters::KEY_METERING_AREAS));
902 return BAD_VALUE;
903 }
904
905 // ZOOM
906 int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
907 if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
908 ALOGE("%s: Requested zoom level %d is not supported",
909 __FUNCTION__, zoom);
910 return BAD_VALUE;
911 }
912
913 // VIDEO_SIZE
914 int videoWidth, videoHeight;
915 newParams.getVideoSize(&videoWidth, &videoHeight);
916 if (videoWidth != mParameters.videoWidth ||
917 videoHeight != mParameters.videoHeight) {
918 if (mState == RECORD) {
919 ALOGE("%s: Video size cannot be updated when recording is active!",
920 __FUNCTION__);
921 return BAD_VALUE;
922 }
923 camera_metadata_entry_t availableVideoSizes =
924 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
925 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
926 if (availableVideoSizes.data.i32[i] == videoWidth &&
927 availableVideoSizes.data.i32[i+1] == videoHeight) break;
928 }
929 if (i == availableVideoSizes.count) {
930 ALOGE("%s: Requested video size %d x %d is not supported",
931 __FUNCTION__, videoWidth, videoHeight);
932 return BAD_VALUE;
933 }
934 }
935
936 // RECORDING_HINT (always supported)
937 bool recordingHint = boolFromString(
938 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
939
940 // VIDEO_STABILIZATION
941 bool videoStabilization = boolFromString(
942 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
943 camera_metadata_entry_t availableVideoStabilizationModes =
944 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
945 if (videoStabilization && availableVideoStabilizationModes.count == 1) {
946 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
947 }
948
949 /** Update internal parameters */
950 mParameters.previewWidth = previewWidth;
951 mParameters.previewHeight = previewHeight;
952 mParameters.previewFpsRangeMin = previewFpsRangeMin;
953 mParameters.previewFpsRangeMax = previewFpsRangeMax;
954 mParameters.previewFps = previewFps;
955 mParameters.previewFormat = previewFormat;
956
957 mParameters.pictureWidth = pictureWidth;
958 mParameters.pictureHeight = pictureHeight;
959
960 mParameters.jpegThumbWidth = jpegThumbWidth;
961 mParameters.jpegThumbHeight = jpegThumbHeight;
962 mParameters.jpegQuality = jpegQuality;
963 mParameters.jpegThumbQuality = jpegThumbQuality;
964
965 mParameters.gpsEnabled = gpsEnabled;
966 mParameters.gpsLatitude = gpsLatitude;
967 mParameters.gpsLongitude = gpsLongitude;
968 mParameters.gpsAltitude = gpsAltitude;
969 mParameters.gpsTimestamp = gpsTimestamp;
970 mParameters.gpsProcessingMethod = gpsProcessingMethod;
971
972 mParameters.wbMode = wbMode;
973 mParameters.effectMode = effectMode;
974 mParameters.antibandingMode = antibandingMode;
975 mParameters.sceneMode = sceneMode;
976
977 mParameters.flashMode = flashMode;
978 mParameters.focusMode = focusMode;
979
980 mParameters.focusingAreas = focusingAreas;
981 mParameters.exposureCompensation = exposureCompensation;
982 mParameters.autoExposureLock = autoExposureLock;
983 mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
984 mParameters.meteringAreas = meteringAreas;
985 mParameters.zoom = zoom;
986
987 mParameters.videoWidth = videoWidth;
988 mParameters.videoHeight = videoHeight;
989
990 mParameters.recordingHint = recordingHint;
991 mParameters.videoStabilization = videoStabilization;
992
993 updatePreviewRequest();
994
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700995 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700996}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700997
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700998String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700999 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001000 Mutex::Autolock icl(mICameraLock);
1001
1002 Mutex::Autolock pl(mParamsLock);
1003
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001004 // TODO: Deal with focus distances
1005 return mParamsFlattened;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001006}
1007
1008status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001009 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001010 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001011 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001012}
1013
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001014/** Device-related methods */
1015
1016camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1017 size_t minCount, size_t maxCount) {
1018 status_t res;
1019 camera_metadata_entry_t entry;
1020 res = find_camera_metadata_entry(mDevice->info(),
1021 tag,
1022 &entry);
1023 if (CC_UNLIKELY( res != OK )) {
1024 const char* tagSection = get_camera_metadata_section_name(tag);
1025 if (tagSection == NULL) tagSection = "<unknown>";
1026 const char* tagName = get_camera_metadata_tag_name(tag);
1027 if (tagName == NULL) tagName = "<unknown>";
1028
1029 ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1030 tagSection, tagName, tag, strerror(-res), res);
1031 entry.count = 0;
1032 entry.data.u8 = NULL;
1033 } else if (CC_UNLIKELY(
1034 (minCount != 0 && entry.count < minCount) ||
1035 (maxCount != 0 && entry.count > maxCount) ) ) {
1036 const char* tagSection = get_camera_metadata_section_name(tag);
1037 if (tagSection == NULL) tagSection = "<unknown>";
1038 const char* tagName = get_camera_metadata_tag_name(tag);
1039 if (tagName == NULL) tagName = "<unknown>";
1040 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1041 "Expected between %d and %d values, but got %d values",
1042 tagSection, tagName, tag, minCount, maxCount, entry.count);
1043 entry.count = 0;
1044 entry.data.u8 = NULL;
1045 }
1046
1047 return entry;
1048}
1049
1050/** Utility methods */
1051
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001052
1053status_t Camera2Client::buildDefaultParameters() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001054 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001055 Mutex::Autolock pl(mParamsLock);
1056
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001057 status_t res;
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001058 CameraParameters params;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001059
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001060 camera_metadata_entry_t availableProcessedSizes =
1061 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1062 if (!availableProcessedSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001063
1064 // TODO: Pick more intelligently
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001065 mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1066 mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1067 mParameters.videoWidth = mParameters.previewWidth;
1068 mParameters.videoHeight = mParameters.previewHeight;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001069
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001070 params.setPreviewSize(mParameters.previewWidth, mParameters.previewHeight);
1071 params.setVideoSize(mParameters.videoWidth, mParameters.videoHeight);
1072 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1073 String8::format("%dx%d",
1074 mParameters.previewWidth, mParameters.previewHeight));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001075 {
1076 String8 supportedPreviewSizes;
1077 for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1078 if (i != 0) supportedPreviewSizes += ",";
1079 supportedPreviewSizes += String8::format("%dx%d",
1080 availableProcessedSizes.data.i32[i],
1081 availableProcessedSizes.data.i32[i+1]);
1082 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001083 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001084 supportedPreviewSizes);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001085 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001086 supportedPreviewSizes);
1087 }
1088
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001089 camera_metadata_entry_t availableFpsRanges =
1090 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1091 if (!availableFpsRanges.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001092
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001093 mParameters.previewFpsRangeMin = availableFpsRanges.data.i32[0];
1094 mParameters.previewFpsRangeMax = availableFpsRanges.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001095
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001096 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1097 String8::format("%d,%d",
1098 mParameters.previewFpsRangeMin,
1099 mParameters.previewFpsRangeMax));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001100
1101 {
1102 String8 supportedPreviewFpsRange;
1103 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1104 if (i != 0) supportedPreviewFpsRange += ",";
1105 supportedPreviewFpsRange += String8::format("(%d,%d)",
1106 availableFpsRanges.data.i32[i],
1107 availableFpsRanges.data.i32[i+1]);
1108 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001109 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001110 supportedPreviewFpsRange);
1111 }
1112
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001113 mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1114 params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1115 formatEnumToString(mParameters.previewFormat)); // NV21
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001116
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001117 camera_metadata_entry_t availableFormats =
1118 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1119
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001120 {
1121 String8 supportedPreviewFormats;
1122 bool addComma = false;
1123 for (size_t i=0; i < availableFormats.count; i++) {
1124 if (addComma) supportedPreviewFormats += ",";
1125 addComma = true;
1126 switch (availableFormats.data.i32[i]) {
1127 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001128 supportedPreviewFormats +=
1129 CameraParameters::PIXEL_FORMAT_YUV422SP;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001130 break;
1131 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001132 supportedPreviewFormats +=
1133 CameraParameters::PIXEL_FORMAT_YUV420SP;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001134 break;
1135 case HAL_PIXEL_FORMAT_YCbCr_422_I:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001136 supportedPreviewFormats +=
1137 CameraParameters::PIXEL_FORMAT_YUV422I;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001138 break;
1139 case HAL_PIXEL_FORMAT_YV12:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001140 supportedPreviewFormats +=
1141 CameraParameters::PIXEL_FORMAT_YUV420P;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001142 break;
1143 case HAL_PIXEL_FORMAT_RGB_565:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001144 supportedPreviewFormats +=
1145 CameraParameters::PIXEL_FORMAT_RGB565;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001146 break;
1147 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1148 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1149 addComma = false;
1150 break;
1151 default:
1152 ALOGW("%s: Camera %d: Unknown preview format: %x",
1153 __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1154 addComma = false;
1155 break;
1156 }
1157 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001158 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001159 supportedPreviewFormats);
1160 }
1161
1162 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
1163 // still have to do something sane for them
1164
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001165 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
1166 mParameters.previewFpsRangeMin);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001167
1168 {
1169 String8 supportedPreviewFrameRates;
1170 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1171 if (i != 0) supportedPreviewFrameRates += ",";
1172 supportedPreviewFrameRates += String8::format("%d",
1173 availableFpsRanges.data.i32[i]);
1174 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001175 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001176 supportedPreviewFrameRates);
1177 }
1178
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001179 camera_metadata_entry_t availableJpegSizes =
1180 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
1181 if (!availableJpegSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001182
1183 // TODO: Pick maximum
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001184 mParameters.pictureWidth = availableJpegSizes.data.i32[0];
1185 mParameters.pictureHeight = availableJpegSizes.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001186
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001187 params.setPictureSize(mParameters.pictureWidth,
1188 mParameters.pictureHeight);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001189
1190 {
1191 String8 supportedPictureSizes;
1192 for (size_t i=0; i < availableJpegSizes.count; i += 2) {
1193 if (i != 0) supportedPictureSizes += ",";
1194 supportedPictureSizes += String8::format("%dx%d",
1195 availableJpegSizes.data.i32[i],
1196 availableJpegSizes.data.i32[i+1]);
1197 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001198 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001199 supportedPictureSizes);
1200 }
1201
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001202 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
1203 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
1204 CameraParameters::PIXEL_FORMAT_JPEG);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001205
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001206 camera_metadata_entry_t availableJpegThumbnailSizes =
1207 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
1208 if (!availableJpegThumbnailSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001209
1210 // TODO: Pick default thumbnail size sensibly
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001211 mParameters.jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0];
1212 mParameters.jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001213
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001214 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
1215 mParameters.jpegThumbWidth);
1216 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
1217 mParameters.jpegThumbHeight);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001218
1219 {
1220 String8 supportedJpegThumbSizes;
1221 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
1222 if (i != 0) supportedJpegThumbSizes += ",";
1223 supportedJpegThumbSizes += String8::format("%dx%d",
1224 availableJpegThumbnailSizes.data.i32[i],
1225 availableJpegThumbnailSizes.data.i32[i+1]);
1226 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001227 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001228 supportedJpegThumbSizes);
1229 }
1230
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001231 mParameters.jpegThumbQuality = 90;
1232 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
1233 mParameters.jpegThumbQuality);
1234 mParameters.jpegQuality = 90;
1235 params.set(CameraParameters::KEY_JPEG_QUALITY,
1236 mParameters.jpegQuality);
1237 mParameters.jpegRotation = 0;
1238 params.set(CameraParameters::KEY_ROTATION,
1239 mParameters.jpegRotation);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001240
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001241 mParameters.gpsEnabled = false;
1242 mParameters.gpsProcessingMethod = "unknown";
1243 // GPS fields in CameraParameters are not set by implementation
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001244
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001245 mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
1246 params.set(CameraParameters::KEY_WHITE_BALANCE,
1247 CameraParameters::WHITE_BALANCE_AUTO);
1248
1249 camera_metadata_entry_t availableWhiteBalanceModes =
1250 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001251 {
1252 String8 supportedWhiteBalance;
1253 bool addComma = false;
1254 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
1255 if (addComma) supportedWhiteBalance += ",";
1256 addComma = true;
1257 switch (availableWhiteBalanceModes.data.u8[i]) {
1258 case ANDROID_CONTROL_AWB_AUTO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001259 supportedWhiteBalance +=
1260 CameraParameters::WHITE_BALANCE_AUTO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001261 break;
1262 case ANDROID_CONTROL_AWB_INCANDESCENT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001263 supportedWhiteBalance +=
1264 CameraParameters::WHITE_BALANCE_INCANDESCENT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001265 break;
1266 case ANDROID_CONTROL_AWB_FLUORESCENT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001267 supportedWhiteBalance +=
1268 CameraParameters::WHITE_BALANCE_FLUORESCENT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001269 break;
1270 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001271 supportedWhiteBalance +=
1272 CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001273 break;
1274 case ANDROID_CONTROL_AWB_DAYLIGHT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001275 supportedWhiteBalance +=
1276 CameraParameters::WHITE_BALANCE_DAYLIGHT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001277 break;
1278 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001279 supportedWhiteBalance +=
1280 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001281 break;
1282 case ANDROID_CONTROL_AWB_TWILIGHT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001283 supportedWhiteBalance +=
1284 CameraParameters::WHITE_BALANCE_TWILIGHT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001285 break;
1286 case ANDROID_CONTROL_AWB_SHADE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001287 supportedWhiteBalance +=
1288 CameraParameters::WHITE_BALANCE_SHADE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001289 break;
1290 // Skipping values not mappable to v1 API
1291 case ANDROID_CONTROL_AWB_OFF:
1292 addComma = false;
1293 break;
1294 default:
1295 ALOGW("%s: Camera %d: Unknown white balance value: %d",
1296 __FUNCTION__, mCameraId,
1297 availableWhiteBalanceModes.data.u8[i]);
1298 addComma = false;
1299 break;
1300 }
1301 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001302 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001303 supportedWhiteBalance);
1304 }
1305
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001306 mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
1307 params.set(CameraParameters::KEY_EFFECT,
1308 CameraParameters::EFFECT_NONE);
1309
1310 camera_metadata_entry_t availableEffects =
1311 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1312 if (!availableEffects.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001313 {
1314 String8 supportedEffects;
1315 bool addComma = false;
1316 for (size_t i=0; i < availableEffects.count; i++) {
1317 if (addComma) supportedEffects += ",";
1318 addComma = true;
1319 switch (availableEffects.data.u8[i]) {
1320 case ANDROID_CONTROL_EFFECT_OFF:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001321 supportedEffects +=
1322 CameraParameters::EFFECT_NONE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001323 break;
1324 case ANDROID_CONTROL_EFFECT_MONO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001325 supportedEffects +=
1326 CameraParameters::EFFECT_MONO;
1327 break;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001328 case ANDROID_CONTROL_EFFECT_NEGATIVE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001329 supportedEffects +=
1330 CameraParameters::EFFECT_NEGATIVE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001331 break;
1332 case ANDROID_CONTROL_EFFECT_SOLARIZE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001333 supportedEffects +=
1334 CameraParameters::EFFECT_SOLARIZE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001335 break;
1336 case ANDROID_CONTROL_EFFECT_SEPIA:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001337 supportedEffects +=
1338 CameraParameters::EFFECT_SEPIA;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001339 break;
1340 case ANDROID_CONTROL_EFFECT_POSTERIZE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001341 supportedEffects +=
1342 CameraParameters::EFFECT_POSTERIZE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001343 break;
1344 case ANDROID_CONTROL_EFFECT_WHITEBOARD:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001345 supportedEffects +=
1346 CameraParameters::EFFECT_WHITEBOARD;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001347 break;
1348 case ANDROID_CONTROL_EFFECT_BLACKBOARD:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001349 supportedEffects +=
1350 CameraParameters::EFFECT_BLACKBOARD;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001351 break;
1352 case ANDROID_CONTROL_EFFECT_AQUA:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001353 supportedEffects +=
1354 CameraParameters::EFFECT_AQUA;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001355 break;
1356 default:
1357 ALOGW("%s: Camera %d: Unknown effect value: %d",
1358 __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
1359 addComma = false;
1360 break;
1361 }
1362 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001363 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001364 }
1365
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001366 mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
1367 params.set(CameraParameters::KEY_ANTIBANDING,
1368 CameraParameters::ANTIBANDING_AUTO);
1369
1370 camera_metadata_entry_t availableAntibandingModes =
1371 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1372 if (!availableAntibandingModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001373 {
1374 String8 supportedAntibanding;
1375 bool addComma = false;
1376 for (size_t i=0; i < availableAntibandingModes.count; i++) {
1377 if (addComma) supportedAntibanding += ",";
1378 addComma = true;
1379 switch (availableAntibandingModes.data.u8[i]) {
1380 case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001381 supportedAntibanding +=
1382 CameraParameters::ANTIBANDING_OFF;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001383 break;
1384 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001385 supportedAntibanding +=
1386 CameraParameters::ANTIBANDING_50HZ;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001387 break;
1388 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001389 supportedAntibanding +=
1390 CameraParameters::ANTIBANDING_60HZ;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001391 break;
1392 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001393 supportedAntibanding +=
1394 CameraParameters::ANTIBANDING_AUTO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001395 break;
1396 default:
1397 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
1398 __FUNCTION__, mCameraId,
1399 availableAntibandingModes.data.u8[i]);
1400 addComma = false;
1401 break;
1402 }
1403 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001404 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001405 supportedAntibanding);
1406 }
1407
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001408 mParameters.sceneMode = ANDROID_CONTROL_OFF;
1409 params.set(CameraParameters::KEY_SCENE_MODE,
1410 CameraParameters::SCENE_MODE_AUTO);
1411
1412 camera_metadata_entry_t availableSceneModes =
1413 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1414 if (!availableSceneModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001415 {
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001416 String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001417 bool addComma = true;
1418 bool noSceneModes = false;
1419 for (size_t i=0; i < availableSceneModes.count; i++) {
1420 if (addComma) supportedSceneModes += ",";
1421 addComma = true;
1422 switch (availableSceneModes.data.u8[i]) {
1423 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
1424 noSceneModes = true;
1425 break;
1426 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
1427 // Not in old API
1428 addComma = false;
1429 break;
1430 case ANDROID_CONTROL_SCENE_MODE_ACTION:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001431 supportedSceneModes +=
1432 CameraParameters::SCENE_MODE_ACTION;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001433 break;
1434 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001435 supportedSceneModes +=
1436 CameraParameters::SCENE_MODE_PORTRAIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001437 break;
1438 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001439 supportedSceneModes +=
1440 CameraParameters::SCENE_MODE_LANDSCAPE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001441 break;
1442 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001443 supportedSceneModes +=
1444 CameraParameters::SCENE_MODE_NIGHT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001445 break;
1446 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001447 supportedSceneModes +=
1448 CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001449 break;
1450 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001451 supportedSceneModes +=
1452 CameraParameters::SCENE_MODE_THEATRE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001453 break;
1454 case ANDROID_CONTROL_SCENE_MODE_BEACH:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001455 supportedSceneModes +=
1456 CameraParameters::SCENE_MODE_BEACH;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001457 break;
1458 case ANDROID_CONTROL_SCENE_MODE_SNOW:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001459 supportedSceneModes +=
1460 CameraParameters::SCENE_MODE_SNOW;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001461 break;
1462 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001463 supportedSceneModes +=
1464 CameraParameters::SCENE_MODE_SUNSET;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001465 break;
1466 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001467 supportedSceneModes +=
1468 CameraParameters::SCENE_MODE_STEADYPHOTO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001469 break;
1470 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001471 supportedSceneModes +=
1472 CameraParameters::SCENE_MODE_FIREWORKS;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001473 break;
1474 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001475 supportedSceneModes +=
1476 CameraParameters::SCENE_MODE_SPORTS;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001477 break;
1478 case ANDROID_CONTROL_SCENE_MODE_PARTY:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001479 supportedSceneModes +=
1480 CameraParameters::SCENE_MODE_PARTY;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001481 break;
1482 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001483 supportedSceneModes +=
1484 CameraParameters::SCENE_MODE_CANDLELIGHT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001485 break;
1486 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001487 supportedSceneModes +=
1488 CameraParameters::SCENE_MODE_BARCODE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001489 break;
1490 default:
1491 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001492 __FUNCTION__, mCameraId,
1493 availableSceneModes.data.u8[i]);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001494 addComma = false;
1495 break;
1496 }
1497 }
1498 if (!noSceneModes) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001499 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001500 supportedSceneModes);
1501 }
1502 }
1503
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001504 camera_metadata_entry_t flashAvailable =
1505 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1506 if (!flashAvailable.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001507
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001508 camera_metadata_entry_t availableAeModes =
1509 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1510 if (!availableAeModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001511
1512 if (flashAvailable.data.u8[0]) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001513 mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
1514 params.set(CameraParameters::KEY_FLASH_MODE,
1515 CameraParameters::FLASH_MODE_AUTO);
1516
1517 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
1518 supportedFlashModes = supportedFlashModes +
1519 "," + CameraParameters::FLASH_MODE_AUTO +
1520 "," + CameraParameters::FLASH_MODE_ON +
1521 "," + CameraParameters::FLASH_MODE_TORCH;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001522 for (size_t i=0; i < availableAeModes.count; i++) {
1523 if (availableAeModes.data.u8[i] ==
1524 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001525 supportedFlashModes = supportedFlashModes + "," +
1526 CameraParameters::FLASH_MODE_RED_EYE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001527 break;
1528 }
1529 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001530 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001531 supportedFlashModes);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001532 } else {
1533 mParameters.flashMode = Parameters::FLASH_MODE_OFF;
1534 params.set(CameraParameters::KEY_FLASH_MODE,
1535 CameraParameters::FLASH_MODE_OFF);
1536 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
1537 CameraParameters::FLASH_MODE_OFF);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001538 }
1539
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001540 camera_metadata_entry_t minFocusDistance =
1541 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
1542 if (!minFocusDistance.count) return NO_INIT;
1543
1544 camera_metadata_entry_t availableAfModes =
1545 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1546 if (!availableAfModes.count) return NO_INIT;
1547
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001548 if (minFocusDistance.data.f[0] == 0) {
1549 // Fixed-focus lens
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001550 mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
1551 params.set(CameraParameters::KEY_FOCUS_MODE,
1552 CameraParameters::FOCUS_MODE_FIXED);
1553 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1554 CameraParameters::FOCUS_MODE_FIXED);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001555 } else {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001556 mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1557 params.set(CameraParameters::KEY_FOCUS_MODE,
1558 CameraParameters::FOCUS_MODE_AUTO);
1559 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
1560 supportedFocusModes = supportedFocusModes + "," +
1561 CameraParameters::FOCUS_MODE_INFINITY;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001562 bool addComma = true;
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001563
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001564 for (size_t i=0; i < availableAfModes.count; i++) {
1565 if (addComma) supportedFocusModes += ",";
1566 addComma = true;
1567 switch (availableAfModes.data.u8[i]) {
1568 case ANDROID_CONTROL_AF_AUTO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001569 supportedFocusModes +=
1570 CameraParameters::FOCUS_MODE_AUTO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001571 break;
1572 case ANDROID_CONTROL_AF_MACRO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001573 supportedFocusModes +=
1574 CameraParameters::FOCUS_MODE_MACRO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001575 break;
1576 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001577 supportedFocusModes +=
1578 CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001579 break;
1580 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001581 supportedFocusModes +=
1582 CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001583 break;
1584 case ANDROID_CONTROL_AF_EDOF:
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001585 supportedFocusModes +=
1586 CameraParameters::FOCUS_MODE_EDOF;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001587 break;
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -07001588 // Not supported in old API
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001589 case ANDROID_CONTROL_AF_OFF:
1590 addComma = false;
1591 break;
1592 default:
1593 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
1594 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
1595 addComma = false;
1596 break;
1597 }
1598 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001599 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001600 supportedFocusModes);
1601 }
1602
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001603 camera_metadata_entry_t max3aRegions =
1604 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
1605 if (!max3aRegions.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001606
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001607 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001608 max3aRegions.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001609 params.set(CameraParameters::KEY_FOCUS_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001610 "(0,0,0,0,0)");
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001611 mParameters.focusingAreas.clear();
1612 mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001613
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001614 camera_metadata_entry_t availableFocalLengths =
1615 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
1616 if (!availableFocalLengths.count) return NO_INIT;
1617
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001618 float minFocalLength = availableFocalLengths.data.f[0];
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001619 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001620
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001621 camera_metadata_entry_t sensorSize =
1622 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
1623 if (!sensorSize.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001624
1625 // The fields of view here assume infinity focus, maximum wide angle
1626 float horizFov = 180 / M_PI *
1627 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
1628 float vertFov = 180 / M_PI *
1629 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001630 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
1631 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001632
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001633 mParameters.exposureCompensation = 0;
1634 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
1635 mParameters.exposureCompensation);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001636
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001637 camera_metadata_entry_t exposureCompensationRange =
1638 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
1639 if (!exposureCompensationRange.count) return NO_INIT;
1640
1641 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001642 exposureCompensationRange.data.i32[1]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001643 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001644 exposureCompensationRange.data.i32[0]);
1645
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001646 camera_metadata_entry_t exposureCompensationStep =
1647 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
1648 if (!exposureCompensationStep.count) return NO_INIT;
1649
1650 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001651 exposureCompensationStep.data.r[0].numerator /
1652 exposureCompensationStep.data.r[0].denominator);
1653
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001654 mParameters.autoExposureLock = false;
1655 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
1656 CameraParameters::FALSE);
1657 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
1658 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001659
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001660 mParameters.autoWhiteBalanceLock = false;
1661 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
1662 CameraParameters::FALSE);
1663 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
1664 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001665
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001666 mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
1667 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001668 max3aRegions.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001669 params.set(CameraParameters::KEY_METERING_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001670 "(0,0,0,0,0)");
1671
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001672 mParameters.zoom = 0;
1673 params.set(CameraParameters::KEY_ZOOM, mParameters.zoom);
1674 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001675
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001676 camera_metadata_entry_t maxDigitalZoom =
1677 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
1678 if (!maxDigitalZoom.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001679
1680 {
1681 String8 zoomRatios;
1682 float zoom = 1.f;
1683 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001684 (NUM_ZOOM_STEPS-1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001685 bool addComma = false;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001686 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001687 if (addComma) zoomRatios += ",";
1688 addComma = true;
1689 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
1690 zoom += zoomIncrement;
1691 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001692 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001693 }
1694
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001695 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
1696 CameraParameters::TRUE);
1697 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
1698 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001699
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001700 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001701 "Infinity,Infinity,Infinity");
1702
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001703 camera_metadata_entry_t maxFacesDetected =
1704 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
1705 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001706 maxFacesDetected.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001707 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001708 0);
1709
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001710 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
1711 formatEnumToString(HAL_PIXEL_FORMAT_YCrCb_420_SP));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001712
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001713 params.set(CameraParameters::KEY_RECORDING_HINT,
1714 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001715
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001716 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
1717 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001718
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001719 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
1720 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001721
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001722 camera_metadata_entry_t availableVideoStabilizationModes =
1723 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1724 if (!availableVideoStabilizationModes.count) return NO_INIT;
1725
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001726 if (availableVideoStabilizationModes.count > 1) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001727 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1728 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001729 } else {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001730 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1731 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001732 }
1733
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001734 mParamsFlattened = params.flatten();
1735
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001736 return OK;
1737}
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001738
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001739status_t Camera2Client::updatePreviewRequest() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001740 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001741 status_t res;
1742 if (mPreviewRequest == NULL) {
1743 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1744 &mPreviewRequest);
1745 if (res != OK) {
1746 ALOGE("%s: Camera %d: Unable to create default preview request: "
1747 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1748 return res;
1749 }
1750 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001751 // TODO: Adjust for params changes
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001752 return OK;
1753}
1754
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001755int Camera2Client::formatStringToEnum(const char *format) {
1756 return
1757 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1758 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1759 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1760 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1761 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1762 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1763 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1764 HAL_PIXEL_FORMAT_YV12 : // YV12
1765 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1766 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1767 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1768 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1769 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1770 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1771 -1;
1772}
1773
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001774const char* Camera2Client::formatEnumToString(int format) {
1775 const char *fmt;
1776 switch(format) {
1777 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1778 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1779 break;
1780 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1781 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1782 break;
1783 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1784 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1785 break;
1786 case HAL_PIXEL_FORMAT_YV12: // YV12
1787 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1788 break;
1789 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1790 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1791 break;
1792 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1793 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1794 break;
1795 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1796 ALOGW("Raw sensor preview format requested.");
1797 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1798 break;
1799 default:
1800 ALOGE("%s: Unknown preview format: %x",
1801 __FUNCTION__, format);
1802 fmt = NULL;
1803 break;
1804 }
1805 return fmt;
1806}
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001807
1808int Camera2Client::wbModeStringToEnum(const char *wbMode) {
1809 return
1810 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1811 ANDROID_CONTROL_AWB_AUTO :
1812 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1813 ANDROID_CONTROL_AWB_INCANDESCENT :
1814 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1815 ANDROID_CONTROL_AWB_FLUORESCENT :
1816 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1817 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1818 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1819 ANDROID_CONTROL_AWB_DAYLIGHT :
1820 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1821 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1822 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1823 ANDROID_CONTROL_AWB_TWILIGHT :
1824 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1825 ANDROID_CONTROL_AWB_SHADE :
1826 -1;
1827}
1828
1829int Camera2Client::effectModeStringToEnum(const char *effectMode) {
1830 return
1831 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1832 ANDROID_CONTROL_EFFECT_OFF :
1833 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1834 ANDROID_CONTROL_EFFECT_MONO :
1835 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1836 ANDROID_CONTROL_EFFECT_NEGATIVE :
1837 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1838 ANDROID_CONTROL_EFFECT_SOLARIZE :
1839 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1840 ANDROID_CONTROL_EFFECT_SEPIA :
1841 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1842 ANDROID_CONTROL_EFFECT_POSTERIZE :
1843 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1844 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1845 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1846 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1847 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1848 ANDROID_CONTROL_EFFECT_AQUA :
1849 -1;
1850}
1851
1852int Camera2Client::abModeStringToEnum(const char *abMode) {
1853 return
1854 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1855 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1856 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1857 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1858 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1859 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1860 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1861 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1862 -1;
1863}
1864
1865int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
1866 return
1867 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1868 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1869 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1870 ANDROID_CONTROL_SCENE_MODE_ACTION :
1871 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1872 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1873 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1874 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1875 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1876 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1877 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1878 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1879 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1880 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1881 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1882 ANDROID_CONTROL_SCENE_MODE_BEACH :
1883 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1884 ANDROID_CONTROL_SCENE_MODE_SNOW :
1885 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1886 ANDROID_CONTROL_SCENE_MODE_SUNSET :
1887 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1888 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1889 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1890 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1891 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1892 ANDROID_CONTROL_SCENE_MODE_SPORTS :
1893 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1894 ANDROID_CONTROL_SCENE_MODE_PARTY :
1895 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1896 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1897 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1898 ANDROID_CONTROL_SCENE_MODE_BARCODE:
1899 -1;
1900}
1901
1902Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
1903 const char *flashMode) {
1904 return
1905 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1906 Parameters::FLASH_MODE_OFF :
1907 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1908 Parameters::FLASH_MODE_AUTO :
1909 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1910 Parameters::FLASH_MODE_ON :
1911 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1912 Parameters::FLASH_MODE_RED_EYE :
1913 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1914 Parameters::FLASH_MODE_TORCH :
1915 Parameters::FLASH_MODE_INVALID;
1916}
1917
1918Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
1919 const char *focusMode) {
1920 return
1921 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1922 Parameters::FOCUS_MODE_AUTO :
1923 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1924 Parameters::FOCUS_MODE_INFINITY :
1925 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1926 Parameters::FOCUS_MODE_MACRO :
1927 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1928 Parameters::FOCUS_MODE_FIXED :
1929 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1930 Parameters::FOCUS_MODE_EDOF :
1931 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1932 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1933 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1934 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1935 Parameters::FOCUS_MODE_INVALID;
1936}
1937
1938status_t Camera2Client::parseAreas(const char *areasCStr,
1939 Vector<Parameters::Area> *areas) {
1940 static const size_t NUM_FIELDS = 5;
1941 areas->clear();
1942 if (areasCStr == NULL) {
1943 // If no key exists, use default (0,0,0,0,0)
1944 areas->push();
1945 return OK;
1946 }
1947 String8 areasStr(areasCStr);
1948 ssize_t areaStart = areasStr.find("(", 0) + 1;
1949 while (areaStart != 0) {
1950 const char* area = areasStr.string() + areaStart;
1951 char *numEnd;
1952 int vals[NUM_FIELDS];
1953 for (size_t i = 0; i < NUM_FIELDS; i++) {
1954 errno = 0;
1955 vals[i] = strtol(area, &numEnd, 10);
1956 if (errno || numEnd == area) return BAD_VALUE;
1957 area = numEnd + 1;
1958 }
1959 areas->push(Parameters::Area(
1960 vals[0], vals[1], vals[2], vals[3], vals[4]) );
1961 areaStart = areasStr.find("(", areaStart) + 1;
1962 }
1963 return OK;
1964}
1965
1966status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
1967 size_t maxRegions) {
1968 // Definition of valid area can be found in
1969 // include/camera/CameraParameters.h
1970 if (areas.size() == 0) return BAD_VALUE;
1971 if (areas.size() == 1) {
1972 if (areas[0].left == 0 &&
1973 areas[0].top == 0 &&
1974 areas[0].right == 0 &&
1975 areas[0].bottom == 0 &&
1976 areas[0].weight == 0) {
1977 // Single (0,0,0,0,0) entry is always valid (== driver decides)
1978 return OK;
1979 }
1980 }
1981 if (areas.size() > maxRegions) {
1982 ALOGE("%s: Too many areas requested: %d",
1983 __FUNCTION__, areas.size());
1984 return BAD_VALUE;
1985 }
1986
1987 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
1988 a != areas.end(); a++) {
1989 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
1990 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
1991 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
1992 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
1993 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
1994 if (a->left >= a->right) return BAD_VALUE;
1995 if (a->top >= a->bottom) return BAD_VALUE;
1996 }
1997 return OK;
1998}
1999
2000bool Camera2Client::boolFromString(const char *boolStr) {
2001 return !boolStr ? false :
2002 !strcmp(boolStr, CameraParameters::TRUE) ? true :
2003 false;
2004}
2005
2006
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002007} // namespace android