Camera2Client.cpp revision ac45eb3dfa7347f7b8c98be1111b2a5f9e344c46
189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project/* 289fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * Copyright (C) 2012 The Android Open Source Project 389fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * 489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * you may not use this file except in compliance with the License. 689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * You may obtain a copy of the License at 789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * 889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 989fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * 1089fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 1189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 1289fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 1389fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * See the License for the specific language governing permissions and 1489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project * limitations under the License. 1589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project */ 1689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 1789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#define LOG_TAG "Camera2Client" 1889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#define ATRACE_TAG ATRACE_TAG_CAMERA 1989fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project//#define LOG_NDEBUG 0 2089fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 2189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <utils/Log.h> 2289fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <utils/Trace.h> 2389fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 2489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <cutils/properties.h> 2589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <gui/SurfaceTextureClient.h> 2689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <gui/Surface.h> 2789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 2889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include <math.h> 2989fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 3089fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#include "Camera2Client.h" 3189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 3289fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Projectnamespace android { 331703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent 3489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 35d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 36d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent 37d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurentstatic int getCallingPid() { 38d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent return IPCThreadState::self()->getCallingPid(); 39d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent} 40d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent 41d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurentstatic int getCallingUid() { 42d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent return IPCThreadState::self()->getCallingUid(); 43d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent} 44d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent 4544d9848d6656777a18019223e0d35f2fcc67719aEric Laurent// Interface used by CameraService 4644d9848d6656777a18019223e0d35f2fcc67719aEric Laurent 4744d9848d6656777a18019223e0d35f2fcc67719aEric LaurentCamera2Client::Camera2Client(const sp<CameraService>& cameraService, 4844d9848d6656777a18019223e0d35f2fcc67719aEric Laurent const sp<ICameraClient>& cameraClient, 4944d9848d6656777a18019223e0d35f2fcc67719aEric Laurent int cameraId, 501703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent int cameraFacing, 511703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent int clientPid): 521703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent Client(cameraService, cameraClient, 531703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent cameraId, cameraFacing, clientPid), 541703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent mState(NOT_INITIALIZED), 551703cdfee717b1b312bf8979816a9e2f16a82e5dEric Laurent mPreviewStreamId(NO_PREVIEW_STREAM), 5689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project mPreviewRequest(NULL) 5789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project{ 5889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project ATRACE_CALL(); 5989fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 6089fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project mDevice = new Camera2Device(cameraId); 6189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project} 62362c4e697d8e9c034e964ac7b40227e054491547Glenn Kasten 63362c4e697d8e9c034e964ac7b40227e054491547Glenn Kastenstatus_t Camera2Client::initialize(camera_module_t *module) 6489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project{ 6589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project ATRACE_CALL(); 6689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project status_t res; 6789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 68d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent res = mDevice->initialize(module); 69d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent if (res != OK) { 70d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 71d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent __FUNCTION__, mCameraId, strerror(-res), res); 72d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent return NO_INIT; 73d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent } 7489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 7589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project res = buildDefaultParameters(); 7689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project if (res != OK) { 7789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 78573266210fb2b2e7d86fbd46d0dfe16763611d91Eric Laurent __FUNCTION__, mCameraId, strerror(-res), res); 79c2f1f07084818942352c6bbfb36af9b6b330eb4eEric Laurent return NO_INIT; 80c2f1f07084818942352c6bbfb36af9b6b330eb4eEric Laurent } 81c2f1f07084818942352c6bbfb36af9b6b330eb4eEric Laurent 82d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent if (gLogLevel >= 1) { 83b9980659501d0428d65d8292f3c32da69d37fbd2Glenn Kasten ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 840d255b2d9061ba31f13ada3fc0f7e51916407176Jean-Michel Trivi mCameraId); 8589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project ALOGD("%s", mParamsFlattened.string()); 86c2f1f07084818942352c6bbfb36af9b6b330eb4eEric Laurent } 8738ccae2c0324daa305f3fe77d25fdf5edec0b0e1Eric Laurent 88be916aa1267e2e6b1c148f51d11bcbbc79cb864cEric Laurent mState = STOPPED; 8938ccae2c0324daa305f3fe77d25fdf5edec0b0e1Eric Laurent 9038ccae2c0324daa305f3fe77d25fdf5edec0b0e1Eric Laurent return OK; 91d1b449aad6c087a69f5ec66b7facb2845b73f1cbEric Laurent} 920d255b2d9061ba31f13ada3fc0f7e51916407176Jean-Michel Trivi 9389fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source ProjectCamera2Client::~Camera2Client() { 9489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project ATRACE_CALL(); 9589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project mDestructionStarted = true; 9689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 9789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project disconnect(); 9889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project 9989fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project} 10038ccae2c0324daa305f3fe77d25fdf5edec0b0e1Eric Laurent 10189fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Projectstatus_t Camera2Client::dump(int fd, const Vector<String16>& args) { 10289fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project String8 result; 10389fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project result.appendFormat("Client2[%d] (%p) PID: %d:\n", 10489fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project mCameraId, 10589fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project getCameraClient()->asBinder().get(), 10689fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project mClientPid); 10789fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project result.append(" State: "); 10889fa4ad53f2f4d57adbc97ae1149fc00c9b6f3c5The Android Open Source Project#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 265 write(fd, result.string(), result.size()); 266 267 // TODO: Dump Camera2Device 268 269#undef CASE_APPEND_ENUM 270 return NO_ERROR; 271} 272 273// ICamera interface 274 275void Camera2Client::disconnect() { 276 ATRACE_CALL(); 277 Mutex::Autolock icl(mICameraLock); 278 279 if (mDevice == 0) return; 280 281 stopPreviewLocked(); 282 283 if (mPreviewStreamId != NO_PREVIEW_STREAM) { 284 mDevice->deleteStream(mPreviewStreamId); 285 mPreviewStreamId = NO_PREVIEW_STREAM; 286 } 287 288 CameraService::Client::disconnect(); 289} 290 291status_t Camera2Client::connect(const sp<ICameraClient>& client) { 292 ATRACE_CALL(); 293 Mutex::Autolock icl(mICameraLock); 294 295 return BAD_VALUE; 296} 297 298status_t Camera2Client::lock() { 299 ATRACE_CALL(); 300 Mutex::Autolock icl(mICameraLock); 301 302 return BAD_VALUE; 303} 304 305status_t Camera2Client::unlock() { 306 ATRACE_CALL(); 307 Mutex::Autolock icl(mICameraLock); 308 309 return BAD_VALUE; 310} 311 312status_t Camera2Client::setPreviewDisplay( 313 const sp<Surface>& surface) { 314 ATRACE_CALL(); 315 Mutex::Autolock icl(mICameraLock); 316 317 if (mState >= PREVIEW) return INVALID_OPERATION; 318 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); 327} 328 329status_t Camera2Client::setPreviewTexture( 330 const sp<ISurfaceTexture>& surfaceTexture) { 331 ATRACE_CALL(); 332 Mutex::Autolock icl(mICameraLock); 333 334 if (mState >= PREVIEW) return INVALID_OPERATION; 335 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) { 347 ATRACE_CALL(); 348 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 } 360 res = mDevice->createStream(window, 361 mParameters.previewWidth, mParameters.previewHeight, 362 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 363 &mPreviewStreamId); 364 if (res != OK) { 365 return res; 366 } 367 368 if (mState == WAITING_FOR_PREVIEW_WINDOW) { 369 return startPreview(); 370 } 371 372 return OK; 373} 374 375void Camera2Client::setPreviewCallbackFlag(int flag) { 376 ATRACE_CALL(); 377 Mutex::Autolock icl(mICameraLock); 378} 379 380status_t Camera2Client::startPreview() { 381 ATRACE_CALL(); 382 Mutex::Autolock icl(mICameraLock); 383 384 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; 428} 429 430void Camera2Client::stopPreview() { 431 ATRACE_CALL(); 432 Mutex::Autolock icl(mICameraLock); 433 stopPreviewLocked(); 434} 435 436void Camera2Client::stopPreviewLocked() { 437 ATRACE_CALL(); 438 if (mState != PREVIEW) return; 439 440 mDevice->setStreamingRequest(NULL); 441 mState = STOPPED; 442} 443 444bool Camera2Client::previewEnabled() { 445 ATRACE_CALL(); 446 Mutex::Autolock icl(mICameraLock); 447 return mState == PREVIEW; 448} 449 450status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 451 ATRACE_CALL(); 452 Mutex::Autolock icl(mICameraLock); 453 return BAD_VALUE; 454} 455 456status_t Camera2Client::startRecording() { 457 ATRACE_CALL(); 458 Mutex::Autolock icl(mICameraLock); 459 return BAD_VALUE; 460} 461 462void Camera2Client::stopRecording() { 463 ATRACE_CALL(); 464 Mutex::Autolock icl(mICameraLock); 465} 466 467bool Camera2Client::recordingEnabled() { 468 ATRACE_CALL(); 469 Mutex::Autolock icl(mICameraLock); 470 return BAD_VALUE; 471} 472 473void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 474 ATRACE_CALL(); 475 Mutex::Autolock icl(mICameraLock); 476} 477 478status_t Camera2Client::autoFocus() { 479 ATRACE_CALL(); 480 Mutex::Autolock icl(mICameraLock); 481 return OK; 482} 483 484status_t Camera2Client::cancelAutoFocus() { 485 ATRACE_CALL(); 486 Mutex::Autolock icl(mICameraLock); 487 return OK; 488} 489 490status_t Camera2Client::takePicture(int msgType) { 491 ATRACE_CALL(); 492 Mutex::Autolock icl(mICameraLock); 493 return BAD_VALUE; 494} 495 496status_t Camera2Client::setParameters(const String8& params) { 497 ATRACE_CALL(); 498 Mutex::Autolock icl(mICameraLock); 499 return OK; 500} 501 502String8 Camera2Client::getParameters() const { 503 ATRACE_CALL(); 504 Mutex::Autolock icl(mICameraLock); 505 506 Mutex::Autolock pl(mParamsLock); 507 508 // TODO: Deal with focus distances 509 return mParamsFlattened; 510} 511 512status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 513 ATRACE_CALL(); 514 Mutex::Autolock icl(mICameraLock); 515 return OK; 516} 517 518/** Device-related methods */ 519 520camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag, 521 size_t minCount, size_t maxCount) { 522 status_t res; 523 camera_metadata_entry_t entry; 524 res = find_camera_metadata_entry(mDevice->info(), 525 tag, 526 &entry); 527 if (CC_UNLIKELY( res != OK )) { 528 const char* tagSection = get_camera_metadata_section_name(tag); 529 if (tagSection == NULL) tagSection = "<unknown>"; 530 const char* tagName = get_camera_metadata_tag_name(tag); 531 if (tagName == NULL) tagName = "<unknown>"; 532 533 ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)", 534 tagSection, tagName, tag, strerror(-res), res); 535 entry.count = 0; 536 entry.data.u8 = NULL; 537 } else if (CC_UNLIKELY( 538 (minCount != 0 && entry.count < minCount) || 539 (maxCount != 0 && entry.count > maxCount) ) ) { 540 const char* tagSection = get_camera_metadata_section_name(tag); 541 if (tagSection == NULL) tagSection = "<unknown>"; 542 const char* tagName = get_camera_metadata_tag_name(tag); 543 if (tagName == NULL) tagName = "<unknown>"; 544 ALOGE("Malformed static metadata entry '%s.%s' (%x):" 545 "Expected between %d and %d values, but got %d values", 546 tagSection, tagName, tag, minCount, maxCount, entry.count); 547 entry.count = 0; 548 entry.data.u8 = NULL; 549 } 550 551 return entry; 552} 553 554/** Utility methods */ 555 556 557status_t Camera2Client::buildDefaultParameters() { 558 ATRACE_CALL(); 559 Mutex::Autolock pl(mParamsLock); 560 561 status_t res; 562 CameraParameters params; 563 564 camera_metadata_entry_t availableProcessedSizes = 565 staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2); 566 if (!availableProcessedSizes.count) return NO_INIT; 567 568 // TODO: Pick more intelligently 569 mParameters.previewWidth = availableProcessedSizes.data.i32[0]; 570 mParameters.previewHeight = availableProcessedSizes.data.i32[1]; 571 mParameters.videoWidth = mParameters.previewWidth; 572 mParameters.videoHeight = mParameters.previewHeight; 573 574 params.setPreviewSize(mParameters.previewWidth, mParameters.previewHeight); 575 params.setVideoSize(mParameters.videoWidth, mParameters.videoHeight); 576 params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, 577 String8::format("%dx%d", 578 mParameters.previewWidth, mParameters.previewHeight)); 579 { 580 String8 supportedPreviewSizes; 581 for (size_t i=0; i < availableProcessedSizes.count; i += 2) { 582 if (i != 0) supportedPreviewSizes += ","; 583 supportedPreviewSizes += String8::format("%dx%d", 584 availableProcessedSizes.data.i32[i], 585 availableProcessedSizes.data.i32[i+1]); 586 } 587 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 588 supportedPreviewSizes); 589 params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, 590 supportedPreviewSizes); 591 } 592 593 camera_metadata_entry_t availableFpsRanges = 594 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2); 595 if (!availableFpsRanges.count) return NO_INIT; 596 597 mParameters.previewFpsRangeMin = availableFpsRanges.data.i32[0]; 598 mParameters.previewFpsRangeMax = availableFpsRanges.data.i32[1]; 599 600 params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 601 String8::format("%d,%d", 602 mParameters.previewFpsRangeMin, 603 mParameters.previewFpsRangeMax)); 604 605 { 606 String8 supportedPreviewFpsRange; 607 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 608 if (i != 0) supportedPreviewFpsRange += ","; 609 supportedPreviewFpsRange += String8::format("(%d,%d)", 610 availableFpsRanges.data.i32[i], 611 availableFpsRanges.data.i32[i+1]); 612 } 613 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, 614 supportedPreviewFpsRange); 615 } 616 617 mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 618 params.set(CameraParameters::KEY_PREVIEW_FORMAT, 619 formatEnumToString(mParameters.previewFormat)); // NV21 620 621 camera_metadata_entry_t availableFormats = 622 staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS); 623 624 { 625 String8 supportedPreviewFormats; 626 bool addComma = false; 627 for (size_t i=0; i < availableFormats.count; i++) { 628 if (addComma) supportedPreviewFormats += ","; 629 addComma = true; 630 switch (availableFormats.data.i32[i]) { 631 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 632 supportedPreviewFormats += "yuv422sp"; 633 break; 634 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 635 supportedPreviewFormats += "yuv420sp"; 636 break; 637 case HAL_PIXEL_FORMAT_YCbCr_422_I: 638 supportedPreviewFormats += "yuv422i-yuyv"; 639 break; 640 case HAL_PIXEL_FORMAT_YV12: 641 supportedPreviewFormats += "yuv420p"; 642 break; 643 case HAL_PIXEL_FORMAT_RGB_565: 644 supportedPreviewFormats += "rgb565"; 645 break; 646 // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats 647 case HAL_PIXEL_FORMAT_RAW_SENSOR: 648 addComma = false; 649 break; 650 default: 651 ALOGW("%s: Camera %d: Unknown preview format: %x", 652 __FUNCTION__, mCameraId, availableFormats.data.i32[i]); 653 addComma = false; 654 break; 655 } 656 } 657 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 658 supportedPreviewFormats); 659 } 660 661 // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but 662 // still have to do something sane for them 663 664 params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE, 665 mParameters.previewFpsRangeMin); 666 667 { 668 String8 supportedPreviewFrameRates; 669 for (size_t i=0; i < availableFpsRanges.count; i += 2) { 670 if (i != 0) supportedPreviewFrameRates += ","; 671 supportedPreviewFrameRates += String8::format("%d", 672 availableFpsRanges.data.i32[i]); 673 } 674 params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, 675 supportedPreviewFrameRates); 676 } 677 678 camera_metadata_entry_t availableJpegSizes = 679 staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2); 680 if (!availableJpegSizes.count) return NO_INIT; 681 682 // TODO: Pick maximum 683 mParameters.pictureWidth = availableJpegSizes.data.i32[0]; 684 mParameters.pictureHeight = availableJpegSizes.data.i32[1]; 685 686 params.setPictureSize(mParameters.pictureWidth, 687 mParameters.pictureHeight); 688 689 { 690 String8 supportedPictureSizes; 691 for (size_t i=0; i < availableJpegSizes.count; i += 2) { 692 if (i != 0) supportedPictureSizes += ","; 693 supportedPictureSizes += String8::format("%dx%d", 694 availableJpegSizes.data.i32[i], 695 availableJpegSizes.data.i32[i+1]); 696 } 697 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 698 supportedPictureSizes); 699 } 700 701 params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 702 params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 703 CameraParameters::PIXEL_FORMAT_JPEG); 704 705 camera_metadata_entry_t availableJpegThumbnailSizes = 706 staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2); 707 if (!availableJpegThumbnailSizes.count) return NO_INIT; 708 709 // TODO: Pick default thumbnail size sensibly 710 mParameters.jpegThumbWidth = availableJpegThumbnailSizes.data.i32[0]; 711 mParameters.jpegThumbHeight = availableJpegThumbnailSizes.data.i32[1]; 712 713 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, 714 mParameters.jpegThumbWidth); 715 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, 716 mParameters.jpegThumbHeight); 717 718 { 719 String8 supportedJpegThumbSizes; 720 for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) { 721 if (i != 0) supportedJpegThumbSizes += ","; 722 supportedJpegThumbSizes += String8::format("%dx%d", 723 availableJpegThumbnailSizes.data.i32[i], 724 availableJpegThumbnailSizes.data.i32[i+1]); 725 } 726 params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 727 supportedJpegThumbSizes); 728 } 729 730 mParameters.jpegThumbQuality = 90; 731 params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, 732 mParameters.jpegThumbQuality); 733 mParameters.jpegQuality = 90; 734 params.set(CameraParameters::KEY_JPEG_QUALITY, 735 mParameters.jpegQuality); 736 mParameters.jpegRotation = 0; 737 params.set(CameraParameters::KEY_ROTATION, 738 mParameters.jpegRotation); 739 740 mParameters.gpsEnabled = false; 741 mParameters.gpsProcessingMethod = "unknown"; 742 // GPS fields in CameraParameters are not set by implementation 743 744 mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO; 745 params.set(CameraParameters::KEY_WHITE_BALANCE, 746 CameraParameters::WHITE_BALANCE_AUTO); 747 748 camera_metadata_entry_t availableWhiteBalanceModes = 749 staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES); 750 { 751 String8 supportedWhiteBalance; 752 bool addComma = false; 753 for (size_t i=0; i < availableWhiteBalanceModes.count; i++) { 754 if (addComma) supportedWhiteBalance += ","; 755 addComma = true; 756 switch (availableWhiteBalanceModes.data.u8[i]) { 757 case ANDROID_CONTROL_AWB_AUTO: 758 supportedWhiteBalance += "auto"; 759 break; 760 case ANDROID_CONTROL_AWB_INCANDESCENT: 761 supportedWhiteBalance += "incandescent"; 762 break; 763 case ANDROID_CONTROL_AWB_FLUORESCENT: 764 supportedWhiteBalance += "fluorescent"; 765 break; 766 case ANDROID_CONTROL_AWB_WARM_FLUORESCENT: 767 supportedWhiteBalance += "warm-fluorescent"; 768 break; 769 case ANDROID_CONTROL_AWB_DAYLIGHT: 770 supportedWhiteBalance += "daylight"; 771 break; 772 case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT: 773 supportedWhiteBalance += "cloudy-daylight"; 774 break; 775 case ANDROID_CONTROL_AWB_TWILIGHT: 776 supportedWhiteBalance += "twilight"; 777 break; 778 case ANDROID_CONTROL_AWB_SHADE: 779 supportedWhiteBalance += "shade"; 780 break; 781 // Skipping values not mappable to v1 API 782 case ANDROID_CONTROL_AWB_OFF: 783 addComma = false; 784 break; 785 default: 786 ALOGW("%s: Camera %d: Unknown white balance value: %d", 787 __FUNCTION__, mCameraId, 788 availableWhiteBalanceModes.data.u8[i]); 789 addComma = false; 790 break; 791 } 792 } 793 params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 794 supportedWhiteBalance); 795 } 796 797 mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF; 798 params.set(CameraParameters::KEY_EFFECT, 799 CameraParameters::EFFECT_NONE); 800 801 camera_metadata_entry_t availableEffects = 802 staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS); 803 if (!availableEffects.count) return NO_INIT; 804 { 805 String8 supportedEffects; 806 bool addComma = false; 807 for (size_t i=0; i < availableEffects.count; i++) { 808 if (addComma) supportedEffects += ","; 809 addComma = true; 810 switch (availableEffects.data.u8[i]) { 811 case ANDROID_CONTROL_EFFECT_OFF: 812 supportedEffects += "none"; 813 break; 814 case ANDROID_CONTROL_EFFECT_MONO: 815 supportedEffects += "mono"; 816 case ANDROID_CONTROL_EFFECT_NEGATIVE: 817 supportedEffects += "negative"; 818 break; 819 case ANDROID_CONTROL_EFFECT_SOLARIZE: 820 supportedEffects += "solarize"; 821 break; 822 case ANDROID_CONTROL_EFFECT_SEPIA: 823 supportedEffects += "sepia"; 824 break; 825 case ANDROID_CONTROL_EFFECT_POSTERIZE: 826 supportedEffects += "posterize"; 827 break; 828 case ANDROID_CONTROL_EFFECT_WHITEBOARD: 829 supportedEffects += "whiteboard"; 830 break; 831 case ANDROID_CONTROL_EFFECT_BLACKBOARD: 832 supportedEffects += "blackboard"; 833 break; 834 case ANDROID_CONTROL_EFFECT_AQUA: 835 supportedEffects += "aqua"; 836 break; 837 default: 838 ALOGW("%s: Camera %d: Unknown effect value: %d", 839 __FUNCTION__, mCameraId, availableEffects.data.u8[i]); 840 addComma = false; 841 break; 842 } 843 } 844 params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects); 845 } 846 847 mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 848 params.set(CameraParameters::KEY_ANTIBANDING, 849 CameraParameters::ANTIBANDING_AUTO); 850 851 camera_metadata_entry_t availableAntibandingModes = 852 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES); 853 if (!availableAntibandingModes.count) return NO_INIT; 854 { 855 String8 supportedAntibanding; 856 bool addComma = false; 857 for (size_t i=0; i < availableAntibandingModes.count; i++) { 858 if (addComma) supportedAntibanding += ","; 859 addComma = true; 860 switch (availableAntibandingModes.data.u8[i]) { 861 case ANDROID_CONTROL_AE_ANTIBANDING_OFF: 862 supportedAntibanding += "off"; 863 break; 864 case ANDROID_CONTROL_AE_ANTIBANDING_50HZ: 865 supportedAntibanding += "50hz"; 866 break; 867 case ANDROID_CONTROL_AE_ANTIBANDING_60HZ: 868 supportedAntibanding += "60hz"; 869 break; 870 case ANDROID_CONTROL_AE_ANTIBANDING_AUTO: 871 supportedAntibanding += "auto"; 872 break; 873 default: 874 ALOGW("%s: Camera %d: Unknown antibanding value: %d", 875 __FUNCTION__, mCameraId, 876 availableAntibandingModes.data.u8[i]); 877 addComma = false; 878 break; 879 } 880 } 881 params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, 882 supportedAntibanding); 883 } 884 885 mParameters.sceneMode = ANDROID_CONTROL_OFF; 886 params.set(CameraParameters::KEY_SCENE_MODE, 887 CameraParameters::SCENE_MODE_AUTO); 888 889 camera_metadata_entry_t availableSceneModes = 890 staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES); 891 if (!availableSceneModes.count) return NO_INIT; 892 { 893 String8 supportedSceneModes("auto"); 894 bool addComma = true; 895 bool noSceneModes = false; 896 for (size_t i=0; i < availableSceneModes.count; i++) { 897 if (addComma) supportedSceneModes += ","; 898 addComma = true; 899 switch (availableSceneModes.data.u8[i]) { 900 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 901 noSceneModes = true; 902 break; 903 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 904 // Not in old API 905 addComma = false; 906 break; 907 case ANDROID_CONTROL_SCENE_MODE_ACTION: 908 supportedSceneModes += "action"; 909 break; 910 case ANDROID_CONTROL_SCENE_MODE_PORTRAIT: 911 supportedSceneModes += "portrait"; 912 break; 913 case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE: 914 supportedSceneModes += "landscape"; 915 break; 916 case ANDROID_CONTROL_SCENE_MODE_NIGHT: 917 supportedSceneModes += "night"; 918 break; 919 case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT: 920 supportedSceneModes += "night-portrait"; 921 break; 922 case ANDROID_CONTROL_SCENE_MODE_THEATRE: 923 supportedSceneModes += "theatre"; 924 break; 925 case ANDROID_CONTROL_SCENE_MODE_BEACH: 926 supportedSceneModes += "beach"; 927 break; 928 case ANDROID_CONTROL_SCENE_MODE_SNOW: 929 supportedSceneModes += "snow"; 930 break; 931 case ANDROID_CONTROL_SCENE_MODE_SUNSET: 932 supportedSceneModes += "sunset"; 933 break; 934 case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO: 935 supportedSceneModes += "steadyphoto"; 936 break; 937 case ANDROID_CONTROL_SCENE_MODE_FIREWORKS: 938 supportedSceneModes += "fireworks"; 939 break; 940 case ANDROID_CONTROL_SCENE_MODE_SPORTS: 941 supportedSceneModes += "sports"; 942 break; 943 case ANDROID_CONTROL_SCENE_MODE_PARTY: 944 supportedSceneModes += "party"; 945 break; 946 case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT: 947 supportedSceneModes += "candlelight"; 948 break; 949 case ANDROID_CONTROL_SCENE_MODE_BARCODE: 950 supportedSceneModes += "barcode"; 951 break; 952 default: 953 ALOGW("%s: Camera %d: Unknown scene mode value: %d", 954 __FUNCTION__, mCameraId, availableSceneModes.data.u8[i]); 955 addComma = false; 956 break; 957 } 958 } 959 if (!noSceneModes) { 960 params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 961 supportedSceneModes); 962 } 963 } 964 965 camera_metadata_entry_t flashAvailable = 966 staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1); 967 if (!flashAvailable.count) return NO_INIT; 968 969 camera_metadata_entry_t availableAeModes = 970 staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES); 971 if (!availableAeModes.count) return NO_INIT; 972 973 if (flashAvailable.data.u8[0]) { 974 mParameters.flashMode = Parameters::FLASH_MODE_AUTO; 975 params.set(CameraParameters::KEY_FLASH_MODE, 976 CameraParameters::FLASH_MODE_AUTO); 977 978 String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF); 979 supportedFlashModes = supportedFlashModes + 980 "," + CameraParameters::FLASH_MODE_AUTO + 981 "," + CameraParameters::FLASH_MODE_ON + 982 "," + CameraParameters::FLASH_MODE_TORCH; 983 for (size_t i=0; i < availableAeModes.count; i++) { 984 if (availableAeModes.data.u8[i] == 985 ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) { 986 supportedFlashModes = supportedFlashModes + "," + 987 CameraParameters::FLASH_MODE_RED_EYE; 988 break; 989 } 990 } 991 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 992 supportedFlashModes); 993 } else { 994 mParameters.flashMode = Parameters::FLASH_MODE_OFF; 995 params.set(CameraParameters::KEY_FLASH_MODE, 996 CameraParameters::FLASH_MODE_OFF); 997 params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 998 CameraParameters::FLASH_MODE_OFF); 999 } 1000 1001 camera_metadata_entry_t minFocusDistance = 1002 staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1); 1003 if (!minFocusDistance.count) return NO_INIT; 1004 1005 camera_metadata_entry_t availableAfModes = 1006 staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES); 1007 if (!availableAfModes.count) return NO_INIT; 1008 1009 if (minFocusDistance.data.f[0] == 0) { 1010 // Fixed-focus lens 1011 mParameters.focusMode = Parameters::FOCUS_MODE_FIXED; 1012 params.set(CameraParameters::KEY_FOCUS_MODE, 1013 CameraParameters::FOCUS_MODE_FIXED); 1014 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 1015 CameraParameters::FOCUS_MODE_FIXED); 1016 } else { 1017 mParameters.focusMode = Parameters::FOCUS_MODE_AUTO; 1018 params.set(CameraParameters::KEY_FOCUS_MODE, 1019 CameraParameters::FOCUS_MODE_AUTO); 1020 String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED); 1021 supportedFocusModes = supportedFocusModes + "," + 1022 CameraParameters::FOCUS_MODE_INFINITY; 1023 bool addComma = true; 1024 for (size_t i=0; i < availableAfModes.count; i++) { 1025 if (addComma) supportedFocusModes += ","; 1026 addComma = true; 1027 switch (availableAfModes.data.u8[i]) { 1028 case ANDROID_CONTROL_AF_AUTO: 1029 supportedFocusModes += "auto"; 1030 break; 1031 case ANDROID_CONTROL_AF_MACRO: 1032 supportedFocusModes += "macro"; 1033 break; 1034 case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO: 1035 supportedFocusModes += "continuous-video"; 1036 break; 1037 case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE: 1038 supportedFocusModes += "continuous-picture"; 1039 break; 1040 case ANDROID_CONTROL_AF_EDOF: 1041 supportedFocusModes += "edof"; 1042 break; 1043 // Not supported in v1 API 1044 case ANDROID_CONTROL_AF_OFF: 1045 addComma = false; 1046 break; 1047 default: 1048 ALOGW("%s: Camera %d: Unknown AF mode value: %d", 1049 __FUNCTION__, mCameraId, availableAfModes.data.u8[i]); 1050 addComma = false; 1051 break; 1052 } 1053 } 1054 params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 1055 supportedFocusModes); 1056 } 1057 1058 camera_metadata_entry_t max3aRegions = 1059 staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1); 1060 if (!max3aRegions.count) return NO_INIT; 1061 1062 params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, 1063 max3aRegions.data.i32[0]); 1064 params.set(CameraParameters::KEY_FOCUS_AREAS, 1065 "(0,0,0,0,0)"); 1066 mParameters.focusingAreas.clear(); 1067 mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0)); 1068 1069 camera_metadata_entry_t availableFocalLengths = 1070 staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS); 1071 if (!availableFocalLengths.count) return NO_INIT; 1072 1073 float minFocalLength = availableFocalLengths.data.f[0]; 1074 params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength); 1075 1076 camera_metadata_entry_t sensorSize = 1077 staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2); 1078 if (!sensorSize.count) return NO_INIT; 1079 1080 // The fields of view here assume infinity focus, maximum wide angle 1081 float horizFov = 180 / M_PI * 1082 2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength)); 1083 float vertFov = 180 / M_PI * 1084 2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength)); 1085 params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov); 1086 params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov); 1087 1088 mParameters.exposureCompensation = 0; 1089 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, 1090 mParameters.exposureCompensation); 1091 1092 camera_metadata_entry_t exposureCompensationRange = 1093 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2); 1094 if (!exposureCompensationRange.count) return NO_INIT; 1095 1096 params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, 1097 exposureCompensationRange.data.i32[1]); 1098 params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, 1099 exposureCompensationRange.data.i32[0]); 1100 1101 camera_metadata_entry_t exposureCompensationStep = 1102 staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1); 1103 if (!exposureCompensationStep.count) return NO_INIT; 1104 1105 params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, 1106 exposureCompensationStep.data.r[0].numerator / 1107 exposureCompensationStep.data.r[0].denominator); 1108 1109 mParameters.autoExposureLock = false; 1110 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, 1111 CameraParameters::FALSE); 1112 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 1113 CameraParameters::TRUE); 1114 1115 mParameters.autoWhiteBalanceLock = false; 1116 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, 1117 CameraParameters::FALSE); 1118 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 1119 CameraParameters::TRUE); 1120 1121 mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0)); 1122 params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, 1123 max3aRegions.data.i32[0]); 1124 params.set(CameraParameters::KEY_METERING_AREAS, 1125 "(0,0,0,0,0)"); 1126 1127 mParameters.zoom = 0; 1128 params.set(CameraParameters::KEY_ZOOM, mParameters.zoom); 1129 params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1); 1130 1131 camera_metadata_entry_t maxDigitalZoom = 1132 staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1); 1133 if (!maxDigitalZoom.count) return NO_INIT; 1134 1135 { 1136 String8 zoomRatios; 1137 float zoom = 1.f; 1138 float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) / 1139 (NUM_ZOOM_STEPS-1); 1140 bool addComma = false; 1141 for (size_t i=0; i < NUM_ZOOM_STEPS; i++) { 1142 if (addComma) zoomRatios += ","; 1143 addComma = true; 1144 zoomRatios += String8::format("%d", static_cast<int>(zoom * 100)); 1145 zoom += zoomIncrement; 1146 } 1147 params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios); 1148 } 1149 1150 params.set(CameraParameters::KEY_ZOOM_SUPPORTED, 1151 CameraParameters::TRUE); 1152 params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, 1153 CameraParameters::TRUE); 1154 1155 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 1156 "Infinity,Infinity,Infinity"); 1157 1158 camera_metadata_entry_t maxFacesDetected = 1159 staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1); 1160 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, 1161 maxFacesDetected.data.i32[0]); 1162 params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, 1163 0); 1164 1165 params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 1166 formatEnumToString(HAL_PIXEL_FORMAT_YCrCb_420_SP)); 1167 1168 params.set(CameraParameters::KEY_RECORDING_HINT, 1169 CameraParameters::FALSE); 1170 1171 params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, 1172 CameraParameters::TRUE); 1173 1174 params.set(CameraParameters::KEY_VIDEO_STABILIZATION, 1175 CameraParameters::FALSE); 1176 1177 camera_metadata_entry_t availableVideoStabilizationModes = 1178 staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); 1179 if (!availableVideoStabilizationModes.count) return NO_INIT; 1180 1181 if (availableVideoStabilizationModes.count > 1) { 1182 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 1183 CameraParameters::TRUE); 1184 } else { 1185 params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, 1186 CameraParameters::FALSE); 1187 } 1188 1189 mParamsFlattened = params.flatten(); 1190 1191 return OK; 1192} 1193 1194status_t Camera2Client::updatePreviewRequest() { 1195 ATRACE_CALL(); 1196 status_t res; 1197 if (mPreviewRequest == NULL) { 1198 res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW, 1199 &mPreviewRequest); 1200 if (res != OK) { 1201 ALOGE("%s: Camera %d: Unable to create default preview request: " 1202 "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 1203 return res; 1204 } 1205 } 1206 // TODO: Adjust for params changes 1207 return OK; 1208} 1209 1210const char* Camera2Client::formatEnumToString(int format) { 1211 const char *fmt; 1212 switch(format) { 1213 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1214 fmt = CameraParameters::PIXEL_FORMAT_YUV422SP; 1215 break; 1216 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1217 fmt = CameraParameters::PIXEL_FORMAT_YUV420SP; 1218 break; 1219 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1220 fmt = CameraParameters::PIXEL_FORMAT_YUV422I; 1221 break; 1222 case HAL_PIXEL_FORMAT_YV12: // YV12 1223 fmt = CameraParameters::PIXEL_FORMAT_YUV420P; 1224 break; 1225 case HAL_PIXEL_FORMAT_RGB_565: // RGB565 1226 fmt = CameraParameters::PIXEL_FORMAT_RGB565; 1227 break; 1228 case HAL_PIXEL_FORMAT_RGBA_8888: // RGBA8888 1229 fmt = CameraParameters::PIXEL_FORMAT_RGBA8888; 1230 break; 1231 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1232 ALOGW("Raw sensor preview format requested."); 1233 fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB; 1234 break; 1235 default: 1236 ALOGE("%s: Unknown preview format: %x", 1237 __FUNCTION__, format); 1238 fmt = NULL; 1239 break; 1240 } 1241 return fmt; 1242} 1243} // namespace android 1244