blob: 31cfed642cce2a131bcd2433c4c84ccb4172fea9 [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,
Igor Murashkinecf17e82012-10-02 16:05:11 -070058 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080059 uid_t clientUid,
Shuzhen Wang06fcfb02018-07-30 18:23:31 -070060 int servicePid):
Philip P. Moltmann9e648f62019-11-04 12:52:45 -080061 Camera2ClientBase(cameraService, cameraClient, clientPackageName, clientFeatureId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080062 cameraDeviceId, api1CameraId, cameraFacing,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080063 clientPid, clientUid, servicePid),
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080064 mParameters(api1CameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070065{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070066 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070067
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070068 SharedParameters::Lock l(mParameters);
69 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070070}
71
Emilian Peevbd8c5032018-02-14 23:05:40 +000072status_t Camera2Client::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) {
73 return initializeImpl(manager, monitorTags);
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080074}
75
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -070076bool Camera2Client::isZslEnabledInStillTemplate() {
77 bool zslEnabled = false;
78 CameraMetadata stillTemplate;
Emilian Peevf4816702020-04-03 15:44:51 -070079 status_t res = mDevice->createDefaultRequest(
80 camera_request_template_t::CAMERA_TEMPLATE_STILL_CAPTURE, &stillTemplate);
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -070081 if (res == OK) {
82 camera_metadata_entry_t enableZsl = stillTemplate.find(ANDROID_CONTROL_ENABLE_ZSL);
83 if (enableZsl.count == 1) {
84 zslEnabled = (enableZsl.data.u8[0] == ANDROID_CONTROL_ENABLE_ZSL_TRUE);
85 }
86 }
87
88 return zslEnabled;
89}
90
Yin-Chia Yehdce65c82017-01-06 15:03:53 -080091template<typename TProviderPtr>
Emilian Peevbd8c5032018-02-14 23:05:40 +000092status_t Camera2Client::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070093{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070094 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070095 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070096 status_t res;
97
Emilian Peevbd8c5032018-02-14 23:05:40 +000098 res = Camera2ClientBase::initialize(providerPtr, monitorTags);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080099 if (res != OK) {
100 return res;
101 }
102
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700103 {
104 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700105
Shuzhen Wangb131f4a2018-06-21 18:19:11 -0700106 res = l.mParameters.initialize(mDevice.get(), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700107 if (res != OK) {
108 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
109 __FUNCTION__, mCameraId, strerror(-res), res);
110 return NO_INIT;
111 }
Chien-Yu Chenfa52c0f2017-08-22 17:50:54 -0700112
113 l.mParameters.isDeviceZslSupported = isZslEnabledInStillTemplate();
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700114 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -0700115
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700116 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700117
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700118 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700119 threadName = String8::format("C2-%d-StreamProc",
120 mCameraId);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700121
Igor Murashkince124da2013-03-04 14:53:08 -0800122 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700123 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700124 mCameraId);
125 mFrameProcessor->run(threadName.string());
126
127 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700128 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700129 mCameraId);
130 mCaptureSequencer->run(threadName.string());
131
132 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700133 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700134 mCameraId);
135 mJpegProcessor->run(threadName.string());
136
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800137 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
138
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700139 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700140 mCameraId);
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800141 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700142
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700143 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700144 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700145 mCameraId);
146 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700147
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700148 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700149 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700150 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
151 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700152 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700153 }
154
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700155 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700156}
157
158Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700159 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700160 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700161
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700162 mDestructionStarted = true;
163
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700164 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700165
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700166 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700167}
168
169status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800170 return BasicClient::dump(fd, args);
171}
172
173status_t Camera2Client::dumpClient(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700174 String8 result;
Ruben Brunkcc776712015-02-17 20:18:47 -0800175 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", mCameraId,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -0800176 (getRemoteCallback() != NULL ?
Marco Nelissenf8880202014-11-14 07:58:25 -0800177 (IInterface::asBinder(getRemoteCallback()).get()) : NULL),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700178 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700179 result.append(" State: ");
180#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
181
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700182 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700183
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700184 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700185
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700186 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700187 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700188 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700189 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700190 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700193 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700194 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700195 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700196 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700197 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700198 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700199 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700200 p.jpegQuality, p.jpegThumbQuality);
201 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700202 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700203 p.gpsEnabled ? "enabled" : "disabled");
204 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700205 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700206 p.gpsCoordinates[0], p.gpsCoordinates[1],
207 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000208 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700209 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700210 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700211 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700212 }
213
214 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700215 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800216 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
217 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
218 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700224 default: result.append("UNKNOWN\n");
225 }
226
227 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700228 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800229 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
230 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700238 default: result.append("UNKNOWN\n");
239 }
240
241 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700242 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800243 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
245 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700247 default: result.append("UNKNOWN\n");
248 }
249
250 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700251 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800252 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700253 result.append("AUTO\n"); break;
Emilian Peev53eea852018-06-20 14:13:14 +0100254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
260 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
261 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
262 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
263 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
264 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
265 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
266 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
267 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
268 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
269 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
270 default: result.append("UNKNOWN\n");
271 }
272
273 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700274 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700275 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
276 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
277 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
278 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
279 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
280 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
281 default: result.append("UNKNOWN\n");
282 }
283
284 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700285 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700286 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
287 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
288 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
289 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
290 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
291 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
292 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
293 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
294 default: result.append("UNKNOWN\n");
295 }
296
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700297 result.append(" Focus state: ");
298 switch (p.focusState) {
299 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
300 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
301 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700302 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700303 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
304 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
305 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
306 default: result.append("UNKNOWN\n");
307 }
308
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700309 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700310 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700311 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700312 p.focusingAreas[i].left,
313 p.focusingAreas[i].top,
314 p.focusingAreas[i].right,
315 p.focusingAreas[i].bottom,
316 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700317 }
318
319 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700320 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700321
322 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700323 p.autoExposureLock ? "enabled" : "disabled",
324 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700325
326 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700327 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700328 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700329 p.meteringAreas[i].left,
330 p.meteringAreas[i].top,
331 p.meteringAreas[i].right,
332 p.meteringAreas[i].bottom,
333 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700334 }
335
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700336 result.appendFormat(" Zoom index: %d\n", p.zoom);
337 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
338 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700339
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700340 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700341 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700342
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700343 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700344 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700345
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700346 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
347 p.fastInfo.bestStillCaptureFpsRange[0],
348 p.fastInfo.bestStillCaptureFpsRange[1]);
349
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700350 result.appendFormat(" Use zero shutter lag: %s\n",
351 p.useZeroShutterLag() ? "yes" : "no");
352
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700353 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700354 result.appendFormat(" Preview stream ID: %d\n",
355 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700356 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700357 getCaptureStreamId());
358 result.appendFormat(" Recording stream ID: %d\n",
359 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700360
361 result.append(" Quirks for this camera:\n");
362 bool haveQuirk = false;
363 if (p.quirks.triggerAfWithAuto) {
364 result.appendFormat(" triggerAfWithAuto\n");
365 haveQuirk = true;
366 }
367 if (p.quirks.useZslFormat) {
368 result.appendFormat(" useZslFormat\n");
369 haveQuirk = true;
370 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700371 if (p.quirks.meteringCropRegion) {
372 result.appendFormat(" meteringCropRegion\n");
373 haveQuirk = true;
374 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700375 if (p.quirks.partialResults) {
376 result.appendFormat(" usePartialResult\n");
377 haveQuirk = true;
378 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700379 if (!haveQuirk) {
380 result.appendFormat(" none\n");
381 }
382
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700383 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700384
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700385 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700386
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700387 mCaptureSequencer->dump(fd, args);
388
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700389 mFrameProcessor->dump(fd, args);
390
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700391 mZslProcessor->dump(fd, args);
392
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800393 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700394#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700395}
396
397// ICamera interface
398
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800399binder::Status Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700400 ATRACE_CALL();
Shuzhen Wang316781a2020-08-18 18:11:01 -0700401 nsecs_t startTime = systemTime();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800402 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700403
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800404 binder::Status res = binder::Status::ok();
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800405 // Allow both client and the cameraserver to disconnect at all times
Jayant Chowdhary12361932018-08-27 14:46:13 -0700406 int callingPid = CameraThreadState::getCallingPid();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800407 if (callingPid != mClientPid && callingPid != mServicePid) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700408
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800409 if (mDevice == 0) return res;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700410
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700411 ALOGV("Camera %d: Shutting down", mCameraId);
412
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700413 /**
414 * disconnect() cannot call any methods that might need to promote a
415 * wp<Camera2Client>, since disconnect can be called from the destructor, at
416 * which point all such promotions will fail.
417 */
418
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700419 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700420
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700421 {
422 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800423 if (l.mParameters.state == Parameters::DISCONNECTED) return res;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700424 l.mParameters.state = Parameters::DISCONNECTED;
425 }
426
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700427 mFrameProcessor->requestExit();
428 mCaptureSequencer->requestExit();
429 mJpegProcessor->requestExit();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800430 mZslProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700431 mCallbackProcessor->requestExit();
432
433 ALOGV("Camera %d: Waiting for threads", mCameraId);
434
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700435 {
436 // Don't wait with lock held, in case the other threads need to
437 // complete callbacks that re-enter Camera2Client
438 mBinderSerializationLock.unlock();
439
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700440 mFrameProcessor->join();
441 mCaptureSequencer->join();
442 mJpegProcessor->join();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800443 mZslProcessor->join();
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700444 mCallbackProcessor->join();
445
446 mBinderSerializationLock.lock();
447 }
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700448
Ruben Brunkdfe71552013-12-05 11:00:37 -0800449 ALOGV("Camera %d: Deleting streams", mCameraId);
450
451 mStreamingProcessor->deletePreviewStream();
452 mStreamingProcessor->deleteRecordingStream();
453 mJpegProcessor->deleteStream();
454 mCallbackProcessor->deleteStream();
455 mZslProcessor->deleteStream();
456
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700457 ALOGV("Camera %d: Disconnecting device", mCameraId);
458
459 mDevice->disconnect();
460
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700461 CameraService::Client::disconnect();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800462
Shuzhen Wang316781a2020-08-18 18:11:01 -0700463 int32_t closeLatencyMs = ns2ms(systemTime() - startTime);
464 CameraServiceProxyWrapper::logClose(mCameraIdStr, closeLatencyMs);
465
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800466 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700467}
468
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800469status_t Camera2Client::connect(const sp<hardware::ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700470 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700471 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800472 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700473
Jayant Chowdhary12361932018-08-27 14:46:13 -0700474 if (mClientPid != 0 && CameraThreadState::getCallingPid() != mClientPid) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700475 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
476 "current locked to pid %d", __FUNCTION__,
Jayant Chowdhary12361932018-08-27 14:46:13 -0700477 mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700478 return BAD_VALUE;
479 }
480
Jayant Chowdhary12361932018-08-27 14:46:13 -0700481 mClientPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700482
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800483 mRemoteCallback = client;
484 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700485
486 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700487}
488
489status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700490 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700491 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800492 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700493 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700494 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700495
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700496 if (mClientPid == 0) {
Jayant Chowdhary12361932018-08-27 14:46:13 -0700497 mClientPid = CameraThreadState::getCallingPid();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700498 return OK;
499 }
500
Jayant Chowdhary12361932018-08-27 14:46:13 -0700501 if (mClientPid != CameraThreadState::getCallingPid()) {
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700502 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700503 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700504 return EBUSY;
505 }
506
507 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700508}
509
510status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700511 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700512 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800513 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700514 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700515 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700516
Jayant Chowdhary12361932018-08-27 14:46:13 -0700517 if (mClientPid == CameraThreadState::getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700518 SharedParameters::Lock l(mParameters);
519 if (l.mParameters.state == Parameters::RECORD ||
520 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
521 ALOGD("Not allowed to unlock camera during recording.");
522 return INVALID_OPERATION;
523 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700524 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800525 mRemoteCallback.clear();
526 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700527 return OK;
528 }
529
530 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
Jayant Chowdhary12361932018-08-27 14:46:13 -0700531 __FUNCTION__, mCameraId, CameraThreadState::getCallingPid(), mClientPid);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700532 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700533}
534
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700535status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800536 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700537 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700538 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800539 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700540 status_t res;
541 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700542
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700543 sp<IBinder> binder;
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700544 sp<Surface> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800545 if (bufferProducer != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -0800546 binder = IInterface::asBinder(bufferProducer);
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700547 // Using controlledByApp flag to ensure that the buffer queue remains in
548 // async mode for the old camera API, where many applications depend
549 // on that behavior.
550 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700551 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700552 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700553}
554
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700555status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700556 const sp<Surface>& window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700557 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700558 status_t res;
559
560 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700561 ALOGV("%s: Camera %d: New window is same as old window",
562 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700563 return NO_ERROR;
564 }
565
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700566 Parameters::State state;
567 {
568 SharedParameters::Lock l(mParameters);
569 state = l.mParameters.state;
570 }
571 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700572 case Parameters::DISCONNECTED:
573 case Parameters::RECORD:
574 case Parameters::STILL_CAPTURE:
575 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700576 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700577 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700578 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700579 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700580 case Parameters::STOPPED:
581 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700582 // OK
583 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700584 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700585 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700586 res = stopStream();
587 if (res != OK) {
588 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
589 __FUNCTION__, strerror(-res), res);
590 return res;
591 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700592 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700593 break;
594 }
595
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700596 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700597 res = mStreamingProcessor->setPreviewWindow(window);
598 if (res != OK) {
599 ALOGE("%s: Unable to set new preview window: %s (%d)",
600 __FUNCTION__, strerror(-res), res);
601 return res;
602 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700603
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700604 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
605 SharedParameters::Lock l(mParameters);
606 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700607 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700608 }
609
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700610 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700611}
612
613void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700614 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700615 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800616 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700617
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700618 if ( checkPid(__FUNCTION__) != OK) return;
619
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700620 SharedParameters::Lock l(mParameters);
621 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700622}
623
624void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
625 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700626
627 switch(params.state) {
628 case Parameters::STOPPED:
629 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
630 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700631 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700632 // OK
633 break;
634 default:
635 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
636 ALOGE("%s: Camera %d: Can't use preview callbacks "
637 "in state %d", __FUNCTION__, mCameraId, params.state);
638 return;
639 }
640 }
641
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700642 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
643 ALOGV("%s: setting oneshot", __FUNCTION__);
644 params.previewCallbackOneShot = true;
645 }
646 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700647
Zhijun He527748a2013-09-15 21:06:10 -0700648 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700649 // Disable any existing preview callback window when enabling
650 // preview callback flags
651 res = mCallbackProcessor->setCallbackWindow(NULL);
652 if (res != OK) {
653 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
654 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
655 return;
656 }
657 params.previewCallbackSurface = false;
658 }
659
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700660 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700661
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700662 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700663 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700664 if (res != OK) {
665 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
666 __FUNCTION__, mCameraId,
667 Parameters::getStateName(params.state));
668 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700669 }
670 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700671}
672
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700673status_t Camera2Client::setPreviewCallbackTarget(
674 const sp<IGraphicBufferProducer>& callbackProducer) {
675 ATRACE_CALL();
676 ALOGV("%s: E", __FUNCTION__);
677 Mutex::Autolock icl(mBinderSerializationLock);
678 status_t res;
679 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
680
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700681 sp<Surface> window;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700682 if (callbackProducer != 0) {
683 window = new Surface(callbackProducer);
684 }
685
686 res = mCallbackProcessor->setCallbackWindow(window);
687 if (res != OK) {
688 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
689 __FUNCTION__, mCameraId, strerror(-res), res);
690 return res;
691 }
692
693 SharedParameters::Lock l(mParameters);
694
695 if (window != NULL) {
696 // Disable traditional callbacks when a valid callback target is given
697 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
698 l.mParameters.previewCallbackOneShot = false;
699 l.mParameters.previewCallbackSurface = true;
700 } else {
701 // Disable callback target if given a NULL interface.
702 l.mParameters.previewCallbackSurface = false;
703 }
704
705 switch(l.mParameters.state) {
706 case Parameters::PREVIEW:
707 res = startPreviewL(l.mParameters, true);
708 break;
709 case Parameters::RECORD:
710 case Parameters::VIDEO_SNAPSHOT:
711 res = startRecordingL(l.mParameters, true);
712 break;
713 default:
714 break;
715 }
716 if (res != OK) {
717 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
718 __FUNCTION__, mCameraId,
719 Parameters::getStateName(l.mParameters.state));
720 }
721
722 return OK;
723}
724
725
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700726status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700727 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700728 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800729 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700730 status_t res;
731 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700732 SharedParameters::Lock l(mParameters);
733 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700734}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700735
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700736status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700737 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700738 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700739
740 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
741
Yin-Chia Yehdf143042020-02-05 12:41:07 -0800742 if (params.state == Parameters::DISCONNECTED) {
743 ALOGE("%s: Camera %d has been disconnected.", __FUNCTION__, mCameraId);
744 return INVALID_OPERATION;
745 }
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700746 if ( (params.state == Parameters::PREVIEW ||
747 params.state == Parameters::RECORD ||
748 params.state == Parameters::VIDEO_SNAPSHOT)
749 && !restart) {
750 // Succeed attempt to re-enter a streaming state
751 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
752 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700753 return OK;
754 }
755 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700756 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700757 __FUNCTION__,
758 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700759 return INVALID_OPERATION;
760 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700761
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700762 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700763 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700764 return OK;
765 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700766 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800767 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700768
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700769 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700770 if (res != OK) {
771 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
772 __FUNCTION__, mCameraId, strerror(-res), res);
773 return res;
774 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700775
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800776 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
777
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700778 // We could wait to create the JPEG output stream until first actual use
779 // (first takePicture call). However, this would substantially increase the
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800780 // first capture latency on HAL3 devices.
781 // So create it unconditionally at preview start. As a drawback,
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700782 // this increases gralloc memory consumption for applications that don't
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800783 // ever take a picture. Do not enter this mode when jpeg stream will slow
784 // down preview.
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700785 // TODO: Find a better compromise, though this likely would involve HAL
786 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700787 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800788 // If jpeg stream will slow down preview, make sure we remove it before starting preview
789 if (params.slowJpegMode) {
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700790 if (lastJpegStreamId != NO_STREAM) {
791 // Pause preview if we are streaming
792 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
793 if (activeRequestId != 0) {
794 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
795 if (res != OK) {
796 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
797 __FUNCTION__, mCameraId, strerror(-res), res);
798 }
799 res = mDevice->waitUntilDrained();
800 if (res != OK) {
801 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
802 __FUNCTION__, mCameraId, strerror(-res), res);
803 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800804 }
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700805
806 res = mJpegProcessor->deleteStream();
807
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800808 if (res != OK) {
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700809 ALOGE("%s: Camera %d: delete Jpeg stream failed: %s (%d)",
810 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800811 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800812
Yin-Chia Yeh86325522018-07-26 10:01:19 -0700813 if (activeRequestId != 0) {
814 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
815 if (res != OK) {
816 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
817 __FUNCTION__, mCameraId, strerror(-res), res);
818 }
Yin-Chia Yeh693047d2018-03-08 12:14:19 -0800819 }
820 }
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800821 } else {
822 res = updateProcessorStream(mJpegProcessor, params);
823 if (res != OK) {
824 ALOGE("%s: Camera %d: Can't pre-configure still image "
825 "stream: %s (%d)",
826 __FUNCTION__, mCameraId, strerror(-res), res);
827 return res;
828 }
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700829 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700830 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700831
Zhijun Hed1d64672013-09-06 15:00:01 -0700832 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700833 bool callbacksEnabled = (params.previewCallbackFlags &
834 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
835 params.previewCallbackSurface;
836
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700837 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700838 // Can't have recording stream hanging around when enabling callbacks,
839 // since it exceeds the max stream count on some devices.
840 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
841 ALOGV("%s: Camera %d: Clearing out recording stream before "
842 "creating callback stream", __FUNCTION__, mCameraId);
843 res = mStreamingProcessor->stopStream();
844 if (res != OK) {
845 ALOGE("%s: Camera %d: Can't stop streaming to delete "
846 "recording stream", __FUNCTION__, mCameraId);
847 return res;
848 }
849 res = mStreamingProcessor->deleteRecordingStream();
850 if (res != OK) {
851 ALOGE("%s: Camera %d: Unable to delete recording stream before "
852 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
853 strerror(-res), res);
854 return res;
855 }
856 }
857
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700858 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700859 if (res != OK) {
860 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
861 __FUNCTION__, mCameraId, strerror(-res), res);
862 return res;
863 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700864 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800865 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
866 /**
867 * Delete the unused callback stream when preview stream is changed and
868 * preview is not enabled. Don't need stop preview stream as preview is in
869 * STOPPED state now.
870 */
871 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
872 res = mCallbackProcessor->deleteStream();
873 if (res != OK) {
874 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
875 __FUNCTION__, mCameraId, strerror(-res), res);
876 return res;
877 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700878 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700879
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -0700880 if (params.useZeroShutterLag() &&
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700881 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700882 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700883 if (res != OK) {
884 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
885 __FUNCTION__, mCameraId, strerror(-res), res);
886 return res;
887 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700888
889 if (jpegStreamChanged) {
890 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
891 __FUNCTION__, mCameraId);
892 mZslProcessor->clearZslQueue();
893 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700894 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700895 } else {
896 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700897 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700898
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700899 outputStreams.push(getPreviewStreamId());
900
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700901 if (params.isDeviceZslSupported) {
902 // If device ZSL is supported, resume preview buffers that may be paused
903 // during last takePicture().
904 mDevice->dropStreamBuffers(false, getPreviewStreamId());
905 }
906
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700907 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700908 if (!restart) {
909 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700910 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700911 ALOGE("%s: Camera %d: Can't set up preview request: "
912 "%s (%d)", __FUNCTION__, mCameraId,
913 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700914 return res;
915 }
916 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700917 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
918 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700919 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700920 if (!restart) {
921 res = mStreamingProcessor->updateRecordingRequest(params);
922 if (res != OK) {
923 ALOGE("%s: Camera %d: Can't set up preview request with "
924 "record hint: %s (%d)", __FUNCTION__, mCameraId,
925 strerror(-res), res);
926 return res;
927 }
928 }
929 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
930 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700931 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700932 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700933 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700934 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700935 return res;
936 }
937
Jasmine Chen33d09ca2021-01-22 19:42:54 +0800938 mCallbackProcessor->unpauseCallback();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700939 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700940 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700941}
942
943void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700944 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700945 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800946 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700947 status_t res;
948 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700949 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700950}
951
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700952void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700953 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700954 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700955 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700956 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700957 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700958 SharedParameters::Lock l(mParameters);
959 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700960 }
961
962 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700963 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800964 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700965 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700966 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700967 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700968 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700969 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -0700970 FALLTHROUGH_INTENDED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700971 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700972 case Parameters::PREVIEW:
Jasmine Chen33d09ca2021-01-22 19:42:54 +0800973 mCallbackProcessor->pauseCallback();
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700974 syncWithDevice();
Emilian Peev2a8e2832019-08-23 13:00:31 -0700975 // Due to flush a camera device sync is not a sufficient
976 // guarantee that the current client parameters are
977 // correctly applied. To resolve this wait for the current
978 // request id to return in the results.
979 waitUntilCurrentRequestIdLocked();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700980 res = stopStream();
981 if (res != OK) {
982 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
983 __FUNCTION__, mCameraId, strerror(-res), res);
984 }
Ruchit Sharma2cec0df2014-08-20 16:02:08 -0400985
986 // Flush all in-process captures and buffer in order to stop
987 // preview faster.
988 res = mDevice->flush();
989 if (res != OK) {
990 ALOGE("%s: Camera %d: Unable to flush pending requests: %s (%d)",
991 __FUNCTION__, mCameraId, strerror(-res), res);
992 }
993
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700994 res = mDevice->waitUntilDrained();
995 if (res != OK) {
996 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
997 __FUNCTION__, mCameraId, strerror(-res), res);
998 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -0700999 // Clean up recording stream
1000 res = mStreamingProcessor->deleteRecordingStream();
1001 if (res != OK) {
1002 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1003 "stop preview: %s (%d)",
1004 __FUNCTION__, mCameraId, strerror(-res), res);
1005 }
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001006 FALLTHROUGH_INTENDED;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001007 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
1008 SharedParameters::Lock l(mParameters);
1009 l.mParameters.state = Parameters::STOPPED;
1010 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001011 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001012 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001013 default:
1014 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001015 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001016 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001017}
1018
1019bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001020 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001021 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001022 status_t res;
1023 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
1024
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001025 SharedParameters::Lock l(mParameters);
1026 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001027}
1028
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001029status_t Camera2Client::setVideoBufferMode(int32_t videoBufferMode) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001030 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001031 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001032 status_t res;
1033 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1034
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001035 SharedParameters::Lock l(mParameters);
1036 switch (l.mParameters.state) {
1037 case Parameters::RECORD:
1038 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001039 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001040 __FUNCTION__, mCameraId,
1041 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001042 return INVALID_OPERATION;
1043 default:
1044 // OK
1045 break;
1046 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001047
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001048 if (videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1049 ALOGE("%s: %d: Only video buffer queue is supported", __FUNCTION__, __LINE__);
1050 return BAD_VALUE;
1051 }
1052
1053 l.mParameters.videoBufferMode = videoBufferMode;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001054
1055 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001056}
1057
1058status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001059 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001060 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001061 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001062 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001063 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001064 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001065
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001066 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001067}
1068
1069status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
Yunlian Jiang7fd5bdb2016-11-22 15:16:25 -08001070 status_t res = OK;
Igor Murashkin22d58d32012-10-02 19:07:14 -07001071
1072 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
1073
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001074 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001075 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001076 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001077 if (res != OK) return res;
Zhijun He96ff5c42014-10-13 22:20:37 -07001078 // Make sure first preview request is submitted to the HAL device to avoid
1079 // two consecutive set of configure_streams being called into the HAL.
1080 // TODO: Refactor this to avoid initial preview configuration.
1081 syncWithDevice();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001082 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001083 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001084 // Ready to go
1085 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001086 case Parameters::RECORD:
1087 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001088 // OK to call this when recording is already on, just skip unless
1089 // we're looking to restart
1090 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001091 break;
1092 default:
1093 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001094 __FUNCTION__, mCameraId,
1095 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001096 return INVALID_OPERATION;
1097 };
1098
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001099 if (params.videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1100 ALOGE("%s: Camera %d: Recording only supported buffer queue mode, but "
1101 "mode %d is requested!", __FUNCTION__, mCameraId, params.videoBufferMode);
1102 return INVALID_OPERATION;
1103 }
1104
1105 if (!mStreamingProcessor->haveValidRecordingWindow()) {
1106 ALOGE("%s: No valid recording window", __FUNCTION__);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001107 return INVALID_OPERATION;
1108 }
1109
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001110 if (!restart) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001111 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001112 mStreamingProcessor->updateRecordingRequest(params);
1113 if (res != OK) {
1114 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1115 __FUNCTION__, mCameraId, strerror(-res), res);
1116 return res;
1117 }
1118 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001119
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001120 // Not all devices can support a preview callback stream and a recording
1121 // stream at the same time, so assume none of them can.
1122 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1123 ALOGV("%s: Camera %d: Clearing out callback stream before "
1124 "creating recording stream", __FUNCTION__, mCameraId);
1125 res = mStreamingProcessor->stopStream();
1126 if (res != OK) {
1127 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1128 __FUNCTION__, mCameraId);
1129 return res;
1130 }
1131 res = mCallbackProcessor->deleteStream();
1132 if (res != OK) {
1133 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1134 "record: %s (%d)", __FUNCTION__, mCameraId,
1135 strerror(-res), res);
1136 return res;
1137 }
1138 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001139
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001140 // Clean up ZSL before transitioning into recording
1141 if (mZslProcessor->getStreamId() != NO_STREAM) {
1142 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1143 "creating recording stream", __FUNCTION__, mCameraId);
1144 res = mStreamingProcessor->stopStream();
1145 if (res != OK) {
1146 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1147 __FUNCTION__, mCameraId);
1148 return res;
1149 }
1150 res = mDevice->waitUntilDrained();
1151 if (res != OK) {
1152 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1153 __FUNCTION__, mCameraId, strerror(-res), res);
1154 }
1155 res = mZslProcessor->clearZslQueue();
1156 if (res != OK) {
1157 ALOGE("%s: Camera %d: Can't clear zsl queue",
1158 __FUNCTION__, mCameraId);
1159 return res;
1160 }
1161 res = mZslProcessor->deleteStream();
1162 if (res != OK) {
1163 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1164 "record: %s (%d)", __FUNCTION__, mCameraId,
1165 strerror(-res), res);
1166 return res;
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001167 }
1168 }
1169
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001170 // Disable callbacks if they're enabled; can't record and use callbacks,
1171 // and we can't fail record start without stagefright asserting.
1172 params.previewCallbackFlags = 0;
1173
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001174 // May need to reconfigure video snapshot JPEG sizes
1175 // during recording startup, so need a more complex sequence here to
1176 // ensure an early stream reconfiguration doesn't happen
1177 bool recordingStreamNeedsUpdate;
1178 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
1179 if (res != OK) {
1180 ALOGE("%s: Camera %d: Can't query recording stream",
1181 __FUNCTION__, mCameraId);
1182 return res;
1183 }
1184
1185 if (recordingStreamNeedsUpdate) {
1186 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1187 // Right now camera device cannot handle configureStream failure gracefully
1188 // when device is streaming
1189 res = mStreamingProcessor->stopStream();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001190 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001191 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1192 "stream", __FUNCTION__, mCameraId);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001193 return res;
1194 }
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001195 res = mDevice->waitUntilDrained();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001196 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001197 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1198 "%s (%d)", __FUNCTION__, mCameraId,
1199 strerror(-res), res);
1200 }
1201
1202 res = updateProcessorStream<
1203 StreamingProcessor,
1204 &StreamingProcessor::updateRecordingStream>(
1205 mStreamingProcessor,
1206 params);
1207 if (res != OK) {
1208 ALOGE("%s: Camera %d: Unable to update recording stream: "
1209 "%s (%d)", __FUNCTION__, mCameraId,
1210 strerror(-res), res);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001211 return res;
1212 }
1213 }
1214
Zhijun Hed1d64672013-09-06 15:00:01 -07001215 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001216 outputStreams.push(getPreviewStreamId());
1217 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001218
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001219 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1220 outputStreams);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001221
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001222 // startStream might trigger a configureStream call and device might fail
1223 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1224 // to video size.
1225 if (res == BAD_VALUE) {
1226 overrideVideoSnapshotSize(params);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001227 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1228 outputStreams);
1229 }
1230
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001231 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001232 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001233 __FUNCTION__, mCameraId, strerror(-res), res);
1234 return res;
1235 }
1236
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001237 if (params.state < Parameters::RECORD) {
1238 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001239 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001240
1241 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001242}
1243
1244void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001245 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001246 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001247 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001248 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001249
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001250 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001251 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1252
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001253 switch (l.mParameters.state) {
1254 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001255 // OK to stop
1256 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001257 case Parameters::STOPPED:
1258 case Parameters::PREVIEW:
1259 case Parameters::STILL_CAPTURE:
1260 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001261 default:
1262 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001263 __FUNCTION__, mCameraId,
1264 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001265 return;
1266 };
1267
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001268 sCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001269
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001270 // Remove recording stream because the video target may be abandoned soon.
1271 res = stopStream();
1272 if (res != OK) {
1273 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1274 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001275 }
1276
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001277 res = mDevice->waitUntilDrained();
1278 if (res != OK) {
1279 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1280 __FUNCTION__, mCameraId, strerror(-res), res);
1281 }
1282 // Clean up recording stream
1283 res = mStreamingProcessor->deleteRecordingStream();
1284 if (res != OK) {
1285 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1286 "stop preview: %s (%d)",
1287 __FUNCTION__, mCameraId, strerror(-res), res);
1288 }
1289 l.mParameters.recoverOverriddenJpegSize();
1290
1291 // Restart preview
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001292 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001293 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001294 ALOGE("%s: Camera %d: Unable to return to preview",
1295 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001296 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001297}
1298
1299bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001300 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001301 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001302
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001303 if ( checkPid(__FUNCTION__) != OK) return false;
1304
James Dong8da4cd72012-08-04 19:58:07 -07001305 return recordingEnabledL();
1306}
1307
1308bool Camera2Client::recordingEnabledL() {
1309 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001310 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001311
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001312 return (l.mParameters.state == Parameters::RECORD
1313 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001314}
1315
1316void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001317 (void)mem;
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001318 ATRACE_CALL();
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001319 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001320}
1321
Chien-Yu Chen2d13b1d2016-04-28 12:11:20 -07001322void Camera2Client::releaseRecordingFrameHandle(native_handle_t *handle) {
1323 (void)handle;
1324 ATRACE_CALL();
1325 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1326}
1327
Yin-Chia Yehb5df5472017-03-20 19:32:19 -07001328void Camera2Client::releaseRecordingFrameHandleBatch(
1329 const std::vector<native_handle_t*>& handles) {
1330 (void)handles;
1331 ATRACE_CALL();
1332 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
1333}
1334
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001335status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001336 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001337 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001338 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001339 status_t res;
1340 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1341
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001342 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001343 bool notifyImmediately = false;
1344 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001345 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001346 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001347 if (l.mParameters.state < Parameters::PREVIEW) {
Zhijun Hef79f8ca2014-09-22 23:52:54 -07001348 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1349 __FUNCTION__, mCameraId, l.mParameters.state);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001350 return INVALID_OPERATION;
1351 }
1352
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001353 /**
1354 * If the camera does not support auto-focus, it is a no-op and
1355 * onAutoFocus(boolean, Camera) callback will be called immediately
1356 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001357 *
1358 * Similarly, if focus mode is set to INFINITY, there's no reason to
1359 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001360 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001361 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1362 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001363 notifyImmediately = true;
1364 notifySuccess = true;
1365 }
1366 /**
1367 * If we're in CAF mode, and AF has already been locked, just fire back
1368 * the callback right away; the HAL would not send a notification since
1369 * no state change would happen on a AF trigger.
1370 */
1371 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1372 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1373 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1374 notifyImmediately = true;
1375 notifySuccess = true;
1376 }
1377 /**
1378 * Send immediate notification back to client
1379 */
1380 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001381 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1382 if (l.mRemoteCallback != 0) {
1383 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001384 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001385 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001386 return OK;
1387 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001388 /**
1389 * Handle quirk mode for AF in scene modes
1390 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001391 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001392 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001393 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1394 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001395 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1396 __FUNCTION__, l.mParameters.focusMode);
1397 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1398 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1399 updateRequests(l.mParameters);
1400 }
1401
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001402 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1403 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001404 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001405 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1406
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001407 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001408
1409 mDevice->triggerAutofocus(triggerId);
1410
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001411 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001412}
1413
1414status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001415 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001416 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001417 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001418 status_t res;
1419 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1420
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001421 int triggerId;
1422 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001423 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001424 // Canceling does nothing in FIXED or INFINITY modes
1425 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1426 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1427 return OK;
1428 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001429
1430 // An active AF trigger is canceled
1431 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1432 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1433 }
1434
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001435 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001436
1437 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001438 // the real state at this point. No need to cancel explicitly if
1439 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001440 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1441 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1442 l.mParameters.shadowFocusMode);
1443 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1444 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1445 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001446
1447 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001448 }
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001449 if (l.mParameters.allowZslMode) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001450 mZslProcessor->clearZslQueue();
1451 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001452 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001453 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001454
1455 mDevice->triggerCancelAutofocus(triggerId);
1456
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001457 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001458}
1459
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001460status_t Camera2Client::takePicture(int /*msgType*/) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001461 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001462 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001463 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001464 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001465
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001466 int takePictureCounter;
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001467 bool shouldSyncWithDevice = true;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001468 {
1469 SharedParameters::Lock l(mParameters);
1470 switch (l.mParameters.state) {
1471 case Parameters::DISCONNECTED:
1472 case Parameters::STOPPED:
1473 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1474 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001475 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001476 return INVALID_OPERATION;
1477 case Parameters::PREVIEW:
1478 // Good to go for takePicture
1479 res = commandStopFaceDetectionL(l.mParameters);
1480 if (res != OK) {
1481 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1482 __FUNCTION__, mCameraId);
1483 return res;
1484 }
1485 l.mParameters.state = Parameters::STILL_CAPTURE;
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001486
1487 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1488 if (l.mParameters.isJpegSizeOverridden() &&
1489 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1490 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1491 if (res != OK) {
1492 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1493 __FUNCTION__, mCameraId, strerror(-res), res);
1494 }
1495 res = mDevice->waitUntilDrained();
1496 if (res != OK) {
1497 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1498 __FUNCTION__, mCameraId, strerror(-res), res);
1499 }
1500 // Clean up recording stream
1501 res = mStreamingProcessor->deleteRecordingStream();
1502 if (res != OK) {
1503 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1504 "stop preview: %s (%d)",
1505 __FUNCTION__, mCameraId, strerror(-res), res);
1506 }
1507 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1508 if (res != OK) {
1509 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1510 __FUNCTION__, mCameraId, strerror(-res), res);
1511 }
1512 l.mParameters.recoverOverriddenJpegSize();
1513 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001514 break;
1515 case Parameters::RECORD:
1516 // Good to go for video snapshot
1517 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1518 break;
1519 case Parameters::STILL_CAPTURE:
1520 case Parameters::VIDEO_SNAPSHOT:
1521 ALOGE("%s: Camera %d: Already taking a picture",
1522 __FUNCTION__, mCameraId);
1523 return INVALID_OPERATION;
1524 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001525
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001526 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Zhijun Hee2d83752014-06-23 10:22:37 -07001527 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001528 // slowJpegMode will create jpeg stream in CaptureSequencer before capturing
1529 if (!l.mParameters.slowJpegMode) {
1530 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1531 }
1532
Yin-Chia Yehd3c5b082014-09-15 14:50:06 -07001533 // If video snapshot fail to configureStream, try override video snapshot size to
1534 // video size
1535 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1536 overrideVideoSnapshotSize(l.mParameters);
1537 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1538 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001539 if (res != OK) {
1540 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1541 __FUNCTION__, mCameraId, strerror(-res), res);
1542 return res;
1543 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001544 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001545
1546 // Clear ZSL buffer queue when Jpeg size is changed.
1547 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001548 if (l.mParameters.allowZslMode && jpegStreamChanged) {
Zhijun Hee2d83752014-06-23 10:22:37 -07001549 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1550 __FUNCTION__, mCameraId);
1551 mZslProcessor->clearZslQueue();
1552 }
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001553
1554 // We should always sync with the device in case flash is turned on,
1555 // the camera device suggests that flash is needed (AE state FLASH_REQUIRED)
1556 // or we are in some other AE state different from CONVERGED that may need
1557 // precapture trigger.
1558 if (l.mParameters.flashMode != Parameters::FLASH_MODE_ON &&
1559 (l.mParameters.aeState == ANDROID_CONTROL_AE_STATE_CONVERGED)) {
1560 shouldSyncWithDevice = false;
1561 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001562 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001563
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001564 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1565
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001566 // Make sure HAL has correct settings in case precapture trigger is needed.
1567 if (shouldSyncWithDevice) {
1568 syncWithDevice();
1569 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001570
Shuzhen Wang06fcfb02018-07-30 18:23:31 -07001571 res = mCaptureSequencer->startCapture();
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001572 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001573 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001574 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001575 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001576
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001577 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001578}
1579
1580status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001581 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001582 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001583 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001584 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001585 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1586
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001587 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001588
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001589 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001590 res = l.mParameters.set(params);
1591 if (res != OK) return res;
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001592 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1593
Eino-Ville Talvalac451d0f2016-06-30 17:17:35 -07001594 if (l.mParameters.allowZslMode && focusModeAfter != focusModeBefore) {
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001595 mZslProcessor->clearZslQueue();
1596 }
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001597
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001598 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001599
1600 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001601}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001602
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001603String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001604 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001605 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001606 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001607 // The camera service can unconditionally get the parameters at all times
Jayant Chowdhary12361932018-08-27 14:46:13 -07001608 if (CameraThreadState::getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001609
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001610 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001611
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001612 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001613}
1614
1615status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001616 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001617 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001618 status_t res;
1619 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001620
1621 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1622 cmd, arg1, arg2);
1623
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001624 switch (cmd) {
1625 case CAMERA_CMD_START_SMOOTH_ZOOM:
1626 return commandStartSmoothZoomL();
1627 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1628 return commandStopSmoothZoomL();
1629 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1630 return commandSetDisplayOrientationL(arg1);
1631 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1632 return commandEnableShutterSoundL(arg1 == 1);
1633 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1634 return commandPlayRecordingSoundL();
1635 case CAMERA_CMD_START_FACE_DETECTION:
1636 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001637 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001638 SharedParameters::Lock l(mParameters);
1639 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001640 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001641 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1642 return commandEnableFocusMoveMsgL(arg1 == 1);
1643 case CAMERA_CMD_PING:
1644 return commandPingL();
1645 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -07001646 case CAMERA_CMD_SET_VIDEO_FORMAT:
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001647 ALOGE("%s: command %d (arguments %d, %d) is not supported.",
1648 __FUNCTION__, cmd, arg1, arg2);
1649 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001650 default:
1651 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1652 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001653 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001654 }
1655}
James Dong983cf232012-08-01 16:39:55 -07001656
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001657status_t Camera2Client::commandStartSmoothZoomL() {
1658 ALOGE("%s: Unimplemented!", __FUNCTION__);
1659 return OK;
1660}
James Dong983cf232012-08-01 16:39:55 -07001661
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001662status_t Camera2Client::commandStopSmoothZoomL() {
1663 ALOGE("%s: Unimplemented!", __FUNCTION__);
1664 return OK;
1665}
James Dong983cf232012-08-01 16:39:55 -07001666
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001667status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001668 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001669 mCameraFacing == CAMERA_FACING_FRONT);
1670 if (transform == -1) {
1671 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1672 __FUNCTION__, mCameraId, degrees);
1673 return BAD_VALUE;
1674 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001675 SharedParameters::Lock l(mParameters);
1676 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001677 getPreviewStreamId() != NO_STREAM) {
1678 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001679 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001680 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001681 return OK;
1682}
1683
1684status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001685 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001686 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001687 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001688 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001689 }
1690
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001691 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001692 return OK;
1693}
1694
1695status_t Camera2Client::commandPlayRecordingSoundL() {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001696 sCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001697 return OK;
1698}
1699
Igor Murashkinddf3c502012-10-12 16:56:11 -07001700status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001701 ALOGV("%s: Camera %d: Starting face detection",
1702 __FUNCTION__, mCameraId);
1703 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001704 SharedParameters::Lock l(mParameters);
1705 switch (l.mParameters.state) {
1706 case Parameters::DISCONNECTED:
1707 case Parameters::STOPPED:
1708 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1709 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001710 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1711 __FUNCTION__, mCameraId);
1712 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001713 case Parameters::PREVIEW:
1714 case Parameters::RECORD:
1715 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001716 // Good to go for starting face detect
1717 break;
1718 }
1719 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001720 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001721 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001722 ALOGE("%s: Camera %d: Face detection not supported",
1723 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001724 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001725 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001726 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001727
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001728 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001729
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001730 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001731
1732 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001733}
1734
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001735status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001736 status_t res = OK;
1737 ALOGV("%s: Camera %d: Stopping face detection",
1738 __FUNCTION__, mCameraId);
1739
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001740 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001741
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001742 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001743
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001744 if (params.state == Parameters::PREVIEW
1745 || params.state == Parameters::RECORD
1746 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001747 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001748 }
1749
1750 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001751}
1752
1753status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001754 SharedParameters::Lock l(mParameters);
1755 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001756
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001757 return OK;
1758}
1759
1760status_t Camera2Client::commandPingL() {
1761 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001762 SharedParameters::Lock l(mParameters);
1763 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001764 return OK;
1765 } else {
1766 return NO_INIT;
1767 }
1768}
1769
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001770void Camera2Client::notifyError(int32_t errorCode,
Ruben Brunka485dfe2015-04-14 13:43:47 -07001771 const CaptureResultExtras& resultExtras) {
1772 int32_t err = CAMERA_ERROR_UNKNOWN;
1773 switch(errorCode) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001774 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001775 err = CAMERA_ERROR_RELEASED;
1776 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001777 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001778 err = CAMERA_ERROR_UNKNOWN;
1779 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001780 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001781 err = CAMERA_ERROR_SERVER_DIED;
1782 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001783 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
1784 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
1785 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001786 ALOGW("%s: Received recoverable error %d from HAL - ignoring, requestId %" PRId32,
1787 __FUNCTION__, errorCode, resultExtras.requestId);
Emilian Peev4746fff2020-06-25 14:37:31 -07001788
1789 if ((hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST == errorCode) ||
1790 (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == errorCode)) {
1791 Mutex::Autolock al(mLatestRequestMutex);
1792
1793 mLatestFailedRequestId = resultExtras.requestId;
1794 mLatestRequestSignal.signal();
1795 }
Yin-Chia Yeh0d2fa082019-02-20 12:31:53 -08001796 mCaptureSequencer->notifyError(errorCode, resultExtras);
Ruben Brunka485dfe2015-04-14 13:43:47 -07001797 return;
1798 default:
1799 err = CAMERA_ERROR_UNKNOWN;
1800 break;
1801 }
1802
1803 ALOGE("%s: Error condition %d reported by HAL, requestId %" PRId32, __FUNCTION__, errorCode,
1804 resultExtras.requestId);
1805
1806 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1807 if (l.mRemoteCallback != nullptr) {
1808 l.mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, err, 0);
1809 }
1810}
1811
1812
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001813/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001814void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1815 ALOGV("%s: Autofocus state now %d, last trigger %d",
1816 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001817 bool sendCompletedMessage = false;
1818 bool sendMovingMessage = false;
1819
1820 bool success = false;
1821 bool afInMotion = false;
1822 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001823 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001824 // Trace end of AF state
1825 char tmp[32];
1826 if (l.mParameters.afStateCounter > 0) {
1827 camera_metadata_enum_snprint(
1828 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1829 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1830 }
1831
1832 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001833 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001834 l.mParameters.afStateCounter++;
1835
1836 // Trace start of AF state
1837
1838 camera_metadata_enum_snprint(
1839 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1840 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1841
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001842 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001843 case Parameters::FOCUS_MODE_AUTO:
1844 case Parameters::FOCUS_MODE_MACRO:
1845 // Don't send notifications upstream if they're not for the current AF
1846 // trigger. For example, if cancel was called in between, or if we
1847 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001848 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001849 switch (newState) {
1850 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1851 success = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001852 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001853 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1854 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001855 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001856 break;
1857 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1858 // Just starting focusing, ignore
1859 break;
1860 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1861 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1862 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001863 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001864 default:
1865 // Unexpected in AUTO/MACRO mode
1866 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1867 __FUNCTION__, newState);
1868 break;
1869 }
1870 break;
1871 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1872 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1873 switch (newState) {
1874 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1875 success = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001876 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001877 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1878 // Don't send notifications upstream if they're not for
1879 // the current AF trigger. For example, if cancel was
1880 // called in between, or if we already sent a
1881 // notification about this AF call.
1882 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001883 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001884 sendCompletedMessage = true;
1885 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001886 if (l.mParameters.enableFocusMoveMessages &&
1887 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001888 sendMovingMessage = true;
1889 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001890 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001891 break;
1892 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1893 // Cancel was called, or we switched state; care if
1894 // currently moving
1895 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001896 if (l.mParameters.enableFocusMoveMessages &&
1897 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001898 sendMovingMessage = true;
1899 }
1900 break;
1901 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1902 // Start passive scan, inform upstream
1903 afInMotion = true;
Chih-Hung Hsieh5ff77102018-10-12 15:19:00 -07001904 FALLTHROUGH_INTENDED;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001905 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001906 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001907 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001908 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001909 sendMovingMessage = true;
1910 }
1911 break;
1912 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001913 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001914 break;
1915 case Parameters::FOCUS_MODE_EDOF:
1916 case Parameters::FOCUS_MODE_INFINITY:
1917 case Parameters::FOCUS_MODE_FIXED:
1918 default:
1919 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001920 ALOGE("%s: Unexpected AF state change %d "
1921 "(ID %d) in focus mode %d",
1922 __FUNCTION__, newState, triggerId,
1923 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001924 }
1925 }
1926 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001927 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001928 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1929 if (l.mRemoteCallback != 0) {
1930 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001931 afInMotion ? 1 : 0, 0);
1932 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001933 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001934 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001935 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001936 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1937 if (l.mRemoteCallback != 0) {
1938 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001939 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001940 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001941 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001942}
1943
1944void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1945 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1946 __FUNCTION__, newState, triggerId);
Emilian Peev6e2ba3f2018-10-25 12:36:52 +01001947 {
1948 SharedParameters::Lock l(mParameters);
1949 // Update state
1950 l.mParameters.aeState = newState;
1951 }
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001952 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001953}
1954
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001955void Camera2Client::notifyShutter(const CaptureResultExtras& resultExtras,
1956 nsecs_t timestamp) {
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001957 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
1958 __FUNCTION__, resultExtras.requestId, timestamp);
1959 mCaptureSequencer->notifyShutter(resultExtras, timestamp);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07001960
1961 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001962}
1963
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001964camera2::SharedParameters& Camera2Client::getParameters() {
1965 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001966}
1967
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001968int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001969 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001970}
1971
1972int Camera2Client::getCaptureStreamId() const {
1973 return mJpegProcessor->getStreamId();
1974}
1975
1976int Camera2Client::getCallbackStreamId() const {
1977 return mCallbackProcessor->getStreamId();
1978}
1979
1980int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001981 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001982}
1983
1984int Camera2Client::getZslStreamId() const {
1985 return mZslProcessor->getStreamId();
1986}
1987
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001988status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001989 const wp<camera2::FrameProcessor::FilteredListener>& listener, bool sendPartials) {
Zhijun He25a0aef2014-06-25 11:40:02 -07001990 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001991}
1992
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001993status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001994 const wp<camera2::FrameProcessor::FilteredListener>& listener) {
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001995 return mFrameProcessor->removeListener(minId, maxId, listener);
1996}
1997
1998status_t Camera2Client::stopStream() {
1999 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07002000}
2001
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08002002status_t Camera2Client::createJpegStreamL(Parameters &params) {
2003 status_t res = OK;
2004 int lastJpegStreamId = mJpegProcessor->getStreamId();
2005 if (lastJpegStreamId != NO_STREAM) {
2006 return INVALID_OPERATION;
2007 }
2008
2009 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2010 if (res != OK) {
2011 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2012 __FUNCTION__, mCameraId, strerror(-res), res);
2013 return res;
2014 }
2015
2016 res = mDevice->flush();
2017 if (res != OK) {
2018 ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
2019 __FUNCTION__, mCameraId, strerror(-res), res);
2020 return res;
2021 }
2022
2023 // Ideally we don't need this, but current camera device
2024 // status tracking mechanism demands it.
2025 res = mDevice->waitUntilDrained();
2026 if (res != OK) {
2027 ALOGE("%s: Camera %d: Waiting device drain failed: %s (%d)",
2028 __FUNCTION__, mCameraId, strerror(-res), res);
2029 }
2030
2031 res = updateProcessorStream(mJpegProcessor, params);
2032 return res;
2033}
2034
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002035const int32_t Camera2Client::kPreviewRequestIdStart;
2036const int32_t Camera2Client::kPreviewRequestIdEnd;
2037const int32_t Camera2Client::kRecordingRequestIdStart;
2038const int32_t Camera2Client::kRecordingRequestIdEnd;
2039const int32_t Camera2Client::kCaptureRequestIdStart;
2040const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07002041
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07002042/** Utility methods */
2043
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07002044status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002045 status_t res;
2046
Igor Murashkin22d58d32012-10-02 19:07:14 -07002047 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
2048
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002049 res = mStreamingProcessor->incrementStreamingIds();
2050 if (res != OK) {
2051 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
2052 __FUNCTION__, mCameraId, strerror(-res), res);
2053 return res;
2054 }
2055
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002056 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002057 if (res != OK) {
2058 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
2059 __FUNCTION__, mCameraId, strerror(-res), res);
2060 return res;
2061 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002062 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002063 if (res != OK) {
2064 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
2065 __FUNCTION__, mCameraId, strerror(-res), res);
2066 return res;
2067 }
2068
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002069 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07002070 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002071 if (res != OK) {
2072 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
2073 __FUNCTION__, mCameraId, strerror(-res), res);
2074 return res;
2075 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07002076 } else if (params.state == Parameters::RECORD ||
2077 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07002078 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002079 if (res != OK) {
2080 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
2081 __FUNCTION__, mCameraId, strerror(-res), res);
2082 return res;
2083 }
2084 }
2085 return res;
2086}
2087
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07002088
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002089size_t Camera2Client::calculateBufferSize(int width, int height,
2090 int format, int stride) {
2091 switch (format) {
2092 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2093 return width * height * 2;
2094 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2095 return width * height * 3 / 2;
2096 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2097 return width * height * 2;
2098 case HAL_PIXEL_FORMAT_YV12: { // YV12
2099 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07002100 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002101 size_t uvSize = uvStride * height / 2;
2102 return ySize + uvSize * 2;
2103 }
2104 case HAL_PIXEL_FORMAT_RGB_565:
2105 return width * height * 2;
2106 case HAL_PIXEL_FORMAT_RGBA_8888:
2107 return width * height * 4;
Eino-Ville Talvalaa97dfeb2015-02-19 16:26:13 -08002108 case HAL_PIXEL_FORMAT_RAW16:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002109 return width * height * 2;
2110 default:
2111 ALOGE("%s: Unknown preview format: %x",
2112 __FUNCTION__, format);
2113 return 0;
2114 }
2115}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002116
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002117status_t Camera2Client::syncWithDevice() {
2118 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07002119 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002120 status_t res;
2121
2122 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2123 if (activeRequestId == 0) return OK;
2124
2125 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
2126 if (res == TIMED_OUT) {
2127 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
2128 __FUNCTION__, mCameraId);
2129 } else if (res != OK) {
2130 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
2131 __FUNCTION__, mCameraId);
2132 }
2133 return res;
2134}
2135
Igor Murashkindca254a2013-05-13 14:53:44 -07002136template <typename ProcessorT>
2137status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2138 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07002139 // No default template arguments until C++11, so we need this overload
2140 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
2141 processor, params);
2142}
2143
2144template <typename ProcessorT,
2145 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
2146status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2147 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07002148 status_t res;
2149
Igor Murashkin82db9e62013-05-21 11:38:49 -07002150 // Get raw pointer since sp<T> doesn't have operator->*
2151 ProcessorT *processorPtr = processor.get();
2152 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002153
2154 /**
2155 * Can't update the stream if it's busy?
2156 *
2157 * Then we need to stop the device (by temporarily clearing the request
2158 * queue) and then try again. Resume streaming once we're done.
2159 */
2160 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07002161 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2162 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07002163 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2164 if (res != OK) {
2165 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2166 __FUNCTION__, mCameraId, strerror(-res), res);
2167 }
2168
2169 res = mDevice->waitUntilDrained();
2170 if (res != OK) {
2171 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2172 __FUNCTION__, mCameraId, strerror(-res), res);
2173 }
2174
Igor Murashkin82db9e62013-05-21 11:38:49 -07002175 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002176 if (res != OK) {
2177 ALOGE("%s: Camera %d: Failed to update processing stream "
2178 " despite having halted streaming first: %s (%d)",
2179 __FUNCTION__, mCameraId, strerror(-res), res);
2180 }
2181
2182 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2183 if (res != OK) {
2184 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2185 __FUNCTION__, mCameraId, strerror(-res), res);
2186 }
2187 }
2188
2189 return res;
2190}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002191
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07002192status_t Camera2Client::overrideVideoSnapshotSize(Parameters &params) {
2193 ALOGV("%s: Camera %d: configure still size to video size before recording"
2194 , __FUNCTION__, mCameraId);
2195 params.overrideJpegSizeByVideoSize();
2196 status_t res = updateProcessorStream(mJpegProcessor, params);
2197 if (res != OK) {
2198 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2199 __FUNCTION__, mCameraId, strerror(-res), res);
2200 }
2201 return res;
2202}
2203
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08002204status_t Camera2Client::setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) {
2205 ATRACE_CALL();
2206 ALOGV("%s: E", __FUNCTION__);
2207 Mutex::Autolock icl(mBinderSerializationLock);
2208 status_t res;
2209 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
2210
2211 sp<IBinder> binder = IInterface::asBinder(bufferProducer);
2212 if (binder == mVideoSurface) {
2213 ALOGV("%s: Camera %d: New video window is same as old video window",
2214 __FUNCTION__, mCameraId);
2215 return NO_ERROR;
2216 }
2217
2218 sp<Surface> window;
2219 int format;
2220 android_dataspace dataSpace;
2221
2222 if (bufferProducer != nullptr) {
2223 // Using controlledByApp flag to ensure that the buffer queue remains in
2224 // async mode for the old camera API, where many applications depend
2225 // on that behavior.
2226 window = new Surface(bufferProducer, /*controlledByApp*/ true);
2227
2228 ANativeWindow *anw = window.get();
2229
2230 if ((res = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
2231 ALOGE("%s: Failed to query Surface format", __FUNCTION__);
2232 return res;
2233 }
2234
2235 if ((res = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
2236 reinterpret_cast<int*>(&dataSpace))) != OK) {
2237 ALOGE("%s: Failed to query Surface dataSpace", __FUNCTION__);
2238 return res;
2239 }
2240 }
2241
2242 Parameters::State state;
2243 {
2244 SharedParameters::Lock l(mParameters);
2245 state = l.mParameters.state;
2246 }
2247
2248 switch (state) {
2249 case Parameters::STOPPED:
2250 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
2251 case Parameters::PREVIEW:
2252 // OK
2253 break;
2254 case Parameters::DISCONNECTED:
2255 case Parameters::RECORD:
2256 case Parameters::STILL_CAPTURE:
2257 case Parameters::VIDEO_SNAPSHOT:
2258 default:
2259 ALOGE("%s: Camera %d: Cannot set video target while in state %s",
2260 __FUNCTION__, mCameraId,
2261 Parameters::getStateName(state));
2262 return INVALID_OPERATION;
2263 }
2264
2265 mVideoSurface = binder;
2266 res = mStreamingProcessor->setRecordingWindow(window);
2267 if (res != OK) {
2268 ALOGE("%s: Unable to set new recording window: %s (%d)",
2269 __FUNCTION__, strerror(-res), res);
2270 return res;
2271 }
2272
2273 {
2274 SharedParameters::Lock l(mParameters);
2275 l.mParameters.videoFormat = format;
2276 l.mParameters.videoDataSpace = dataSpace;
2277 }
2278
2279 return OK;
2280}
2281
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07002282status_t Camera2Client::setAudioRestriction(int /*mode*/) {
Yin-Chia Yehdba03232019-08-19 15:54:28 -07002283 // Empty implementation. setAudioRestriction is hidden interface and not
2284 // supported by android.hardware.Camera API
2285 return INVALID_OPERATION;
2286}
2287
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07002288int32_t Camera2Client::getGlobalAudioRestriction() {
2289 // Empty implementation. getAudioRestriction is hidden interface and not
2290 // supported by android.hardware.Camera API
2291 return INVALID_OPERATION;
2292}
2293
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08002294status_t Camera2Client::setRotateAndCropOverride(uint8_t rotateAndCrop) {
2295 if (rotateAndCrop > ANDROID_SCALER_ROTATE_AND_CROP_AUTO) return BAD_VALUE;
2296
2297 return mDevice->setRotateAndCropAutoBehavior(
2298 static_cast<camera_metadata_enum_android_scaler_rotate_and_crop_t>(rotateAndCrop));
2299}
2300
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08002301bool Camera2Client::supportsCameraMute() {
2302 return mDevice->supportsCameraMute();
2303}
2304
2305status_t Camera2Client::setCameraMute(bool enabled) {
2306 return mDevice->setCameraMute(enabled);
2307}
2308
Emilian Peev2a8e2832019-08-23 13:00:31 -07002309status_t Camera2Client::waitUntilCurrentRequestIdLocked() {
2310 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2311 if (activeRequestId != 0) {
2312 auto res = waitUntilRequestIdApplied(activeRequestId,
2313 mDevice->getExpectedInFlightDuration());
2314 if (res == TIMED_OUT) {
2315 ALOGE("%s: Camera %d: Timed out waiting for current request id to return in results!",
2316 __FUNCTION__, mCameraId);
2317 return res;
2318 } else if (res != OK) {
2319 ALOGE("%s: Camera %d: Error while waiting for current request id to return in results!",
2320 __FUNCTION__, mCameraId);
2321 return res;
2322 }
2323 }
2324
2325 return OK;
2326}
2327
2328status_t Camera2Client::waitUntilRequestIdApplied(int32_t requestId, nsecs_t timeout) {
2329 Mutex::Autolock l(mLatestRequestMutex);
Emilian Peev4746fff2020-06-25 14:37:31 -07002330 while ((mLatestRequestId != requestId) && (mLatestFailedRequestId != requestId)) {
Emilian Peev2a8e2832019-08-23 13:00:31 -07002331 nsecs_t startTime = systemTime();
2332
2333 auto res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2334 if (res != OK) return res;
2335
2336 timeout -= (systemTime() - startTime);
2337 }
2338
Emilian Peev4746fff2020-06-25 14:37:31 -07002339 return (mLatestRequestId == requestId) ? OK : DEAD_OBJECT;
Emilian Peev2a8e2832019-08-23 13:00:31 -07002340}
2341
2342void Camera2Client::notifyRequestId(int32_t requestId) {
2343 Mutex::Autolock al(mLatestRequestMutex);
2344
2345 mLatestRequestId = requestId;
2346 mLatestRequestSignal.signal();
2347}
2348
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07002349const char* Camera2Client::kAutofocusLabel = "autofocus";
2350const char* Camera2Client::kTakepictureLabel = "take_picture";
2351
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002352} // namespace android