Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 1 | /* |
| 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 Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 18 | #define ATRACE_TAG ATRACE_TAG_CAMERA |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 19 | //#define LOG_NDEBUG 0 |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 20 | |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 21 | #include <utils/Log.h> |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 22 | #include <utils/Trace.h> |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 23 | |
| 24 | #include <cutils/properties.h> |
| 25 | #include <gui/SurfaceTextureClient.h> |
| 26 | #include <gui/Surface.h> |
| 27 | |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 28 | #include <math.h> |
| 29 | |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 30 | #include "Camera2Client.h" |
| 31 | |
| 32 | namespace android { |
| 33 | |
| 34 | #define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); |
| 35 | #define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); |
| 36 | |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 37 | static int getCallingPid() { |
| 38 | return IPCThreadState::self()->getCallingPid(); |
| 39 | } |
| 40 | |
| 41 | static int getCallingUid() { |
| 42 | return IPCThreadState::self()->getCallingUid(); |
| 43 | } |
| 44 | |
| 45 | // Interface used by CameraService |
| 46 | |
| 47 | Camera2Client::Camera2Client(const sp<CameraService>& cameraService, |
| 48 | const sp<ICameraClient>& cameraClient, |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 49 | int cameraId, |
| 50 | int cameraFacing, |
| 51 | int clientPid): |
| 52 | Client(cameraService, cameraClient, |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 53 | cameraId, cameraFacing, clientPid), |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 54 | mState(NOT_INITIALIZED), |
| 55 | mParams(NULL), |
| 56 | mPreviewStreamId(NO_PREVIEW_STREAM), |
| 57 | mPreviewRequest(NULL) |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 58 | { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 59 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 60 | |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 61 | mDevice = new Camera2Device(cameraId); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | status_t Camera2Client::initialize(camera_module_t *module) |
| 65 | { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 66 | ATRACE_CALL(); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 67 | 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 Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 88 | mState = STOPPED; |
| 89 | |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 90 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | Camera2Client::~Camera2Client() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 94 | ATRACE_CALL(); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 95 | mDestructionStarted = true; |
| 96 | |
| 97 | if (mParams) delete mParams; |
| 98 | |
| 99 | disconnect(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | status_t Camera2Client::dump(int fd, const Vector<String16>& args) { |
Eino-Ville Talvala | 611f619 | 2012-05-31 12:28:23 -0700 | [diff] [blame] | 103 | 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 Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | // ICamera interface |
| 113 | |
| 114 | void Camera2Client::disconnect() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 115 | ATRACE_CALL(); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 116 | if (mDevice == 0) return; |
| 117 | |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 118 | stopPreview(); |
| 119 | |
| 120 | if (mPreviewStreamId != NO_PREVIEW_STREAM) { |
| 121 | mDevice->deleteStream(mPreviewStreamId); |
| 122 | mPreviewStreamId = NO_PREVIEW_STREAM; |
| 123 | } |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 124 | |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 125 | CameraService::Client::disconnect(); |
| 126 | } |
| 127 | |
| 128 | status_t Camera2Client::connect(const sp<ICameraClient>& client) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 129 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 130 | return BAD_VALUE; |
| 131 | } |
| 132 | |
| 133 | status_t Camera2Client::lock() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 134 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 135 | return BAD_VALUE; |
| 136 | } |
| 137 | |
| 138 | status_t Camera2Client::unlock() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 139 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 140 | return BAD_VALUE; |
| 141 | } |
| 142 | |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 143 | status_t Camera2Client::setPreviewDisplay( |
| 144 | const sp<Surface>& surface) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 145 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 146 | 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 Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 156 | } |
| 157 | |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 158 | status_t Camera2Client::setPreviewTexture( |
| 159 | const sp<ISurfaceTexture>& surfaceTexture) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 160 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 161 | 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 | |
| 172 | status_t Camera2Client::setPreviewWindow(const sp<IBinder>& binder, |
| 173 | const sp<ANativeWindow>& window) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 174 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 175 | 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 Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 202 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | void Camera2Client::setPreviewCallbackFlag(int flag) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 206 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | status_t Camera2Client::startPreview() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 210 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 211 | 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 Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | void Camera2Client::stopPreview() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 258 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 259 | if (mState != PREVIEW) return; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 260 | |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 261 | mDevice->setStreamingRequest(NULL); |
| 262 | mState = STOPPED; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | bool Camera2Client::previewEnabled() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 266 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 267 | return mState == PREVIEW; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 268 | } |
| 269 | |
| 270 | status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 271 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 272 | return BAD_VALUE; |
| 273 | } |
| 274 | |
| 275 | status_t Camera2Client::startRecording() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 276 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 277 | return BAD_VALUE; |
| 278 | } |
| 279 | |
| 280 | void Camera2Client::stopRecording() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 281 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | bool Camera2Client::recordingEnabled() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 285 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 286 | return BAD_VALUE; |
| 287 | } |
| 288 | |
| 289 | void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 290 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | status_t Camera2Client::autoFocus() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 294 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 295 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 296 | } |
| 297 | |
| 298 | status_t Camera2Client::cancelAutoFocus() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 299 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 300 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | status_t Camera2Client::takePicture(int msgType) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 304 | ATRACE_CALL(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 305 | return BAD_VALUE; |
| 306 | } |
| 307 | |
| 308 | status_t Camera2Client::setParameters(const String8& params) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 309 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 310 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 311 | } |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 312 | |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 313 | String8 Camera2Client::getParameters() const { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 314 | ATRACE_CALL(); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 315 | return mParams->flatten(); |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 319 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 320 | return OK; |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 321 | } |
| 322 | |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 323 | // private methods |
| 324 | |
| 325 | status_t Camera2Client::buildDefaultParameters() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 326 | ATRACE_CALL(); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 327 | 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 Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 903 | mParams->set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 904 | |
| 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 Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 914 | (NUM_ZOOM_STEPS-1); |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 915 | bool addComma = false; |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 916 | for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { |
Eino-Ville Talvala | f69c70d | 2012-05-20 15:59:14 -0700 | [diff] [blame] | 917 | 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 Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 967 | |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 968 | status_t Camera2Client::updatePreviewRequest() { |
Eino-Ville Talvala | a189097 | 2012-05-31 11:18:52 -0700 | [diff] [blame] | 969 | ATRACE_CALL(); |
Eino-Ville Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 970 | 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 Talvala | 6db981c | 2012-05-21 18:54:30 -0700 | [diff] [blame] | 981 | return OK; |
| 982 | } |
| 983 | |
Eino-Ville Talvala | 61ab9f9 | 2012-05-17 10:30:54 -0700 | [diff] [blame] | 984 | } // namespace android |