blob: 5a320a997f7b9fabf298b9d7550640a0f010fdb3 [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
368 if (mState == WAITING_FOR_PREVIEW_WINDOW) {
369 return startPreview();
370 }
371
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700372 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700373}
374
375void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700376 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700377 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700378}
379
380status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700381 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700382 Mutex::Autolock icl(mICameraLock);
383
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700384 status_t res;
385 if (mState == PREVIEW) return INVALID_OPERATION;
386
387 if (mPreviewStreamId == NO_PREVIEW_STREAM) {
388 mState = WAITING_FOR_PREVIEW_WINDOW;
389 return OK;
390 }
391
392 if (mPreviewRequest == NULL) {
393 updatePreviewRequest();
394 }
395
396 uint8_t outputStream = mPreviewStreamId;
397
398 camera_metadata_entry_t outputStreams;
399 res = find_camera_metadata_entry(mPreviewRequest,
400 ANDROID_REQUEST_OUTPUT_STREAMS,
401 &outputStreams);
402 if (res == NAME_NOT_FOUND) {
403 res = add_camera_metadata_entry(mPreviewRequest,
404 ANDROID_REQUEST_OUTPUT_STREAMS,
405 &outputStream, 1);
406 } else if (res == OK) {
407 res = update_camera_metadata_entry(mPreviewRequest,
408 outputStreams.index, &outputStream, 1, NULL);
409 }
410
411 if (res != OK) {
412 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
413 __FUNCTION__, mCameraId, strerror(-res), res);
414 mState = STOPPED;
415 return res;
416 }
417
418 res = mDevice->setStreamingRequest(mPreviewRequest);
419 if (res != OK) {
420 ALOGE("%s: Camera %d: Unable to set preview request to start preview: %s (%d)",
421 __FUNCTION__, mCameraId, strerror(-res), res);
422 mState = STOPPED;
423 return res;
424 }
425 mState = PREVIEW;
426
427 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700428}
429
430void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700431 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700432 Mutex::Autolock icl(mICameraLock);
433 stopPreviewLocked();
434}
435
436void Camera2Client::stopPreviewLocked() {
437 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700438 if (mState != PREVIEW) return;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700439
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700440 mDevice->setStreamingRequest(NULL);
441 mState = STOPPED;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700442}
443
444bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700445 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700446 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700447 return mState == PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700448}
449
450status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700451 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700452 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700453 return BAD_VALUE;
454}
455
456status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700457 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700458 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700459 return BAD_VALUE;
460}
461
462void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700463 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700464 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700465}
466
467bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700468 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700469 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700470 return BAD_VALUE;
471}
472
473void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700474 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700475 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700476}
477
478status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700479 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700480 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700481 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700482}
483
484status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700485 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700486 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700487 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700488}
489
490status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700491 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700492 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700493 return BAD_VALUE;
494}
495
496status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700497 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700498 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -0700499 Mutex::Autolock pl(mParamsLock);
500 status_t res;
501
502 CameraParameters newParams(params);
503
504 // TODO: Currently ignoring any changes to supposedly read-only
505 // parameters such as supported preview sizes, etc. Should probably
506 // produce an error if they're changed.
507
508 /** Extract and verify new parameters */
509
510 size_t i;
511
512 // PREVIEW_SIZE
513 int previewWidth, previewHeight;
514 newParams.getPreviewSize(&previewWidth, &previewHeight);
515
516 if (previewWidth != mParameters.previewWidth ||
517 previewHeight != mParameters.previewHeight) {
518 if (mState >= PREVIEW) {
519 ALOGE("%s: Preview size cannot be updated when preview "
520 "is active!", __FUNCTION__);
521 return BAD_VALUE;
522 }
523 camera_metadata_entry_t availablePreviewSizes =
524 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
525 for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
526 if (availablePreviewSizes.data.i32[i] == previewWidth &&
527 availablePreviewSizes.data.i32[i+1] == previewHeight) break;
528 }
529 if (i == availablePreviewSizes.count) {
530 ALOGE("%s: Requested preview size %d x %d is not supported",
531 __FUNCTION__, previewWidth, previewHeight);
532 return BAD_VALUE;
533 }
534 }
535
536 // PREVIEW_FPS_RANGE
537 int previewFpsRangeMin, previewFpsRangeMax, previewFps = 0;
538 bool fpsRangeChanged = false;
539 newParams.getPreviewFpsRange(&previewFpsRangeMin, &previewFpsRangeMax);
540 if (previewFpsRangeMin != mParameters.previewFpsRangeMin ||
541 previewFpsRangeMax != mParameters.previewFpsRangeMax) {
542 fpsRangeChanged = true;
543 camera_metadata_entry_t availablePreviewFpsRanges =
544 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
545 for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
546 if ((availablePreviewFpsRanges.data.i32[i] ==
547 previewFpsRangeMin) &&
548 (availablePreviewFpsRanges.data.i32[i+1] ==
549 previewFpsRangeMax) ) {
550 break;
551 }
552 }
553 if (i == availablePreviewFpsRanges.count) {
554 ALOGE("%s: Requested preview FPS range %d - %d is not supported",
555 __FUNCTION__, previewFpsRangeMin, previewFpsRangeMax);
556 return BAD_VALUE;
557 }
558 previewFps = previewFpsRangeMin;
559 }
560
561 // PREVIEW_FORMAT
562 int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
563 if (previewFormat != mParameters.previewFormat) {
564 if (mState >= PREVIEW) {
565 ALOGE("%s: Preview format cannot be updated when preview "
566 "is active!", __FUNCTION__);
567 return BAD_VALUE;
568 }
569 camera_metadata_entry_t availableFormats =
570 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
571 for (i = 0; i < availableFormats.count; i++) {
572 if (availableFormats.data.i32[i] == previewFormat) break;
573 }
574 if (i == availableFormats.count) {
575 ALOGE("%s: Requested preview format %s (0x%x) is not supported",
576 __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
577 return BAD_VALUE;
578 }
579 }
580
581 // PREVIEW_FRAME_RATE
582 // Deprecated, only use if the preview fps range is unchanged this time.
583 // The single-value FPS is the same as the minimum of the range.
584 if (!fpsRangeChanged) {
585 previewFps = newParams.getPreviewFrameRate();
586 if (previewFps != mParameters.previewFps) {
587 camera_metadata_entry_t availableFrameRates =
588 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
589 for (i = 0; i < availableFrameRates.count; i+=2) {
590 if (availableFrameRates.data.i32[i] == previewFps) break;
591 }
592 if (i == availableFrameRates.count) {
593 ALOGE("%s: Requested preview frame rate %d is not supported",
594 __FUNCTION__, previewFps);
595 return BAD_VALUE;
596 }
597 previewFpsRangeMin = availableFrameRates.data.i32[i];
598 previewFpsRangeMax = availableFrameRates.data.i32[i+1];
599 }
600 }
601
602 // PICTURE_SIZE
603 int pictureWidth, pictureHeight;
604 newParams.getPictureSize(&pictureWidth, &pictureHeight);
605 if (pictureWidth == mParameters.pictureWidth ||
606 pictureHeight == mParameters.pictureHeight) {
607 camera_metadata_entry_t availablePictureSizes =
608 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
609 for (i = 0; i < availablePictureSizes.count; i+=2) {
610 if (availablePictureSizes.data.i32[i] == pictureWidth &&
611 availablePictureSizes.data.i32[i+1] == pictureHeight) break;
612 }
613 if (i == availablePictureSizes.count) {
614 ALOGE("%s: Requested picture size %d x %d is not supported",
615 __FUNCTION__, pictureWidth, pictureHeight);
616 return BAD_VALUE;
617 }
618 }
619
620 // JPEG_THUMBNAIL_WIDTH/HEIGHT
621 int jpegThumbWidth, jpegThumbHeight;
622 jpegThumbWidth =
623 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
624 jpegThumbHeight =
625 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
626 if (jpegThumbWidth != mParameters.jpegThumbWidth ||
627 jpegThumbHeight != mParameters.jpegThumbHeight) {
628 camera_metadata_entry_t availableJpegThumbSizes =
629 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
630 for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
631 if (availableJpegThumbSizes.data.i32[i] == jpegThumbWidth &&
632 availableJpegThumbSizes.data.i32[i+1] == jpegThumbHeight) {
633 break;
634 }
635 }
636 if (i == availableJpegThumbSizes.count) {
637 ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
638 __FUNCTION__, jpegThumbWidth, jpegThumbHeight);
639 return BAD_VALUE;
640 }
641 }
642
643 // JPEG_THUMBNAIL_QUALITY
644 int jpegThumbQuality =
645 newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
646 if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
647 ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
648 __FUNCTION__, jpegThumbQuality);
649 return BAD_VALUE;
650 }
651
652 // JPEG_QUALITY
653 int jpegQuality =
654 newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
655 if (jpegQuality < 0 || jpegQuality > 100) {
656 ALOGE("%s: Requested JPEG quality %d is not supported",
657 __FUNCTION__, jpegQuality);
658 return BAD_VALUE;
659 }
660
661 // ROTATION
662 int jpegRotation =
663 newParams.getInt(CameraParameters::KEY_ROTATION);
664 if (jpegRotation != 0 &&
665 jpegRotation != 90 &&
666 jpegRotation != 180 &&
667 jpegRotation != 270) {
668 ALOGE("%s: Requested picture rotation angle %d is not supported",
669 __FUNCTION__, jpegRotation);
670 return BAD_VALUE;
671 }
672
673 // GPS
674 bool gpsEnabled = false;
675 double gpsLatitude = 0, gpsLongitude = 0, gpsAltitude = 0;
676 int64_t gpsTimestamp = 0;
677 String8 gpsProcessingMethod;
678 const char *gpsLatStr =
679 newParams.get(CameraParameters::KEY_GPS_LATITUDE);
680 if (gpsLatStr != NULL) {
681 const char *gpsLongStr =
682 newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
683 const char *gpsAltitudeStr =
684 newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
685 const char *gpsTimeStr =
686 newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
687 const char *gpsProcMethodStr =
688 newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
689 if (gpsLongStr == NULL ||
690 gpsAltitudeStr == NULL ||
691 gpsTimeStr == NULL ||
692 gpsProcMethodStr == NULL) {
693 ALOGE("%s: Incomplete set of GPS parameters provided",
694 __FUNCTION__);
695 return BAD_VALUE;
696 }
697 char *endPtr;
698 errno = 0;
699 gpsLatitude = strtod(gpsLatStr, &endPtr);
700 if (errno || endPtr == gpsLatStr) {
701 ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
702 return BAD_VALUE;
703 }
704 errno = 0;
705 gpsLongitude = strtod(gpsLongStr, &endPtr);
706 if (errno || endPtr == gpsLongStr) {
707 ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
708 return BAD_VALUE;
709 }
710 errno = 0;
711 gpsAltitude = strtod(gpsAltitudeStr, &endPtr);
712 if (errno || endPtr == gpsAltitudeStr) {
713 ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
714 gpsAltitudeStr);
715 return BAD_VALUE;
716 }
717 errno = 0;
718 gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
719 if (errno || endPtr == gpsTimeStr) {
720 ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
721 return BAD_VALUE;
722 }
723 gpsProcessingMethod = gpsProcMethodStr;
724
725 gpsEnabled = true;
726 }
727
728 // WHITE_BALANCE
729 int wbMode = wbModeStringToEnum(
730 newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
731 if (wbMode != mParameters.wbMode) {
732 camera_metadata_entry_t availableWbModes =
733 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
734 for (i = 0; i < availableWbModes.count; i++) {
735 if (wbMode == availableWbModes.data.u8[i]) break;
736 }
737 if (i == availableWbModes.count) {
738 ALOGE("%s: Requested white balance mode %s is not supported",
739 __FUNCTION__,
740 newParams.get(CameraParameters::KEY_WHITE_BALANCE));
741 return BAD_VALUE;
742 }
743 }
744
745 // EFFECT
746 int effectMode = effectModeStringToEnum(
747 newParams.get(CameraParameters::KEY_EFFECT) );
748 if (effectMode != mParameters.effectMode) {
749 camera_metadata_entry_t availableEffectModes =
750 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
751 for (i = 0; i < availableEffectModes.count; i++) {
752 if (effectMode == availableEffectModes.data.u8[i]) break;
753 }
754 if (i == availableEffectModes.count) {
755 ALOGE("%s: Requested effect mode \"%s\" is not supported",
756 __FUNCTION__,
757 newParams.get(CameraParameters::KEY_EFFECT) );
758 return BAD_VALUE;
759 }
760 }
761
762 // ANTIBANDING
763 int antibandingMode = abModeStringToEnum(
764 newParams.get(CameraParameters::KEY_ANTIBANDING) );
765 if (antibandingMode != mParameters.antibandingMode) {
766 camera_metadata_entry_t availableAbModes =
767 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
768 for (i = 0; i < availableAbModes.count; i++) {
769 if (antibandingMode == availableAbModes.data.u8[i]) break;
770 }
771 if (i == availableAbModes.count) {
772 ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
773 __FUNCTION__,
774 newParams.get(CameraParameters::KEY_ANTIBANDING));
775 return BAD_VALUE;
776 }
777 }
778
779 // SCENE_MODE
780 int sceneMode = sceneModeStringToEnum(
781 newParams.get(CameraParameters::KEY_SCENE_MODE) );
782 if (sceneMode != mParameters.sceneMode) {
783 camera_metadata_entry_t availableSceneModes =
784 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
785 for (i = 0; i < availableSceneModes.count; i++) {
786 if (sceneMode == availableSceneModes.data.u8[i]) break;
787 }
788 if (i == availableSceneModes.count) {
789 ALOGE("%s: Requested scene mode \"%s\" is not supported",
790 __FUNCTION__,
791 newParams.get(CameraParameters::KEY_SCENE_MODE));
792 return BAD_VALUE;
793 }
794 }
795
796 // FLASH_MODE
797 Parameters::flashMode_t flashMode = flashModeStringToEnum(
798 newParams.get(CameraParameters::KEY_FLASH_MODE) );
799 if (flashMode != mParameters.flashMode) {
800 camera_metadata_entry_t flashAvailable =
801 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
802 if (!flashAvailable.data.u8[0] &&
803 flashMode != Parameters::FLASH_MODE_OFF) {
804 ALOGE("%s: Requested flash mode \"%s\" is not supported: "
805 "No flash on device", __FUNCTION__,
806 newParams.get(CameraParameters::KEY_FLASH_MODE));
807 return BAD_VALUE;
808 } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
809 camera_metadata_entry_t availableAeModes =
810 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
811 for (i = 0; i < availableAeModes.count; i++) {
812 if (flashMode == availableAeModes.data.u8[i]) break;
813 }
814 if (i == availableAeModes.count) {
815 ALOGE("%s: Requested flash mode \"%s\" is not supported",
816 __FUNCTION__,
817 newParams.get(CameraParameters::KEY_FLASH_MODE));
818 return BAD_VALUE;
819 }
820 } else if (flashMode == -1) {
821 ALOGE("%s: Requested flash mode \"%s\" is unknown",
822 __FUNCTION__,
823 newParams.get(CameraParameters::KEY_FLASH_MODE));
824 return BAD_VALUE;
825 }
826 }
827
828 // FOCUS_MODE
829 Parameters::focusMode_t focusMode = focusModeStringToEnum(
830 newParams.get(CameraParameters::KEY_FOCUS_MODE));
831 if (focusMode != mParameters.focusMode) {
832 if (focusMode != Parameters::FOCUS_MODE_FIXED) {
833 camera_metadata_entry_t minFocusDistance =
834 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
835 if (minFocusDistance.data.f[0] == 0) {
836 ALOGE("%s: Requested focus mode \"%s\" is not available: "
837 "fixed focus lens",
838 __FUNCTION__,
839 newParams.get(CameraParameters::KEY_FOCUS_MODE));
840 return BAD_VALUE;
841 } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
842 camera_metadata_entry_t availableFocusModes =
843 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
844 for (i = 0; i < availableFocusModes.count; i++) {
845 if (focusMode == availableFocusModes.data.u8[i]) break;
846 }
847 if (i == availableFocusModes.count) {
848 ALOGE("%s: Requested focus mode \"%s\" is not supported",
849 __FUNCTION__,
850 newParams.get(CameraParameters::KEY_FOCUS_MODE));
851 return BAD_VALUE;
852 }
853 }
854 }
855 }
856
857 // FOCUS_AREAS
858 Vector<Parameters::Area> focusingAreas;
859 res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
860 &focusingAreas);
861 size_t max3aRegions =
862 (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
863 if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
864 if (res != OK) {
865 ALOGE("%s: Requested focus areas are malformed: %s",
866 __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
867 return BAD_VALUE;
868 }
869
870 // EXPOSURE_COMPENSATION
871 int exposureCompensation =
872 newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
873 camera_metadata_entry_t exposureCompensationRange =
874 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
875 if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
876 exposureCompensation > exposureCompensationRange.data.i32[1]) {
877 ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
878 __FUNCTION__, exposureCompensation);
879 return BAD_VALUE;
880 }
881
882 // AUTO_EXPOSURE_LOCK (always supported)
883 bool autoExposureLock = boolFromString(
884 newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
885
886 // AUTO_WHITEBALANCE_LOCK (always supported)
887 bool autoWhiteBalanceLock = boolFromString(
888 newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
889
890 // METERING_AREAS
891 Vector<Parameters::Area> meteringAreas;
892 res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
893 &meteringAreas);
894 if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
895 if (res != OK) {
896 ALOGE("%s: Requested metering areas are malformed: %s",
897 __FUNCTION__,
898 newParams.get(CameraParameters::KEY_METERING_AREAS));
899 return BAD_VALUE;
900 }
901
902 // ZOOM
903 int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
904 if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
905 ALOGE("%s: Requested zoom level %d is not supported",
906 __FUNCTION__, zoom);
907 return BAD_VALUE;
908 }
909
910 // VIDEO_SIZE
911 int videoWidth, videoHeight;
912 newParams.getVideoSize(&videoWidth, &videoHeight);
913 if (videoWidth != mParameters.videoWidth ||
914 videoHeight != mParameters.videoHeight) {
915 if (mState == RECORD) {
916 ALOGE("%s: Video size cannot be updated when recording is active!",
917 __FUNCTION__);
918 return BAD_VALUE;
919 }
920 camera_metadata_entry_t availableVideoSizes =
921 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
922 for (i = 0; i < availableVideoSizes.count; i += 2 ) {
923 if (availableVideoSizes.data.i32[i] == videoWidth &&
924 availableVideoSizes.data.i32[i+1] == videoHeight) break;
925 }
926 if (i == availableVideoSizes.count) {
927 ALOGE("%s: Requested video size %d x %d is not supported",
928 __FUNCTION__, videoWidth, videoHeight);
929 return BAD_VALUE;
930 }
931 }
932
933 // RECORDING_HINT (always supported)
934 bool recordingHint = boolFromString(
935 newParams.get(CameraParameters::KEY_RECORDING_HINT) );
936
937 // VIDEO_STABILIZATION
938 bool videoStabilization = boolFromString(
939 newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
940 camera_metadata_entry_t availableVideoStabilizationModes =
941 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
942 if (videoStabilization && availableVideoStabilizationModes.count == 1) {
943 ALOGE("%s: Video stabilization not supported", __FUNCTION__);
944 }
945
946 /** Update internal parameters */
947 mParameters.previewWidth = previewWidth;
948 mParameters.previewHeight = previewHeight;
949 mParameters.previewFpsRangeMin = previewFpsRangeMin;
950 mParameters.previewFpsRangeMax = previewFpsRangeMax;
951 mParameters.previewFps = previewFps;
952 mParameters.previewFormat = previewFormat;
953
954 mParameters.pictureWidth = pictureWidth;
955 mParameters.pictureHeight = pictureHeight;
956
957 mParameters.jpegThumbWidth = jpegThumbWidth;
958 mParameters.jpegThumbHeight = jpegThumbHeight;
959 mParameters.jpegQuality = jpegQuality;
960 mParameters.jpegThumbQuality = jpegThumbQuality;
961
962 mParameters.gpsEnabled = gpsEnabled;
963 mParameters.gpsLatitude = gpsLatitude;
964 mParameters.gpsLongitude = gpsLongitude;
965 mParameters.gpsAltitude = gpsAltitude;
966 mParameters.gpsTimestamp = gpsTimestamp;
967 mParameters.gpsProcessingMethod = gpsProcessingMethod;
968
969 mParameters.wbMode = wbMode;
970 mParameters.effectMode = effectMode;
971 mParameters.antibandingMode = antibandingMode;
972 mParameters.sceneMode = sceneMode;
973
974 mParameters.flashMode = flashMode;
975 mParameters.focusMode = focusMode;
976
977 mParameters.focusingAreas = focusingAreas;
978 mParameters.exposureCompensation = exposureCompensation;
979 mParameters.autoExposureLock = autoExposureLock;
980 mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
981 mParameters.meteringAreas = meteringAreas;
982 mParameters.zoom = zoom;
983
984 mParameters.videoWidth = videoWidth;
985 mParameters.videoHeight = videoHeight;
986
987 mParameters.recordingHint = recordingHint;
988 mParameters.videoStabilization = videoStabilization;
989
990 updatePreviewRequest();
991
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700992 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700993}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700994
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700995String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700996 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700997 Mutex::Autolock icl(mICameraLock);
998
999 Mutex::Autolock pl(mParamsLock);
1000
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001001 // TODO: Deal with focus distances
1002 return mParamsFlattened;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001003}
1004
1005status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001006 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001007 Mutex::Autolock icl(mICameraLock);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001008 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001009}
1010
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001011/** Device-related methods */
1012
1013camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1014 size_t minCount, size_t maxCount) {
1015 status_t res;
1016 camera_metadata_entry_t entry;
1017 res = find_camera_metadata_entry(mDevice->info(),
1018 tag,
1019 &entry);
1020 if (CC_UNLIKELY( res != OK )) {
1021 const char* tagSection = get_camera_metadata_section_name(tag);
1022 if (tagSection == NULL) tagSection = "<unknown>";
1023 const char* tagName = get_camera_metadata_tag_name(tag);
1024 if (tagName == NULL) tagName = "<unknown>";
1025
1026 ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1027 tagSection, tagName, tag, strerror(-res), res);
1028 entry.count = 0;
1029 entry.data.u8 = NULL;
1030 } else if (CC_UNLIKELY(
1031 (minCount != 0 && entry.count < minCount) ||
1032 (maxCount != 0 && entry.count > maxCount) ) ) {
1033 const char* tagSection = get_camera_metadata_section_name(tag);
1034 if (tagSection == NULL) tagSection = "<unknown>";
1035 const char* tagName = get_camera_metadata_tag_name(tag);
1036 if (tagName == NULL) tagName = "<unknown>";
1037 ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1038 "Expected between %d and %d values, but got %d values",
1039 tagSection, tagName, tag, minCount, maxCount, entry.count);
1040 entry.count = 0;
1041 entry.data.u8 = NULL;
1042 }
1043
1044 return entry;
1045}
1046
1047/** Utility methods */
1048
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001049
1050status_t Camera2Client::buildDefaultParameters() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001051 ATRACE_CALL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001052 Mutex::Autolock pl(mParamsLock);
1053
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001054 status_t res;
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001055 CameraParameters params;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001056
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001057 camera_metadata_entry_t availableProcessedSizes =
1058 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1059 if (!availableProcessedSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001060
1061 // TODO: Pick more intelligently
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001062 mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1063 mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1064 mParameters.videoWidth = mParameters.previewWidth;
1065 mParameters.videoHeight = mParameters.previewHeight;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001066
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001067 params.setPreviewSize(mParameters.previewWidth, mParameters.previewHeight);
1068 params.setVideoSize(mParameters.videoWidth, mParameters.videoHeight);
1069 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1070 String8::format("%dx%d",
1071 mParameters.previewWidth, mParameters.previewHeight));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001072 {
1073 String8 supportedPreviewSizes;
1074 for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1075 if (i != 0) supportedPreviewSizes += ",";
1076 supportedPreviewSizes += String8::format("%dx%d",
1077 availableProcessedSizes.data.i32[i],
1078 availableProcessedSizes.data.i32[i+1]);
1079 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001080 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001081 supportedPreviewSizes);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001082 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001083 supportedPreviewSizes);
1084 }
1085
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001086 camera_metadata_entry_t availableFpsRanges =
1087 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1088 if (!availableFpsRanges.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001089
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001090 mParameters.previewFpsRangeMin = availableFpsRanges.data.i32[0];
1091 mParameters.previewFpsRangeMax = availableFpsRanges.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001092
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001093 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1094 String8::format("%d,%d",
1095 mParameters.previewFpsRangeMin,
1096 mParameters.previewFpsRangeMax));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001097
1098 {
1099 String8 supportedPreviewFpsRange;
1100 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1101 if (i != 0) supportedPreviewFpsRange += ",";
1102 supportedPreviewFpsRange += String8::format("(%d,%d)",
1103 availableFpsRanges.data.i32[i],
1104 availableFpsRanges.data.i32[i+1]);
1105 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001106 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001107 supportedPreviewFpsRange);
1108 }
1109
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001110 mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1111 params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1112 formatEnumToString(mParameters.previewFormat)); // NV21
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001113
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001114 camera_metadata_entry_t availableFormats =
1115 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1116
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001117 {
1118 String8 supportedPreviewFormats;
1119 bool addComma = false;
1120 for (size_t i=0; i < availableFormats.count; i++) {
1121 if (addComma) supportedPreviewFormats += ",";
1122 addComma = true;
1123 switch (availableFormats.data.i32[i]) {
1124 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1125 supportedPreviewFormats += "yuv422sp";
1126 break;
1127 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1128 supportedPreviewFormats += "yuv420sp";
1129 break;
1130 case HAL_PIXEL_FORMAT_YCbCr_422_I:
1131 supportedPreviewFormats += "yuv422i-yuyv";
1132 break;
1133 case HAL_PIXEL_FORMAT_YV12:
1134 supportedPreviewFormats += "yuv420p";
1135 break;
1136 case HAL_PIXEL_FORMAT_RGB_565:
1137 supportedPreviewFormats += "rgb565";
1138 break;
1139 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1140 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1141 addComma = false;
1142 break;
1143 default:
1144 ALOGW("%s: Camera %d: Unknown preview format: %x",
1145 __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1146 addComma = false;
1147 break;
1148 }
1149 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001150 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001151 supportedPreviewFormats);
1152 }
1153
1154 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
1155 // still have to do something sane for them
1156
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001157 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
1158 mParameters.previewFpsRangeMin);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001159
1160 {
1161 String8 supportedPreviewFrameRates;
1162 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1163 if (i != 0) supportedPreviewFrameRates += ",";
1164 supportedPreviewFrameRates += String8::format("%d",
1165 availableFpsRanges.data.i32[i]);
1166 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001167 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001168 supportedPreviewFrameRates);
1169 }
1170
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001171 camera_metadata_entry_t availableJpegSizes =
1172 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
1173 if (!availableJpegSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001174
1175 // TODO: Pick maximum
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001176 mParameters.pictureWidth = availableJpegSizes.data.i32[0];
1177 mParameters.pictureHeight = availableJpegSizes.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001178
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001179 params.setPictureSize(mParameters.pictureWidth,
1180 mParameters.pictureHeight);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001181
1182 {
1183 String8 supportedPictureSizes;
1184 for (size_t i=0; i < availableJpegSizes.count; i += 2) {
1185 if (i != 0) supportedPictureSizes += ",";
1186 supportedPictureSizes += String8::format("%dx%d",
1187 availableJpegSizes.data.i32[i],
1188 availableJpegSizes.data.i32[i+1]);
1189 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001190 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001191 supportedPictureSizes);
1192 }
1193
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001194 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
1195 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
1196 CameraParameters::PIXEL_FORMAT_JPEG);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001197
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001198 camera_metadata_entry_t availableJpegThumbnailSizes =
1199 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
1200 if (!availableJpegThumbnailSizes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001201
1202 // TODO: Pick default thumbnail size sensibly
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001203 mParameters.jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0];
1204 mParameters.jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1];
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001205
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001206 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
1207 mParameters.jpegThumbWidth);
1208 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
1209 mParameters.jpegThumbHeight);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001210
1211 {
1212 String8 supportedJpegThumbSizes;
1213 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
1214 if (i != 0) supportedJpegThumbSizes += ",";
1215 supportedJpegThumbSizes += String8::format("%dx%d",
1216 availableJpegThumbnailSizes.data.i32[i],
1217 availableJpegThumbnailSizes.data.i32[i+1]);
1218 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001219 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001220 supportedJpegThumbSizes);
1221 }
1222
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001223 mParameters.jpegThumbQuality = 90;
1224 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
1225 mParameters.jpegThumbQuality);
1226 mParameters.jpegQuality = 90;
1227 params.set(CameraParameters::KEY_JPEG_QUALITY,
1228 mParameters.jpegQuality);
1229 mParameters.jpegRotation = 0;
1230 params.set(CameraParameters::KEY_ROTATION,
1231 mParameters.jpegRotation);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001232
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001233 mParameters.gpsEnabled = false;
1234 mParameters.gpsProcessingMethod = "unknown";
1235 // GPS fields in CameraParameters are not set by implementation
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001236
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001237 mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
1238 params.set(CameraParameters::KEY_WHITE_BALANCE,
1239 CameraParameters::WHITE_BALANCE_AUTO);
1240
1241 camera_metadata_entry_t availableWhiteBalanceModes =
1242 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001243 {
1244 String8 supportedWhiteBalance;
1245 bool addComma = false;
1246 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
1247 if (addComma) supportedWhiteBalance += ",";
1248 addComma = true;
1249 switch (availableWhiteBalanceModes.data.u8[i]) {
1250 case ANDROID_CONTROL_AWB_AUTO:
1251 supportedWhiteBalance += "auto";
1252 break;
1253 case ANDROID_CONTROL_AWB_INCANDESCENT:
1254 supportedWhiteBalance += "incandescent";
1255 break;
1256 case ANDROID_CONTROL_AWB_FLUORESCENT:
1257 supportedWhiteBalance += "fluorescent";
1258 break;
1259 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
1260 supportedWhiteBalance += "warm-fluorescent";
1261 break;
1262 case ANDROID_CONTROL_AWB_DAYLIGHT:
1263 supportedWhiteBalance += "daylight";
1264 break;
1265 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
1266 supportedWhiteBalance += "cloudy-daylight";
1267 break;
1268 case ANDROID_CONTROL_AWB_TWILIGHT:
1269 supportedWhiteBalance += "twilight";
1270 break;
1271 case ANDROID_CONTROL_AWB_SHADE:
1272 supportedWhiteBalance += "shade";
1273 break;
1274 // Skipping values not mappable to v1 API
1275 case ANDROID_CONTROL_AWB_OFF:
1276 addComma = false;
1277 break;
1278 default:
1279 ALOGW("%s: Camera %d: Unknown white balance value: %d",
1280 __FUNCTION__, mCameraId,
1281 availableWhiteBalanceModes.data.u8[i]);
1282 addComma = false;
1283 break;
1284 }
1285 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001286 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001287 supportedWhiteBalance);
1288 }
1289
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001290 mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
1291 params.set(CameraParameters::KEY_EFFECT,
1292 CameraParameters::EFFECT_NONE);
1293
1294 camera_metadata_entry_t availableEffects =
1295 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1296 if (!availableEffects.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001297 {
1298 String8 supportedEffects;
1299 bool addComma = false;
1300 for (size_t i=0; i < availableEffects.count; i++) {
1301 if (addComma) supportedEffects += ",";
1302 addComma = true;
1303 switch (availableEffects.data.u8[i]) {
1304 case ANDROID_CONTROL_EFFECT_OFF:
1305 supportedEffects += "none";
1306 break;
1307 case ANDROID_CONTROL_EFFECT_MONO:
1308 supportedEffects += "mono";
1309 case ANDROID_CONTROL_EFFECT_NEGATIVE:
1310 supportedEffects += "negative";
1311 break;
1312 case ANDROID_CONTROL_EFFECT_SOLARIZE:
1313 supportedEffects += "solarize";
1314 break;
1315 case ANDROID_CONTROL_EFFECT_SEPIA:
1316 supportedEffects += "sepia";
1317 break;
1318 case ANDROID_CONTROL_EFFECT_POSTERIZE:
1319 supportedEffects += "posterize";
1320 break;
1321 case ANDROID_CONTROL_EFFECT_WHITEBOARD:
1322 supportedEffects += "whiteboard";
1323 break;
1324 case ANDROID_CONTROL_EFFECT_BLACKBOARD:
1325 supportedEffects += "blackboard";
1326 break;
1327 case ANDROID_CONTROL_EFFECT_AQUA:
1328 supportedEffects += "aqua";
1329 break;
1330 default:
1331 ALOGW("%s: Camera %d: Unknown effect value: %d",
1332 __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
1333 addComma = false;
1334 break;
1335 }
1336 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001337 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001338 }
1339
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001340 mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
1341 params.set(CameraParameters::KEY_ANTIBANDING,
1342 CameraParameters::ANTIBANDING_AUTO);
1343
1344 camera_metadata_entry_t availableAntibandingModes =
1345 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1346 if (!availableAntibandingModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001347 {
1348 String8 supportedAntibanding;
1349 bool addComma = false;
1350 for (size_t i=0; i < availableAntibandingModes.count; i++) {
1351 if (addComma) supportedAntibanding += ",";
1352 addComma = true;
1353 switch (availableAntibandingModes.data.u8[i]) {
1354 case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
1355 supportedAntibanding += "off";
1356 break;
1357 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
1358 supportedAntibanding += "50hz";
1359 break;
1360 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
1361 supportedAntibanding += "60hz";
1362 break;
1363 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
1364 supportedAntibanding += "auto";
1365 break;
1366 default:
1367 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
1368 __FUNCTION__, mCameraId,
1369 availableAntibandingModes.data.u8[i]);
1370 addComma = false;
1371 break;
1372 }
1373 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001374 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001375 supportedAntibanding);
1376 }
1377
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001378 mParameters.sceneMode = ANDROID_CONTROL_OFF;
1379 params.set(CameraParameters::KEY_SCENE_MODE,
1380 CameraParameters::SCENE_MODE_AUTO);
1381
1382 camera_metadata_entry_t availableSceneModes =
1383 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1384 if (!availableSceneModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001385 {
1386 String8 supportedSceneModes("auto");
1387 bool addComma = true;
1388 bool noSceneModes = false;
1389 for (size_t i=0; i < availableSceneModes.count; i++) {
1390 if (addComma) supportedSceneModes += ",";
1391 addComma = true;
1392 switch (availableSceneModes.data.u8[i]) {
1393 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
1394 noSceneModes = true;
1395 break;
1396 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
1397 // Not in old API
1398 addComma = false;
1399 break;
1400 case ANDROID_CONTROL_SCENE_MODE_ACTION:
1401 supportedSceneModes += "action";
1402 break;
1403 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
1404 supportedSceneModes += "portrait";
1405 break;
1406 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
1407 supportedSceneModes += "landscape";
1408 break;
1409 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
1410 supportedSceneModes += "night";
1411 break;
1412 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
1413 supportedSceneModes += "night-portrait";
1414 break;
1415 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
1416 supportedSceneModes += "theatre";
1417 break;
1418 case ANDROID_CONTROL_SCENE_MODE_BEACH:
1419 supportedSceneModes += "beach";
1420 break;
1421 case ANDROID_CONTROL_SCENE_MODE_SNOW:
1422 supportedSceneModes += "snow";
1423 break;
1424 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
1425 supportedSceneModes += "sunset";
1426 break;
1427 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
1428 supportedSceneModes += "steadyphoto";
1429 break;
1430 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
1431 supportedSceneModes += "fireworks";
1432 break;
1433 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
1434 supportedSceneModes += "sports";
1435 break;
1436 case ANDROID_CONTROL_SCENE_MODE_PARTY:
1437 supportedSceneModes += "party";
1438 break;
1439 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
1440 supportedSceneModes += "candlelight";
1441 break;
1442 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
1443 supportedSceneModes += "barcode";
1444 break;
1445 default:
1446 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
1447 __FUNCTION__, mCameraId, availableSceneModes.data.u8[i]);
1448 addComma = false;
1449 break;
1450 }
1451 }
1452 if (!noSceneModes) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001453 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001454 supportedSceneModes);
1455 }
1456 }
1457
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001458 camera_metadata_entry_t flashAvailable =
1459 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1460 if (!flashAvailable.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001461
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001462 camera_metadata_entry_t availableAeModes =
1463 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1464 if (!availableAeModes.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001465
1466 if (flashAvailable.data.u8[0]) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001467 mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
1468 params.set(CameraParameters::KEY_FLASH_MODE,
1469 CameraParameters::FLASH_MODE_AUTO);
1470
1471 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
1472 supportedFlashModes = supportedFlashModes +
1473 "," + CameraParameters::FLASH_MODE_AUTO +
1474 "," + CameraParameters::FLASH_MODE_ON +
1475 "," + CameraParameters::FLASH_MODE_TORCH;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001476 for (size_t i=0; i < availableAeModes.count; i++) {
1477 if (availableAeModes.data.u8[i] ==
1478 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001479 supportedFlashModes = supportedFlashModes + "," +
1480 CameraParameters::FLASH_MODE_RED_EYE;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001481 break;
1482 }
1483 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001484 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001485 supportedFlashModes);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001486 } else {
1487 mParameters.flashMode = Parameters::FLASH_MODE_OFF;
1488 params.set(CameraParameters::KEY_FLASH_MODE,
1489 CameraParameters::FLASH_MODE_OFF);
1490 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
1491 CameraParameters::FLASH_MODE_OFF);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001492 }
1493
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001494 camera_metadata_entry_t minFocusDistance =
1495 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
1496 if (!minFocusDistance.count) return NO_INIT;
1497
1498 camera_metadata_entry_t availableAfModes =
1499 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1500 if (!availableAfModes.count) return NO_INIT;
1501
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001502 if (minFocusDistance.data.f[0] == 0) {
1503 // Fixed-focus lens
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001504 mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
1505 params.set(CameraParameters::KEY_FOCUS_MODE,
1506 CameraParameters::FOCUS_MODE_FIXED);
1507 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1508 CameraParameters::FOCUS_MODE_FIXED);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001509 } else {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001510 mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1511 params.set(CameraParameters::KEY_FOCUS_MODE,
1512 CameraParameters::FOCUS_MODE_AUTO);
1513 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
1514 supportedFocusModes = supportedFocusModes + "," +
1515 CameraParameters::FOCUS_MODE_INFINITY;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001516 bool addComma = true;
1517 for (size_t i=0; i < availableAfModes.count; i++) {
1518 if (addComma) supportedFocusModes += ",";
1519 addComma = true;
1520 switch (availableAfModes.data.u8[i]) {
1521 case ANDROID_CONTROL_AF_AUTO:
1522 supportedFocusModes += "auto";
1523 break;
1524 case ANDROID_CONTROL_AF_MACRO:
1525 supportedFocusModes += "macro";
1526 break;
1527 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
1528 supportedFocusModes += "continuous-video";
1529 break;
1530 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
1531 supportedFocusModes += "continuous-picture";
1532 break;
1533 case ANDROID_CONTROL_AF_EDOF:
1534 supportedFocusModes += "edof";
1535 break;
1536 // Not supported in v1 API
1537 case ANDROID_CONTROL_AF_OFF:
1538 addComma = false;
1539 break;
1540 default:
1541 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
1542 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
1543 addComma = false;
1544 break;
1545 }
1546 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001547 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001548 supportedFocusModes);
1549 }
1550
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001551 camera_metadata_entry_t max3aRegions =
1552 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
1553 if (!max3aRegions.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001554
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001555 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001556 max3aRegions.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001557 params.set(CameraParameters::KEY_FOCUS_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001558 "(0,0,0,0,0)");
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001559 mParameters.focusingAreas.clear();
1560 mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001561
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001562 camera_metadata_entry_t availableFocalLengths =
1563 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
1564 if (!availableFocalLengths.count) return NO_INIT;
1565
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001566 float minFocalLength = availableFocalLengths.data.f[0];
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001567 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001568
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001569 camera_metadata_entry_t sensorSize =
1570 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
1571 if (!sensorSize.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001572
1573 // The fields of view here assume infinity focus, maximum wide angle
1574 float horizFov = 180 / M_PI *
1575 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
1576 float vertFov = 180 / M_PI *
1577 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001578 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
1579 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001580
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001581 mParameters.exposureCompensation = 0;
1582 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
1583 mParameters.exposureCompensation);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001584
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001585 camera_metadata_entry_t exposureCompensationRange =
1586 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
1587 if (!exposureCompensationRange.count) return NO_INIT;
1588
1589 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001590 exposureCompensationRange.data.i32[1]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001591 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001592 exposureCompensationRange.data.i32[0]);
1593
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001594 camera_metadata_entry_t exposureCompensationStep =
1595 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
1596 if (!exposureCompensationStep.count) return NO_INIT;
1597
1598 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001599 exposureCompensationStep.data.r[0].numerator /
1600 exposureCompensationStep.data.r[0].denominator);
1601
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001602 mParameters.autoExposureLock = false;
1603 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
1604 CameraParameters::FALSE);
1605 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
1606 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001607
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001608 mParameters.autoWhiteBalanceLock = false;
1609 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
1610 CameraParameters::FALSE);
1611 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
1612 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001613
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001614 mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
1615 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001616 max3aRegions.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001617 params.set(CameraParameters::KEY_METERING_AREAS,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001618 "(0,0,0,0,0)");
1619
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001620 mParameters.zoom = 0;
1621 params.set(CameraParameters::KEY_ZOOM, mParameters.zoom);
1622 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001623
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001624 camera_metadata_entry_t maxDigitalZoom =
1625 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
1626 if (!maxDigitalZoom.count) return NO_INIT;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001627
1628 {
1629 String8 zoomRatios;
1630 float zoom = 1.f;
1631 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001632 (NUM_ZOOM_STEPS-1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001633 bool addComma = false;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001634 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001635 if (addComma) zoomRatios += ",";
1636 addComma = true;
1637 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
1638 zoom += zoomIncrement;
1639 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001640 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001641 }
1642
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001643 params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
1644 CameraParameters::TRUE);
1645 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
1646 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001647
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001648 params.set(CameraParameters::KEY_FOCUS_DISTANCES,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001649 "Infinity,Infinity,Infinity");
1650
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001651 camera_metadata_entry_t maxFacesDetected =
1652 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
1653 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001654 maxFacesDetected.data.i32[0]);
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001655 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001656 0);
1657
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001658 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
1659 formatEnumToString(HAL_PIXEL_FORMAT_YCrCb_420_SP));
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001660
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001661 params.set(CameraParameters::KEY_RECORDING_HINT,
1662 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001663
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001664 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
1665 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001666
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001667 params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
1668 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001669
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001670 camera_metadata_entry_t availableVideoStabilizationModes =
1671 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1672 if (!availableVideoStabilizationModes.count) return NO_INIT;
1673
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001674 if (availableVideoStabilizationModes.count > 1) {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001675 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1676 CameraParameters::TRUE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001677 } else {
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001678 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
1679 CameraParameters::FALSE);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001680 }
1681
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001682 mParamsFlattened = params.flatten();
1683
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001684 return OK;
1685}
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001686
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001687status_t Camera2Client::updatePreviewRequest() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001688 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001689 status_t res;
1690 if (mPreviewRequest == NULL) {
1691 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
1692 &mPreviewRequest);
1693 if (res != OK) {
1694 ALOGE("%s: Camera %d: Unable to create default preview request: "
1695 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
1696 return res;
1697 }
1698 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001699 // TODO: Adjust for params changes
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001700 return OK;
1701}
1702
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001703int Camera2Client::formatStringToEnum(const char *format) {
1704 return
1705 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
1706 HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
1707 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
1708 HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
1709 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
1710 HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
1711 !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
1712 HAL_PIXEL_FORMAT_YV12 : // YV12
1713 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
1714 HAL_PIXEL_FORMAT_RGB_565 : // RGB565
1715 !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
1716 HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
1717 !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
1718 HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
1719 -1;
1720}
1721
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001722const char* Camera2Client::formatEnumToString(int format) {
1723 const char *fmt;
1724 switch(format) {
1725 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1726 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
1727 break;
1728 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1729 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
1730 break;
1731 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1732 fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
1733 break;
1734 case HAL_PIXEL_FORMAT_YV12: // YV12
1735 fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
1736 break;
1737 case HAL_PIXEL_FORMAT_RGB_565: // RGB565
1738 fmt = CameraParameters::PIXEL_FORMAT_RGB565;
1739 break;
1740 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888
1741 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
1742 break;
1743 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1744 ALOGW("Raw sensor preview format requested.");
1745 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
1746 break;
1747 default:
1748 ALOGE("%s: Unknown preview format: %x",
1749 __FUNCTION__, format);
1750 fmt = NULL;
1751 break;
1752 }
1753 return fmt;
1754}
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001755
1756int Camera2Client::wbModeStringToEnum(const char *wbMode) {
1757 return
1758 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
1759 ANDROID_CONTROL_AWB_AUTO :
1760 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
1761 ANDROID_CONTROL_AWB_INCANDESCENT :
1762 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
1763 ANDROID_CONTROL_AWB_FLUORESCENT :
1764 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
1765 ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
1766 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
1767 ANDROID_CONTROL_AWB_DAYLIGHT :
1768 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
1769 ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
1770 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
1771 ANDROID_CONTROL_AWB_TWILIGHT :
1772 !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
1773 ANDROID_CONTROL_AWB_SHADE :
1774 -1;
1775}
1776
1777int Camera2Client::effectModeStringToEnum(const char *effectMode) {
1778 return
1779 !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
1780 ANDROID_CONTROL_EFFECT_OFF :
1781 !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
1782 ANDROID_CONTROL_EFFECT_MONO :
1783 !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
1784 ANDROID_CONTROL_EFFECT_NEGATIVE :
1785 !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
1786 ANDROID_CONTROL_EFFECT_SOLARIZE :
1787 !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
1788 ANDROID_CONTROL_EFFECT_SEPIA :
1789 !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
1790 ANDROID_CONTROL_EFFECT_POSTERIZE :
1791 !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
1792 ANDROID_CONTROL_EFFECT_WHITEBOARD :
1793 !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
1794 ANDROID_CONTROL_EFFECT_BLACKBOARD :
1795 !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
1796 ANDROID_CONTROL_EFFECT_AQUA :
1797 -1;
1798}
1799
1800int Camera2Client::abModeStringToEnum(const char *abMode) {
1801 return
1802 !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
1803 ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
1804 !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
1805 ANDROID_CONTROL_AE_ANTIBANDING_OFF :
1806 !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
1807 ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
1808 !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
1809 ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
1810 -1;
1811}
1812
1813int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
1814 return
1815 !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
1816 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
1817 !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
1818 ANDROID_CONTROL_SCENE_MODE_ACTION :
1819 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
1820 ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
1821 !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
1822 ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
1823 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
1824 ANDROID_CONTROL_SCENE_MODE_NIGHT :
1825 !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
1826 ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
1827 !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
1828 ANDROID_CONTROL_SCENE_MODE_THEATRE :
1829 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
1830 ANDROID_CONTROL_SCENE_MODE_BEACH :
1831 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
1832 ANDROID_CONTROL_SCENE_MODE_SNOW :
1833 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
1834 ANDROID_CONTROL_SCENE_MODE_SUNSET :
1835 !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
1836 ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
1837 !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
1838 ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
1839 !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
1840 ANDROID_CONTROL_SCENE_MODE_SPORTS :
1841 !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
1842 ANDROID_CONTROL_SCENE_MODE_PARTY :
1843 !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
1844 ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
1845 !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
1846 ANDROID_CONTROL_SCENE_MODE_BARCODE:
1847 -1;
1848}
1849
1850Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
1851 const char *flashMode) {
1852 return
1853 !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
1854 Parameters::FLASH_MODE_OFF :
1855 !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
1856 Parameters::FLASH_MODE_AUTO :
1857 !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
1858 Parameters::FLASH_MODE_ON :
1859 !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
1860 Parameters::FLASH_MODE_RED_EYE :
1861 !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
1862 Parameters::FLASH_MODE_TORCH :
1863 Parameters::FLASH_MODE_INVALID;
1864}
1865
1866Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
1867 const char *focusMode) {
1868 return
1869 !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
1870 Parameters::FOCUS_MODE_AUTO :
1871 !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
1872 Parameters::FOCUS_MODE_INFINITY :
1873 !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
1874 Parameters::FOCUS_MODE_MACRO :
1875 !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
1876 Parameters::FOCUS_MODE_FIXED :
1877 !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
1878 Parameters::FOCUS_MODE_EDOF :
1879 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
1880 Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
1881 !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
1882 Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
1883 Parameters::FOCUS_MODE_INVALID;
1884}
1885
1886status_t Camera2Client::parseAreas(const char *areasCStr,
1887 Vector<Parameters::Area> *areas) {
1888 static const size_t NUM_FIELDS = 5;
1889 areas->clear();
1890 if (areasCStr == NULL) {
1891 // If no key exists, use default (0,0,0,0,0)
1892 areas->push();
1893 return OK;
1894 }
1895 String8 areasStr(areasCStr);
1896 ssize_t areaStart = areasStr.find("(", 0) + 1;
1897 while (areaStart != 0) {
1898 const char* area = areasStr.string() + areaStart;
1899 char *numEnd;
1900 int vals[NUM_FIELDS];
1901 for (size_t i = 0; i < NUM_FIELDS; i++) {
1902 errno = 0;
1903 vals[i] = strtol(area, &numEnd, 10);
1904 if (errno || numEnd == area) return BAD_VALUE;
1905 area = numEnd + 1;
1906 }
1907 areas->push(Parameters::Area(
1908 vals[0], vals[1], vals[2], vals[3], vals[4]) );
1909 areaStart = areasStr.find("(", areaStart) + 1;
1910 }
1911 return OK;
1912}
1913
1914status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
1915 size_t maxRegions) {
1916 // Definition of valid area can be found in
1917 // include/camera/CameraParameters.h
1918 if (areas.size() == 0) return BAD_VALUE;
1919 if (areas.size() == 1) {
1920 if (areas[0].left == 0 &&
1921 areas[0].top == 0 &&
1922 areas[0].right == 0 &&
1923 areas[0].bottom == 0 &&
1924 areas[0].weight == 0) {
1925 // Single (0,0,0,0,0) entry is always valid (== driver decides)
1926 return OK;
1927 }
1928 }
1929 if (areas.size() > maxRegions) {
1930 ALOGE("%s: Too many areas requested: %d",
1931 __FUNCTION__, areas.size());
1932 return BAD_VALUE;
1933 }
1934
1935 for (Vector<Parameters::Area>::const_iterator a = areas.begin();
1936 a != areas.end(); a++) {
1937 if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
1938 if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
1939 if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
1940 if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
1941 if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
1942 if (a->left >= a->right) return BAD_VALUE;
1943 if (a->top >= a->bottom) return BAD_VALUE;
1944 }
1945 return OK;
1946}
1947
1948bool Camera2Client::boolFromString(const char *boolStr) {
1949 return !boolStr ? false :
1950 !strcmp(boolStr, CameraParameters::TRUE) ? true :
1951 false;
1952}
1953
1954
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001955} // namespace android