Camera2Client.cpp revision 661076292093f82aec488baf8460cdf204a5efd2
10b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly/* 2fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * Copyright (C) 2012 The Android Open Source Project 3fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * 4fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * Licensed under the Apache License, Version 2.0 (the "License"); 5fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * you may not use this file except in compliance with the License. 6fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * You may obtain a copy of the License at 7fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * 8fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * http://www.apache.org/licenses/LICENSE-2.0 9fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * 10fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * Unless required by applicable law or agreed to in writing, software 11fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * distributed under the License is distributed on an "AS IS" BASIS, 12fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * See the License for the specific language governing permissions and 14fa0fd39a4bf296d254aa398c1b19ec960efa641dZhihai Xu * limitations under the License. 150b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly */ 160b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 170b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly#define LOG_TAG "Camera2Client" 180b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly#define ATRACE_TAG ATRACE_TAG_CAMERA 1916fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly//#define LOG_NDEBUG 0 203b147b770269173d5d711d6c33f142dc5e723824zzy 2116fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly#include <utils/Log.h> 2216fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly#include <utils/Trace.h> 2316fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly 24238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde#include <cutils/properties.h> 250b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly#include <gui/Surface.h> 263b147b770269173d5d711d6c33f142dc5e723824zzy 270b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly#include "api1/Camera2Client.h" 280b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 290b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly#include "api1/client2/StreamingProcessor.h" 30e6748ce31f18782b7a47a5b2eb251efd83e7b609Andreas Gampe#include "api1/client2/JpegProcessor.h" 31fea17de7aaa5729d3111102b2734b158403d2780Jeff Sharkey#include "api1/client2/CaptureSequencer.h" 32b49a89635906e0901637a4a4c1c2f5bb263b6595zzy#include "api1/client2/CallbackProcessor.h" 333b147b770269173d5d711d6c33f142dc5e723824zzy#include "api1/client2/ZslProcessor.h" 34238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde#include "api1/client2/ZslProcessor3.h" 35238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 363b147b770269173d5d711d6c33f142dc5e723824zzy#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 373b147b770269173d5d711d6c33f142dc5e723824zzy#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 380b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 3945e2704ff512d41e22af2801d76e96955469ce8dNick Pellynamespace android { 400b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pellyusing namespace camera2; 4145e2704ff512d41e22af2801d76e96955469ce8dNick Pelly 4245e2704ff512d41e22af2801d76e96955469ce8dNick Pellystatic int getCallingPid() { 4345e2704ff512d41e22af2801d76e96955469ce8dNick Pelly return IPCThreadState::self()->getCallingPid(); 449fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main} 459fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main 46f51eadaf1f83abfe16a609a4ded6d789494689b2Jake Hamby// Interface used by CameraService 479fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main 480b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick PellyCamera2Client::Camera2Client(const sp<CameraService>& cameraService, 499fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main const sp<ICameraClient>& cameraClient, 509fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main const String16& clientPackageName, 519fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main int cameraId, 520b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly int cameraFacing, 539fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main int clientPid, 549fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main uid_t clientUid, 559fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main int servicePid, 569fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main int deviceVersion): 579fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main Camera2ClientBase(cameraService, cameraClient, clientPackageName, 589fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main cameraId, cameraFacing, clientPid, clientUid, servicePid), 5945e2704ff512d41e22af2801d76e96955469ce8dNick Pelly mParameters(cameraId, cameraFacing), 609fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main mDeviceVersion(deviceVersion) 619fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main{ 6245e2704ff512d41e22af2801d76e96955469ce8dNick Pelly ATRACE_CALL(); 639fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main 649fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main SharedParameters::Lock l(mParameters); 659fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main l.mParameters.state = Parameters::DISCONNECTED; 669fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main} 679fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main 689fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Mainstatus_t Camera2Client::initialize(camera_module_t *module) 699fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main{ 7045e2704ff512d41e22af2801d76e96955469ce8dNick Pelly ATRACE_CALL(); 7145e2704ff512d41e22af2801d76e96955469ce8dNick Pelly ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId); 72cf44059813539bf7f36dabd278cef93ba3122c56Nick Pelly status_t res; 739fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main 749fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main res = Camera2ClientBase::initialize(module); 759fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main if (res != OK) { 763aef8e1d1b2f0b87d470bcccf37ba4ebb6560c45Joe Fernandez return res; 773aef8e1d1b2f0b87d470bcccf37ba4ebb6560c45Joe Fernandez } 783aef8e1d1b2f0b87d470bcccf37ba4ebb6560c45Joe Fernandez 79382871b03fd6d1d1207d20cf647fa73e71a8496eMarie Janssen SharedParameters::Lock l(mParameters); 803aef8e1d1b2f0b87d470bcccf37ba4ebb6560c45Joe Fernandez 813aef8e1d1b2f0b87d470bcccf37ba4ebb6560c45Joe Fernandez res = l.mParameters.initialize(&(mDevice->info())); 829fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main if (res != OK) { 839fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 849fab0aef19a4633d2e4670564e5d7ae9e52fe11fScott Main __FUNCTION__, mCameraId, strerror(-res), res); 850b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly return NO_INIT; 860b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 8716fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly 88f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPenna String8 threadName; 89f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPenna 9016fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly mStreamingProcessor = new StreamingProcessor(this); 9124bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly threadName = String8::format("C2-%d-StreamProc", 9224bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly mCameraId); 93238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde mStreamingProcessor->run(threadName.string()); 9424bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly 95f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach mFrameProcessor = new FrameProcessor(mDevice, this); 96238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde threadName = String8::format("C2-%d-FrameProc", 97f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach mCameraId); 98f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach mFrameProcessor->run(threadName.string()); 99238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 100f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach mCaptureSequencer = new CaptureSequencer(this); 101f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach threadName = String8::format("C2-%d-CaptureSeq", 102238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde mCameraId); 1036a669fac385b51b8bb01844b77a9a43840dda854Nick Pelly mCaptureSequencer->run(threadName.string()); 10424bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly 10524bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); 10624bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly threadName = String8::format("C2-%d-JpegProc", 1073b147b770269173d5d711d6c33f142dc5e723824zzy mCameraId); 1083b147b770269173d5d711d6c33f142dc5e723824zzy mJpegProcessor->run(threadName.string()); 109238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 1102328423d19416da0c1068883c33e612d5729fc47Casper Bonde switch (mDeviceVersion) { 1113b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde case CAMERA_DEVICE_API_VERSION_2_0: { 1123b147b770269173d5d711d6c33f142dc5e723824zzy sp<ZslProcessor> zslProc = 1136a669fac385b51b8bb01844b77a9a43840dda854Nick Pelly new ZslProcessor(this, mCaptureSequencer); 1143b147b770269173d5d711d6c33f142dc5e723824zzy mZslProcessor = zslProc; 1153b147b770269173d5d711d6c33f142dc5e723824zzy mZslProcessorThread = zslProc; 1160b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly break; 1170b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 1180b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly case CAMERA_DEVICE_API_VERSION_3_0:{ 1190b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly sp<ZslProcessor3> zslProc = 1203b147b770269173d5d711d6c33f142dc5e723824zzy new ZslProcessor3(this, mCaptureSequencer); 1212328423d19416da0c1068883c33e612d5729fc47Casper Bonde mZslProcessor = zslProc; 1222328423d19416da0c1068883c33e612d5729fc47Casper Bonde mZslProcessorThread = zslProc; 1233b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde break; 1243b147b770269173d5d711d6c33f142dc5e723824zzy } 1253b147b770269173d5d711d6c33f142dc5e723824zzy default: 1263b147b770269173d5d711d6c33f142dc5e723824zzy break; 1273b147b770269173d5d711d6c33f142dc5e723824zzy } 12868c692df5f667dcee42506d3c6459d3dc2e1cdd6Mike Lockwood threadName = String8::format("C2-%d-ZslProc", 1293b147b770269173d5d711d6c33f142dc5e723824zzy mCameraId); 1303b147b770269173d5d711d6c33f142dc5e723824zzy mZslProcessorThread->run(threadName.string()); 1313b147b770269173d5d711d6c33f142dc5e723824zzy 1323b147b770269173d5d711d6c33f142dc5e723824zzy mCallbackProcessor = new CallbackProcessor(this); 133238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde threadName = String8::format("C2-%d-CallbkProc", 134238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde mCameraId); 135238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde mCallbackProcessor->run(threadName.string()); 136238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 137238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (gLogLevel >= 1) { 1380b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 139ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie mCameraId); 140ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie ALOGD("%s", l.mParameters.paramsFlattened.string()); 141ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie } 1423b147b770269173d5d711d6c33f142dc5e723824zzy 1433b147b770269173d5d711d6c33f142dc5e723824zzy return OK; 144ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie} 145ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie 14671c3c7806acb2b2b7b8441817c26a2101d447bbeNick PellyCamera2Client::~Camera2Client() { 1473b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 14871c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly ALOGV("~Camera2Client"); 149ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie 1503b147b770269173d5d711d6c33f142dc5e723824zzy mDestructionStarted = true; 1510b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 1520b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly disconnect(); 153bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly 1546a669fac385b51b8bb01844b77a9a43840dda854Nick Pelly ALOGI("Camera %d: Closed", mCameraId); 1550b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly} 1560b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 1570b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pellystatus_t Camera2Client::dump(int fd, const Vector<String16>& args) { 158bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly String8 result; 1590b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n", 16016fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly mCameraId, 1610b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly getRemoteCallback()->asBinder().get(), 162f51eadaf1f83abfe16a609a4ded6d789494689b2Jake Hamby String8(mClientPackageName).string(), 1630b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly mClientPid); 164bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly result.append(" State: "); 16516fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break; 1663b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde 1672328423d19416da0c1068883c33e612d5729fc47Casper Bonde const Parameters& p = mParameters.unsafeAccess(); 1682328423d19416da0c1068883c33e612d5729fc47Casper Bonde 1692328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.append(Parameters::getStateName(p.state)); 1702328423d19416da0c1068883c33e612d5729fc47Casper Bonde 1712328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.append("\n Current parameters:\n"); 1722328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Preview size: %d x %d\n", 1732328423d19416da0c1068883c33e612d5729fc47Casper Bonde p.previewWidth, p.previewHeight); 1742328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Preview FPS range: %d - %d\n", 1752328423d19416da0c1068883c33e612d5729fc47Casper Bonde p.previewFpsRange[0], p.previewFpsRange[1]); 1762328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Preview HAL pixel format: 0x%x\n", 1772328423d19416da0c1068883c33e612d5729fc47Casper Bonde p.previewFormat); 1782328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Preview transform: %x\n", 1793b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde p.previewTransform); 1802328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Picture size: %d x %d\n", 1812328423d19416da0c1068883c33e612d5729fc47Casper Bonde p.pictureWidth, p.pictureHeight); 1822328423d19416da0c1068883c33e612d5729fc47Casper Bonde result.appendFormat(" Jpeg thumbnail size: %d x %d\n", 1832328423d19416da0c1068883c33e612d5729fc47Casper Bonde p.jpegThumbSize[0], p.jpegThumbSize[1]); 1843b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n", 1853b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde p.jpegQuality, p.jpegThumbQuality); 186238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation); 187238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde result.appendFormat(" GPS tags %s\n", 188238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde p.gpsEnabled ? "enabled" : "disabled"); 18924bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly if (p.gpsEnabled) { 19024bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n", 19124bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly p.gpsCoordinates[0], p.gpsCoordinates[1], 19224bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly p.gpsCoordinates[2]); 193238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde result.appendFormat(" GPS timestamp: %lld\n", 194b49a89635906e0901637a4a4c1c2f5bb263b6595zzy p.gpsTimestamp); 195b49a89635906e0901637a4a4c1c2f5bb263b6595zzy result.appendFormat(" GPS processing method: %s\n", 1966a669fac385b51b8bb01844b77a9a43840dda854Nick Pelly p.gpsProcessingMethod.string()); 1970b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 1982328423d19416da0c1068883c33e612d5729fc47Casper Bonde 1993b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde result.append(" White balance mode: "); 2000b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly switch (p.wbMode) { 201bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO) 2023b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT) 2033b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT) 2043b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT) 2053b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT) 2063b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT) 207bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT) 2083b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE) 2093b147b770269173d5d711d6c33f142dc5e723824zzy default: result.append("UNKNOWN\n"); 210bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly } 2113b147b770269173d5d711d6c33f142dc5e723824zzy 212bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly result.append(" Effect mode: "); 213bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly switch (p.effectMode) { 2143b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF) 2153b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO) 2163b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE) 2173b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE) 218238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA) 2193b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE) 2203b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD) 2213b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD) 2223b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA) 2233b147b770269173d5d711d6c33f142dc5e723824zzy default: result.append("UNKNOWN\n"); 2240b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 2250b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 226238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde result.append(" Antibanding mode: "); 227238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde switch (p.antibandingMode) { 228238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO) 2293b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF) 230238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ) 2312328423d19416da0c1068883c33e612d5729fc47Casper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ) 2323b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde default: result.append("UNKNOWN\n"); 2333b147b770269173d5d711d6c33f142dc5e723824zzy } 2343b147b770269173d5d711d6c33f142dc5e723824zzy 2353b147b770269173d5d711d6c33f142dc5e723824zzy result.append(" Scene mode: "); 2363b147b770269173d5d711d6c33f142dc5e723824zzy switch (p.sceneMode) { 2373b147b770269173d5d711d6c33f142dc5e723824zzy case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 238e6748ce31f18782b7a47a5b2eb251efd83e7b609Andreas Gampe result.append("AUTO\n"); break; 2393b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION) 240e6748ce31f18782b7a47a5b2eb251efd83e7b609Andreas Gampe CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT) 24171bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE) 2423b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT) 2433b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT) 244569ff225a3879363bb31548a664161fee5270a0dZach Johnson CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE) 245569ff225a3879363bb31548a664161fee5270a0dZach Johnson CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH) 2467fd724611b8113c7f584c603d14fd44071cad799Neil Fuller CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW) 2473b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET) 2483b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO) 2493b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS) 2503b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS) 2513b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY) 2520b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT) 253bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE) 25416fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly default: result.append("UNKNOWN\n"); 255bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly } 256bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly 257bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly result.append(" Flash mode: "); 258bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly switch (p.flashMode) { 259bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF) 260bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO) 261bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON) 262f51eadaf1f83abfe16a609a4ded6d789494689b2Jake Hamby CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH) 263bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE) 264bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID) 265bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly default: result.append("UNKNOWN\n"); 2663b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde } 267bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly 268bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly result.append(" Focus mode: "); 26945e2704ff512d41e22af2801d76e96955469ce8dNick Pelly switch (p.focusMode) { 2700b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO) 2710b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO) 2720b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) 2730b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE) 2740b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF) 2750b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY) 2760b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED) 2770b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID) 2783b147b770269173d5d711d6c33f142dc5e723824zzy default: result.append("UNKNOWN\n"); 2793b147b770269173d5d711d6c33f142dc5e723824zzy } 2803b147b770269173d5d711d6c33f142dc5e723824zzy 2813b147b770269173d5d711d6c33f142dc5e723824zzy result.append(" Focus state: "); 2823b147b770269173d5d711d6c33f142dc5e723824zzy switch (p.focusState) { 2833b147b770269173d5d711d6c33f142dc5e723824zzy CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE) 284238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN) 285238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED) 2862328423d19416da0c1068883c33e612d5729fc47Casper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED) 2872328423d19416da0c1068883c33e612d5729fc47Casper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN) 2883b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED) 2893b3d1fea94318a4892fbd4353269749af417a81aCasper Bonde CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED) 2903b147b770269173d5d711d6c33f142dc5e723824zzy default: result.append("UNKNOWN\n"); 2910b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 2920b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 2930b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.append(" Focusing areas:\n"); 29445e2704ff512d41e22af2801d76e96955469ce8dNick Pelly for (size_t i = 0; i < p.focusingAreas.size(); i++) { 29545e2704ff512d41e22af2801d76e96955469ce8dNick Pelly result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 2960b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.focusingAreas[i].left, 297bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly p.focusingAreas[i].top, 298bd022f423a33f0794bb53e5b0720da2d67e4631cNick Pelly p.focusingAreas[i].right, 2990b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.focusingAreas[i].bottom, 3000b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.focusingAreas[i].weight); 3010b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 3020b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 30345e2704ff512d41e22af2801d76e96955469ce8dNick Pelly result.appendFormat(" Exposure compensation index: %d\n", 3040b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.exposureCompensation); 3050b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 3060b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat(" AE lock %s, AWB lock %s\n", 3070b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.autoExposureLock ? "enabled" : "disabled", 3080b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.autoWhiteBalanceLock ? "enabled" : "disabled" ); 3090b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 3100b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat(" Metering areas:\n"); 3110b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly for (size_t i = 0; i < p.meteringAreas.size(); i++) { 3120b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 3130b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.meteringAreas[i].left, 31445e2704ff512d41e22af2801d76e96955469ce8dNick Pelly p.meteringAreas[i].top, 3150b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.meteringAreas[i].right, 3160b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.meteringAreas[i].bottom, 3170b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.meteringAreas[i].weight); 3180b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly } 3190b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly 3200b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat(" Zoom index: %d\n", p.zoom); 3210b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly result.appendFormat(" Video size: %d x %d\n", p.videoWidth, 3220b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly p.videoHeight); 32324bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly 324ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie result.appendFormat(" Recording hint is %s\n", 325ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie p.recordingHint ? "set" : "not set"); 326ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie 327ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie result.appendFormat(" Video stabilization is %s\n", 328ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie p.videoStabilization ? "enabled" : "disabled"); 329ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie 3303b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" Selected still capture FPS range: %d - %d\n", 3313b147b770269173d5d711d6c33f142dc5e723824zzy p.fastInfo.bestStillCaptureFpsRange[0], 3323b147b770269173d5d711d6c33f142dc5e723824zzy p.fastInfo.bestStillCaptureFpsRange[1]); 3333b147b770269173d5d711d6c33f142dc5e723824zzy 3343b147b770269173d5d711d6c33f142dc5e723824zzy result.append(" Current streams:\n"); 3353b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" Preview stream ID: %d\n", 3363b147b770269173d5d711d6c33f142dc5e723824zzy getPreviewStreamId()); 3373b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" Capture stream ID: %d\n", 3383b147b770269173d5d711d6c33f142dc5e723824zzy getCaptureStreamId()); 3393b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" Recording stream ID: %d\n", 3403b147b770269173d5d711d6c33f142dc5e723824zzy getRecordingStreamId()); 3413b147b770269173d5d711d6c33f142dc5e723824zzy 3423b147b770269173d5d711d6c33f142dc5e723824zzy result.append(" Quirks for this camera:\n"); 3433b147b770269173d5d711d6c33f142dc5e723824zzy bool haveQuirk = false; 3443b147b770269173d5d711d6c33f142dc5e723824zzy if (p.quirks.triggerAfWithAuto) { 3453b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" triggerAfWithAuto\n"); 3463b147b770269173d5d711d6c33f142dc5e723824zzy haveQuirk = true; 3473b147b770269173d5d711d6c33f142dc5e723824zzy } 3483b147b770269173d5d711d6c33f142dc5e723824zzy if (p.quirks.useZslFormat) { 3493b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" useZslFormat\n"); 3503b147b770269173d5d711d6c33f142dc5e723824zzy haveQuirk = true; 3513b147b770269173d5d711d6c33f142dc5e723824zzy } 3523b147b770269173d5d711d6c33f142dc5e723824zzy if (p.quirks.meteringCropRegion) { 3533b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" meteringCropRegion\n"); 3543b147b770269173d5d711d6c33f142dc5e723824zzy haveQuirk = true; 3553b147b770269173d5d711d6c33f142dc5e723824zzy } 3563b147b770269173d5d711d6c33f142dc5e723824zzy if (!haveQuirk) { 3573b147b770269173d5d711d6c33f142dc5e723824zzy result.appendFormat(" none\n"); 3583b147b770269173d5d711d6c33f142dc5e723824zzy } 359238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 360238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde write(fd, result.string(), result.size()); 3610f42037eb7b5118015c2caca635538324ccf0ccffredc 3620f42037eb7b5118015c2caca635538324ccf0ccffredc mStreamingProcessor->dump(fd, args); 3633b147b770269173d5d711d6c33f142dc5e723824zzy 3643b147b770269173d5d711d6c33f142dc5e723824zzy mCaptureSequencer->dump(fd, args); 3653b147b770269173d5d711d6c33f142dc5e723824zzy 366563e414784eb81e4ea4051667d5c8855b17f7534Matthew Xie mFrameProcessor->dump(fd, args); 3673b147b770269173d5d711d6c33f142dc5e723824zzy 3683b147b770269173d5d711d6c33f142dc5e723824zzy mZslProcessor->dump(fd, args); 3693b147b770269173d5d711d6c33f142dc5e723824zzy 3707fd724611b8113c7f584c603d14fd44071cad799Neil Fuller return dumpDevice(fd, args); 3713b147b770269173d5d711d6c33f142dc5e723824zzy#undef CASE_APPEND_ENUM 3723b147b770269173d5d711d6c33f142dc5e723824zzy} 3733b147b770269173d5d711d6c33f142dc5e723824zzy 3743b147b770269173d5d711d6c33f142dc5e723824zzy// ICamera interface 3753b147b770269173d5d711d6c33f142dc5e723824zzy 3763b147b770269173d5d711d6c33f142dc5e723824zzyvoid Camera2Client::disconnect() { 3773b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 3783b147b770269173d5d711d6c33f142dc5e723824zzy Mutex::Autolock icl(mBinderSerializationLock); 3793b147b770269173d5d711d6c33f142dc5e723824zzy 3803b147b770269173d5d711d6c33f142dc5e723824zzy // Allow both client and the media server to disconnect at all times 3813b147b770269173d5d711d6c33f142dc5e723824zzy int callingPid = getCallingPid(); 3823b147b770269173d5d711d6c33f142dc5e723824zzy if (callingPid != mClientPid && callingPid != mServicePid) return; 3833b147b770269173d5d711d6c33f142dc5e723824zzy 3843b147b770269173d5d711d6c33f142dc5e723824zzy if (mDevice == 0) return; 3853b147b770269173d5d711d6c33f142dc5e723824zzy 3863b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("Camera %d: Shutting down", mCameraId); 3873e8eb40950f4d02322ded64503314b7db2bf9825Sharvil Nanavati 3883b147b770269173d5d711d6c33f142dc5e723824zzy /** 389ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie * disconnect() cannot call any methods that might need to promote a 390ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie * wp<Camera2Client>, since disconnect can be called from the destructor, at 391ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie * which point all such promotions will fail. 39224bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly */ 39324bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly 39424bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly stopPreviewL(); 39524bb9b8af4ff691538fe9e517e8156016b0da6cdNick Pelly 3963b147b770269173d5d711d6c33f142dc5e723824zzy { 3973b147b770269173d5d711d6c33f142dc5e723824zzy SharedParameters::Lock l(mParameters); 398903ac6f399dcd4f574bf388daa7b5f5907d448d3fredc if (l.mParameters.state == Parameters::DISCONNECTED) return; 3990f42037eb7b5118015c2caca635538324ccf0ccffredc l.mParameters.state = Parameters::DISCONNECTED; 4000f42037eb7b5118015c2caca635538324ccf0ccffredc } 4010f42037eb7b5118015c2caca635538324ccf0ccffredc 4020f42037eb7b5118015c2caca635538324ccf0ccffredc mStreamingProcessor->deletePreviewStream(); 40371c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly mStreamingProcessor->deleteRecordingStream(); 4040f42037eb7b5118015c2caca635538324ccf0ccffredc mJpegProcessor->deleteStream(); 4053b147b770269173d5d711d6c33f142dc5e723824zzy mCallbackProcessor->deleteStream(); 4063b147b770269173d5d711d6c33f142dc5e723824zzy mZslProcessor->deleteStream(); 4073b147b770269173d5d711d6c33f142dc5e723824zzy 4083b147b770269173d5d711d6c33f142dc5e723824zzy mStreamingProcessor->requestExit(); 4093b147b770269173d5d711d6c33f142dc5e723824zzy mFrameProcessor->requestExit(); 41071c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly mCaptureSequencer->requestExit(); 4113b147b770269173d5d711d6c33f142dc5e723824zzy mJpegProcessor->requestExit(); 41271c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly mZslProcessorThread->requestExit(); 4133b147b770269173d5d711d6c33f142dc5e723824zzy mCallbackProcessor->requestExit(); 414f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPenna 415563e414784eb81e4ea4051667d5c8855b17f7534Matthew Xie ALOGV("Camera %d: Waiting for threads", mCameraId); 4163b147b770269173d5d711d6c33f142dc5e723824zzy 4173b147b770269173d5d711d6c33f142dc5e723824zzy mStreamingProcessor->join(); 4183b147b770269173d5d711d6c33f142dc5e723824zzy mFrameProcessor->join(); 419fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker mCaptureSequencer->join(); 420fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker mJpegProcessor->join(); 421fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker mZslProcessorThread->join(); 422fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker mCallbackProcessor->join(); 423fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker 4247fd724611b8113c7f584c603d14fd44071cad799Neil Fuller ALOGV("Camera %d: Disconnecting device", mCameraId); 4257fd724611b8113c7f584c603d14fd44071cad799Neil Fuller 4267fd724611b8113c7f584c603d14fd44071cad799Neil Fuller mDevice->disconnect(); 4273b147b770269173d5d711d6c33f142dc5e723824zzy 4283b147b770269173d5d711d6c33f142dc5e723824zzy mDevice.clear(); 4293b147b770269173d5d711d6c33f142dc5e723824zzy 430f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPenna CameraService::Client::disconnect(); 4313b147b770269173d5d711d6c33f142dc5e723824zzy} 4323b147b770269173d5d711d6c33f142dc5e723824zzy 4333b147b770269173d5d711d6c33f142dc5e723824zzystatus_t Camera2Client::connect(const sp<ICameraClient>& client) { 4343b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 4353b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("%s: E", __FUNCTION__); 436f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPenna Mutex::Autolock icl(mBinderSerializationLock); 437238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 4383b147b770269173d5d711d6c33f142dc5e723824zzy if (mClientPid != 0 && getCallingPid() != mClientPid) { 4393b147b770269173d5d711d6c33f142dc5e723824zzy ALOGE("%s: Camera %d: Connection attempt from pid %d; " 4403b147b770269173d5d711d6c33f142dc5e723824zzy "current locked to pid %d", __FUNCTION__, 4413b147b770269173d5d711d6c33f142dc5e723824zzy mCameraId, getCallingPid(), mClientPid); 442726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie return BAD_VALUE; 443726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie } 444726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie 445726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie mClientPid = getCallingPid(); 446726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie 447726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie mRemoteCallback = client; 448726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie mSharedCameraCallbacks = client; 449726652e9d3f1adf6b68dedfa4618b490b7f1b4a3Matthew Xie 4503b147b770269173d5d711d6c33f142dc5e723824zzy return OK; 4513b147b770269173d5d711d6c33f142dc5e723824zzy} 4523b147b770269173d5d711d6c33f142dc5e723824zzy 4533b147b770269173d5d711d6c33f142dc5e723824zzystatus_t Camera2Client::lock() { 4543b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 455ceb6c9f517ede73bfb677e55fda9d9db6089ae69Matthew Xie ALOGV("%s: E", __FUNCTION__); 4563b147b770269173d5d711d6c33f142dc5e723824zzy Mutex::Autolock icl(mBinderSerializationLock); 4573b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d", 458238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 459238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 460652678af4d18b9a6c18ce6a860de01d958bc82fezzy if (mClientPid == 0) { 461652678af4d18b9a6c18ce6a860de01d958bc82fezzy mClientPid = getCallingPid(); 462652678af4d18b9a6c18ce6a860de01d958bc82fezzy return OK; 463652678af4d18b9a6c18ce6a860de01d958bc82fezzy } 4643b147b770269173d5d711d6c33f142dc5e723824zzy 465652678af4d18b9a6c18ce6a860de01d958bc82fezzy if (mClientPid != getCallingPid()) { 466652678af4d18b9a6c18ce6a860de01d958bc82fezzy ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d", 4673b147b770269173d5d711d6c33f142dc5e723824zzy __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 4683b147b770269173d5d711d6c33f142dc5e723824zzy return EBUSY; 4693b147b770269173d5d711d6c33f142dc5e723824zzy } 4703b147b770269173d5d711d6c33f142dc5e723824zzy 4713b147b770269173d5d711d6c33f142dc5e723824zzy return OK; 4723b147b770269173d5d711d6c33f142dc5e723824zzy} 47371c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly 4743b147b770269173d5d711d6c33f142dc5e723824zzystatus_t Camera2Client::unlock() { 47571c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly ATRACE_CALL(); 47671c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly ALOGV("%s: E", __FUNCTION__); 47771c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly Mutex::Autolock icl(mBinderSerializationLock); 478563e414784eb81e4ea4051667d5c8855b17f7534Matthew Xie ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d", 4793b147b770269173d5d711d6c33f142dc5e723824zzy __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 48071c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly 48171bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy if (mClientPid == getCallingPid()) { 48271bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy SharedParameters::Lock l(mParameters); 48371bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy if (l.mParameters.state == Parameters::RECORD || 48471bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy l.mParameters.state == Parameters::VIDEO_SNAPSHOT) { 48571bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy ALOGD("Not allowed to unlock camera during recording."); 48671bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy return INVALID_OPERATION; 48771bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy } 48871bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy mClientPid = 0; 489610770d7129a33fdca5c23939f9ee0a80d0322f9Zhihai Xu mRemoteCallback.clear(); 49071bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy mSharedCameraCallbacks.clear(); 49171bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy return OK; 49271bfafc84af4b820748b12e1a1010b0dfa7bdea6zzy } 49371c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly 49471c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d", 495238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 496610770d7129a33fdca5c23939f9ee0a80d0322f9Zhihai Xu return EBUSY; 497238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde} 498238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 499238e0f934f1f47263b384bc745ae0678c777130dCasper Bondestatus_t Camera2Client::setPreviewTarget( 500238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde const sp<IGraphicBufferProducer>& bufferProducer) { 501238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ATRACE_CALL(); 502238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGV("%s: E", __FUNCTION__); 503238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde Mutex::Autolock icl(mBinderSerializationLock); 504238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde status_t res; 505238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 506238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 507238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde sp<IBinder> binder; 508238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde sp<ANativeWindow> window; 509238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (bufferProducer != 0) { 510238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde binder = bufferProducer->asBinder(); 511238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // Using controlledByApp flag to ensure that the buffer queue remains in 512238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // async mode for the old camera API, where many applications depend 513238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // on that behavior. 514238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde window = new Surface(bufferProducer, /*controlledByApp*/ true); 515238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 516238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return setPreviewWindowL(binder, window); 517238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde} 518238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 519238e0f934f1f47263b384bc745ae0678c777130dCasper Bondestatus_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder, 520238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde sp<ANativeWindow> window) { 521238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ATRACE_CALL(); 522238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde status_t res; 523610770d7129a33fdca5c23939f9ee0a80d0322f9Zhihai Xu 524610770d7129a33fdca5c23939f9ee0a80d0322f9Zhihai Xu if (binder == mPreviewSurface) { 525610770d7129a33fdca5c23939f9ee0a80d0322f9Zhihai Xu ALOGV("%s: Camera %d: New window is same as old window", 52671c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly __FUNCTION__, mCameraId); 52771c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly return NO_ERROR; 52871c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly } 529238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 530238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde Parameters::State state; 531238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde { 532238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde SharedParameters::Lock l(mParameters); 533238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde state = l.mParameters.state; 534238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 535238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde switch (state) { 536238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::DISCONNECTED: 537238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::RECORD: 538238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::STILL_CAPTURE: 539238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::VIDEO_SNAPSHOT: 540238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGE("%s: Camera %d: Cannot set preview display while in state %s", 541238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, mCameraId, 542238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde Parameters::getStateName(state)); 543fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom return INVALID_OPERATION; 544fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom case Parameters::STOPPED: 545fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom case Parameters::WAITING_FOR_PREVIEW_WINDOW: 546fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom // OK 547fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom break; 548fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom case Parameters::PREVIEW: 549238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // Already running preview - need to stop and create a new stream 550fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom res = stopStream(); 551fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom if (res != OK) { 552fc59c344bfd792674d9bfa388c4afe8bc00a90a4Christine Hallstrom ALOGE("%s: Unable to stop preview to swap windows: %s (%d)", 553238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, strerror(-res), res); 554238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return res; 555238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 556238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 557238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde break; 558238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 559238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 5603b147b770269173d5d711d6c33f142dc5e723824zzy mPreviewSurface = binder; 5613b147b770269173d5d711d6c33f142dc5e723824zzy res = mStreamingProcessor->setPreviewWindow(window); 5623b147b770269173d5d711d6c33f142dc5e723824zzy if (res != OK) { 5633b147b770269173d5d711d6c33f142dc5e723824zzy ALOGE("%s: Unable to set new preview window: %s (%d)", 564fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker __FUNCTION__, strerror(-res), res); 565fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker return res; 566fc61da5ada4e96822a6bf6646437615af5632be3Ajay Panicker } 5673b147b770269173d5d711d6c33f142dc5e723824zzy 5683b147b770269173d5d711d6c33f142dc5e723824zzy if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) { 5693b147b770269173d5d711d6c33f142dc5e723824zzy SharedParameters::Lock l(mParameters); 5703b147b770269173d5d711d6c33f142dc5e723824zzy l.mParameters.state = state; 5713b147b770269173d5d711d6c33f142dc5e723824zzy return startPreviewL(l.mParameters, false); 5723b147b770269173d5d711d6c33f142dc5e723824zzy } 5733b147b770269173d5d711d6c33f142dc5e723824zzy 5743b147b770269173d5d711d6c33f142dc5e723824zzy return OK; 5753b147b770269173d5d711d6c33f142dc5e723824zzy} 5763b147b770269173d5d711d6c33f142dc5e723824zzy 577f3de98a2d09e2e84c0ca0eb55ab7cf7d943135d1Joe LaPennavoid Camera2Client::setPreviewCallbackFlag(int flag) { 5783b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 5793b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag); 5803b147b770269173d5d711d6c33f142dc5e723824zzy Mutex::Autolock icl(mBinderSerializationLock); 5813b147b770269173d5d711d6c33f142dc5e723824zzy 5823b147b770269173d5d711d6c33f142dc5e723824zzy if ( checkPid(__FUNCTION__) != OK) return; 58301771021e38f9dedce7910c81fea26a9bf837d9dZhihai Xu 58401771021e38f9dedce7910c81fea26a9bf837d9dZhihai Xu SharedParameters::Lock l(mParameters); 58501771021e38f9dedce7910c81fea26a9bf837d9dZhihai Xu setPreviewCallbackFlagL(l.mParameters, flag); 58601771021e38f9dedce7910c81fea26a9bf837d9dZhihai Xu} 5873b147b770269173d5d711d6c33f142dc5e723824zzy 58871c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pellyvoid Camera2Client::setPreviewCallbackFlagL(Parameters ¶ms, int flag) { 58971c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly status_t res = OK; 59071c3c7806acb2b2b7b8441817c26a2101d447bbeNick Pelly 5913b147b770269173d5d711d6c33f142dc5e723824zzy switch(params.state) { 5923b147b770269173d5d711d6c33f142dc5e723824zzy case Parameters::STOPPED: 59316fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly case Parameters::WAITING_FOR_PREVIEW_WINDOW: 5943b147b770269173d5d711d6c33f142dc5e723824zzy case Parameters::PREVIEW: 5953b147b770269173d5d711d6c33f142dc5e723824zzy case Parameters::STILL_CAPTURE: 5963b147b770269173d5d711d6c33f142dc5e723824zzy // OK 597238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde break; 598238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde default: 599238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) { 600238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGE("%s: Camera %d: Can't use preview callbacks " 601238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde "in state %d", __FUNCTION__, mCameraId, params.state); 602238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return; 603238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 604238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 605238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 606238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) { 607238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGV("%s: setting oneshot", __FUNCTION__); 608238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde params.previewCallbackOneShot = true; 609238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 610238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (params.previewCallbackFlags != (uint32_t)flag) { 611238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 612238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) { 613238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // Disable any existing preview callback window when enabling 614238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // preview callback flags 615238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde res = mCallbackProcessor->setCallbackWindow(NULL); 616238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (res != OK) { 617238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGE("%s: Camera %d: Unable to clear preview callback surface:" 618238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res); 619238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return; 620f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach } 621f455986a45328614c8dd07a4d60a30b9ddc3d994Andre Eisenbach params.previewCallbackSurface = false; 622238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 623238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 624238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde params.previewCallbackFlags = flag; 625238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 626238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (params.state == Parameters::PREVIEW) { 627238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde res = startPreviewL(params, true); 628238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (res != OK) { 629238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGE("%s: Camera %d: Unable to refresh request in state %s", 630238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, mCameraId, 631238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde Parameters::getStateName(params.state)); 632238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 633238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 634238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 635238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde} 636238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 637238e0f934f1f47263b384bc745ae0678c777130dCasper Bondestatus_t Camera2Client::setPreviewCallbackTarget( 6383b147b770269173d5d711d6c33f142dc5e723824zzy const sp<IGraphicBufferProducer>& callbackProducer) { 639fea17de7aaa5729d3111102b2734b158403d2780Jeff Sharkey ATRACE_CALL(); 6403b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("%s: E", __FUNCTION__); 6413b147b770269173d5d711d6c33f142dc5e723824zzy Mutex::Autolock icl(mBinderSerializationLock); 6423b147b770269173d5d711d6c33f142dc5e723824zzy status_t res; 6433b147b770269173d5d711d6c33f142dc5e723824zzy if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 6443b147b770269173d5d711d6c33f142dc5e723824zzy 645238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde sp<ANativeWindow> window; 646238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (callbackProducer != 0) { 6473b147b770269173d5d711d6c33f142dc5e723824zzy window = new Surface(callbackProducer); 648238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 6493b147b770269173d5d711d6c33f142dc5e723824zzy 6503b147b770269173d5d711d6c33f142dc5e723824zzy res = mCallbackProcessor->setCallbackWindow(window); 651652678af4d18b9a6c18ce6a860de01d958bc82fezzy if (res != OK) { 652652678af4d18b9a6c18ce6a860de01d958bc82fezzy ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)", 6533b147b770269173d5d711d6c33f142dc5e723824zzy __FUNCTION__, mCameraId, strerror(-res), res); 6543b147b770269173d5d711d6c33f142dc5e723824zzy return res; 6553b147b770269173d5d711d6c33f142dc5e723824zzy } 6563b147b770269173d5d711d6c33f142dc5e723824zzy 657238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde SharedParameters::Lock l(mParameters); 658238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 6593b147b770269173d5d711d6c33f142dc5e723824zzy if (window != NULL) { 660563e414784eb81e4ea4051667d5c8855b17f7534Matthew Xie // Disable traditional callbacks when a valid callback target is given 661238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP; 662238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde l.mParameters.previewCallbackOneShot = false; 6633b147b770269173d5d711d6c33f142dc5e723824zzy l.mParameters.previewCallbackSurface = true; 6643b147b770269173d5d711d6c33f142dc5e723824zzy } else { 6653b147b770269173d5d711d6c33f142dc5e723824zzy // Disable callback target if given a NULL interface. 6663b147b770269173d5d711d6c33f142dc5e723824zzy l.mParameters.previewCallbackSurface = false; 667238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 668238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 669238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde switch(l.mParameters.state) { 670238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::PREVIEW: 671238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde res = startPreviewL(l.mParameters, true); 672238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde break; 673238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::RECORD: 674238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde case Parameters::VIDEO_SNAPSHOT: 675238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde res = startRecordingL(l.mParameters, true); 676238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde break; 677238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde default: 678238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde break; 679238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 6803b147b770269173d5d711d6c33f142dc5e723824zzy if (res != OK) { 6813b147b770269173d5d711d6c33f142dc5e723824zzy ALOGE("%s: Camera %d: Unable to refresh request in state %s", 6823b147b770269173d5d711d6c33f142dc5e723824zzy __FUNCTION__, mCameraId, 6833b147b770269173d5d711d6c33f142dc5e723824zzy Parameters::getStateName(l.mParameters.state)); 684d6883533e4ac3f73d2fde1db9a1dddf06dac6709fredc } 685238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 686238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return OK; 6873b147b770269173d5d711d6c33f142dc5e723824zzy} 6883b147b770269173d5d711d6c33f142dc5e723824zzy 6893b147b770269173d5d711d6c33f142dc5e723824zzy 6903b147b770269173d5d711d6c33f142dc5e723824zzystatus_t Camera2Client::startPreview() { 69116fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly ATRACE_CALL(); 6923b147b770269173d5d711d6c33f142dc5e723824zzy ALOGV("%s: E", __FUNCTION__); 6933b147b770269173d5d711d6c33f142dc5e723824zzy Mutex::Autolock icl(mBinderSerializationLock); 6943b147b770269173d5d711d6c33f142dc5e723824zzy status_t res; 6953b147b770269173d5d711d6c33f142dc5e723824zzy if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 6963b147b770269173d5d711d6c33f142dc5e723824zzy SharedParameters::Lock l(mParameters); 6973b147b770269173d5d711d6c33f142dc5e723824zzy return startPreviewL(l.mParameters, false); 698563e414784eb81e4ea4051667d5c8855b17f7534Matthew Xie} 6993b147b770269173d5d711d6c33f142dc5e723824zzy 7003b147b770269173d5d711d6c33f142dc5e723824zzystatus_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) { 7013b147b770269173d5d711d6c33f142dc5e723824zzy ATRACE_CALL(); 70216fb88a673c41b93c5d57ccb28c2697e7d87701aNick Pelly status_t res; 703238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 704238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart); 705238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde 706238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if ( (params.state == Parameters::PREVIEW || 707238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde params.state == Parameters::RECORD || 708238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde params.state == Parameters::VIDEO_SNAPSHOT) 709238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde && !restart) { 710238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde // Succeed attempt to re-enter a streaming state 711238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGI("%s: Camera %d: Preview already active, ignoring restart", 712238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde __FUNCTION__, mCameraId); 713238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde return OK; 714238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde } 715238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde if (params.state > Parameters::PREVIEW && !restart) { 716238e0f934f1f47263b384bc745ae0678c777130dCasper Bonde ALOGE("%s: Can't start preview in state %s", 7170b6955a48bad9aee01ae2f0c06d3f168ca603ab7Nick Pelly __FUNCTION__, 718 Parameters::getStateName(params.state)); 719 return INVALID_OPERATION; 720 } 721 722 if (!mStreamingProcessor->haveValidPreviewWindow()) { 723 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 724 return OK; 725 } 726 params.state = Parameters::STOPPED; 727 728 res = mStreamingProcessor->updatePreviewStream(params); 729 if (res != OK) { 730 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)", 731 __FUNCTION__, mCameraId, strerror(-res), res); 732 return res; 733 } 734 735 // We could wait to create the JPEG output stream until first actual use 736 // (first takePicture call). However, this would substantially increase the 737 // first capture latency on HAL3 devices, and potentially on some HAL2 738 // devices. So create it unconditionally at preview start. As a drawback, 739 // this increases gralloc memory consumption for applications that don't 740 // ever take a picture. 741 // TODO: Find a better compromise, though this likely would involve HAL 742 // changes. 743 res = updateProcessorStream(mJpegProcessor, params); 744 if (res != OK) { 745 ALOGE("%s: Camera %d: Can't pre-configure still image " 746 "stream: %s (%d)", 747 __FUNCTION__, mCameraId, strerror(-res), res); 748 return res; 749 } 750 751 Vector<int32_t> outputStreams; 752 bool callbacksEnabled = (params.previewCallbackFlags & 753 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) || 754 params.previewCallbackSurface; 755 756 if (callbacksEnabled) { 757 // Can't have recording stream hanging around when enabling callbacks, 758 // since it exceeds the max stream count on some devices. 759 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) { 760 ALOGV("%s: Camera %d: Clearing out recording stream before " 761 "creating callback stream", __FUNCTION__, mCameraId); 762 res = mStreamingProcessor->stopStream(); 763 if (res != OK) { 764 ALOGE("%s: Camera %d: Can't stop streaming to delete " 765 "recording stream", __FUNCTION__, mCameraId); 766 return res; 767 } 768 res = mStreamingProcessor->deleteRecordingStream(); 769 if (res != OK) { 770 ALOGE("%s: Camera %d: Unable to delete recording stream before " 771 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId, 772 strerror(-res), res); 773 return res; 774 } 775 } 776 777 res = mCallbackProcessor->updateStream(params); 778 if (res != OK) { 779 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 780 __FUNCTION__, mCameraId, strerror(-res), res); 781 return res; 782 } 783 outputStreams.push(getCallbackStreamId()); 784 } 785 if (params.zslMode && !params.recordingHint) { 786 res = updateProcessorStream(mZslProcessor, params); 787 if (res != OK) { 788 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)", 789 __FUNCTION__, mCameraId, strerror(-res), res); 790 return res; 791 } 792 outputStreams.push(getZslStreamId()); 793 } else { 794 mZslProcessor->deleteStream(); 795 } 796 797 outputStreams.push(getPreviewStreamId()); 798 799 if (!params.recordingHint) { 800 if (!restart) { 801 res = mStreamingProcessor->updatePreviewRequest(params); 802 if (res != OK) { 803 ALOGE("%s: Camera %d: Can't set up preview request: " 804 "%s (%d)", __FUNCTION__, mCameraId, 805 strerror(-res), res); 806 return res; 807 } 808 } 809 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW, 810 outputStreams); 811 } else { 812 if (!restart) { 813 res = mStreamingProcessor->updateRecordingRequest(params); 814 if (res != OK) { 815 ALOGE("%s: Camera %d: Can't set up preview request with " 816 "record hint: %s (%d)", __FUNCTION__, mCameraId, 817 strerror(-res), res); 818 return res; 819 } 820 } 821 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD, 822 outputStreams); 823 } 824 if (res != OK) { 825 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)", 826 __FUNCTION__, mCameraId, strerror(-res), res); 827 return res; 828 } 829 830 params.state = Parameters::PREVIEW; 831 return OK; 832} 833 834void Camera2Client::stopPreview() { 835 ATRACE_CALL(); 836 ALOGV("%s: E", __FUNCTION__); 837 Mutex::Autolock icl(mBinderSerializationLock); 838 status_t res; 839 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 840 stopPreviewL(); 841} 842 843void Camera2Client::stopPreviewL() { 844 ATRACE_CALL(); 845 status_t res; 846 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds 847 Parameters::State state; 848 { 849 SharedParameters::Lock l(mParameters); 850 state = l.mParameters.state; 851 } 852 853 switch (state) { 854 case Parameters::DISCONNECTED: 855 // Nothing to do. 856 break; 857 case Parameters::STOPPED: 858 case Parameters::VIDEO_SNAPSHOT: 859 case Parameters::STILL_CAPTURE: 860 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout); 861 // no break 862 case Parameters::RECORD: 863 case Parameters::PREVIEW: 864 syncWithDevice(); 865 res = stopStream(); 866 if (res != OK) { 867 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)", 868 __FUNCTION__, mCameraId, strerror(-res), res); 869 } 870 res = mDevice->waitUntilDrained(); 871 if (res != OK) { 872 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)", 873 __FUNCTION__, mCameraId, strerror(-res), res); 874 } 875 // no break 876 case Parameters::WAITING_FOR_PREVIEW_WINDOW: { 877 SharedParameters::Lock l(mParameters); 878 l.mParameters.state = Parameters::STOPPED; 879 commandStopFaceDetectionL(l.mParameters); 880 break; 881 } 882 default: 883 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId, 884 state); 885 } 886} 887 888bool Camera2Client::previewEnabled() { 889 ATRACE_CALL(); 890 Mutex::Autolock icl(mBinderSerializationLock); 891 status_t res; 892 if ( (res = checkPid(__FUNCTION__) ) != OK) return false; 893 894 SharedParameters::Lock l(mParameters); 895 return l.mParameters.state == Parameters::PREVIEW; 896} 897 898status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 899 ATRACE_CALL(); 900 Mutex::Autolock icl(mBinderSerializationLock); 901 status_t res; 902 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 903 904 SharedParameters::Lock l(mParameters); 905 switch (l.mParameters.state) { 906 case Parameters::RECORD: 907 case Parameters::VIDEO_SNAPSHOT: 908 ALOGE("%s: Camera %d: Can't be called in state %s", 909 __FUNCTION__, mCameraId, 910 Parameters::getStateName(l.mParameters.state)); 911 return INVALID_OPERATION; 912 default: 913 // OK 914 break; 915 } 916 917 l.mParameters.storeMetadataInBuffers = enabled; 918 919 return OK; 920} 921 922status_t Camera2Client::startRecording() { 923 ATRACE_CALL(); 924 ALOGV("%s: E", __FUNCTION__); 925 Mutex::Autolock icl(mBinderSerializationLock); 926 status_t res; 927 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 928 SharedParameters::Lock l(mParameters); 929 930 return startRecordingL(l.mParameters, false); 931} 932 933status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) { 934 status_t res; 935 936 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart); 937 938 switch (params.state) { 939 case Parameters::STOPPED: 940 res = startPreviewL(params, false); 941 if (res != OK) return res; 942 break; 943 case Parameters::PREVIEW: 944 // Ready to go 945 break; 946 case Parameters::RECORD: 947 case Parameters::VIDEO_SNAPSHOT: 948 // OK to call this when recording is already on, just skip unless 949 // we're looking to restart 950 if (!restart) return OK; 951 break; 952 default: 953 ALOGE("%s: Camera %d: Can't start recording in state %s", 954 __FUNCTION__, mCameraId, 955 Parameters::getStateName(params.state)); 956 return INVALID_OPERATION; 957 }; 958 959 if (!params.storeMetadataInBuffers) { 960 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but " 961 "non-metadata recording mode requested!", __FUNCTION__, 962 mCameraId); 963 return INVALID_OPERATION; 964 } 965 966 if (!restart) { 967 mCameraService->playSound(CameraService::SOUND_RECORDING); 968 mStreamingProcessor->updateRecordingRequest(params); 969 if (res != OK) { 970 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 971 __FUNCTION__, mCameraId, strerror(-res), res); 972 return res; 973 } 974 } 975 976 // Not all devices can support a preview callback stream and a recording 977 // stream at the same time, so assume none of them can. 978 if (mCallbackProcessor->getStreamId() != NO_STREAM) { 979 ALOGV("%s: Camera %d: Clearing out callback stream before " 980 "creating recording stream", __FUNCTION__, mCameraId); 981 res = mStreamingProcessor->stopStream(); 982 if (res != OK) { 983 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream", 984 __FUNCTION__, mCameraId); 985 return res; 986 } 987 res = mCallbackProcessor->deleteStream(); 988 if (res != OK) { 989 ALOGE("%s: Camera %d: Unable to delete callback stream before " 990 "record: %s (%d)", __FUNCTION__, mCameraId, 991 strerror(-res), res); 992 return res; 993 } 994 } 995 // Disable callbacks if they're enabled; can't record and use callbacks, 996 // and we can't fail record start without stagefright asserting. 997 params.previewCallbackFlags = 0; 998 999 res = updateProcessorStream< 1000 StreamingProcessor, 1001 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor, 1002 params); 1003 if (res != OK) { 1004 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)", 1005 __FUNCTION__, mCameraId, strerror(-res), res); 1006 return res; 1007 } 1008 1009 Vector<int32_t> outputStreams; 1010 outputStreams.push(getPreviewStreamId()); 1011 outputStreams.push(getRecordingStreamId()); 1012 1013 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD, 1014 outputStreams); 1015 if (res != OK) { 1016 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)", 1017 __FUNCTION__, mCameraId, strerror(-res), res); 1018 return res; 1019 } 1020 1021 if (params.state < Parameters::RECORD) { 1022 params.state = Parameters::RECORD; 1023 } 1024 1025 return OK; 1026} 1027 1028void Camera2Client::stopRecording() { 1029 ATRACE_CALL(); 1030 ALOGV("%s: E", __FUNCTION__); 1031 Mutex::Autolock icl(mBinderSerializationLock); 1032 SharedParameters::Lock l(mParameters); 1033 1034 status_t res; 1035 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 1036 1037 switch (l.mParameters.state) { 1038 case Parameters::RECORD: 1039 // OK to stop 1040 break; 1041 case Parameters::STOPPED: 1042 case Parameters::PREVIEW: 1043 case Parameters::STILL_CAPTURE: 1044 case Parameters::VIDEO_SNAPSHOT: 1045 default: 1046 ALOGE("%s: Camera %d: Can't stop recording in state %s", 1047 __FUNCTION__, mCameraId, 1048 Parameters::getStateName(l.mParameters.state)); 1049 return; 1050 }; 1051 1052 mCameraService->playSound(CameraService::SOUND_RECORDING); 1053 1054 res = startPreviewL(l.mParameters, true); 1055 if (res != OK) { 1056 ALOGE("%s: Camera %d: Unable to return to preview", 1057 __FUNCTION__, mCameraId); 1058 } 1059} 1060 1061bool Camera2Client::recordingEnabled() { 1062 ATRACE_CALL(); 1063 Mutex::Autolock icl(mBinderSerializationLock); 1064 1065 if ( checkPid(__FUNCTION__) != OK) return false; 1066 1067 return recordingEnabledL(); 1068} 1069 1070bool Camera2Client::recordingEnabledL() { 1071 ATRACE_CALL(); 1072 SharedParameters::Lock l(mParameters); 1073 1074 return (l.mParameters.state == Parameters::RECORD 1075 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT); 1076} 1077 1078void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 1079 ATRACE_CALL(); 1080 Mutex::Autolock icl(mBinderSerializationLock); 1081 if ( checkPid(__FUNCTION__) != OK) return; 1082 1083 mStreamingProcessor->releaseRecordingFrame(mem); 1084} 1085 1086status_t Camera2Client::autoFocus() { 1087 ATRACE_CALL(); 1088 Mutex::Autolock icl(mBinderSerializationLock); 1089 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1090 status_t res; 1091 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1092 1093 int triggerId; 1094 bool notifyImmediately = false; 1095 bool notifySuccess = false; 1096 { 1097 SharedParameters::Lock l(mParameters); 1098 if (l.mParameters.state < Parameters::PREVIEW) { 1099 return INVALID_OPERATION; 1100 } 1101 1102 /** 1103 * If the camera does not support auto-focus, it is a no-op and 1104 * onAutoFocus(boolean, Camera) callback will be called immediately 1105 * with a fake value of success set to true. 1106 * 1107 * Similarly, if focus mode is set to INFINITY, there's no reason to 1108 * bother the HAL. 1109 */ 1110 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED || 1111 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) { 1112 notifyImmediately = true; 1113 notifySuccess = true; 1114 } 1115 /** 1116 * If we're in CAF mode, and AF has already been locked, just fire back 1117 * the callback right away; the HAL would not send a notification since 1118 * no state change would happen on a AF trigger. 1119 */ 1120 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE || 1121 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) && 1122 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) { 1123 notifyImmediately = true; 1124 notifySuccess = true; 1125 } 1126 /** 1127 * Send immediate notification back to client 1128 */ 1129 if (notifyImmediately) { 1130 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks); 1131 if (l.mRemoteCallback != 0) { 1132 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS, 1133 notifySuccess ? 1 : 0, 0); 1134 } 1135 return OK; 1136 } 1137 /** 1138 * Handle quirk mode for AF in scene modes 1139 */ 1140 if (l.mParameters.quirks.triggerAfWithAuto && 1141 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED && 1142 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO && 1143 !l.mParameters.focusingAreas[0].isEmpty()) { 1144 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO", 1145 __FUNCTION__, l.mParameters.focusMode); 1146 l.mParameters.shadowFocusMode = l.mParameters.focusMode; 1147 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO; 1148 updateRequests(l.mParameters); 1149 } 1150 1151 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter; 1152 triggerId = l.mParameters.currentAfTriggerId; 1153 } 1154 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId); 1155 1156 syncWithDevice(); 1157 1158 mDevice->triggerAutofocus(triggerId); 1159 1160 return OK; 1161} 1162 1163status_t Camera2Client::cancelAutoFocus() { 1164 ATRACE_CALL(); 1165 Mutex::Autolock icl(mBinderSerializationLock); 1166 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1167 status_t res; 1168 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1169 1170 int triggerId; 1171 { 1172 SharedParameters::Lock l(mParameters); 1173 // Canceling does nothing in FIXED or INFINITY modes 1174 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED || 1175 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) { 1176 return OK; 1177 } 1178 1179 // An active AF trigger is canceled 1180 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) { 1181 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId); 1182 } 1183 1184 triggerId = ++l.mParameters.afTriggerCounter; 1185 1186 // When using triggerAfWithAuto quirk, may need to reset focus mode to 1187 // the real state at this point. No need to cancel explicitly if 1188 // changing the AF mode. 1189 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) { 1190 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__, 1191 l.mParameters.shadowFocusMode); 1192 l.mParameters.focusMode = l.mParameters.shadowFocusMode; 1193 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID; 1194 updateRequests(l.mParameters); 1195 1196 return OK; 1197 } 1198 } 1199 syncWithDevice(); 1200 1201 mDevice->triggerCancelAutofocus(triggerId); 1202 1203 return OK; 1204} 1205 1206status_t Camera2Client::takePicture(int msgType) { 1207 ATRACE_CALL(); 1208 Mutex::Autolock icl(mBinderSerializationLock); 1209 status_t res; 1210 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1211 1212 int takePictureCounter; 1213 { 1214 SharedParameters::Lock l(mParameters); 1215 switch (l.mParameters.state) { 1216 case Parameters::DISCONNECTED: 1217 case Parameters::STOPPED: 1218 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1219 ALOGE("%s: Camera %d: Cannot take picture without preview enabled", 1220 __FUNCTION__, mCameraId); 1221 return INVALID_OPERATION; 1222 case Parameters::PREVIEW: 1223 // Good to go for takePicture 1224 res = commandStopFaceDetectionL(l.mParameters); 1225 if (res != OK) { 1226 ALOGE("%s: Camera %d: Unable to stop face detection for still capture", 1227 __FUNCTION__, mCameraId); 1228 return res; 1229 } 1230 l.mParameters.state = Parameters::STILL_CAPTURE; 1231 break; 1232 case Parameters::RECORD: 1233 // Good to go for video snapshot 1234 l.mParameters.state = Parameters::VIDEO_SNAPSHOT; 1235 break; 1236 case Parameters::STILL_CAPTURE: 1237 case Parameters::VIDEO_SNAPSHOT: 1238 ALOGE("%s: Camera %d: Already taking a picture", 1239 __FUNCTION__, mCameraId); 1240 return INVALID_OPERATION; 1241 } 1242 1243 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId); 1244 1245 res = updateProcessorStream(mJpegProcessor, l.mParameters); 1246 if (res != OK) { 1247 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)", 1248 __FUNCTION__, mCameraId, strerror(-res), res); 1249 return res; 1250 } 1251 takePictureCounter = ++l.mParameters.takePictureCounter; 1252 } 1253 1254 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter); 1255 1256 // Need HAL to have correct settings before (possibly) triggering precapture 1257 syncWithDevice(); 1258 1259 res = mCaptureSequencer->startCapture(msgType); 1260 if (res != OK) { 1261 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)", 1262 __FUNCTION__, mCameraId, strerror(-res), res); 1263 } 1264 1265 return res; 1266} 1267 1268status_t Camera2Client::setParameters(const String8& params) { 1269 ATRACE_CALL(); 1270 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1271 Mutex::Autolock icl(mBinderSerializationLock); 1272 status_t res; 1273 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1274 1275 SharedParameters::Lock l(mParameters); 1276 1277 res = l.mParameters.set(params); 1278 if (res != OK) return res; 1279 1280 res = updateRequests(l.mParameters); 1281 1282 return res; 1283} 1284 1285String8 Camera2Client::getParameters() const { 1286 ATRACE_CALL(); 1287 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1288 Mutex::Autolock icl(mBinderSerializationLock); 1289 if ( checkPid(__FUNCTION__) != OK) return String8(); 1290 1291 SharedParameters::ReadLock l(mParameters); 1292 1293 return l.mParameters.get(); 1294} 1295 1296status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 1297 ATRACE_CALL(); 1298 Mutex::Autolock icl(mBinderSerializationLock); 1299 status_t res; 1300 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1301 1302 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId, 1303 cmd, arg1, arg2); 1304 1305 switch (cmd) { 1306 case CAMERA_CMD_START_SMOOTH_ZOOM: 1307 return commandStartSmoothZoomL(); 1308 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 1309 return commandStopSmoothZoomL(); 1310 case CAMERA_CMD_SET_DISPLAY_ORIENTATION: 1311 return commandSetDisplayOrientationL(arg1); 1312 case CAMERA_CMD_ENABLE_SHUTTER_SOUND: 1313 return commandEnableShutterSoundL(arg1 == 1); 1314 case CAMERA_CMD_PLAY_RECORDING_SOUND: 1315 return commandPlayRecordingSoundL(); 1316 case CAMERA_CMD_START_FACE_DETECTION: 1317 return commandStartFaceDetectionL(arg1); 1318 case CAMERA_CMD_STOP_FACE_DETECTION: { 1319 SharedParameters::Lock l(mParameters); 1320 return commandStopFaceDetectionL(l.mParameters); 1321 } 1322 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: 1323 return commandEnableFocusMoveMsgL(arg1 == 1); 1324 case CAMERA_CMD_PING: 1325 return commandPingL(); 1326 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT: 1327 return commandSetVideoBufferCountL(arg1); 1328 default: 1329 ALOGE("%s: Unknown command %d (arguments %d, %d)", 1330 __FUNCTION__, cmd, arg1, arg2); 1331 return BAD_VALUE; 1332 } 1333} 1334 1335status_t Camera2Client::commandStartSmoothZoomL() { 1336 ALOGE("%s: Unimplemented!", __FUNCTION__); 1337 return OK; 1338} 1339 1340status_t Camera2Client::commandStopSmoothZoomL() { 1341 ALOGE("%s: Unimplemented!", __FUNCTION__); 1342 return OK; 1343} 1344 1345status_t Camera2Client::commandSetDisplayOrientationL(int degrees) { 1346 int transform = Parameters::degToTransform(degrees, 1347 mCameraFacing == CAMERA_FACING_FRONT); 1348 if (transform == -1) { 1349 ALOGE("%s: Camera %d: Error setting %d as display orientation value", 1350 __FUNCTION__, mCameraId, degrees); 1351 return BAD_VALUE; 1352 } 1353 SharedParameters::Lock l(mParameters); 1354 if (transform != l.mParameters.previewTransform && 1355 getPreviewStreamId() != NO_STREAM) { 1356 mDevice->setStreamTransform(getPreviewStreamId(), transform); 1357 } 1358 l.mParameters.previewTransform = transform; 1359 return OK; 1360} 1361 1362status_t Camera2Client::commandEnableShutterSoundL(bool enable) { 1363 SharedParameters::Lock l(mParameters); 1364 if (enable) { 1365 l.mParameters.playShutterSound = true; 1366 return OK; 1367 } 1368 1369 // Disabling shutter sound may not be allowed. In that case only 1370 // allow the mediaserver process to disable the sound. 1371 char value[PROPERTY_VALUE_MAX]; 1372 property_get("ro.camera.sound.forced", value, "0"); 1373 if (strncmp(value, "0", 2) != 0) { 1374 // Disabling shutter sound is not allowed. Deny if the current 1375 // process is not mediaserver. 1376 if (getCallingPid() != getpid()) { 1377 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)", 1378 getCallingPid()); 1379 return PERMISSION_DENIED; 1380 } 1381 } 1382 1383 l.mParameters.playShutterSound = false; 1384 return OK; 1385} 1386 1387status_t Camera2Client::commandPlayRecordingSoundL() { 1388 mCameraService->playSound(CameraService::SOUND_RECORDING); 1389 return OK; 1390} 1391 1392status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) { 1393 ALOGV("%s: Camera %d: Starting face detection", 1394 __FUNCTION__, mCameraId); 1395 status_t res; 1396 SharedParameters::Lock l(mParameters); 1397 switch (l.mParameters.state) { 1398 case Parameters::DISCONNECTED: 1399 case Parameters::STOPPED: 1400 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1401 case Parameters::STILL_CAPTURE: 1402 ALOGE("%s: Camera %d: Cannot start face detection without preview active", 1403 __FUNCTION__, mCameraId); 1404 return INVALID_OPERATION; 1405 case Parameters::PREVIEW: 1406 case Parameters::RECORD: 1407 case Parameters::VIDEO_SNAPSHOT: 1408 // Good to go for starting face detect 1409 break; 1410 } 1411 // Ignoring type 1412 if (l.mParameters.fastInfo.bestFaceDetectMode == 1413 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) { 1414 ALOGE("%s: Camera %d: Face detection not supported", 1415 __FUNCTION__, mCameraId); 1416 return BAD_VALUE; 1417 } 1418 if (l.mParameters.enableFaceDetect) return OK; 1419 1420 l.mParameters.enableFaceDetect = true; 1421 1422 res = updateRequests(l.mParameters); 1423 1424 return res; 1425} 1426 1427status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) { 1428 status_t res = OK; 1429 ALOGV("%s: Camera %d: Stopping face detection", 1430 __FUNCTION__, mCameraId); 1431 1432 if (!params.enableFaceDetect) return OK; 1433 1434 params.enableFaceDetect = false; 1435 1436 if (params.state == Parameters::PREVIEW 1437 || params.state == Parameters::RECORD 1438 || params.state == Parameters::VIDEO_SNAPSHOT) { 1439 res = updateRequests(params); 1440 } 1441 1442 return res; 1443} 1444 1445status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) { 1446 SharedParameters::Lock l(mParameters); 1447 l.mParameters.enableFocusMoveMessages = enable; 1448 1449 return OK; 1450} 1451 1452status_t Camera2Client::commandPingL() { 1453 // Always ping back if access is proper and device is alive 1454 SharedParameters::Lock l(mParameters); 1455 if (l.mParameters.state != Parameters::DISCONNECTED) { 1456 return OK; 1457 } else { 1458 return NO_INIT; 1459 } 1460} 1461 1462status_t Camera2Client::commandSetVideoBufferCountL(size_t count) { 1463 if (recordingEnabledL()) { 1464 ALOGE("%s: Camera %d: Error setting video buffer count after " 1465 "recording was started", __FUNCTION__, mCameraId); 1466 return INVALID_OPERATION; 1467 } 1468 1469 return mStreamingProcessor->setRecordingBufferCount(count); 1470} 1471 1472/** Device-related methods */ 1473void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) { 1474 ALOGV("%s: Autofocus state now %d, last trigger %d", 1475 __FUNCTION__, newState, triggerId); 1476 bool sendCompletedMessage = false; 1477 bool sendMovingMessage = false; 1478 1479 bool success = false; 1480 bool afInMotion = false; 1481 { 1482 SharedParameters::Lock l(mParameters); 1483 // Trace end of AF state 1484 char tmp[32]; 1485 if (l.mParameters.afStateCounter > 0) { 1486 camera_metadata_enum_snprint( 1487 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp)); 1488 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter); 1489 } 1490 1491 // Update state 1492 l.mParameters.focusState = newState; 1493 l.mParameters.afStateCounter++; 1494 1495 // Trace start of AF state 1496 1497 camera_metadata_enum_snprint( 1498 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp)); 1499 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter); 1500 1501 switch (l.mParameters.focusMode) { 1502 case Parameters::FOCUS_MODE_AUTO: 1503 case Parameters::FOCUS_MODE_MACRO: 1504 // Don't send notifications upstream if they're not for the current AF 1505 // trigger. For example, if cancel was called in between, or if we 1506 // already sent a notification about this AF call. 1507 if (triggerId != l.mParameters.currentAfTriggerId) break; 1508 switch (newState) { 1509 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1510 success = true; 1511 // no break 1512 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1513 sendCompletedMessage = true; 1514 l.mParameters.currentAfTriggerId = -1; 1515 break; 1516 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1517 // Just starting focusing, ignore 1518 break; 1519 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1520 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1521 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1522 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED: 1523 default: 1524 // Unexpected in AUTO/MACRO mode 1525 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d", 1526 __FUNCTION__, newState); 1527 break; 1528 } 1529 break; 1530 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1531 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1532 switch (newState) { 1533 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1534 success = true; 1535 // no break 1536 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1537 // Don't send notifications upstream if they're not for 1538 // the current AF trigger. For example, if cancel was 1539 // called in between, or if we already sent a 1540 // notification about this AF call. 1541 // Send both a 'AF done' callback and a 'AF move' callback 1542 if (triggerId != l.mParameters.currentAfTriggerId) break; 1543 sendCompletedMessage = true; 1544 afInMotion = false; 1545 if (l.mParameters.enableFocusMoveMessages && 1546 l.mParameters.afInMotion) { 1547 sendMovingMessage = true; 1548 } 1549 l.mParameters.currentAfTriggerId = -1; 1550 break; 1551 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1552 // Cancel was called, or we switched state; care if 1553 // currently moving 1554 afInMotion = false; 1555 if (l.mParameters.enableFocusMoveMessages && 1556 l.mParameters.afInMotion) { 1557 sendMovingMessage = true; 1558 } 1559 break; 1560 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1561 // Start passive scan, inform upstream 1562 afInMotion = true; 1563 // no break 1564 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1565 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED: 1566 // Stop passive scan, inform upstream 1567 if (l.mParameters.enableFocusMoveMessages) { 1568 sendMovingMessage = true; 1569 } 1570 break; 1571 } 1572 l.mParameters.afInMotion = afInMotion; 1573 break; 1574 case Parameters::FOCUS_MODE_EDOF: 1575 case Parameters::FOCUS_MODE_INFINITY: 1576 case Parameters::FOCUS_MODE_FIXED: 1577 default: 1578 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) { 1579 ALOGE("%s: Unexpected AF state change %d " 1580 "(ID %d) in focus mode %d", 1581 __FUNCTION__, newState, triggerId, 1582 l.mParameters.focusMode); 1583 } 1584 } 1585 } 1586 if (sendMovingMessage) { 1587 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks); 1588 if (l.mRemoteCallback != 0) { 1589 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE, 1590 afInMotion ? 1 : 0, 0); 1591 } 1592 } 1593 if (sendCompletedMessage) { 1594 ATRACE_ASYNC_END(kAutofocusLabel, triggerId); 1595 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks); 1596 if (l.mRemoteCallback != 0) { 1597 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS, 1598 success ? 1 : 0, 0); 1599 } 1600 } 1601} 1602 1603void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) { 1604 ALOGV("%s: Autoexposure state now %d, last trigger %d", 1605 __FUNCTION__, newState, triggerId); 1606 mCaptureSequencer->notifyAutoExposure(newState, triggerId); 1607} 1608 1609camera2::SharedParameters& Camera2Client::getParameters() { 1610 return mParameters; 1611} 1612 1613int Camera2Client::getPreviewStreamId() const { 1614 return mStreamingProcessor->getPreviewStreamId(); 1615} 1616 1617int Camera2Client::getCaptureStreamId() const { 1618 return mJpegProcessor->getStreamId(); 1619} 1620 1621int Camera2Client::getCallbackStreamId() const { 1622 return mCallbackProcessor->getStreamId(); 1623} 1624 1625int Camera2Client::getRecordingStreamId() const { 1626 return mStreamingProcessor->getRecordingStreamId(); 1627} 1628 1629int Camera2Client::getZslStreamId() const { 1630 return mZslProcessor->getStreamId(); 1631} 1632 1633status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId, 1634 wp<camera2::FrameProcessor::FilteredListener> listener) { 1635 return mFrameProcessor->registerListener(minId, maxId, listener); 1636} 1637 1638status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId, 1639 wp<camera2::FrameProcessor::FilteredListener> listener) { 1640 return mFrameProcessor->removeListener(minId, maxId, listener); 1641} 1642 1643status_t Camera2Client::stopStream() { 1644 return mStreamingProcessor->stopStream(); 1645} 1646 1647const int32_t Camera2Client::kPreviewRequestIdStart; 1648const int32_t Camera2Client::kPreviewRequestIdEnd; 1649const int32_t Camera2Client::kRecordingRequestIdStart; 1650const int32_t Camera2Client::kRecordingRequestIdEnd; 1651const int32_t Camera2Client::kCaptureRequestIdStart; 1652const int32_t Camera2Client::kCaptureRequestIdEnd; 1653 1654/** Utility methods */ 1655 1656status_t Camera2Client::updateRequests(Parameters ¶ms) { 1657 status_t res; 1658 1659 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state); 1660 1661 res = mStreamingProcessor->incrementStreamingIds(); 1662 if (res != OK) { 1663 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)", 1664 __FUNCTION__, mCameraId, strerror(-res), res); 1665 return res; 1666 } 1667 1668 res = mStreamingProcessor->updatePreviewRequest(params); 1669 if (res != OK) { 1670 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)", 1671 __FUNCTION__, mCameraId, strerror(-res), res); 1672 return res; 1673 } 1674 res = mStreamingProcessor->updateRecordingRequest(params); 1675 if (res != OK) { 1676 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 1677 __FUNCTION__, mCameraId, strerror(-res), res); 1678 return res; 1679 } 1680 1681 if (params.state == Parameters::PREVIEW) { 1682 res = startPreviewL(params, true); 1683 if (res != OK) { 1684 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)", 1685 __FUNCTION__, mCameraId, strerror(-res), res); 1686 return res; 1687 } 1688 } else if (params.state == Parameters::RECORD || 1689 params.state == Parameters::VIDEO_SNAPSHOT) { 1690 res = startRecordingL(params, true); 1691 if (res != OK) { 1692 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)", 1693 __FUNCTION__, mCameraId, strerror(-res), res); 1694 return res; 1695 } 1696 } 1697 return res; 1698} 1699 1700 1701size_t Camera2Client::calculateBufferSize(int width, int height, 1702 int format, int stride) { 1703 switch (format) { 1704 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1705 return width * height * 2; 1706 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1707 return width * height * 3 / 2; 1708 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1709 return width * height * 2; 1710 case HAL_PIXEL_FORMAT_YV12: { // YV12 1711 size_t ySize = stride * height; 1712 size_t uvStride = (stride / 2 + 0xF) & ~0xF; 1713 size_t uvSize = uvStride * height / 2; 1714 return ySize + uvSize * 2; 1715 } 1716 case HAL_PIXEL_FORMAT_RGB_565: 1717 return width * height * 2; 1718 case HAL_PIXEL_FORMAT_RGBA_8888: 1719 return width * height * 4; 1720 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1721 return width * height * 2; 1722 default: 1723 ALOGE("%s: Unknown preview format: %x", 1724 __FUNCTION__, format); 1725 return 0; 1726 } 1727} 1728 1729status_t Camera2Client::syncWithDevice() { 1730 ATRACE_CALL(); 1731 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms 1732 status_t res; 1733 1734 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId(); 1735 if (activeRequestId == 0) return OK; 1736 1737 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout); 1738 if (res == TIMED_OUT) { 1739 ALOGE("%s: Camera %d: Timed out waiting sync with HAL", 1740 __FUNCTION__, mCameraId); 1741 } else if (res != OK) { 1742 ALOGE("%s: Camera %d: Error while waiting to sync with HAL", 1743 __FUNCTION__, mCameraId); 1744 } 1745 return res; 1746} 1747 1748template <typename ProcessorT> 1749status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor, 1750 camera2::Parameters params) { 1751 // No default template arguments until C++11, so we need this overload 1752 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>( 1753 processor, params); 1754} 1755 1756template <typename ProcessorT, 1757 status_t (ProcessorT::*updateStreamF)(const Parameters &)> 1758status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor, 1759 Parameters params) { 1760 status_t res; 1761 1762 // Get raw pointer since sp<T> doesn't have operator->* 1763 ProcessorT *processorPtr = processor.get(); 1764 res = (processorPtr->*updateStreamF)(params); 1765 1766 /** 1767 * Can't update the stream if it's busy? 1768 * 1769 * Then we need to stop the device (by temporarily clearing the request 1770 * queue) and then try again. Resume streaming once we're done. 1771 */ 1772 if (res == -EBUSY) { 1773 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__, 1774 mCameraId); 1775 res = mStreamingProcessor->togglePauseStream(/*pause*/true); 1776 if (res != OK) { 1777 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)", 1778 __FUNCTION__, mCameraId, strerror(-res), res); 1779 } 1780 1781 res = mDevice->waitUntilDrained(); 1782 if (res != OK) { 1783 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)", 1784 __FUNCTION__, mCameraId, strerror(-res), res); 1785 } 1786 1787 res = (processorPtr->*updateStreamF)(params); 1788 if (res != OK) { 1789 ALOGE("%s: Camera %d: Failed to update processing stream " 1790 " despite having halted streaming first: %s (%d)", 1791 __FUNCTION__, mCameraId, strerror(-res), res); 1792 } 1793 1794 res = mStreamingProcessor->togglePauseStream(/*pause*/false); 1795 if (res != OK) { 1796 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)", 1797 __FUNCTION__, mCameraId, strerror(-res), res); 1798 } 1799 } 1800 1801 return res; 1802} 1803 1804const char* Camera2Client::kAutofocusLabel = "autofocus"; 1805const char* Camera2Client::kTakepictureLabel = "take_picture"; 1806 1807} // namespace android 1808