blob: 4fc362973c5723a3cda9d39c2a1bae079f40bd37 [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),
55 mParams(NULL),
56 mPreviewStreamId(NO_PREVIEW_STREAM),
57 mPreviewRequest(NULL)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070058{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070059 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070060
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070061 mDevice = new Camera2Device(cameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070062}
63
64status_t Camera2Client::initialize(camera_module_t *module)
65{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070066 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070067 status_t res;
68
69 res = mDevice->initialize(module);
70 if (res != OK) {
71 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
72 __FUNCTION__, mCameraId, strerror(-res), res);
73 return NO_INIT;
74 }
75
76 res = buildDefaultParameters();
77 if (res != OK) {
78 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
79 __FUNCTION__, mCameraId, strerror(-res), res);
80 return NO_INIT;
81 }
82 if (gLogLevel >= 1) {
83 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
84 mCameraId);
85 mParams->dump();
86 }
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
97 if (mParams) delete mParams;
98
99 disconnect();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700100}
101
102status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700103 String8 result;
104 result.appendFormat("Client2[%d] (%p) PID: %d:\n",
105 mCameraId,
106 getCameraClient()->asBinder().get(),
107 mClientPid);
108 write(fd, result.string(), result.size());
109 return NO_ERROR;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700110}
111
112// ICamera interface
113
114void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700115 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700116 if (mDevice == 0) return;
117
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700118 stopPreview();
119
120 if (mPreviewStreamId != NO_PREVIEW_STREAM) {
121 mDevice->deleteStream(mPreviewStreamId);
122 mPreviewStreamId = NO_PREVIEW_STREAM;
123 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700124
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700125 CameraService::Client::disconnect();
126}
127
128status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700129 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700130 return BAD_VALUE;
131}
132
133status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700134 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700135 return BAD_VALUE;
136}
137
138status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700139 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700140 return BAD_VALUE;
141}
142
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700143status_t Camera2Client::setPreviewDisplay(
144 const sp<Surface>& surface) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700145 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700146 if (mState == PREVIEW) return INVALID_OPERATION;
147
148 sp<IBinder> binder;
149 sp<ANativeWindow> window;
150 if (surface != 0) {
151 binder = surface->asBinder();
152 window = surface;
153 }
154
155 return setPreviewWindow(binder,window);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700156}
157
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700158status_t Camera2Client::setPreviewTexture(
159 const sp<ISurfaceTexture>& surfaceTexture) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700160 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700161 if (mState == PREVIEW) return INVALID_OPERATION;
162
163 sp<IBinder> binder;
164 sp<ANativeWindow> window;
165 if (surfaceTexture != 0) {
166 binder = surfaceTexture->asBinder();
167 window = new SurfaceTextureClient(surfaceTexture);
168 }
169 return setPreviewWindow(binder, window);
170}
171
172status_t Camera2Client::setPreviewWindow(const sp<IBinder>& binder,
173 const sp<ANativeWindow>& window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700174 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700175 status_t res;
176
177 if (binder == mPreviewSurface) {
178 return NO_ERROR;
179 }
180
181 if (mPreviewStreamId != NO_PREVIEW_STREAM) {
182 res = mDevice->deleteStream(mPreviewStreamId);
183 if (res != OK) {
184 return res;
185 }
186 }
187
188 int previewWidth, previewHeight;
189 mParams->getPreviewSize(&previewWidth, &previewHeight);
190
191 res = mDevice->createStream(window,
192 previewWidth, previewHeight, CAMERA2_HAL_PIXEL_FORMAT_OPAQUE,
193 &mPreviewStreamId);
194 if (res != OK) {
195 return res;
196 }
197
198 if (mState == WAITING_FOR_PREVIEW_WINDOW) {
199 return startPreview();
200 }
201
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700202 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700203}
204
205void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700206 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700207}
208
209status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700210 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700211 status_t res;
212 if (mState == PREVIEW) return INVALID_OPERATION;
213
214 if (mPreviewStreamId == NO_PREVIEW_STREAM) {
215 mState = WAITING_FOR_PREVIEW_WINDOW;
216 return OK;
217 }
218
219 if (mPreviewRequest == NULL) {
220 updatePreviewRequest();
221 }
222
223 uint8_t outputStream = mPreviewStreamId;
224
225 camera_metadata_entry_t outputStreams;
226 res = find_camera_metadata_entry(mPreviewRequest,
227 ANDROID_REQUEST_OUTPUT_STREAMS,
228 &outputStreams);
229 if (res == NAME_NOT_FOUND) {
230 res = add_camera_metadata_entry(mPreviewRequest,
231 ANDROID_REQUEST_OUTPUT_STREAMS,
232 &outputStream, 1);
233 } else if (res == OK) {
234 res = update_camera_metadata_entry(mPreviewRequest,
235 outputStreams.index, &outputStream, 1, NULL);
236 }
237
238 if (res != OK) {
239 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
240 __FUNCTION__, mCameraId, strerror(-res), res);
241 mState = STOPPED;
242 return res;
243 }
244
245 res = mDevice->setStreamingRequest(mPreviewRequest);
246 if (res != OK) {
247 ALOGE("%s: Camera %d: Unable to set preview request to start preview: %s (%d)",
248 __FUNCTION__, mCameraId, strerror(-res), res);
249 mState = STOPPED;
250 return res;
251 }
252 mState = PREVIEW;
253
254 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700255}
256
257void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700258 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700259 if (mState != PREVIEW) return;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700260
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700261 mDevice->setStreamingRequest(NULL);
262 mState = STOPPED;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700263}
264
265bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700266 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700267 return mState == PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700268}
269
270status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700271 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700272 return BAD_VALUE;
273}
274
275status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700276 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700277 return BAD_VALUE;
278}
279
280void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700281 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700282}
283
284bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700285 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700286 return BAD_VALUE;
287}
288
289void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700290 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700291}
292
293status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700294 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700295 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700296}
297
298status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700299 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700300 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700301}
302
303status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700304 ATRACE_CALL();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700305 return BAD_VALUE;
306}
307
308status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700309 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700310 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700311}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700312
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700313String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700314 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700315 return mParams->flatten();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700316}
317
318status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700319 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700320 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700321}
322
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700323// private methods
324
325status_t Camera2Client::buildDefaultParameters() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700326 ATRACE_CALL();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700327 status_t res;
328 if (mParams) {
329 delete mParams;
330 }
331 mParams = new CameraParameters;
332
333 camera_metadata_entry_t availableProcessedSizes;
334 res = find_camera_metadata_entry(mDevice->info(),
335 ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
336 &availableProcessedSizes);
337 if (res != OK) return res;
338 if (availableProcessedSizes.count < 2) {
339 ALOGE("%s: Camera %d: "
340 "Malformed %s entry",
341 __FUNCTION__, mCameraId,
342 get_camera_metadata_tag_name(
343 ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES));
344 return NO_INIT;
345 }
346
347 // TODO: Pick more intelligently
348 int previewWidth = availableProcessedSizes.data.i32[0];
349 int previewHeight = availableProcessedSizes.data.i32[1];
350
351 mParams->setPreviewSize(previewWidth, previewHeight);
352 mParams->setVideoSize(previewWidth, previewHeight);
353 mParams->set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
354 String8::format("%dx%d",previewWidth,previewHeight));
355 {
356 String8 supportedPreviewSizes;
357 for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
358 if (i != 0) supportedPreviewSizes += ",";
359 supportedPreviewSizes += String8::format("%dx%d",
360 availableProcessedSizes.data.i32[i],
361 availableProcessedSizes.data.i32[i+1]);
362 }
363 mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
364 supportedPreviewSizes);
365 mParams->set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
366 supportedPreviewSizes);
367 }
368
369 camera_metadata_entry_t availableFpsRanges;
370 res = find_camera_metadata_entry(mDevice->info(),
371 ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
372 &availableFpsRanges);
373 if (res != OK) return res;
374 if (availableFpsRanges.count < 2) {
375 ALOGE("%s: Camera %d: "
376 "Malformed %s entry",
377 __FUNCTION__, mCameraId,
378 get_camera_metadata_tag_name(
379 ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES));
380 return NO_INIT;
381 }
382
383 int previewFpsRangeMin = availableFpsRanges.data.i32[0];
384 int previewFpsRangeMax = availableFpsRanges.data.i32[1];
385
386 mParams->set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
387 String8::format("%d,%d", previewFpsRangeMin, previewFpsRangeMax));
388
389 {
390 String8 supportedPreviewFpsRange;
391 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
392 if (i != 0) supportedPreviewFpsRange += ",";
393 supportedPreviewFpsRange += String8::format("(%d,%d)",
394 availableFpsRanges.data.i32[i],
395 availableFpsRanges.data.i32[i+1]);
396 }
397 mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
398 supportedPreviewFpsRange);
399 }
400
401 mParams->set(CameraParameters::KEY_PREVIEW_FORMAT,
402 "yuv420sp"); // NV21
403
404 camera_metadata_entry_t availableFormats;
405 res = find_camera_metadata_entry(mDevice->info(),
406 ANDROID_SCALER_AVAILABLE_FORMATS,
407 &availableFormats);
408 {
409 String8 supportedPreviewFormats;
410 bool addComma = false;
411 for (size_t i=0; i < availableFormats.count; i++) {
412 if (addComma) supportedPreviewFormats += ",";
413 addComma = true;
414 switch (availableFormats.data.i32[i]) {
415 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
416 supportedPreviewFormats += "yuv422sp";
417 break;
418 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
419 supportedPreviewFormats += "yuv420sp";
420 break;
421 case HAL_PIXEL_FORMAT_YCbCr_422_I:
422 supportedPreviewFormats += "yuv422i-yuyv";
423 break;
424 case HAL_PIXEL_FORMAT_YV12:
425 supportedPreviewFormats += "yuv420p";
426 break;
427 case HAL_PIXEL_FORMAT_RGB_565:
428 supportedPreviewFormats += "rgb565";
429 break;
430 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
431 case HAL_PIXEL_FORMAT_RAW_SENSOR:
432 addComma = false;
433 break;
434 default:
435 ALOGW("%s: Camera %d: Unknown preview format: %x",
436 __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
437 addComma = false;
438 break;
439 }
440 }
441 mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
442 supportedPreviewFormats);
443 }
444
445 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
446 // still have to do something sane for them
447
448 mParams->set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
449 previewFpsRangeMin);
450
451 {
452 String8 supportedPreviewFrameRates;
453 for (size_t i=0; i < availableFpsRanges.count; i += 2) {
454 if (i != 0) supportedPreviewFrameRates += ",";
455 supportedPreviewFrameRates += String8::format("%d",
456 availableFpsRanges.data.i32[i]);
457 }
458 mParams->set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
459 supportedPreviewFrameRates);
460 }
461
462 camera_metadata_entry_t availableJpegSizes;
463 res = find_camera_metadata_entry(mDevice->info(),
464 ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
465 &availableJpegSizes);
466 if (res != OK) return res;
467 if (availableJpegSizes.count < 2) {
468 ALOGE("%s: Camera %d: "
469 "Malformed %s entry",
470 __FUNCTION__, mCameraId,
471 get_camera_metadata_tag_name(
472 ANDROID_SCALER_AVAILABLE_JPEG_SIZES));
473 return NO_INIT;
474 }
475
476 // TODO: Pick maximum
477 int32_t pictureWidth = availableJpegSizes.data.i32[0];
478 int32_t pictureHeight = availableJpegSizes.data.i32[1];
479
480 mParams->setPictureSize(pictureWidth, pictureHeight);
481
482 {
483 String8 supportedPictureSizes;
484 for (size_t i=0; i < availableJpegSizes.count; i += 2) {
485 if (i != 0) supportedPictureSizes += ",";
486 supportedPictureSizes += String8::format("%dx%d",
487 availableJpegSizes.data.i32[i],
488 availableJpegSizes.data.i32[i+1]);
489 }
490 mParams->set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
491 supportedPictureSizes);
492 }
493
494 mParams->setPictureFormat("jpeg");
495
496 mParams->set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
497 "jpeg");
498
499 camera_metadata_entry_t availableJpegThumbnailSizes;
500 res = find_camera_metadata_entry(mDevice->info(),
501 ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
502 &availableJpegThumbnailSizes);
503 if (res != OK) return res;
504 if (availableJpegThumbnailSizes.count < 2) {
505 ALOGE("%s: Camera %d: "
506 "Malformed %s entry",
507 __FUNCTION__, mCameraId,
508 get_camera_metadata_tag_name(
509 ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES));
510 return NO_INIT;
511 }
512
513 // TODO: Pick default thumbnail size sensibly
514 int32_t jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0];
515 int32_t jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1];
516
517 mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
518 jpegThumbWidth);
519 mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
520 jpegThumbHeight);
521
522 {
523 String8 supportedJpegThumbSizes;
524 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
525 if (i != 0) supportedJpegThumbSizes += ",";
526 supportedJpegThumbSizes += String8::format("%dx%d",
527 availableJpegThumbnailSizes.data.i32[i],
528 availableJpegThumbnailSizes.data.i32[i+1]);
529 }
530 mParams->set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
531 supportedJpegThumbSizes);
532 }
533
534 mParams->set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
535 "90");
536 mParams->set(CameraParameters::KEY_JPEG_QUALITY,
537 "90");
538 mParams->set(CameraParameters::KEY_ROTATION,
539 "0");
540 // Not settting GPS fields
541
542 mParams->set(CameraParameters::KEY_WHITE_BALANCE,
543 "auto");
544
545 camera_metadata_entry_t availableWhiteBalanceModes;
546 res = find_camera_metadata_entry(mDevice->info(),
547 ANDROID_CONTROL_AWB_AVAILABLE_MODES,
548 &availableWhiteBalanceModes);
549 {
550 String8 supportedWhiteBalance;
551 bool addComma = false;
552 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
553 if (addComma) supportedWhiteBalance += ",";
554 addComma = true;
555 switch (availableWhiteBalanceModes.data.u8[i]) {
556 case ANDROID_CONTROL_AWB_AUTO:
557 supportedWhiteBalance += "auto";
558 break;
559 case ANDROID_CONTROL_AWB_INCANDESCENT:
560 supportedWhiteBalance += "incandescent";
561 break;
562 case ANDROID_CONTROL_AWB_FLUORESCENT:
563 supportedWhiteBalance += "fluorescent";
564 break;
565 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
566 supportedWhiteBalance += "warm-fluorescent";
567 break;
568 case ANDROID_CONTROL_AWB_DAYLIGHT:
569 supportedWhiteBalance += "daylight";
570 break;
571 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
572 supportedWhiteBalance += "cloudy-daylight";
573 break;
574 case ANDROID_CONTROL_AWB_TWILIGHT:
575 supportedWhiteBalance += "twilight";
576 break;
577 case ANDROID_CONTROL_AWB_SHADE:
578 supportedWhiteBalance += "shade";
579 break;
580 // Skipping values not mappable to v1 API
581 case ANDROID_CONTROL_AWB_OFF:
582 addComma = false;
583 break;
584 default:
585 ALOGW("%s: Camera %d: Unknown white balance value: %d",
586 __FUNCTION__, mCameraId,
587 availableWhiteBalanceModes.data.u8[i]);
588 addComma = false;
589 break;
590 }
591 }
592 mParams->set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
593 supportedWhiteBalance);
594 }
595
596 mParams->set(CameraParameters::KEY_EFFECT, "none");
597 camera_metadata_entry_t availableEffects;
598 res = find_camera_metadata_entry(mDevice->info(),
599 ANDROID_CONTROL_AVAILABLE_EFFECTS,
600 &availableEffects);
601 if (res != OK) return res;
602 {
603 String8 supportedEffects;
604 bool addComma = false;
605 for (size_t i=0; i < availableEffects.count; i++) {
606 if (addComma) supportedEffects += ",";
607 addComma = true;
608 switch (availableEffects.data.u8[i]) {
609 case ANDROID_CONTROL_EFFECT_OFF:
610 supportedEffects += "none";
611 break;
612 case ANDROID_CONTROL_EFFECT_MONO:
613 supportedEffects += "mono";
614 case ANDROID_CONTROL_EFFECT_NEGATIVE:
615 supportedEffects += "negative";
616 break;
617 case ANDROID_CONTROL_EFFECT_SOLARIZE:
618 supportedEffects += "solarize";
619 break;
620 case ANDROID_CONTROL_EFFECT_SEPIA:
621 supportedEffects += "sepia";
622 break;
623 case ANDROID_CONTROL_EFFECT_POSTERIZE:
624 supportedEffects += "posterize";
625 break;
626 case ANDROID_CONTROL_EFFECT_WHITEBOARD:
627 supportedEffects += "whiteboard";
628 break;
629 case ANDROID_CONTROL_EFFECT_BLACKBOARD:
630 supportedEffects += "blackboard";
631 break;
632 case ANDROID_CONTROL_EFFECT_AQUA:
633 supportedEffects += "aqua";
634 break;
635 default:
636 ALOGW("%s: Camera %d: Unknown effect value: %d",
637 __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
638 addComma = false;
639 break;
640 }
641 }
642 mParams->set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
643 }
644
645 mParams->set(CameraParameters::KEY_ANTIBANDING, "auto");
646 camera_metadata_entry_t availableAntibandingModes;
647 res = find_camera_metadata_entry(mDevice->info(),
648 ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
649 &availableAntibandingModes);
650 if (res != OK) return res;
651 {
652 String8 supportedAntibanding;
653 bool addComma = false;
654 for (size_t i=0; i < availableAntibandingModes.count; i++) {
655 if (addComma) supportedAntibanding += ",";
656 addComma = true;
657 switch (availableAntibandingModes.data.u8[i]) {
658 case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
659 supportedAntibanding += "off";
660 break;
661 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
662 supportedAntibanding += "50hz";
663 break;
664 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
665 supportedAntibanding += "60hz";
666 break;
667 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
668 supportedAntibanding += "auto";
669 break;
670 default:
671 ALOGW("%s: Camera %d: Unknown antibanding value: %d",
672 __FUNCTION__, mCameraId,
673 availableAntibandingModes.data.u8[i]);
674 addComma = false;
675 break;
676 }
677 }
678 mParams->set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
679 supportedAntibanding);
680 }
681
682 mParams->set(CameraParameters::KEY_SCENE_MODE, "auto");
683 camera_metadata_entry_t availableSceneModes;
684 res = find_camera_metadata_entry(mDevice->info(),
685 ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
686 &availableSceneModes);
687 if (res != OK) return res;
688 {
689 String8 supportedSceneModes("auto");
690 bool addComma = true;
691 bool noSceneModes = false;
692 for (size_t i=0; i < availableSceneModes.count; i++) {
693 if (addComma) supportedSceneModes += ",";
694 addComma = true;
695 switch (availableSceneModes.data.u8[i]) {
696 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
697 noSceneModes = true;
698 break;
699 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
700 // Not in old API
701 addComma = false;
702 break;
703 case ANDROID_CONTROL_SCENE_MODE_ACTION:
704 supportedSceneModes += "action";
705 break;
706 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
707 supportedSceneModes += "portrait";
708 break;
709 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
710 supportedSceneModes += "landscape";
711 break;
712 case ANDROID_CONTROL_SCENE_MODE_NIGHT:
713 supportedSceneModes += "night";
714 break;
715 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
716 supportedSceneModes += "night-portrait";
717 break;
718 case ANDROID_CONTROL_SCENE_MODE_THEATRE:
719 supportedSceneModes += "theatre";
720 break;
721 case ANDROID_CONTROL_SCENE_MODE_BEACH:
722 supportedSceneModes += "beach";
723 break;
724 case ANDROID_CONTROL_SCENE_MODE_SNOW:
725 supportedSceneModes += "snow";
726 break;
727 case ANDROID_CONTROL_SCENE_MODE_SUNSET:
728 supportedSceneModes += "sunset";
729 break;
730 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
731 supportedSceneModes += "steadyphoto";
732 break;
733 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
734 supportedSceneModes += "fireworks";
735 break;
736 case ANDROID_CONTROL_SCENE_MODE_SPORTS:
737 supportedSceneModes += "sports";
738 break;
739 case ANDROID_CONTROL_SCENE_MODE_PARTY:
740 supportedSceneModes += "party";
741 break;
742 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
743 supportedSceneModes += "candlelight";
744 break;
745 case ANDROID_CONTROL_SCENE_MODE_BARCODE:
746 supportedSceneModes += "barcode";
747 break;
748 default:
749 ALOGW("%s: Camera %d: Unknown scene mode value: %d",
750 __FUNCTION__, mCameraId, availableSceneModes.data.u8[i]);
751 addComma = false;
752 break;
753 }
754 }
755 if (!noSceneModes) {
756 mParams->set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
757 supportedSceneModes);
758 }
759 }
760
761 camera_metadata_entry_t flashAvailable;
762 res = find_camera_metadata_entry(mDevice->info(),
763 ANDROID_FLASH_AVAILABLE, &flashAvailable);
764 if (res != OK) return res;
765
766 camera_metadata_entry_t availableAeModes;
767 res = find_camera_metadata_entry(mDevice->info(),
768 ANDROID_CONTROL_AE_AVAILABLE_MODES,
769 &availableAeModes);
770 if (res != OK) return res;
771
772 if (flashAvailable.data.u8[0]) {
773 mParams->set(CameraParameters::KEY_FLASH_MODE, "auto");
774 String8 supportedFlashModes("off,auto,on,torch");
775 for (size_t i=0; i < availableAeModes.count; i++) {
776 if (availableAeModes.data.u8[i] ==
777 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
778 supportedFlashModes += ",red-eye";
779 break;
780 }
781 }
782 mParams->set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
783 supportedFlashModes);
784 }
785
786 camera_metadata_entry_t minFocusDistance;
787 res = find_camera_metadata_entry(mDevice->info(),
788 ANDROID_LENS_MINIMUM_FOCUS_DISTANCE,
789 &minFocusDistance);
790 if (res != OK) return res;
791 camera_metadata_entry_t availableAfModes;
792 res = find_camera_metadata_entry(mDevice->info(),
793 ANDROID_CONTROL_AF_AVAILABLE_MODES,
794 &availableAfModes);
795 if (res != OK) return res;
796 if (minFocusDistance.data.f[0] == 0) {
797 // Fixed-focus lens
798 mParams->set(CameraParameters::KEY_FOCUS_MODE, "fixed");
799 mParams->set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, "fixed");
800 } else {
801 mParams->set(CameraParameters::KEY_FOCUS_MODE, "auto");
802 String8 supportedFocusModes("fixed,infinity");
803 bool addComma = true;
804 for (size_t i=0; i < availableAfModes.count; i++) {
805 if (addComma) supportedFocusModes += ",";
806 addComma = true;
807 switch (availableAfModes.data.u8[i]) {
808 case ANDROID_CONTROL_AF_AUTO:
809 supportedFocusModes += "auto";
810 break;
811 case ANDROID_CONTROL_AF_MACRO:
812 supportedFocusModes += "macro";
813 break;
814 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
815 supportedFocusModes += "continuous-video";
816 break;
817 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
818 supportedFocusModes += "continuous-picture";
819 break;
820 case ANDROID_CONTROL_AF_EDOF:
821 supportedFocusModes += "edof";
822 break;
823 // Not supported in v1 API
824 case ANDROID_CONTROL_AF_OFF:
825 addComma = false;
826 break;
827 default:
828 ALOGW("%s: Camera %d: Unknown AF mode value: %d",
829 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
830 addComma = false;
831 break;
832 }
833 }
834 mParams->set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
835 supportedFocusModes);
836 }
837
838 camera_metadata_entry_t max3aRegions;
839 res = find_camera_metadata_entry(mDevice->info(),
840 ANDROID_CONTROL_MAX_REGIONS, &max3aRegions);
841 if (res != OK) return res;
842
843 mParams->set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
844 max3aRegions.data.i32[0]);
845 mParams->set(CameraParameters::KEY_FOCUS_AREAS,
846 "(0,0,0,0,0)");
847
848 camera_metadata_entry_t availableFocalLengths;
849 res = find_camera_metadata_entry(mDevice->info(),
850 ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
851 &availableFocalLengths);
852 if (res != OK) return res;
853 float minFocalLength = availableFocalLengths.data.f[0];
854 mParams->setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
855
856 camera_metadata_entry_t sensorSize;
857 res = find_camera_metadata_entry(mDevice->info(),
858 ANDROID_SENSOR_PHYSICAL_SIZE,
859 &sensorSize);
860 if (res != OK) return res;
861
862 // The fields of view here assume infinity focus, maximum wide angle
863 float horizFov = 180 / M_PI *
864 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
865 float vertFov = 180 / M_PI *
866 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
867 mParams->setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
868 mParams->setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
869
870 mParams->set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 0);
871
872 camera_metadata_entry_t exposureCompensationRange;
873 res = find_camera_metadata_entry(mDevice->info(),
874 ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
875 &exposureCompensationRange);
876 if (res != OK) return res;
877 mParams->set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
878 exposureCompensationRange.data.i32[1]);
879 mParams->set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
880 exposureCompensationRange.data.i32[0]);
881
882 camera_metadata_entry_t exposureCompensationStep;
883 res = find_camera_metadata_entry(mDevice->info(),
884 ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
885 &exposureCompensationStep);
886 if (res != OK) return res;
887 mParams->setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
888 exposureCompensationStep.data.r[0].numerator /
889 exposureCompensationStep.data.r[0].denominator);
890
891 mParams->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
892 mParams->set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
893
894 mParams->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
895 mParams->set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
896
897 mParams->set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
898 max3aRegions.data.i32[0]);
899 mParams->set(CameraParameters::KEY_METERING_AREAS,
900 "(0,0,0,0,0)");
901
902 mParams->set(CameraParameters::KEY_ZOOM, 0);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700903 mParams->set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700904
905 camera_metadata_entry_t maxDigitalZoom;
906 res = find_camera_metadata_entry(mDevice->info(),
907 ANDROID_SCALER_AVAILABLE_MAX_ZOOM, &maxDigitalZoom);
908 if (res != OK) return res;
909
910 {
911 String8 zoomRatios;
912 float zoom = 1.f;
913 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700914 (NUM_ZOOM_STEPS-1);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700915 bool addComma = false;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700916 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700917 if (addComma) zoomRatios += ",";
918 addComma = true;
919 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
920 zoom += zoomIncrement;
921 }
922 mParams->set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
923 }
924
925 mParams->set(CameraParameters::KEY_ZOOM_SUPPORTED, "true");
926 mParams->set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true");
927
928 mParams->set(CameraParameters::KEY_FOCUS_DISTANCES,
929 "Infinity,Infinity,Infinity");
930
931 camera_metadata_entry_t maxFacesDetected;
932 res = find_camera_metadata_entry(mDevice->info(),
933 ANDROID_STATS_MAX_FACE_COUNT,
934 &maxFacesDetected);
935 mParams->set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
936 maxFacesDetected.data.i32[0]);
937 mParams->set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
938 0);
939
940 mParams->set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
941 "yuv420sp");
942
943 mParams->set(CameraParameters::KEY_RECORDING_HINT,
944 "false");
945
946 mParams->set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
947 "true");
948
949 mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION,
950 "false");
951
952 camera_metadata_entry_t availableVideoStabilizationModes;
953 res = find_camera_metadata_entry(mDevice->info(),
954 ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
955 &availableVideoStabilizationModes);
956 if (res != OK) return res;
957 if (availableVideoStabilizationModes.count > 1) {
958 mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
959 "true");
960 } else {
961 mParams->set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
962 "false");
963 }
964
965 return OK;
966}
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700967
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700968status_t Camera2Client::updatePreviewRequest() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700969 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700970 status_t res;
971 if (mPreviewRequest == NULL) {
972 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
973 &mPreviewRequest);
974 if (res != OK) {
975 ALOGE("%s: Camera %d: Unable to create default preview request: "
976 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
977 return res;
978 }
979 }
980 // TODO: Adjust for mParams changes
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700981 return OK;
982}
983
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700984} // namespace android