blob: 944b8ab964d84fbe1781b7fabc715e18d9f22cea [file] [log] [blame]
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Zhijun Hecc27e112013-10-03 16:12:43 -070017#define LOG_TAG "Camera2Client"
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070018#define ATRACE_TAG ATRACE_TAG_CAMERA
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070019//#define LOG_NDEBUG 0
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070020
Kévin PETIT377b2ec2014-02-03 12:35:36 +000021#include <inttypes.h>
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070022#include <utils/Log.h>
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070023#include <utils/Trace.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070024
25#include <cutils/properties.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070026#include <gui/Surface.h>
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080027#include <android/hardware/camera2/ICameraDeviceCallbacks.h>
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070028
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070029#include "api1/Camera2Client.h"
30
31#include "api1/client2/StreamingProcessor.h"
32#include "api1/client2/JpegProcessor.h"
33#include "api1/client2/CaptureSequencer.h"
34#include "api1/client2/CallbackProcessor.h"
35#include "api1/client2/ZslProcessor.h"
Jayant Chowdhary12361932018-08-27 14:46:13 -070036#include "utils/CameraThreadState.h"
Shuzhen Wang316781a2020-08-18 18:11:01 -070037#include "utils/CameraServiceProxyWrapper.h"
Igor Murashkinae500e52013-04-22 14:03:54 -070038
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070039#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
40#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
41
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -070042#ifndef FALLTHROUGH_INTENDED
43#define FALLTHROUGH_INTENDED [[fallthrough]]
44#endif
45
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070046namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070047using namespace camera2;
48
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070049// Interface used by CameraService
50
51Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080052 const sp<hardware::ICameraClient>& cameraClient,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080053 const String16& clientPackageName,
Jooyung Hanb3f7cd22020-01-23 12:27:18 +090054 const std::optional<String16>& clientFeatureId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080055 const String8& cameraDeviceId,
56 int api1CameraId,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070057 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -070058 int sensorOrientation,
Igor Murashkinecf17e82012-10-02 16:05:11 -070059 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080060 uid_t clientUid,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070061 int servicePid,
62 bool overrideForPerfClass):
Philip P. Moltmann9e648f62019-11-04 12:52:45 -080063 Camera2ClientBase(cameraService, cameraClient, clientPackageName, clientFeatureId,
Emilian Peev8b64f282021-03-25 16:49:57 -070064 cameraDeviceId, api1CameraId, cameraFacing, sensorOrientation,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070065 clientPid, clientUid, servicePid, overrideForPerfClass),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080066 mParameters(api1CameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070067{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070068 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070069
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070070 SharedParameters::Lock l(mParameters);
71 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070072}
73
Emilian Peevbd8c5032018-02-14 23:05:40 +000074status_t Camera2Client::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) {
75 return initializeImpl(manager, monitorTags);
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080076}
77
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -070078bool Camera2Client::isZslEnabledInStillTemplate() {
79 bool zslEnabled = false;
80 CameraMetadata stillTemplate;
Emilian Peevf4816702020-04-03 15:44:51 -070081 status_t res = mDevice->createDefaultRequest(
82 camera_request_template_t::CAMERA_TEMPLATE_STILL_CAPTURE, &stillTemplate);
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -070083 if (res == OK) {
84 camera_metadata_entry_t enableZsl = stillTemplate.find(ANDROID_CONTROL_ENABLE_ZSL);
85 if (enableZsl.count == 1) {
86 zslEnabled = (enableZsl.data.u8[0] == ANDROID_CONTROL_ENABLE_ZSL_TRUE);
87 }
88 }
89
90 return zslEnabled;
91}
92
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080093template<typename TProviderPtr>
Emilian Peevbd8c5032018-02-14 23:05:40 +000094status_t Camera2Client::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070095{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070096 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070097 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070098 status_t res;
99
Emilian Peevbd8c5032018-02-14 23:05:40 +0000100 res = Camera2ClientBase::initialize(providerPtr, monitorTags);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800101 if (res != OK) {
102 return res;
103 }
104
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700105 {
106 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700107
Shuzhen Wangb131f4a2018-06-21 18:19:11 -0700108 res = l.mParameters.initialize(mDevice.get(), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700109 if (res != OK) {
110 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
111 __FUNCTION__, mCameraId, strerror(-res), res);
112 return NO_INIT;
113 }
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -0700114
115 l.mParameters.isDeviceZslSupported = isZslEnabledInStillTemplate();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700116 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700117
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700118 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700119
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700120 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700121 threadName = String8::format("C2-%d-StreamProc",
122 mCameraId);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700123
Igor Murashkince124da2013-03-04 14:53:08 -0800124 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700125 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700126 mCameraId);
127 mFrameProcessor->run(threadName.string());
128
129 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700130 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700131 mCameraId);
132 mCaptureSequencer->run(threadName.string());
133
134 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700135 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700136 mCameraId);
137 mJpegProcessor->run(threadName.string());
138
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800139 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
140
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700141 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700142 mCameraId);
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800143 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700144
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700145 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700146 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700147 mCameraId);
148 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700149
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700150 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700151 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700152 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
153 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700154 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700155 }
156
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700157 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700158}
159
160Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700161 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700162 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700163
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700164 mDestructionStarted = true;
165
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700166 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700167
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700168 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700169}
170
171status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800172 return BasicClient::dump(fd, args);
173}
174
175status_t Camera2Client::dumpClient(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700176 String8 result;
Ruben Brunkcc776712015-02-17 20:18:47 -0800177 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", mCameraId,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -0800178 (getRemoteCallback() != NULL ?
Marco Nelissenf8880202014-11-14 07:58:25 -0800179 (IInterface::asBinder(getRemoteCallback()).get()) : NULL),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700180 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 result.append(" State: ");
182#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
183
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700184 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700185
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700186 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700187
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700188 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700189 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700190 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700193 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700194 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700195 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700196 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700197 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700198 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700199 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700200 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700201 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700202 p.jpegQuality, p.jpegThumbQuality);
203 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700204 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700205 p.gpsEnabled ? "enabled" : "disabled");
206 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700207 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700208 p.gpsCoordinates[0], p.gpsCoordinates[1],
209 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000210 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700211 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700212 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700213 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700214 }
215
216 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700217 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800218 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700226 default: result.append("UNKNOWN\n");
227 }
228
229 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700230 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800231 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
238 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
239 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700240 default: result.append("UNKNOWN\n");
241 }
242
243 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700244 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800245 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700249 default: result.append("UNKNOWN\n");
250 }
251
252 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700253 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800254 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700255 result.append("AUTO\n"); break;
Emilian Peev53eea852018-06-20 14:13:14 +0100256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
262 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
263 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
264 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
265 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
266 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
267 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
268 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
269 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
270 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
271 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
272 default: result.append("UNKNOWN\n");
273 }
274
275 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700276 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700277 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
278 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
279 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
280 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
281 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
282 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
283 default: result.append("UNKNOWN\n");
284 }
285
286 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700287 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700288 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
289 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
290 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
291 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
292 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
293 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
294 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
295 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
296 default: result.append("UNKNOWN\n");
297 }
298
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700299 result.append(" Focus state: ");
300 switch (p.focusState) {
301 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
302 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
303 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700304 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700305 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
306 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
307 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
308 default: result.append("UNKNOWN\n");
309 }
310
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700311 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700312 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700313 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700314 p.focusingAreas[i].left,
315 p.focusingAreas[i].top,
316 p.focusingAreas[i].right,
317 p.focusingAreas[i].bottom,
318 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700319 }
320
321 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700322 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700323
324 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700325 p.autoExposureLock ? "enabled" : "disabled",
326 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700327
328 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700329 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700330 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700331 p.meteringAreas[i].left,
332 p.meteringAreas[i].top,
333 p.meteringAreas[i].right,
334 p.meteringAreas[i].bottom,
335 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700336 }
337
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700338 result.appendFormat(" Zoom index: %d\n", p.zoom);
339 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
340 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700341
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700342 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700343 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700344
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700345 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700346 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700347
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700348 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
349 p.fastInfo.bestStillCaptureFpsRange[0],
350 p.fastInfo.bestStillCaptureFpsRange[1]);
351
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700352 result.appendFormat(" Use zero shutter lag: %s\n",
353 p.useZeroShutterLag() ? "yes" : "no");
354
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700355 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700356 result.appendFormat(" Preview stream ID: %d\n",
357 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700358 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700359 getCaptureStreamId());
360 result.appendFormat(" Recording stream ID: %d\n",
361 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700362
363 result.append(" Quirks for this camera:\n");
364 bool haveQuirk = false;
365 if (p.quirks.triggerAfWithAuto) {
366 result.appendFormat(" triggerAfWithAuto\n");
367 haveQuirk = true;
368 }
369 if (p.quirks.useZslFormat) {
370 result.appendFormat(" useZslFormat\n");
371 haveQuirk = true;
372 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700373 if (p.quirks.meteringCropRegion) {
374 result.appendFormat(" meteringCropRegion\n");
375 haveQuirk = true;
376 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700377 if (p.quirks.partialResults) {
378 result.appendFormat(" usePartialResult\n");
379 haveQuirk = true;
380 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700381 if (!haveQuirk) {
382 result.appendFormat(" none\n");
383 }
384
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700385 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700386
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700387 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700388
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700389 mCaptureSequencer->dump(fd, args);
390
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700391 mFrameProcessor->dump(fd, args);
392
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700393 mZslProcessor->dump(fd, args);
394
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800395 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700396#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700397}
398
399// ICamera interface
400
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800401binder::Status Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700402 ATRACE_CALL();
Shuzhen Wang316781a2020-08-18 18:11:01 -0700403 nsecs_t startTime = systemTime();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800404 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700405
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800406 binder::Status res = binder::Status::ok();
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800407 // Allow both client and the cameraserver to disconnect at all times
Jayant Chowdhary12361932018-08-27 14:46:13 -0700408 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800409 if (callingPid != mClientPid && callingPid != mServicePid) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700410
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800411 if (mDevice == 0) return res;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700412
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700413 ALOGV("Camera %d: Shutting down", mCameraId);
414
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700415 /**
416 * disconnect() cannot call any methods that might need to promote a
417 * wp<Camera2Client>, since disconnect can be called from the destructor, at
418 * which point all such promotions will fail.
419 */
420
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700421 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700422
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700423 {
424 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800425 if (l.mParameters.state == Parameters::DISCONNECTED) return res;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700426 l.mParameters.state = Parameters::DISCONNECTED;
427 }
428
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700429 mFrameProcessor->requestExit();
430 mCaptureSequencer->requestExit();
431 mJpegProcessor->requestExit();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800432 mZslProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700433 mCallbackProcessor->requestExit();
434
435 ALOGV("Camera %d: Waiting for threads", mCameraId);
436
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700437 {
438 // Don't wait with lock held, in case the other threads need to
439 // complete callbacks that re-enter Camera2Client
440 mBinderSerializationLock.unlock();
441
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700442 mFrameProcessor->join();
443 mCaptureSequencer->join();
444 mJpegProcessor->join();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800445 mZslProcessor->join();
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700446 mCallbackProcessor->join();
447
448 mBinderSerializationLock.lock();
449 }
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700450
Ruben Brunkdfe71552013-12-05 11:00:37 -0800451 ALOGV("Camera %d: Deleting streams", mCameraId);
452
453 mStreamingProcessor->deletePreviewStream();
454 mStreamingProcessor->deleteRecordingStream();
455 mJpegProcessor->deleteStream();
456 mCallbackProcessor->deleteStream();
457 mZslProcessor->deleteStream();
458
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700459 ALOGV("Camera %d: Disconnecting device", mCameraId);
460
461 mDevice->disconnect();
462
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700463 CameraService::Client::disconnect();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800464
Shuzhen Wang316781a2020-08-18 18:11:01 -0700465 int32_t closeLatencyMs = ns2ms(systemTime() - startTime);
466 CameraServiceProxyWrapper::logClose(mCameraIdStr, closeLatencyMs);
467
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800468 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700469}
470
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800471status_t Camera2Client::connect(const sp<hardware::ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700472 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700473 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800474 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700475
Jayant Chowdhary12361932018-08-27 14:46:13 -0700476 if (mClientPid != 0 && CameraThreadState::getCallingPid() != mClientPid) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700477 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
478 "current locked to pid %d", __FUNCTION__,
Jayant Chowdhary12361932018-08-27 14:46:13 -0700479 mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700480 return BAD_VALUE;
481 }
482
Jayant Chowdhary12361932018-08-27 14:46:13 -0700483 mClientPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700484
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800485 mRemoteCallback = client;
486 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700487
488 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700489}
490
491status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700492 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700493 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800494 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700495 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700496 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700497
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700498 if (mClientPid == 0) {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700499 mClientPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700500 return OK;
501 }
502
Jayant Chowdhary12361932018-08-27 14:46:13 -0700503 if (mClientPid != CameraThreadState::getCallingPid()) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700504 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700505 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700506 return EBUSY;
507 }
508
509 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700510}
511
512status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700513 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700514 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800515 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700516 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700517 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700518
Jayant Chowdhary12361932018-08-27 14:46:13 -0700519 if (mClientPid == CameraThreadState::getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700520 SharedParameters::Lock l(mParameters);
521 if (l.mParameters.state == Parameters::RECORD ||
522 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
523 ALOGD("Not allowed to unlock camera during recording.");
524 return INVALID_OPERATION;
525 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700526 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800527 mRemoteCallback.clear();
528 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700529 return OK;
530 }
531
532 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700533 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700534 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700535}
536
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700537status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800538 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700539 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700540 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800541 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700542 status_t res;
543 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700544
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700545 sp<IBinder> binder;
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700546 sp<Surface> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800547 if (bufferProducer != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -0800548 binder = IInterface::asBinder(bufferProducer);
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700549 // Using controlledByApp flag to ensure that the buffer queue remains in
550 // async mode for the old camera API, where many applications depend
551 // on that behavior.
552 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700553 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700554 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700555}
556
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700557status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700558 const sp<Surface>& window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700559 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700560 status_t res;
561
562 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700563 ALOGV("%s: Camera %d: New window is same as old window",
564 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700565 return NO_ERROR;
566 }
567
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700568 Parameters::State state;
569 {
570 SharedParameters::Lock l(mParameters);
571 state = l.mParameters.state;
572 }
573 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700574 case Parameters::DISCONNECTED:
575 case Parameters::RECORD:
576 case Parameters::STILL_CAPTURE:
577 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700578 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700579 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700580 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700581 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700582 case Parameters::STOPPED:
583 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700584 // OK
585 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700586 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700587 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700588 res = stopStream();
589 if (res != OK) {
590 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
591 __FUNCTION__, strerror(-res), res);
592 return res;
593 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700594 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700595 break;
596 }
597
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700598 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700599 res = mStreamingProcessor->setPreviewWindow(window);
600 if (res != OK) {
601 ALOGE("%s: Unable to set new preview window: %s (%d)",
602 __FUNCTION__, strerror(-res), res);
603 return res;
604 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700605
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700606 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
607 SharedParameters::Lock l(mParameters);
608 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700609 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700610 }
611
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700612 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700613}
614
615void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700616 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700617 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800618 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700619
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700620 if ( checkPid(__FUNCTION__) != OK) return;
621
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700622 SharedParameters::Lock l(mParameters);
623 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700624}
625
626void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
627 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700628
629 switch(params.state) {
630 case Parameters::STOPPED:
631 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
632 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700633 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700634 // OK
635 break;
636 default:
637 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
638 ALOGE("%s: Camera %d: Can't use preview callbacks "
639 "in state %d", __FUNCTION__, mCameraId, params.state);
640 return;
641 }
642 }
643
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700644 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
645 ALOGV("%s: setting oneshot", __FUNCTION__);
646 params.previewCallbackOneShot = true;
647 }
648 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700649
Zhijun He527748a2013-09-15 21:06:10 -0700650 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700651 // Disable any existing preview callback window when enabling
652 // preview callback flags
653 res = mCallbackProcessor->setCallbackWindow(NULL);
654 if (res != OK) {
655 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
656 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
657 return;
658 }
659 params.previewCallbackSurface = false;
660 }
661
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700662 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700663
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700664 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700665 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700666 if (res != OK) {
667 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
668 __FUNCTION__, mCameraId,
669 Parameters::getStateName(params.state));
670 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700671 }
672 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700673}
674
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700675status_t Camera2Client::setPreviewCallbackTarget(
676 const sp<IGraphicBufferProducer>& callbackProducer) {
677 ATRACE_CALL();
678 ALOGV("%s: E", __FUNCTION__);
679 Mutex::Autolock icl(mBinderSerializationLock);
680 status_t res;
681 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
682
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700683 sp<Surface> window;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700684 if (callbackProducer != 0) {
685 window = new Surface(callbackProducer);
686 }
687
688 res = mCallbackProcessor->setCallbackWindow(window);
689 if (res != OK) {
690 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
691 __FUNCTION__, mCameraId, strerror(-res), res);
692 return res;
693 }
694
695 SharedParameters::Lock l(mParameters);
696
697 if (window != NULL) {
698 // Disable traditional callbacks when a valid callback target is given
699 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
700 l.mParameters.previewCallbackOneShot = false;
701 l.mParameters.previewCallbackSurface = true;
702 } else {
703 // Disable callback target if given a NULL interface.
704 l.mParameters.previewCallbackSurface = false;
705 }
706
707 switch(l.mParameters.state) {
708 case Parameters::PREVIEW:
709 res = startPreviewL(l.mParameters, true);
710 break;
711 case Parameters::RECORD:
712 case Parameters::VIDEO_SNAPSHOT:
713 res = startRecordingL(l.mParameters, true);
714 break;
715 default:
716 break;
717 }
718 if (res != OK) {
719 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
720 __FUNCTION__, mCameraId,
721 Parameters::getStateName(l.mParameters.state));
722 }
723
724 return OK;
725}
726
727
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700728status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700729 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700730 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800731 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700732 status_t res;
733 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700734 SharedParameters::Lock l(mParameters);
735 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700736}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700737
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700738status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700739 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700740 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700741
742 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
743
Yin-Chia Yehdf143042020-02-05 12:41:07 -0800744 if (params.state == Parameters::DISCONNECTED) {
745 ALOGE("%s: Camera %d has been disconnected.", __FUNCTION__, mCameraId);
746 return INVALID_OPERATION;
747 }
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700748 if ( (params.state == Parameters::PREVIEW ||
749 params.state == Parameters::RECORD ||
750 params.state == Parameters::VIDEO_SNAPSHOT)
751 && !restart) {
752 // Succeed attempt to re-enter a streaming state
753 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
754 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700755 return OK;
756 }
757 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700758 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700759 __FUNCTION__,
760 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700761 return INVALID_OPERATION;
762 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700763
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700764 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700765 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700766 return OK;
767 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700768 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800769 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700770
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700771 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700772 if (res != OK) {
773 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
774 __FUNCTION__, mCameraId, strerror(-res), res);
775 return res;
776 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700777
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800778 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
779
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700780 // We could wait to create the JPEG output stream until first actual use
781 // (first takePicture call). However, this would substantially increase the
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800782 // first capture latency on HAL3 devices.
783 // So create it unconditionally at preview start. As a drawback,
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700784 // this increases gralloc memory consumption for applications that don't
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800785 // ever take a picture. Do not enter this mode when jpeg stream will slow
786 // down preview.
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700787 // TODO: Find a better compromise, though this likely would involve HAL
788 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700789 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800790 // If jpeg stream will slow down preview, make sure we remove it before starting preview
791 if (params.slowJpegMode) {
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700792 if (lastJpegStreamId != NO_STREAM) {
793 // Pause preview if we are streaming
794 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
795 if (activeRequestId != 0) {
796 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
797 if (res != OK) {
798 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
799 __FUNCTION__, mCameraId, strerror(-res), res);
800 }
801 res = mDevice->waitUntilDrained();
802 if (res != OK) {
803 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
804 __FUNCTION__, mCameraId, strerror(-res), res);
805 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800806 }
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700807
808 res = mJpegProcessor->deleteStream();
809
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800810 if (res != OK) {
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700811 ALOGE("%s: Camera %d: delete Jpeg stream failed: %s (%d)",
812 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800813 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800814
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700815 if (activeRequestId != 0) {
816 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
817 if (res != OK) {
818 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
819 __FUNCTION__, mCameraId, strerror(-res), res);
820 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800821 }
822 }
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800823 } else {
824 res = updateProcessorStream(mJpegProcessor, params);
825 if (res != OK) {
826 ALOGE("%s: Camera %d: Can't pre-configure still image "
827 "stream: %s (%d)",
828 __FUNCTION__, mCameraId, strerror(-res), res);
829 return res;
830 }
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700831 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700832 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700833
Zhijun Hed1d64672013-09-06 15:00:01 -0700834 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700835 bool callbacksEnabled = (params.previewCallbackFlags &
836 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
837 params.previewCallbackSurface;
838
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700839 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700840 // Can't have recording stream hanging around when enabling callbacks,
841 // since it exceeds the max stream count on some devices.
842 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
843 ALOGV("%s: Camera %d: Clearing out recording stream before "
844 "creating callback stream", __FUNCTION__, mCameraId);
845 res = mStreamingProcessor->stopStream();
846 if (res != OK) {
847 ALOGE("%s: Camera %d: Can't stop streaming to delete "
848 "recording stream", __FUNCTION__, mCameraId);
849 return res;
850 }
851 res = mStreamingProcessor->deleteRecordingStream();
852 if (res != OK) {
853 ALOGE("%s: Camera %d: Unable to delete recording stream before "
854 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
855 strerror(-res), res);
856 return res;
857 }
858 }
859
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700860 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700861 if (res != OK) {
862 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
863 __FUNCTION__, mCameraId, strerror(-res), res);
864 return res;
865 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700866 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800867 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
868 /**
869 * Delete the unused callback stream when preview stream is changed and
870 * preview is not enabled. Don't need stop preview stream as preview is in
871 * STOPPED state now.
872 */
873 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
874 res = mCallbackProcessor->deleteStream();
875 if (res != OK) {
876 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
877 __FUNCTION__, mCameraId, strerror(-res), res);
878 return res;
879 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700880 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700881
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700882 if (params.useZeroShutterLag() &&
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700883 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700884 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700885 if (res != OK) {
886 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
887 __FUNCTION__, mCameraId, strerror(-res), res);
888 return res;
889 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700890
891 if (jpegStreamChanged) {
892 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
893 __FUNCTION__, mCameraId);
894 mZslProcessor->clearZslQueue();
895 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700896 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700897 } else {
898 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700899 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700900
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700901 outputStreams.push(getPreviewStreamId());
902
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700903 if (params.isDeviceZslSupported) {
904 // If device ZSL is supported, resume preview buffers that may be paused
905 // during last takePicture().
906 mDevice->dropStreamBuffers(false, getPreviewStreamId());
907 }
908
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700909 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700910 if (!restart) {
911 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700912 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700913 ALOGE("%s: Camera %d: Can't set up preview request: "
914 "%s (%d)", __FUNCTION__, mCameraId,
915 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700916 return res;
917 }
918 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700919 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
920 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700921 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700922 if (!restart) {
923 res = mStreamingProcessor->updateRecordingRequest(params);
924 if (res != OK) {
925 ALOGE("%s: Camera %d: Can't set up preview request with "
926 "record hint: %s (%d)", __FUNCTION__, mCameraId,
927 strerror(-res), res);
928 return res;
929 }
930 }
931 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
932 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700933 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700934 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700935 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700936 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700937 return res;
938 }
939
Jasmine Chen33d09ca2021-01-22 19:42:54 +0800940 mCallbackProcessor->unpauseCallback();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700941 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700942 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700943}
944
945void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700946 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700947 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800948 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700949 status_t res;
950 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700951 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700952}
953
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700954void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700955 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700956 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700957 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700958 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700959 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700960 SharedParameters::Lock l(mParameters);
961 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700962 }
963
964 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700965 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800966 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700967 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700968 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700969 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700970 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700971 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -0700972 FALLTHROUGH_INTENDED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700973 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700974 case Parameters::PREVIEW:
Jasmine Chen33d09ca2021-01-22 19:42:54 +0800975 mCallbackProcessor->pauseCallback();
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700976 syncWithDevice();
Emilian Peev2a8e2832019-08-23 13:00:31 -0700977 // Due to flush a camera device sync is not a sufficient
978 // guarantee that the current client parameters are
979 // correctly applied. To resolve this wait for the current
980 // request id to return in the results.
981 waitUntilCurrentRequestIdLocked();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700982 res = stopStream();
983 if (res != OK) {
984 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
985 __FUNCTION__, mCameraId, strerror(-res), res);
986 }
Ruchit Sharma2cec0df2014-08-20 16:02:08 -0400987
988 // Flush all in-process captures and buffer in order to stop
989 // preview faster.
990 res = mDevice->flush();
991 if (res != OK) {
992 ALOGE("%s: Camera %d: Unable to flush pending requests: %s (%d)",
993 __FUNCTION__, mCameraId, strerror(-res), res);
994 }
995
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700996 res = mDevice->waitUntilDrained();
997 if (res != OK) {
998 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
999 __FUNCTION__, mCameraId, strerror(-res), res);
1000 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -07001001 // Clean up recording stream
1002 res = mStreamingProcessor->deleteRecordingStream();
1003 if (res != OK) {
1004 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1005 "stop preview: %s (%d)",
1006 __FUNCTION__, mCameraId, strerror(-res), res);
1007 }
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001008 FALLTHROUGH_INTENDED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001009 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
1010 SharedParameters::Lock l(mParameters);
1011 l.mParameters.state = Parameters::STOPPED;
1012 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001013 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001014 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001015 default:
1016 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001017 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001018 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001019}
1020
1021bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001022 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001023 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001024 status_t res;
1025 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
1026
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001027 SharedParameters::Lock l(mParameters);
1028 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001029}
1030
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001031status_t Camera2Client::setVideoBufferMode(int32_t videoBufferMode) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001032 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001033 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001034 status_t res;
1035 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1036
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001037 SharedParameters::Lock l(mParameters);
1038 switch (l.mParameters.state) {
1039 case Parameters::RECORD:
1040 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001041 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001042 __FUNCTION__, mCameraId,
1043 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001044 return INVALID_OPERATION;
1045 default:
1046 // OK
1047 break;
1048 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001049
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001050 if (videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1051 ALOGE("%s: %d: Only video buffer queue is supported", __FUNCTION__, __LINE__);
1052 return BAD_VALUE;
1053 }
1054
1055 l.mParameters.videoBufferMode = videoBufferMode;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001056
1057 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001058}
1059
1060status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001061 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001062 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001063 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001064 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001065 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001066 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001067
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001068 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001069}
1070
1071status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
Yunlian Jiang7fd5bdb2016-11-22 15:16:25 -08001072 status_t res = OK;
Igor Murashkin22d58d32012-10-02 19:07:14 -07001073
1074 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
1075
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001076 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001077 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001078 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001079 if (res != OK) return res;
Zhijun He96ff5c42014-10-13 22:20:37 -07001080 // Make sure first preview request is submitted to the HAL device to avoid
1081 // two consecutive set of configure_streams being called into the HAL.
1082 // TODO: Refactor this to avoid initial preview configuration.
1083 syncWithDevice();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001084 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001085 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001086 // Ready to go
1087 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001088 case Parameters::RECORD:
1089 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001090 // OK to call this when recording is already on, just skip unless
1091 // we're looking to restart
1092 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001093 break;
1094 default:
1095 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001096 __FUNCTION__, mCameraId,
1097 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001098 return INVALID_OPERATION;
1099 };
1100
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001101 if (params.videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1102 ALOGE("%s: Camera %d: Recording only supported buffer queue mode, but "
1103 "mode %d is requested!", __FUNCTION__, mCameraId, params.videoBufferMode);
1104 return INVALID_OPERATION;
1105 }
1106
1107 if (!mStreamingProcessor->haveValidRecordingWindow()) {
1108 ALOGE("%s: No valid recording window", __FUNCTION__);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001109 return INVALID_OPERATION;
1110 }
1111
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001112 if (!restart) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001113 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001114 mStreamingProcessor->updateRecordingRequest(params);
1115 if (res != OK) {
1116 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1117 __FUNCTION__, mCameraId, strerror(-res), res);
1118 return res;
1119 }
1120 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001121
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001122 // Not all devices can support a preview callback stream and a recording
1123 // stream at the same time, so assume none of them can.
1124 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1125 ALOGV("%s: Camera %d: Clearing out callback stream before "
1126 "creating recording stream", __FUNCTION__, mCameraId);
1127 res = mStreamingProcessor->stopStream();
1128 if (res != OK) {
1129 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1130 __FUNCTION__, mCameraId);
1131 return res;
1132 }
1133 res = mCallbackProcessor->deleteStream();
1134 if (res != OK) {
1135 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1136 "record: %s (%d)", __FUNCTION__, mCameraId,
1137 strerror(-res), res);
1138 return res;
1139 }
1140 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001141
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001142 // Clean up ZSL before transitioning into recording
1143 if (mZslProcessor->getStreamId() != NO_STREAM) {
1144 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1145 "creating recording stream", __FUNCTION__, mCameraId);
1146 res = mStreamingProcessor->stopStream();
1147 if (res != OK) {
1148 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1149 __FUNCTION__, mCameraId);
1150 return res;
1151 }
1152 res = mDevice->waitUntilDrained();
1153 if (res != OK) {
1154 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1155 __FUNCTION__, mCameraId, strerror(-res), res);
1156 }
1157 res = mZslProcessor->clearZslQueue();
1158 if (res != OK) {
1159 ALOGE("%s: Camera %d: Can't clear zsl queue",
1160 __FUNCTION__, mCameraId);
1161 return res;
1162 }
1163 res = mZslProcessor->deleteStream();
1164 if (res != OK) {
1165 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1166 "record: %s (%d)", __FUNCTION__, mCameraId,
1167 strerror(-res), res);
1168 return res;
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001169 }
1170 }
1171
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001172 // Disable callbacks if they're enabled; can't record and use callbacks,
1173 // and we can't fail record start without stagefright asserting.
1174 params.previewCallbackFlags = 0;
1175
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001176 // May need to reconfigure video snapshot JPEG sizes
1177 // during recording startup, so need a more complex sequence here to
1178 // ensure an early stream reconfiguration doesn't happen
1179 bool recordingStreamNeedsUpdate;
1180 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
1181 if (res != OK) {
1182 ALOGE("%s: Camera %d: Can't query recording stream",
1183 __FUNCTION__, mCameraId);
1184 return res;
1185 }
1186
1187 if (recordingStreamNeedsUpdate) {
1188 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1189 // Right now camera device cannot handle configureStream failure gracefully
1190 // when device is streaming
1191 res = mStreamingProcessor->stopStream();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001192 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001193 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1194 "stream", __FUNCTION__, mCameraId);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001195 return res;
1196 }
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001197 res = mDevice->waitUntilDrained();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001198 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001199 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1200 "%s (%d)", __FUNCTION__, mCameraId,
1201 strerror(-res), res);
1202 }
1203
1204 res = updateProcessorStream<
1205 StreamingProcessor,
1206 &StreamingProcessor::updateRecordingStream>(
1207 mStreamingProcessor,
1208 params);
1209 if (res != OK) {
1210 ALOGE("%s: Camera %d: Unable to update recording stream: "
1211 "%s (%d)", __FUNCTION__, mCameraId,
1212 strerror(-res), res);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001213 return res;
1214 }
1215 }
1216
Zhijun Hed1d64672013-09-06 15:00:01 -07001217 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001218 outputStreams.push(getPreviewStreamId());
1219 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001220
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001221 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1222 outputStreams);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001223
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001224 // startStream might trigger a configureStream call and device might fail
1225 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1226 // to video size.
1227 if (res == BAD_VALUE) {
1228 overrideVideoSnapshotSize(params);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001229 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1230 outputStreams);
1231 }
1232
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001233 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001234 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001235 __FUNCTION__, mCameraId, strerror(-res), res);
1236 return res;
1237 }
1238
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001239 if (params.state < Parameters::RECORD) {
1240 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001241 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001242
1243 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001244}
1245
1246void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001247 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001248 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001249 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001250 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001251
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001252 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001253 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1254
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001255 switch (l.mParameters.state) {
1256 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001257 // OK to stop
1258 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001259 case Parameters::STOPPED:
1260 case Parameters::PREVIEW:
1261 case Parameters::STILL_CAPTURE:
1262 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001263 default:
1264 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001265 __FUNCTION__, mCameraId,
1266 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001267 return;
1268 };
1269
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001270 sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001271
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001272 // Remove recording stream because the video target may be abandoned soon.
1273 res = stopStream();
1274 if (res != OK) {
1275 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1276 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001277 }
1278
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001279 res = mDevice->waitUntilDrained();
1280 if (res != OK) {
1281 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1282 __FUNCTION__, mCameraId, strerror(-res), res);
1283 }
1284 // Clean up recording stream
1285 res = mStreamingProcessor->deleteRecordingStream();
1286 if (res != OK) {
1287 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1288 "stop preview: %s (%d)",
1289 __FUNCTION__, mCameraId, strerror(-res), res);
1290 }
1291 l.mParameters.recoverOverriddenJpegSize();
1292
1293 // Restart preview
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001294 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001295 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001296 ALOGE("%s: Camera %d: Unable to return to preview",
1297 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001298 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001299}
1300
1301bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001302 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001303 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001304
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001305 if ( checkPid(__FUNCTION__) != OK) return false;
1306
James Dong8da4cd72012-08-04 19:58:07 -07001307 return recordingEnabledL();
1308}
1309
1310bool Camera2Client::recordingEnabledL() {
1311 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001312 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001313
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001314 return (l.mParameters.state == Parameters::RECORD
1315 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001316}
1317
1318void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001319 (void)mem;
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001320 ATRACE_CALL();
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001321 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001322}
1323
Chien-Yu Chen2d13b1d2016-04-28 12:11:20 -07001324void Camera2Client::releaseRecordingFrameHandle(native_handle_t *handle) {
1325 (void)handle;
1326 ATRACE_CALL();
1327 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1328}
1329
Yin-Chia Yehb5df5472017-03-20 19:32:19 -07001330void Camera2Client::releaseRecordingFrameHandleBatch(
1331 const std::vector<native_handle_t*>& handles) {
1332 (void)handles;
1333 ATRACE_CALL();
1334 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1335}
1336
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001337status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001338 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001339 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001340 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001341 status_t res;
1342 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1343
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001344 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001345 bool notifyImmediately = false;
1346 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001347 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001348 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001349 if (l.mParameters.state < Parameters::PREVIEW) {
Zhijun Hef79f8ca2014-09-22 23:52:54 -07001350 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1351 __FUNCTION__, mCameraId, l.mParameters.state);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001352 return INVALID_OPERATION;
1353 }
1354
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001355 /**
1356 * If the camera does not support auto-focus, it is a no-op and
1357 * onAutoFocus(boolean, Camera) callback will be called immediately
1358 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001359 *
1360 * Similarly, if focus mode is set to INFINITY, there's no reason to
1361 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001362 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001363 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1364 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001365 notifyImmediately = true;
1366 notifySuccess = true;
1367 }
1368 /**
1369 * If we're in CAF mode, and AF has already been locked, just fire back
1370 * the callback right away; the HAL would not send a notification since
1371 * no state change would happen on a AF trigger.
1372 */
1373 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1374 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1375 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1376 notifyImmediately = true;
1377 notifySuccess = true;
1378 }
1379 /**
1380 * Send immediate notification back to client
1381 */
1382 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001383 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1384 if (l.mRemoteCallback != 0) {
1385 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001386 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001387 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001388 return OK;
1389 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001390 /**
1391 * Handle quirk mode for AF in scene modes
1392 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001393 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001394 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001395 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1396 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001397 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1398 __FUNCTION__, l.mParameters.focusMode);
1399 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1400 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1401 updateRequests(l.mParameters);
1402 }
1403
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001404 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1405 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001406 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001407 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1408
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001409 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001410
1411 mDevice->triggerAutofocus(triggerId);
1412
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001413 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001414}
1415
1416status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001417 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001418 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001419 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001420 status_t res;
1421 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1422
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001423 int triggerId;
1424 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001425 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001426 // Canceling does nothing in FIXED or INFINITY modes
1427 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1428 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1429 return OK;
1430 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001431
1432 // An active AF trigger is canceled
1433 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1434 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1435 }
1436
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001437 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001438
1439 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001440 // the real state at this point. No need to cancel explicitly if
1441 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001442 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1443 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1444 l.mParameters.shadowFocusMode);
1445 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1446 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1447 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001448
1449 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001450 }
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001451 if (l.mParameters.allowZslMode) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001452 mZslProcessor->clearZslQueue();
1453 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001454 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001455 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001456
1457 mDevice->triggerCancelAutofocus(triggerId);
1458
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001459 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001460}
1461
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001462status_t Camera2Client::takePicture(int /*msgType*/) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001463 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001464 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001465 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001466 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001467
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001468 int takePictureCounter;
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001469 bool shouldSyncWithDevice = true;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001470 {
1471 SharedParameters::Lock l(mParameters);
1472 switch (l.mParameters.state) {
1473 case Parameters::DISCONNECTED:
1474 case Parameters::STOPPED:
1475 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1476 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001477 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001478 return INVALID_OPERATION;
1479 case Parameters::PREVIEW:
1480 // Good to go for takePicture
1481 res = commandStopFaceDetectionL(l.mParameters);
1482 if (res != OK) {
1483 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1484 __FUNCTION__, mCameraId);
1485 return res;
1486 }
1487 l.mParameters.state = Parameters::STILL_CAPTURE;
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001488
1489 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1490 if (l.mParameters.isJpegSizeOverridden() &&
1491 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1492 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1493 if (res != OK) {
1494 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1495 __FUNCTION__, mCameraId, strerror(-res), res);
1496 }
1497 res = mDevice->waitUntilDrained();
1498 if (res != OK) {
1499 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1500 __FUNCTION__, mCameraId, strerror(-res), res);
1501 }
1502 // Clean up recording stream
1503 res = mStreamingProcessor->deleteRecordingStream();
1504 if (res != OK) {
1505 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1506 "stop preview: %s (%d)",
1507 __FUNCTION__, mCameraId, strerror(-res), res);
1508 }
1509 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1510 if (res != OK) {
1511 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1512 __FUNCTION__, mCameraId, strerror(-res), res);
1513 }
1514 l.mParameters.recoverOverriddenJpegSize();
1515 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001516 break;
1517 case Parameters::RECORD:
1518 // Good to go for video snapshot
1519 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1520 break;
1521 case Parameters::STILL_CAPTURE:
1522 case Parameters::VIDEO_SNAPSHOT:
1523 ALOGE("%s: Camera %d: Already taking a picture",
1524 __FUNCTION__, mCameraId);
1525 return INVALID_OPERATION;
1526 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001527
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001528 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Zhijun Hee2d83752014-06-23 10:22:37 -07001529 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001530 // slowJpegMode will create jpeg stream in CaptureSequencer before capturing
1531 if (!l.mParameters.slowJpegMode) {
1532 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1533 }
1534
Yin-Chia Yehd3c5b082014-09-15 14:50:06 -07001535 // If video snapshot fail to configureStream, try override video snapshot size to
1536 // video size
1537 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1538 overrideVideoSnapshotSize(l.mParameters);
1539 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1540 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001541 if (res != OK) {
1542 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1543 __FUNCTION__, mCameraId, strerror(-res), res);
1544 return res;
1545 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001546 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001547
1548 // Clear ZSL buffer queue when Jpeg size is changed.
1549 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001550 if (l.mParameters.allowZslMode && jpegStreamChanged) {
Zhijun Hee2d83752014-06-23 10:22:37 -07001551 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1552 __FUNCTION__, mCameraId);
1553 mZslProcessor->clearZslQueue();
1554 }
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001555
1556 // We should always sync with the device in case flash is turned on,
1557 // the camera device suggests that flash is needed (AE state FLASH_REQUIRED)
1558 // or we are in some other AE state different from CONVERGED that may need
1559 // precapture trigger.
1560 if (l.mParameters.flashMode != Parameters::FLASH_MODE_ON &&
1561 (l.mParameters.aeState == ANDROID_CONTROL_AE_STATE_CONVERGED)) {
1562 shouldSyncWithDevice = false;
1563 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001564 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001565
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001566 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1567
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001568 // Make sure HAL has correct settings in case precapture trigger is needed.
1569 if (shouldSyncWithDevice) {
1570 syncWithDevice();
1571 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001572
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001573 res = mCaptureSequencer->startCapture();
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001574 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001575 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001576 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001577 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001578
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001579 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001580}
1581
1582status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001583 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001584 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001585 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001586 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001587 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1588
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001589 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001590
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001591 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001592 res = l.mParameters.set(params);
1593 if (res != OK) return res;
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001594 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1595
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001596 if (l.mParameters.allowZslMode && focusModeAfter != focusModeBefore) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001597 mZslProcessor->clearZslQueue();
1598 }
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001599
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001600 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001601
1602 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001603}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001604
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001605String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001606 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001607 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001608 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001609 // The camera service can unconditionally get the parameters at all times
Jayant Chowdhary12361932018-08-27 14:46:13 -07001610 if (CameraThreadState::getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001611
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001612 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001613
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001614 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001615}
1616
1617status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001618 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001619 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001620 status_t res;
1621 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001622
1623 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1624 cmd, arg1, arg2);
1625
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001626 switch (cmd) {
1627 case CAMERA_CMD_START_SMOOTH_ZOOM:
1628 return commandStartSmoothZoomL();
1629 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1630 return commandStopSmoothZoomL();
1631 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1632 return commandSetDisplayOrientationL(arg1);
1633 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1634 return commandEnableShutterSoundL(arg1 == 1);
1635 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1636 return commandPlayRecordingSoundL();
1637 case CAMERA_CMD_START_FACE_DETECTION:
1638 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001639 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001640 SharedParameters::Lock l(mParameters);
1641 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001642 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001643 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1644 return commandEnableFocusMoveMsgL(arg1 == 1);
1645 case CAMERA_CMD_PING:
1646 return commandPingL();
1647 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -07001648 case CAMERA_CMD_SET_VIDEO_FORMAT:
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001649 ALOGE("%s: command %d (arguments %d, %d) is not supported.",
1650 __FUNCTION__, cmd, arg1, arg2);
1651 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001652 default:
1653 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1654 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001655 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001656 }
1657}
James Dong983cf232012-08-01 16:39:55 -07001658
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001659status_t Camera2Client::commandStartSmoothZoomL() {
1660 ALOGE("%s: Unimplemented!", __FUNCTION__);
1661 return OK;
1662}
James Dong983cf232012-08-01 16:39:55 -07001663
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001664status_t Camera2Client::commandStopSmoothZoomL() {
1665 ALOGE("%s: Unimplemented!", __FUNCTION__);
1666 return OK;
1667}
James Dong983cf232012-08-01 16:39:55 -07001668
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001669status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001670 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001671 mCameraFacing == CAMERA_FACING_FRONT);
1672 if (transform == -1) {
1673 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1674 __FUNCTION__, mCameraId, degrees);
1675 return BAD_VALUE;
1676 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001677 SharedParameters::Lock l(mParameters);
1678 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001679 getPreviewStreamId() != NO_STREAM) {
1680 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001681 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001682 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001683 return OK;
1684}
1685
1686status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001687 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001688 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001689 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001690 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001691 }
1692
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001693 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001694 return OK;
1695}
1696
1697status_t Camera2Client::commandPlayRecordingSoundL() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001698 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001699 return OK;
1700}
1701
Igor Murashkinddf3c502012-10-12 16:56:11 -07001702status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001703 ALOGV("%s: Camera %d: Starting face detection",
1704 __FUNCTION__, mCameraId);
1705 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001706 SharedParameters::Lock l(mParameters);
1707 switch (l.mParameters.state) {
1708 case Parameters::DISCONNECTED:
1709 case Parameters::STOPPED:
1710 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1711 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001712 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1713 __FUNCTION__, mCameraId);
1714 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001715 case Parameters::PREVIEW:
1716 case Parameters::RECORD:
1717 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001718 // Good to go for starting face detect
1719 break;
1720 }
1721 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001722 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001723 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001724 ALOGE("%s: Camera %d: Face detection not supported",
1725 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001726 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001727 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001728 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001729
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001730 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001731
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001732 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001733
1734 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001735}
1736
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001737status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001738 status_t res = OK;
1739 ALOGV("%s: Camera %d: Stopping face detection",
1740 __FUNCTION__, mCameraId);
1741
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001742 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001743
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001744 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001745
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001746 if (params.state == Parameters::PREVIEW
1747 || params.state == Parameters::RECORD
1748 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001749 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001750 }
1751
1752 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001753}
1754
1755status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001756 SharedParameters::Lock l(mParameters);
1757 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001758
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001759 return OK;
1760}
1761
1762status_t Camera2Client::commandPingL() {
1763 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001764 SharedParameters::Lock l(mParameters);
1765 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001766 return OK;
1767 } else {
1768 return NO_INIT;
1769 }
1770}
1771
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001772void Camera2Client::notifyError(int32_t errorCode,
Ruben Brunka485dfe2015-04-14 13:43:47 -07001773 const CaptureResultExtras& resultExtras) {
1774 int32_t err = CAMERA_ERROR_UNKNOWN;
1775 switch(errorCode) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001776 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001777 err = CAMERA_ERROR_RELEASED;
1778 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001779 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001780 err = CAMERA_ERROR_UNKNOWN;
1781 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001782 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001783 err = CAMERA_ERROR_SERVER_DIED;
1784 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001785 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
1786 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
1787 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001788 ALOGW("%s: Received recoverable error %d from HAL - ignoring, requestId %" PRId32,
1789 __FUNCTION__, errorCode, resultExtras.requestId);
Emilian Peev4746fff2020-06-25 14:37:31 -07001790
1791 if ((hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST == errorCode) ||
1792 (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == errorCode)) {
1793 Mutex::Autolock al(mLatestRequestMutex);
1794
1795 mLatestFailedRequestId = resultExtras.requestId;
1796 mLatestRequestSignal.signal();
1797 }
Yin-Chia Yeh0d2fa082019-02-20 12:31:53 -08001798 mCaptureSequencer->notifyError(errorCode, resultExtras);
Ruben Brunka485dfe2015-04-14 13:43:47 -07001799 return;
1800 default:
1801 err = CAMERA_ERROR_UNKNOWN;
1802 break;
1803 }
1804
1805 ALOGE("%s: Error condition %d reported by HAL, requestId %" PRId32, __FUNCTION__, errorCode,
1806 resultExtras.requestId);
1807
1808 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1809 if (l.mRemoteCallback != nullptr) {
1810 l.mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, err, 0);
1811 }
1812}
1813
1814
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001815/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001816void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1817 ALOGV("%s: Autofocus state now %d, last trigger %d",
1818 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001819 bool sendCompletedMessage = false;
1820 bool sendMovingMessage = false;
1821
1822 bool success = false;
1823 bool afInMotion = false;
1824 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001825 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001826 // Trace end of AF state
1827 char tmp[32];
1828 if (l.mParameters.afStateCounter > 0) {
1829 camera_metadata_enum_snprint(
1830 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1831 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1832 }
1833
1834 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001835 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001836 l.mParameters.afStateCounter++;
1837
1838 // Trace start of AF state
1839
1840 camera_metadata_enum_snprint(
1841 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1842 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1843
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001844 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001845 case Parameters::FOCUS_MODE_AUTO:
1846 case Parameters::FOCUS_MODE_MACRO:
1847 // Don't send notifications upstream if they're not for the current AF
1848 // trigger. For example, if cancel was called in between, or if we
1849 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001850 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001851 switch (newState) {
1852 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1853 success = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001854 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001855 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1856 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001857 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001858 break;
1859 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1860 // Just starting focusing, ignore
1861 break;
1862 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1863 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1864 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001865 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001866 default:
1867 // Unexpected in AUTO/MACRO mode
1868 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1869 __FUNCTION__, newState);
1870 break;
1871 }
1872 break;
1873 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1874 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1875 switch (newState) {
1876 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1877 success = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001878 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001879 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1880 // Don't send notifications upstream if they're not for
1881 // the current AF trigger. For example, if cancel was
1882 // called in between, or if we already sent a
1883 // notification about this AF call.
1884 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001885 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001886 sendCompletedMessage = true;
1887 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001888 if (l.mParameters.enableFocusMoveMessages &&
1889 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001890 sendMovingMessage = true;
1891 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001892 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001893 break;
1894 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1895 // Cancel was called, or we switched state; care if
1896 // currently moving
1897 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001898 if (l.mParameters.enableFocusMoveMessages &&
1899 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001900 sendMovingMessage = true;
1901 }
1902 break;
1903 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1904 // Start passive scan, inform upstream
1905 afInMotion = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001906 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001907 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001908 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001909 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001910 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001911 sendMovingMessage = true;
1912 }
1913 break;
1914 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001915 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001916 break;
1917 case Parameters::FOCUS_MODE_EDOF:
1918 case Parameters::FOCUS_MODE_INFINITY:
1919 case Parameters::FOCUS_MODE_FIXED:
1920 default:
1921 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001922 ALOGE("%s: Unexpected AF state change %d "
1923 "(ID %d) in focus mode %d",
1924 __FUNCTION__, newState, triggerId,
1925 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001926 }
1927 }
1928 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001929 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001930 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1931 if (l.mRemoteCallback != 0) {
1932 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001933 afInMotion ? 1 : 0, 0);
1934 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001935 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001936 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001937 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001938 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1939 if (l.mRemoteCallback != 0) {
1940 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001941 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001942 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001943 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001944}
1945
1946void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1947 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1948 __FUNCTION__, newState, triggerId);
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001949 {
1950 SharedParameters::Lock l(mParameters);
1951 // Update state
1952 l.mParameters.aeState = newState;
1953 }
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001954 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001955}
1956
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001957void Camera2Client::notifyShutter(const CaptureResultExtras& resultExtras,
1958 nsecs_t timestamp) {
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001959 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
1960 __FUNCTION__, resultExtras.requestId, timestamp);
1961 mCaptureSequencer->notifyShutter(resultExtras, timestamp);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07001962
1963 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001964}
1965
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001966camera2::SharedParameters& Camera2Client::getParameters() {
1967 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001968}
1969
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001970int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001971 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001972}
1973
1974int Camera2Client::getCaptureStreamId() const {
1975 return mJpegProcessor->getStreamId();
1976}
1977
1978int Camera2Client::getCallbackStreamId() const {
1979 return mCallbackProcessor->getStreamId();
1980}
1981
1982int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001983 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001984}
1985
1986int Camera2Client::getZslStreamId() const {
1987 return mZslProcessor->getStreamId();
1988}
1989
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001990status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001991 const wp<camera2::FrameProcessor::FilteredListener>& listener, bool sendPartials) {
Zhijun He25a0aef2014-06-25 11:40:02 -07001992 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001993}
1994
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001995status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001996 const wp<camera2::FrameProcessor::FilteredListener>& listener) {
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001997 return mFrameProcessor->removeListener(minId, maxId, listener);
1998}
1999
2000status_t Camera2Client::stopStream() {
2001 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07002002}
2003
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08002004status_t Camera2Client::createJpegStreamL(Parameters &params) {
2005 status_t res = OK;
2006 int lastJpegStreamId = mJpegProcessor->getStreamId();
2007 if (lastJpegStreamId != NO_STREAM) {
2008 return INVALID_OPERATION;
2009 }
2010
2011 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2012 if (res != OK) {
2013 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2014 __FUNCTION__, mCameraId, strerror(-res), res);
2015 return res;
2016 }
2017
2018 res = mDevice->flush();
2019 if (res != OK) {
2020 ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
2021 __FUNCTION__, mCameraId, strerror(-res), res);
2022 return res;
2023 }
2024
2025 // Ideally we don't need this, but current camera device
2026 // status tracking mechanism demands it.
2027 res = mDevice->waitUntilDrained();
2028 if (res != OK) {
2029 ALOGE("%s: Camera %d: Waiting device drain failed: %s (%d)",
2030 __FUNCTION__, mCameraId, strerror(-res), res);
2031 }
2032
2033 res = updateProcessorStream(mJpegProcessor, params);
2034 return res;
2035}
2036
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002037const int32_t Camera2Client::kPreviewRequestIdStart;
2038const int32_t Camera2Client::kPreviewRequestIdEnd;
2039const int32_t Camera2Client::kRecordingRequestIdStart;
2040const int32_t Camera2Client::kRecordingRequestIdEnd;
2041const int32_t Camera2Client::kCaptureRequestIdStart;
2042const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07002043
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07002044/** Utility methods */
2045
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07002046status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002047 status_t res;
2048
Igor Murashkin22d58d32012-10-02 19:07:14 -07002049 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
2050
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002051 res = mStreamingProcessor->incrementStreamingIds();
2052 if (res != OK) {
2053 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
2054 __FUNCTION__, mCameraId, strerror(-res), res);
2055 return res;
2056 }
2057
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002058 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002059 if (res != OK) {
2060 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
2061 __FUNCTION__, mCameraId, strerror(-res), res);
2062 return res;
2063 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002064 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002065 if (res != OK) {
2066 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
2067 __FUNCTION__, mCameraId, strerror(-res), res);
2068 return res;
2069 }
2070
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002071 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07002072 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002073 if (res != OK) {
2074 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
2075 __FUNCTION__, mCameraId, strerror(-res), res);
2076 return res;
2077 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002078 } else if (params.state == Parameters::RECORD ||
2079 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002080 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002081 if (res != OK) {
2082 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
2083 __FUNCTION__, mCameraId, strerror(-res), res);
2084 return res;
2085 }
2086 }
2087 return res;
2088}
2089
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07002090
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002091size_t Camera2Client::calculateBufferSize(int width, int height,
2092 int format, int stride) {
2093 switch (format) {
2094 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2095 return width * height * 2;
2096 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2097 return width * height * 3 / 2;
2098 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2099 return width * height * 2;
2100 case HAL_PIXEL_FORMAT_YV12: { // YV12
2101 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07002102 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002103 size_t uvSize = uvStride * height / 2;
2104 return ySize + uvSize * 2;
2105 }
2106 case HAL_PIXEL_FORMAT_RGB_565:
2107 return width * height * 2;
2108 case HAL_PIXEL_FORMAT_RGBA_8888:
2109 return width * height * 4;
Eino-Ville Talvalaa97dfeb2015-02-19 16:26:13 -08002110 case HAL_PIXEL_FORMAT_RAW16:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002111 return width * height * 2;
2112 default:
2113 ALOGE("%s: Unknown preview format: %x",
2114 __FUNCTION__, format);
2115 return 0;
2116 }
2117}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002118
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002119status_t Camera2Client::syncWithDevice() {
2120 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07002121 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002122 status_t res;
2123
2124 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2125 if (activeRequestId == 0) return OK;
2126
2127 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
2128 if (res == TIMED_OUT) {
2129 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
2130 __FUNCTION__, mCameraId);
2131 } else if (res != OK) {
2132 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
2133 __FUNCTION__, mCameraId);
2134 }
2135 return res;
2136}
2137
Igor Murashkindca254a2013-05-13 14:53:44 -07002138template <typename ProcessorT>
2139status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2140 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07002141 // No default template arguments until C++11, so we need this overload
2142 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
2143 processor, params);
2144}
2145
2146template <typename ProcessorT,
2147 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
2148status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2149 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07002150 status_t res;
2151
Igor Murashkin82db9e62013-05-21 11:38:49 -07002152 // Get raw pointer since sp<T> doesn't have operator->*
2153 ProcessorT *processorPtr = processor.get();
2154 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002155
2156 /**
2157 * Can't update the stream if it's busy?
2158 *
2159 * Then we need to stop the device (by temporarily clearing the request
2160 * queue) and then try again. Resume streaming once we're done.
2161 */
2162 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07002163 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2164 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07002165 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2166 if (res != OK) {
2167 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2168 __FUNCTION__, mCameraId, strerror(-res), res);
2169 }
2170
2171 res = mDevice->waitUntilDrained();
2172 if (res != OK) {
2173 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2174 __FUNCTION__, mCameraId, strerror(-res), res);
2175 }
2176
Igor Murashkin82db9e62013-05-21 11:38:49 -07002177 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002178 if (res != OK) {
2179 ALOGE("%s: Camera %d: Failed to update processing stream "
2180 " despite having halted streaming first: %s (%d)",
2181 __FUNCTION__, mCameraId, strerror(-res), res);
2182 }
2183
2184 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2185 if (res != OK) {
2186 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2187 __FUNCTION__, mCameraId, strerror(-res), res);
2188 }
2189 }
2190
2191 return res;
2192}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002193
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07002194status_t Camera2Client::overrideVideoSnapshotSize(Parameters &params) {
2195 ALOGV("%s: Camera %d: configure still size to video size before recording"
2196 , __FUNCTION__, mCameraId);
2197 params.overrideJpegSizeByVideoSize();
2198 status_t res = updateProcessorStream(mJpegProcessor, params);
2199 if (res != OK) {
2200 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2201 __FUNCTION__, mCameraId, strerror(-res), res);
2202 }
2203 return res;
2204}
2205
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08002206status_t Camera2Client::setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) {
2207 ATRACE_CALL();
2208 ALOGV("%s: E", __FUNCTION__);
2209 Mutex::Autolock icl(mBinderSerializationLock);
2210 status_t res;
2211 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
2212
2213 sp<IBinder> binder = IInterface::asBinder(bufferProducer);
2214 if (binder == mVideoSurface) {
2215 ALOGV("%s: Camera %d: New video window is same as old video window",
2216 __FUNCTION__, mCameraId);
2217 return NO_ERROR;
2218 }
2219
2220 sp<Surface> window;
2221 int format;
2222 android_dataspace dataSpace;
2223
2224 if (bufferProducer != nullptr) {
2225 // Using controlledByApp flag to ensure that the buffer queue remains in
2226 // async mode for the old camera API, where many applications depend
2227 // on that behavior.
2228 window = new Surface(bufferProducer, /*controlledByApp*/ true);
2229
2230 ANativeWindow *anw = window.get();
2231
2232 if ((res = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
2233 ALOGE("%s: Failed to query Surface format", __FUNCTION__);
2234 return res;
2235 }
2236
2237 if ((res = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
2238 reinterpret_cast<int*>(&dataSpace))) != OK) {
2239 ALOGE("%s: Failed to query Surface dataSpace", __FUNCTION__);
2240 return res;
2241 }
2242 }
2243
2244 Parameters::State state;
2245 {
2246 SharedParameters::Lock l(mParameters);
2247 state = l.mParameters.state;
2248 }
2249
2250 switch (state) {
2251 case Parameters::STOPPED:
2252 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
2253 case Parameters::PREVIEW:
2254 // OK
2255 break;
2256 case Parameters::DISCONNECTED:
2257 case Parameters::RECORD:
2258 case Parameters::STILL_CAPTURE:
2259 case Parameters::VIDEO_SNAPSHOT:
2260 default:
2261 ALOGE("%s: Camera %d: Cannot set video target while in state %s",
2262 __FUNCTION__, mCameraId,
2263 Parameters::getStateName(state));
2264 return INVALID_OPERATION;
2265 }
2266
2267 mVideoSurface = binder;
2268 res = mStreamingProcessor->setRecordingWindow(window);
2269 if (res != OK) {
2270 ALOGE("%s: Unable to set new recording window: %s (%d)",
2271 __FUNCTION__, strerror(-res), res);
2272 return res;
2273 }
2274
2275 {
2276 SharedParameters::Lock l(mParameters);
2277 l.mParameters.videoFormat = format;
2278 l.mParameters.videoDataSpace = dataSpace;
2279 }
2280
2281 return OK;
2282}
2283
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07002284status_t Camera2Client::setAudioRestriction(int /*mode*/) {
Yin-Chia Yehdba03232019-08-19 15:54:28 -07002285 // Empty implementation. setAudioRestriction is hidden interface and not
2286 // supported by android.hardware.Camera API
2287 return INVALID_OPERATION;
2288}
2289
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07002290int32_t Camera2Client::getGlobalAudioRestriction() {
2291 // Empty implementation. getAudioRestriction is hidden interface and not
2292 // supported by android.hardware.Camera API
2293 return INVALID_OPERATION;
2294}
2295
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08002296status_t Camera2Client::setRotateAndCropOverride(uint8_t rotateAndCrop) {
2297 if (rotateAndCrop > ANDROID_SCALER_ROTATE_AND_CROP_AUTO) return BAD_VALUE;
2298
2299 return mDevice->setRotateAndCropAutoBehavior(
2300 static_cast<camera_metadata_enum_android_scaler_rotate_and_crop_t>(rotateAndCrop));
2301}
2302
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08002303bool Camera2Client::supportsCameraMute() {
2304 return mDevice->supportsCameraMute();
2305}
2306
2307status_t Camera2Client::setCameraMute(bool enabled) {
2308 return mDevice->setCameraMute(enabled);
2309}
2310
Emilian Peev2a8e2832019-08-23 13:00:31 -07002311status_t Camera2Client::waitUntilCurrentRequestIdLocked() {
2312 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2313 if (activeRequestId != 0) {
2314 auto res = waitUntilRequestIdApplied(activeRequestId,
2315 mDevice->getExpectedInFlightDuration());
2316 if (res == TIMED_OUT) {
2317 ALOGE("%s: Camera %d: Timed out waiting for current request id to return in results!",
2318 __FUNCTION__, mCameraId);
2319 return res;
2320 } else if (res != OK) {
2321 ALOGE("%s: Camera %d: Error while waiting for current request id to return in results!",
2322 __FUNCTION__, mCameraId);
2323 return res;
2324 }
2325 }
2326
2327 return OK;
2328}
2329
2330status_t Camera2Client::waitUntilRequestIdApplied(int32_t requestId, nsecs_t timeout) {
2331 Mutex::Autolock l(mLatestRequestMutex);
Emilian Peev4746fff2020-06-25 14:37:31 -07002332 while ((mLatestRequestId != requestId) && (mLatestFailedRequestId != requestId)) {
Emilian Peev2a8e2832019-08-23 13:00:31 -07002333 nsecs_t startTime = systemTime();
2334
2335 auto res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2336 if (res != OK) return res;
2337
2338 timeout -= (systemTime() - startTime);
2339 }
2340
Emilian Peev4746fff2020-06-25 14:37:31 -07002341 return (mLatestRequestId == requestId) ? OK : DEAD_OBJECT;
Emilian Peev2a8e2832019-08-23 13:00:31 -07002342}
2343
2344void Camera2Client::notifyRequestId(int32_t requestId) {
2345 Mutex::Autolock al(mLatestRequestMutex);
2346
2347 mLatestRequestId = requestId;
2348 mLatestRequestSignal.signal();
2349}
2350
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07002351const char* Camera2Client::kAutofocusLabel = "autofocus";
2352const char* Camera2Client::kTakepictureLabel = "take_picture";
2353
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002354} // namespace android