blob: 4eb7b03ae6f08b1b89262a61593335d89663704b [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"
Igor Murashkinae500e52013-04-22 14:03:54 -070036
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070037#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
38#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
39
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070040namespace android {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070041using namespace camera2;
42
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070043static int getCallingPid() {
44 return IPCThreadState::self()->getCallingPid();
45}
46
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070047// Interface used by CameraService
48
49Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080050 const sp<hardware::ICameraClient>& cameraClient,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080051 const String16& clientPackageName,
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -070052 int cameraId,
53 int cameraFacing,
Igor Murashkinecf17e82012-10-02 16:05:11 -070054 int clientPid,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080055 uid_t clientUid,
Igor Murashkina858ea02014-08-19 14:53:08 -070056 int servicePid,
57 bool legacyMode):
Igor Murashkin44cfcf02013-03-01 16:22:28 -080058 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080059 cameraId, cameraFacing, clientPid, clientUid, servicePid),
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070060 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070061{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070062 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070063
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070064 SharedParameters::Lock l(mParameters);
65 l.mParameters.state = Parameters::DISCONNECTED;
Igor Murashkina858ea02014-08-19 14:53:08 -070066
67 mLegacyMode = legacyMode;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070068}
69
Yin-Chia Yehe074a932015-01-30 10:29:02 -080070status_t Camera2Client::initialize(CameraModule *module)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070071{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070072 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070073 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070074 status_t res;
75
Igor Murashkine6800ce2013-03-04 17:25:57 -080076 res = Camera2ClientBase::initialize(module);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080077 if (res != OK) {
78 return res;
79 }
80
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070081 {
82 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070083
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070084 res = l.mParameters.initialize(&(mDevice->info()), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070085 if (res != OK) {
86 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
87 __FUNCTION__, mCameraId, strerror(-res), res);
88 return NO_INIT;
89 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070090 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070091
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070092 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070093
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070094 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -070095 threadName = String8::format("C2-%d-StreamProc",
96 mCameraId);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070097
Igor Murashkince124da2013-03-04 14:53:08 -080098 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -070099 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700100 mCameraId);
101 mFrameProcessor->run(threadName.string());
102
103 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700104 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700105 mCameraId);
106 mCaptureSequencer->run(threadName.string());
107
108 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700109 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700110 mCameraId);
111 mJpegProcessor->run(threadName.string());
112
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800113 mZslProcessor = new ZslProcessor(this, mCaptureSequencer);
114
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700115 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700116 mCameraId);
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800117 mZslProcessor->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700118
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700119 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700120 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700121 mCameraId);
122 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700123
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700124 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700125 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700126 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
127 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700128 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700129 }
130
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700131 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700132}
133
134Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700135 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700136 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700137
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700138 mDestructionStarted = true;
139
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700140 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700141
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700142 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700143}
144
145status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalac4003962016-01-13 10:07:04 -0800146 return BasicClient::dump(fd, args);
147}
148
149status_t Camera2Client::dumpClient(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700150 String8 result;
Ruben Brunkcc776712015-02-17 20:18:47 -0800151 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", mCameraId,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -0800152 (getRemoteCallback() != NULL ?
Marco Nelissenf8880202014-11-14 07:58:25 -0800153 (IInterface::asBinder(getRemoteCallback()).get()) : NULL),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700154 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700155 result.append(" State: ");
156#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
157
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700158 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700159
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700160 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700161
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700162 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700163 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700164 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700165 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700166 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700167 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700168 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700169 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700170 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700171 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700172 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700173 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700174 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700175 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700176 p.jpegQuality, p.jpegThumbQuality);
177 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700178 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700179 p.gpsEnabled ? "enabled" : "disabled");
180 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700181 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700182 p.gpsCoordinates[0], p.gpsCoordinates[1],
183 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000184 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700185 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700186 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700187 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 }
189
190 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700191 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800192 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
193 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
194 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
195 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
196 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
197 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
198 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
199 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700200 default: result.append("UNKNOWN\n");
201 }
202
203 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700204 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800205 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
206 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
207 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
208 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
210 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
211 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
212 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700214 default: result.append("UNKNOWN\n");
215 }
216
217 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700218 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800219 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700223 default: result.append("UNKNOWN\n");
224 }
225
226 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700227 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800228 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700229 result.append("AUTO\n"); break;
230 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
231 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
232 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
238 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
239 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
240 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
241 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
242 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
243 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
245 default: result.append("UNKNOWN\n");
246 }
247
248 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700249 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700250 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
251 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
252 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
253 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
254 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
255 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
256 default: result.append("UNKNOWN\n");
257 }
258
259 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700260 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700261 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
262 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
263 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
264 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
265 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
266 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
267 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
268 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
269 default: result.append("UNKNOWN\n");
270 }
271
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700272 result.append(" Focus state: ");
273 switch (p.focusState) {
274 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
275 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
276 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700277 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700278 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
279 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
280 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
281 default: result.append("UNKNOWN\n");
282 }
283
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700284 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700285 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700286 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700287 p.focusingAreas[i].left,
288 p.focusingAreas[i].top,
289 p.focusingAreas[i].right,
290 p.focusingAreas[i].bottom,
291 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700292 }
293
294 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700295 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700296
297 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700298 p.autoExposureLock ? "enabled" : "disabled",
299 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700300
301 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700302 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700303 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700304 p.meteringAreas[i].left,
305 p.meteringAreas[i].top,
306 p.meteringAreas[i].right,
307 p.meteringAreas[i].bottom,
308 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700309 }
310
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700311 result.appendFormat(" Zoom index: %d\n", p.zoom);
312 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
313 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700314
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700315 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700316 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700317
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700318 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700319 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700320
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700321 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
322 p.fastInfo.bestStillCaptureFpsRange[0],
323 p.fastInfo.bestStillCaptureFpsRange[1]);
324
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700325 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700326 result.appendFormat(" Preview stream ID: %d\n",
327 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700328 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700329 getCaptureStreamId());
330 result.appendFormat(" Recording stream ID: %d\n",
331 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700332
333 result.append(" Quirks for this camera:\n");
334 bool haveQuirk = false;
335 if (p.quirks.triggerAfWithAuto) {
336 result.appendFormat(" triggerAfWithAuto\n");
337 haveQuirk = true;
338 }
339 if (p.quirks.useZslFormat) {
340 result.appendFormat(" useZslFormat\n");
341 haveQuirk = true;
342 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700343 if (p.quirks.meteringCropRegion) {
344 result.appendFormat(" meteringCropRegion\n");
345 haveQuirk = true;
346 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700347 if (p.quirks.partialResults) {
348 result.appendFormat(" usePartialResult\n");
349 haveQuirk = true;
350 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700351 if (!haveQuirk) {
352 result.appendFormat(" none\n");
353 }
354
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700355 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700356
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700357 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700358
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700359 mCaptureSequencer->dump(fd, args);
360
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700361 mFrameProcessor->dump(fd, args);
362
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700363 mZslProcessor->dump(fd, args);
364
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800365 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700366#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700367}
368
369// ICamera interface
370
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800371binder::Status Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700372 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800373 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700374
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800375 binder::Status res = binder::Status::ok();
Chien-Yu Chen98a668f2015-12-18 14:10:33 -0800376 // Allow both client and the cameraserver to disconnect at all times
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700377 int callingPid = getCallingPid();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800378 if (callingPid != mClientPid && callingPid != mServicePid) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700379
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800380 if (mDevice == 0) return res;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700381
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700382 ALOGV("Camera %d: Shutting down", mCameraId);
383
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700384 /**
385 * disconnect() cannot call any methods that might need to promote a
386 * wp<Camera2Client>, since disconnect can be called from the destructor, at
387 * which point all such promotions will fail.
388 */
389
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700390 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700391
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700392 {
393 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800394 if (l.mParameters.state == Parameters::DISCONNECTED) return res;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700395 l.mParameters.state = Parameters::DISCONNECTED;
396 }
397
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700398 mFrameProcessor->requestExit();
399 mCaptureSequencer->requestExit();
400 mJpegProcessor->requestExit();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800401 mZslProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700402 mCallbackProcessor->requestExit();
403
404 ALOGV("Camera %d: Waiting for threads", mCameraId);
405
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700406 {
407 // Don't wait with lock held, in case the other threads need to
408 // complete callbacks that re-enter Camera2Client
409 mBinderSerializationLock.unlock();
410
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700411 mFrameProcessor->join();
412 mCaptureSequencer->join();
413 mJpegProcessor->join();
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800414 mZslProcessor->join();
Eino-Ville Talvala661c21d2014-10-22 14:21:12 -0700415 mCallbackProcessor->join();
416
417 mBinderSerializationLock.lock();
418 }
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700419
Ruben Brunkdfe71552013-12-05 11:00:37 -0800420 ALOGV("Camera %d: Deleting streams", mCameraId);
421
422 mStreamingProcessor->deletePreviewStream();
423 mStreamingProcessor->deleteRecordingStream();
424 mJpegProcessor->deleteStream();
425 mCallbackProcessor->deleteStream();
426 mZslProcessor->deleteStream();
427
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700428 ALOGV("Camera %d: Disconnecting device", mCameraId);
429
430 mDevice->disconnect();
431
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700432 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700433
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700434 CameraService::Client::disconnect();
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800435
436 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700437}
438
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800439status_t Camera2Client::connect(const sp<hardware::ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700440 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700441 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800442 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700443
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700444 if (mClientPid != 0 && getCallingPid() != mClientPid) {
445 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
446 "current locked to pid %d", __FUNCTION__,
447 mCameraId, getCallingPid(), mClientPid);
448 return BAD_VALUE;
449 }
450
451 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700452
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800453 mRemoteCallback = client;
454 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700455
456 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700457}
458
459status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700460 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700461 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800462 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700463 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
464 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700465
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700466 if (mClientPid == 0) {
467 mClientPid = getCallingPid();
468 return OK;
469 }
470
471 if (mClientPid != getCallingPid()) {
472 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
473 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
474 return EBUSY;
475 }
476
477 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700478}
479
480status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700481 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700482 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800483 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700484 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
485 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700486
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700487 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700488 SharedParameters::Lock l(mParameters);
489 if (l.mParameters.state == Parameters::RECORD ||
490 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
491 ALOGD("Not allowed to unlock camera during recording.");
492 return INVALID_OPERATION;
493 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700494 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800495 mRemoteCallback.clear();
496 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700497 return OK;
498 }
499
500 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
501 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
502 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700503}
504
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700505status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800506 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700507 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700508 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800509 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700510 status_t res;
511 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700512
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700513 sp<IBinder> binder;
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700514 sp<Surface> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800515 if (bufferProducer != 0) {
Marco Nelissenf8880202014-11-14 07:58:25 -0800516 binder = IInterface::asBinder(bufferProducer);
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700517 // Using controlledByApp flag to ensure that the buffer queue remains in
518 // async mode for the old camera API, where many applications depend
519 // on that behavior.
520 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700521 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700522 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700523}
524
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700525status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700526 sp<Surface> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700527 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700528 status_t res;
529
530 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700531 ALOGV("%s: Camera %d: New window is same as old window",
532 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700533 return NO_ERROR;
534 }
535
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700536 Parameters::State state;
537 {
538 SharedParameters::Lock l(mParameters);
539 state = l.mParameters.state;
540 }
541 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700542 case Parameters::DISCONNECTED:
543 case Parameters::RECORD:
544 case Parameters::STILL_CAPTURE:
545 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700546 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700547 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700548 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700549 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700550 case Parameters::STOPPED:
551 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700552 // OK
553 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700554 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700555 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700556 res = stopStream();
557 if (res != OK) {
558 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
559 __FUNCTION__, strerror(-res), res);
560 return res;
561 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700562 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700563 break;
564 }
565
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700566 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700567 res = mStreamingProcessor->setPreviewWindow(window);
568 if (res != OK) {
569 ALOGE("%s: Unable to set new preview window: %s (%d)",
570 __FUNCTION__, strerror(-res), res);
571 return res;
572 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700573
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700574 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
575 SharedParameters::Lock l(mParameters);
576 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700577 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700578 }
579
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700580 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700581}
582
583void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700584 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700585 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800586 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700587
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700588 if ( checkPid(__FUNCTION__) != OK) return;
589
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700590 SharedParameters::Lock l(mParameters);
591 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700592}
593
594void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
595 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700596
597 switch(params.state) {
598 case Parameters::STOPPED:
599 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
600 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700601 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700602 // OK
603 break;
604 default:
605 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
606 ALOGE("%s: Camera %d: Can't use preview callbacks "
607 "in state %d", __FUNCTION__, mCameraId, params.state);
608 return;
609 }
610 }
611
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700612 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
613 ALOGV("%s: setting oneshot", __FUNCTION__);
614 params.previewCallbackOneShot = true;
615 }
616 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700617
Zhijun He527748a2013-09-15 21:06:10 -0700618 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700619 // Disable any existing preview callback window when enabling
620 // preview callback flags
621 res = mCallbackProcessor->setCallbackWindow(NULL);
622 if (res != OK) {
623 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
624 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
625 return;
626 }
627 params.previewCallbackSurface = false;
628 }
629
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700630 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700631
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700632 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700633 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700634 if (res != OK) {
635 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
636 __FUNCTION__, mCameraId,
637 Parameters::getStateName(params.state));
638 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700639 }
640 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700641}
642
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700643status_t Camera2Client::setPreviewCallbackTarget(
644 const sp<IGraphicBufferProducer>& callbackProducer) {
645 ATRACE_CALL();
646 ALOGV("%s: E", __FUNCTION__);
647 Mutex::Autolock icl(mBinderSerializationLock);
648 status_t res;
649 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
650
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700651 sp<Surface> window;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700652 if (callbackProducer != 0) {
653 window = new Surface(callbackProducer);
654 }
655
656 res = mCallbackProcessor->setCallbackWindow(window);
657 if (res != OK) {
658 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
659 __FUNCTION__, mCameraId, strerror(-res), res);
660 return res;
661 }
662
663 SharedParameters::Lock l(mParameters);
664
665 if (window != NULL) {
666 // Disable traditional callbacks when a valid callback target is given
667 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
668 l.mParameters.previewCallbackOneShot = false;
669 l.mParameters.previewCallbackSurface = true;
670 } else {
671 // Disable callback target if given a NULL interface.
672 l.mParameters.previewCallbackSurface = false;
673 }
674
675 switch(l.mParameters.state) {
676 case Parameters::PREVIEW:
677 res = startPreviewL(l.mParameters, true);
678 break;
679 case Parameters::RECORD:
680 case Parameters::VIDEO_SNAPSHOT:
681 res = startRecordingL(l.mParameters, true);
682 break;
683 default:
684 break;
685 }
686 if (res != OK) {
687 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
688 __FUNCTION__, mCameraId,
689 Parameters::getStateName(l.mParameters.state));
690 }
691
692 return OK;
693}
694
695
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700696status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700697 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700698 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800699 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700700 status_t res;
701 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700702 SharedParameters::Lock l(mParameters);
703 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700704}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700705
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700706status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700707 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700708 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700709
710 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
711
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700712 if ( (params.state == Parameters::PREVIEW ||
713 params.state == Parameters::RECORD ||
714 params.state == Parameters::VIDEO_SNAPSHOT)
715 && !restart) {
716 // Succeed attempt to re-enter a streaming state
717 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
718 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700719 return OK;
720 }
721 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700722 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700723 __FUNCTION__,
724 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700725 return INVALID_OPERATION;
726 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700727
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700728 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700729 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700730 return OK;
731 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700732 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800733 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700734
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700735 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700736 if (res != OK) {
737 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
738 __FUNCTION__, mCameraId, strerror(-res), res);
739 return res;
740 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700741
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800742 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
743
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700744 // We could wait to create the JPEG output stream until first actual use
745 // (first takePicture call). However, this would substantially increase the
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -0800746 // first capture latency on HAL3 devices.
747 // So create it unconditionally at preview start. As a drawback,
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700748 // this increases gralloc memory consumption for applications that don't
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800749 // ever take a picture. Do not enter this mode when jpeg stream will slow
750 // down preview.
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700751 // TODO: Find a better compromise, though this likely would involve HAL
752 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700753 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -0800754 // If jpeg stream will slow down preview, make sure we remove it before starting preview
755 if (params.slowJpegMode) {
756 mJpegProcessor->deleteStream();
757 } else {
758 res = updateProcessorStream(mJpegProcessor, params);
759 if (res != OK) {
760 ALOGE("%s: Camera %d: Can't pre-configure still image "
761 "stream: %s (%d)",
762 __FUNCTION__, mCameraId, strerror(-res), res);
763 return res;
764 }
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700765 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700766 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700767
Zhijun Hed1d64672013-09-06 15:00:01 -0700768 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700769 bool callbacksEnabled = (params.previewCallbackFlags &
770 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
771 params.previewCallbackSurface;
772
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700773 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700774 // Can't have recording stream hanging around when enabling callbacks,
775 // since it exceeds the max stream count on some devices.
776 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
777 ALOGV("%s: Camera %d: Clearing out recording stream before "
778 "creating callback stream", __FUNCTION__, mCameraId);
779 res = mStreamingProcessor->stopStream();
780 if (res != OK) {
781 ALOGE("%s: Camera %d: Can't stop streaming to delete "
782 "recording stream", __FUNCTION__, mCameraId);
783 return res;
784 }
785 res = mStreamingProcessor->deleteRecordingStream();
786 if (res != OK) {
787 ALOGE("%s: Camera %d: Unable to delete recording stream before "
788 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
789 strerror(-res), res);
790 return res;
791 }
792 }
793
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700794 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700795 if (res != OK) {
796 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
797 __FUNCTION__, mCameraId, strerror(-res), res);
798 return res;
799 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700800 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800801 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
802 /**
803 * Delete the unused callback stream when preview stream is changed and
804 * preview is not enabled. Don't need stop preview stream as preview is in
805 * STOPPED state now.
806 */
807 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
808 res = mCallbackProcessor->deleteStream();
809 if (res != OK) {
810 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
811 __FUNCTION__, mCameraId, strerror(-res), res);
812 return res;
813 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700814 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700815
816 if (params.zslMode && !params.recordingHint &&
817 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700818 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700819 if (res != OK) {
820 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
821 __FUNCTION__, mCameraId, strerror(-res), res);
822 return res;
823 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700824
825 if (jpegStreamChanged) {
826 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
827 __FUNCTION__, mCameraId);
828 mZslProcessor->clearZslQueue();
829 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700830 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700831 } else {
832 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700833 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700834
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700835 outputStreams.push(getPreviewStreamId());
836
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700837 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700838 if (!restart) {
839 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700840 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700841 ALOGE("%s: Camera %d: Can't set up preview request: "
842 "%s (%d)", __FUNCTION__, mCameraId,
843 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700844 return res;
845 }
846 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700847 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
848 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700849 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700850 if (!restart) {
851 res = mStreamingProcessor->updateRecordingRequest(params);
852 if (res != OK) {
853 ALOGE("%s: Camera %d: Can't set up preview request with "
854 "record hint: %s (%d)", __FUNCTION__, mCameraId,
855 strerror(-res), res);
856 return res;
857 }
858 }
859 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
860 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700861 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700862 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700863 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700864 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700865 return res;
866 }
867
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700868 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700869 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700870}
871
872void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700873 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700874 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800875 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700876 status_t res;
877 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700878 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700879}
880
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700881void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700882 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700883 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700884 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700885 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700886 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700887 SharedParameters::Lock l(mParameters);
888 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700889 }
890
891 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700892 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800893 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700894 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700895 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700896 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700897 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700898 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
899 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700900 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700901 case Parameters::PREVIEW:
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700902 syncWithDevice();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700903 res = stopStream();
904 if (res != OK) {
905 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
906 __FUNCTION__, mCameraId, strerror(-res), res);
907 }
Ruchit Sharma2cec0df2014-08-20 16:02:08 -0400908
909 // Flush all in-process captures and buffer in order to stop
910 // preview faster.
911 res = mDevice->flush();
912 if (res != OK) {
913 ALOGE("%s: Camera %d: Unable to flush pending requests: %s (%d)",
914 __FUNCTION__, mCameraId, strerror(-res), res);
915 }
916
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700917 res = mDevice->waitUntilDrained();
918 if (res != OK) {
919 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
920 __FUNCTION__, mCameraId, strerror(-res), res);
921 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -0700922 // Clean up recording stream
923 res = mStreamingProcessor->deleteRecordingStream();
924 if (res != OK) {
925 ALOGE("%s: Camera %d: Unable to delete recording stream before "
926 "stop preview: %s (%d)",
927 __FUNCTION__, mCameraId, strerror(-res), res);
928 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700929 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700930 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
931 SharedParameters::Lock l(mParameters);
932 l.mParameters.state = Parameters::STOPPED;
933 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700934 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700935 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700936 default:
937 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700938 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700939 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700940}
941
942bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700943 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800944 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700945 status_t res;
946 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
947
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700948 SharedParameters::Lock l(mParameters);
949 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700950}
951
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800952status_t Camera2Client::setVideoBufferMode(int32_t videoBufferMode) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700953 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800954 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700955 status_t res;
956 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
957
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700958 SharedParameters::Lock l(mParameters);
959 switch (l.mParameters.state) {
960 case Parameters::RECORD:
961 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700962 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700963 __FUNCTION__, mCameraId,
964 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700965 return INVALID_OPERATION;
966 default:
967 // OK
968 break;
969 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700970
Chien-Yu Chen8cca0752015-11-13 15:28:48 -0800971 if (videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
972 ALOGE("%s: %d: Only video buffer queue is supported", __FUNCTION__, __LINE__);
973 return BAD_VALUE;
974 }
975
976 l.mParameters.videoBufferMode = videoBufferMode;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700977
978 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700979}
980
981status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700982 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700983 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800984 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700985 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700986 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700987 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700988
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700989 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700990}
991
992status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
993 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700994
995 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
996
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700997 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700998 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700999 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001000 if (res != OK) return res;
Zhijun He96ff5c42014-10-13 22:20:37 -07001001 // Make sure first preview request is submitted to the HAL device to avoid
1002 // two consecutive set of configure_streams being called into the HAL.
1003 // TODO: Refactor this to avoid initial preview configuration.
1004 syncWithDevice();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001005 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001006 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001007 // Ready to go
1008 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001009 case Parameters::RECORD:
1010 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001011 // OK to call this when recording is already on, just skip unless
1012 // we're looking to restart
1013 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001014 break;
1015 default:
1016 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001017 __FUNCTION__, mCameraId,
1018 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001019 return INVALID_OPERATION;
1020 };
1021
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001022 if (params.videoBufferMode != VIDEO_BUFFER_MODE_BUFFER_QUEUE) {
1023 ALOGE("%s: Camera %d: Recording only supported buffer queue mode, but "
1024 "mode %d is requested!", __FUNCTION__, mCameraId, params.videoBufferMode);
1025 return INVALID_OPERATION;
1026 }
1027
1028 if (!mStreamingProcessor->haveValidRecordingWindow()) {
1029 ALOGE("%s: No valid recording window", __FUNCTION__);
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001030 return INVALID_OPERATION;
1031 }
1032
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001033 if (!restart) {
Chien-Yu Chen82104eb2015-10-14 11:29:31 -07001034 mCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001035 mStreamingProcessor->updateRecordingRequest(params);
1036 if (res != OK) {
1037 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1038 __FUNCTION__, mCameraId, strerror(-res), res);
1039 return res;
1040 }
1041 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001042
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001043 // Not all devices can support a preview callback stream and a recording
1044 // stream at the same time, so assume none of them can.
1045 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1046 ALOGV("%s: Camera %d: Clearing out callback stream before "
1047 "creating recording stream", __FUNCTION__, mCameraId);
1048 res = mStreamingProcessor->stopStream();
1049 if (res != OK) {
1050 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1051 __FUNCTION__, mCameraId);
1052 return res;
1053 }
1054 res = mCallbackProcessor->deleteStream();
1055 if (res != OK) {
1056 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1057 "record: %s (%d)", __FUNCTION__, mCameraId,
1058 strerror(-res), res);
1059 return res;
1060 }
1061 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001062
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001063 // Clean up ZSL before transitioning into recording
1064 if (mZslProcessor->getStreamId() != NO_STREAM) {
1065 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1066 "creating recording stream", __FUNCTION__, mCameraId);
1067 res = mStreamingProcessor->stopStream();
1068 if (res != OK) {
1069 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1070 __FUNCTION__, mCameraId);
1071 return res;
1072 }
1073 res = mDevice->waitUntilDrained();
1074 if (res != OK) {
1075 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1076 __FUNCTION__, mCameraId, strerror(-res), res);
1077 }
1078 res = mZslProcessor->clearZslQueue();
1079 if (res != OK) {
1080 ALOGE("%s: Camera %d: Can't clear zsl queue",
1081 __FUNCTION__, mCameraId);
1082 return res;
1083 }
1084 res = mZslProcessor->deleteStream();
1085 if (res != OK) {
1086 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1087 "record: %s (%d)", __FUNCTION__, mCameraId,
1088 strerror(-res), res);
1089 return res;
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001090 }
1091 }
1092
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001093 // Disable callbacks if they're enabled; can't record and use callbacks,
1094 // and we can't fail record start without stagefright asserting.
1095 params.previewCallbackFlags = 0;
1096
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001097 // May need to reconfigure video snapshot JPEG sizes
1098 // during recording startup, so need a more complex sequence here to
1099 // ensure an early stream reconfiguration doesn't happen
1100 bool recordingStreamNeedsUpdate;
1101 res = mStreamingProcessor->recordingStreamNeedsUpdate(params, &recordingStreamNeedsUpdate);
1102 if (res != OK) {
1103 ALOGE("%s: Camera %d: Can't query recording stream",
1104 __FUNCTION__, mCameraId);
1105 return res;
1106 }
1107
1108 if (recordingStreamNeedsUpdate) {
1109 // Need to stop stream here so updateProcessorStream won't trigger configureStream
1110 // Right now camera device cannot handle configureStream failure gracefully
1111 // when device is streaming
1112 res = mStreamingProcessor->stopStream();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001113 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001114 ALOGE("%s: Camera %d: Can't stop streaming to update record "
1115 "stream", __FUNCTION__, mCameraId);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001116 return res;
1117 }
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001118 res = mDevice->waitUntilDrained();
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001119 if (res != OK) {
Eino-Ville Talvalad309fb92015-11-25 12:12:45 -08001120 ALOGE("%s: Camera %d: Waiting to stop streaming failed: "
1121 "%s (%d)", __FUNCTION__, mCameraId,
1122 strerror(-res), res);
1123 }
1124
1125 res = updateProcessorStream<
1126 StreamingProcessor,
1127 &StreamingProcessor::updateRecordingStream>(
1128 mStreamingProcessor,
1129 params);
1130 if (res != OK) {
1131 ALOGE("%s: Camera %d: Unable to update recording stream: "
1132 "%s (%d)", __FUNCTION__, mCameraId,
1133 strerror(-res), res);
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001134 return res;
1135 }
1136 }
1137
Zhijun Hed1d64672013-09-06 15:00:01 -07001138 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001139 outputStreams.push(getPreviewStreamId());
1140 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001141
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001142 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1143 outputStreams);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001144
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07001145 // startStream might trigger a configureStream call and device might fail
1146 // configureStream due to jpeg size > video size. Try again with jpeg size overridden
1147 // to video size.
1148 if (res == BAD_VALUE) {
1149 overrideVideoSnapshotSize(params);
Yin-Chia Yeh3ea3fcd2014-09-05 14:14:44 -07001150 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1151 outputStreams);
1152 }
1153
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001154 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001155 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001156 __FUNCTION__, mCameraId, strerror(-res), res);
1157 return res;
1158 }
1159
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001160 if (params.state < Parameters::RECORD) {
1161 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001162 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001163
1164 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001165}
1166
1167void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001168 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001169 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001170 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001171 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001172
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001173 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001174 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1175
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001176 switch (l.mParameters.state) {
1177 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001178 // OK to stop
1179 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001180 case Parameters::STOPPED:
1181 case Parameters::PREVIEW:
1182 case Parameters::STILL_CAPTURE:
1183 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001184 default:
1185 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001186 __FUNCTION__, mCameraId,
1187 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001188 return;
1189 };
1190
Chien-Yu Chen82104eb2015-10-14 11:29:31 -07001191 mCameraService->playSound(CameraService::SOUND_RECORDING_STOP);
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001192
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001193 // Remove recording stream because the video target may be abandoned soon.
1194 res = stopStream();
1195 if (res != OK) {
1196 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
1197 __FUNCTION__, mCameraId, strerror(-res), res);
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001198 }
1199
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001200 res = mDevice->waitUntilDrained();
1201 if (res != OK) {
1202 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1203 __FUNCTION__, mCameraId, strerror(-res), res);
1204 }
1205 // Clean up recording stream
1206 res = mStreamingProcessor->deleteRecordingStream();
1207 if (res != OK) {
1208 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1209 "stop preview: %s (%d)",
1210 __FUNCTION__, mCameraId, strerror(-res), res);
1211 }
1212 l.mParameters.recoverOverriddenJpegSize();
1213
1214 // Restart preview
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001215 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001216 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001217 ALOGE("%s: Camera %d: Unable to return to preview",
1218 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001219 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001220}
1221
1222bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001223 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001224 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001225
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001226 if ( checkPid(__FUNCTION__) != OK) return false;
1227
James Dong8da4cd72012-08-04 19:58:07 -07001228 return recordingEnabledL();
1229}
1230
1231bool Camera2Client::recordingEnabledL() {
1232 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001233 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001234
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001235 return (l.mParameters.state == Parameters::RECORD
1236 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001237}
1238
1239void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Chien-Yu Chen98a668f2015-12-18 14:10:33 -08001240 (void)mem;
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001241 ATRACE_CALL();
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001242 ALOGW("%s: Not supported in buffer queue mode.", __FUNCTION__);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001243}
1244
1245status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001246 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001247 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001248 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001249 status_t res;
1250 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1251
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001252 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001253 bool notifyImmediately = false;
1254 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001255 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001256 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001257 if (l.mParameters.state < Parameters::PREVIEW) {
Zhijun Hef79f8ca2014-09-22 23:52:54 -07001258 ALOGE("%s: Camera %d: Call autoFocus when preview is inactive (state = %d).",
1259 __FUNCTION__, mCameraId, l.mParameters.state);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001260 return INVALID_OPERATION;
1261 }
1262
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001263 /**
1264 * If the camera does not support auto-focus, it is a no-op and
1265 * onAutoFocus(boolean, Camera) callback will be called immediately
1266 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001267 *
1268 * Similarly, if focus mode is set to INFINITY, there's no reason to
1269 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001270 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001271 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1272 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001273 notifyImmediately = true;
1274 notifySuccess = true;
1275 }
1276 /**
1277 * If we're in CAF mode, and AF has already been locked, just fire back
1278 * the callback right away; the HAL would not send a notification since
1279 * no state change would happen on a AF trigger.
1280 */
1281 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1282 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1283 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1284 notifyImmediately = true;
1285 notifySuccess = true;
1286 }
1287 /**
1288 * Send immediate notification back to client
1289 */
1290 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001291 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1292 if (l.mRemoteCallback != 0) {
1293 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001294 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001295 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001296 return OK;
1297 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001298 /**
1299 * Handle quirk mode for AF in scene modes
1300 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001301 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001302 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001303 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1304 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001305 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1306 __FUNCTION__, l.mParameters.focusMode);
1307 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1308 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1309 updateRequests(l.mParameters);
1310 }
1311
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001312 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1313 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001314 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001315 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1316
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001317 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001318
1319 mDevice->triggerAutofocus(triggerId);
1320
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001321 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001322}
1323
1324status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001325 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001326 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001327 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001328 status_t res;
1329 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1330
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001331 int triggerId;
1332 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001333 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001334 // Canceling does nothing in FIXED or INFINITY modes
1335 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1336 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1337 return OK;
1338 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001339
1340 // An active AF trigger is canceled
1341 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1342 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1343 }
1344
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001345 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001346
1347 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001348 // the real state at this point. No need to cancel explicitly if
1349 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001350 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1351 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1352 l.mParameters.shadowFocusMode);
1353 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1354 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1355 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001356
1357 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001358 }
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001359 if (l.mParameters.zslMode) {
1360 mZslProcessor->clearZslQueue();
1361 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001362 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001363 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001364
1365 mDevice->triggerCancelAutofocus(triggerId);
1366
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001367 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001368}
1369
Ben Murdochff823702012-11-28 13:58:29 +00001370status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001371 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001372 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001373 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001374 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001375
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001376 int takePictureCounter;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001377 {
1378 SharedParameters::Lock l(mParameters);
1379 switch (l.mParameters.state) {
1380 case Parameters::DISCONNECTED:
1381 case Parameters::STOPPED:
1382 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1383 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001384 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001385 return INVALID_OPERATION;
1386 case Parameters::PREVIEW:
1387 // Good to go for takePicture
1388 res = commandStopFaceDetectionL(l.mParameters);
1389 if (res != OK) {
1390 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1391 __FUNCTION__, mCameraId);
1392 return res;
1393 }
1394 l.mParameters.state = Parameters::STILL_CAPTURE;
Yin-Chia Yeh092d49c2014-11-06 15:40:13 -08001395
1396 // Remove recording stream to prevent video snapshot jpeg logic kicking in
1397 if (l.mParameters.isJpegSizeOverridden() &&
1398 mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
1399 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1400 if (res != OK) {
1401 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1402 __FUNCTION__, mCameraId, strerror(-res), res);
1403 }
1404 res = mDevice->waitUntilDrained();
1405 if (res != OK) {
1406 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1407 __FUNCTION__, mCameraId, strerror(-res), res);
1408 }
1409 // Clean up recording stream
1410 res = mStreamingProcessor->deleteRecordingStream();
1411 if (res != OK) {
1412 ALOGE("%s: Camera %d: Unable to delete recording stream before "
1413 "stop preview: %s (%d)",
1414 __FUNCTION__, mCameraId, strerror(-res), res);
1415 }
1416 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1417 if (res != OK) {
1418 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1419 __FUNCTION__, mCameraId, strerror(-res), res);
1420 }
1421 l.mParameters.recoverOverriddenJpegSize();
1422 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001423 break;
1424 case Parameters::RECORD:
1425 // Good to go for video snapshot
1426 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1427 break;
1428 case Parameters::STILL_CAPTURE:
1429 case Parameters::VIDEO_SNAPSHOT:
1430 ALOGE("%s: Camera %d: Already taking a picture",
1431 __FUNCTION__, mCameraId);
1432 return INVALID_OPERATION;
1433 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001434
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001435 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Zhijun Hee2d83752014-06-23 10:22:37 -07001436 int lastJpegStreamId = mJpegProcessor->getStreamId();
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001437 // slowJpegMode will create jpeg stream in CaptureSequencer before capturing
1438 if (!l.mParameters.slowJpegMode) {
1439 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1440 }
1441
Yin-Chia Yehd3c5b082014-09-15 14:50:06 -07001442 // If video snapshot fail to configureStream, try override video snapshot size to
1443 // video size
1444 if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
1445 overrideVideoSnapshotSize(l.mParameters);
1446 res = updateProcessorStream(mJpegProcessor, l.mParameters);
1447 }
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001448 if (res != OK) {
1449 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1450 __FUNCTION__, mCameraId, strerror(-res), res);
1451 return res;
1452 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001453 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001454
1455 // Clear ZSL buffer queue when Jpeg size is changed.
1456 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
1457 if (l.mParameters.zslMode && jpegStreamChanged) {
1458 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1459 __FUNCTION__, mCameraId);
1460 mZslProcessor->clearZslQueue();
1461 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001462 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001463
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001464 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1465
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001466 // Need HAL to have correct settings before (possibly) triggering precapture
1467 syncWithDevice();
1468
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001469 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001470 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001471 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001472 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001473 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001474
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001475 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001476}
1477
1478status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001479 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001480 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001481 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001482 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001483 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1484
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001485 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001486
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001487 Parameters::focusMode_t focusModeBefore = l.mParameters.focusMode;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001488 res = l.mParameters.set(params);
1489 if (res != OK) return res;
Yin-Chia Yehdec84fb2014-09-10 15:14:18 -07001490 Parameters::focusMode_t focusModeAfter = l.mParameters.focusMode;
1491
1492 if (l.mParameters.zslMode && focusModeAfter != focusModeBefore) {
1493 mZslProcessor->clearZslQueue();
1494 }
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001495
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001496 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001497
1498 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001499}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001500
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001501String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001502 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001503 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001504 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001505 // The camera service can unconditionally get the parameters at all times
1506 if (getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001507
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001508 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001509
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001510 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001511}
1512
1513status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001514 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001515 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001516 status_t res;
1517 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001518
1519 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1520 cmd, arg1, arg2);
1521
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001522 switch (cmd) {
1523 case CAMERA_CMD_START_SMOOTH_ZOOM:
1524 return commandStartSmoothZoomL();
1525 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1526 return commandStopSmoothZoomL();
1527 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1528 return commandSetDisplayOrientationL(arg1);
1529 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1530 return commandEnableShutterSoundL(arg1 == 1);
1531 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1532 return commandPlayRecordingSoundL();
1533 case CAMERA_CMD_START_FACE_DETECTION:
1534 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001535 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001536 SharedParameters::Lock l(mParameters);
1537 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001538 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001539 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1540 return commandEnableFocusMoveMsgL(arg1 == 1);
1541 case CAMERA_CMD_PING:
1542 return commandPingL();
1543 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -07001544 case CAMERA_CMD_SET_VIDEO_FORMAT:
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08001545 ALOGE("%s: command %d (arguments %d, %d) is not supported.",
1546 __FUNCTION__, cmd, arg1, arg2);
1547 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001548 default:
1549 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1550 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001551 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001552 }
1553}
James Dong983cf232012-08-01 16:39:55 -07001554
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001555status_t Camera2Client::commandStartSmoothZoomL() {
1556 ALOGE("%s: Unimplemented!", __FUNCTION__);
1557 return OK;
1558}
James Dong983cf232012-08-01 16:39:55 -07001559
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001560status_t Camera2Client::commandStopSmoothZoomL() {
1561 ALOGE("%s: Unimplemented!", __FUNCTION__);
1562 return OK;
1563}
James Dong983cf232012-08-01 16:39:55 -07001564
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001565status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001566 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001567 mCameraFacing == CAMERA_FACING_FRONT);
1568 if (transform == -1) {
1569 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1570 __FUNCTION__, mCameraId, degrees);
1571 return BAD_VALUE;
1572 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001573 SharedParameters::Lock l(mParameters);
1574 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001575 getPreviewStreamId() != NO_STREAM) {
1576 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001577 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001578 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001579 return OK;
1580}
1581
1582status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001583 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001584 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001585 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001586 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001587 }
1588
Igor Murashkina858ea02014-08-19 14:53:08 -07001589 // the camera2 api legacy mode can unconditionally disable the shutter sound
1590 if (mLegacyMode) {
1591 ALOGV("%s: Disable shutter sound in legacy mode", __FUNCTION__);
1592 l.mParameters.playShutterSound = false;
1593 return OK;
1594 }
1595
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001596 // Disabling shutter sound may not be allowed. In that case only
1597 // allow the mediaserver process to disable the sound.
1598 char value[PROPERTY_VALUE_MAX];
1599 property_get("ro.camera.sound.forced", value, "0");
1600 if (strncmp(value, "0", 2) != 0) {
1601 // Disabling shutter sound is not allowed. Deny if the current
1602 // process is not mediaserver.
1603 if (getCallingPid() != getpid()) {
1604 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1605 getCallingPid());
1606 return PERMISSION_DENIED;
1607 }
1608 }
1609
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001610 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001611 return OK;
1612}
1613
1614status_t Camera2Client::commandPlayRecordingSoundL() {
Chien-Yu Chen82104eb2015-10-14 11:29:31 -07001615 mCameraService->playSound(CameraService::SOUND_RECORDING_START);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001616 return OK;
1617}
1618
Igor Murashkinddf3c502012-10-12 16:56:11 -07001619status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001620 ALOGV("%s: Camera %d: Starting face detection",
1621 __FUNCTION__, mCameraId);
1622 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001623 SharedParameters::Lock l(mParameters);
1624 switch (l.mParameters.state) {
1625 case Parameters::DISCONNECTED:
1626 case Parameters::STOPPED:
1627 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1628 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001629 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1630 __FUNCTION__, mCameraId);
1631 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001632 case Parameters::PREVIEW:
1633 case Parameters::RECORD:
1634 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001635 // Good to go for starting face detect
1636 break;
1637 }
1638 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001639 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001640 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001641 ALOGE("%s: Camera %d: Face detection not supported",
1642 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001643 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001644 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001645 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001646
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001647 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001648
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001649 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001650
1651 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001652}
1653
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001654status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001655 status_t res = OK;
1656 ALOGV("%s: Camera %d: Stopping face detection",
1657 __FUNCTION__, mCameraId);
1658
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001659 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001660
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001661 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001662
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001663 if (params.state == Parameters::PREVIEW
1664 || params.state == Parameters::RECORD
1665 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001666 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001667 }
1668
1669 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001670}
1671
1672status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001673 SharedParameters::Lock l(mParameters);
1674 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001675
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001676 return OK;
1677}
1678
1679status_t Camera2Client::commandPingL() {
1680 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001681 SharedParameters::Lock l(mParameters);
1682 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001683 return OK;
1684 } else {
1685 return NO_INIT;
1686 }
1687}
1688
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001689void Camera2Client::notifyError(int32_t errorCode,
Ruben Brunka485dfe2015-04-14 13:43:47 -07001690 const CaptureResultExtras& resultExtras) {
1691 int32_t err = CAMERA_ERROR_UNKNOWN;
1692 switch(errorCode) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001693 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001694 err = CAMERA_ERROR_RELEASED;
1695 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001696 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001697 err = CAMERA_ERROR_UNKNOWN;
1698 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001699 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001700 err = CAMERA_ERROR_SERVER_DIED;
1701 break;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001702 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
1703 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
1704 case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
Ruben Brunka485dfe2015-04-14 13:43:47 -07001705 ALOGW("%s: Received recoverable error %d from HAL - ignoring, requestId %" PRId32,
1706 __FUNCTION__, errorCode, resultExtras.requestId);
1707 return;
1708 default:
1709 err = CAMERA_ERROR_UNKNOWN;
1710 break;
1711 }
1712
1713 ALOGE("%s: Error condition %d reported by HAL, requestId %" PRId32, __FUNCTION__, errorCode,
1714 resultExtras.requestId);
1715
1716 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1717 if (l.mRemoteCallback != nullptr) {
1718 l.mRemoteCallback->notifyCallback(CAMERA_MSG_ERROR, err, 0);
1719 }
1720}
1721
1722
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001723/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001724void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1725 ALOGV("%s: Autofocus state now %d, last trigger %d",
1726 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001727 bool sendCompletedMessage = false;
1728 bool sendMovingMessage = false;
1729
1730 bool success = false;
1731 bool afInMotion = false;
1732 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001733 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001734 // Trace end of AF state
1735 char tmp[32];
1736 if (l.mParameters.afStateCounter > 0) {
1737 camera_metadata_enum_snprint(
1738 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1739 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1740 }
1741
1742 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001743 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001744 l.mParameters.afStateCounter++;
1745
1746 // Trace start of AF state
1747
1748 camera_metadata_enum_snprint(
1749 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1750 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1751
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001752 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001753 case Parameters::FOCUS_MODE_AUTO:
1754 case Parameters::FOCUS_MODE_MACRO:
1755 // Don't send notifications upstream if they're not for the current AF
1756 // trigger. For example, if cancel was called in between, or if we
1757 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001758 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001759 switch (newState) {
1760 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1761 success = true;
1762 // no break
1763 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1764 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001765 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001766 break;
1767 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1768 // Just starting focusing, ignore
1769 break;
1770 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1771 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1772 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001773 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001774 default:
1775 // Unexpected in AUTO/MACRO mode
1776 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1777 __FUNCTION__, newState);
1778 break;
1779 }
1780 break;
1781 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1782 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1783 switch (newState) {
1784 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1785 success = true;
1786 // no break
1787 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1788 // Don't send notifications upstream if they're not for
1789 // the current AF trigger. For example, if cancel was
1790 // called in between, or if we already sent a
1791 // notification about this AF call.
1792 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001793 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001794 sendCompletedMessage = true;
1795 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001796 if (l.mParameters.enableFocusMoveMessages &&
1797 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001798 sendMovingMessage = true;
1799 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001800 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001801 break;
1802 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1803 // Cancel was called, or we switched state; care if
1804 // currently moving
1805 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001806 if (l.mParameters.enableFocusMoveMessages &&
1807 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001808 sendMovingMessage = true;
1809 }
1810 break;
1811 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1812 // Start passive scan, inform upstream
1813 afInMotion = true;
1814 // no break
1815 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001816 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001817 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001818 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001819 sendMovingMessage = true;
1820 }
1821 break;
1822 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001823 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001824 break;
1825 case Parameters::FOCUS_MODE_EDOF:
1826 case Parameters::FOCUS_MODE_INFINITY:
1827 case Parameters::FOCUS_MODE_FIXED:
1828 default:
1829 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001830 ALOGE("%s: Unexpected AF state change %d "
1831 "(ID %d) in focus mode %d",
1832 __FUNCTION__, newState, triggerId,
1833 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001834 }
1835 }
1836 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001837 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001838 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1839 if (l.mRemoteCallback != 0) {
1840 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001841 afInMotion ? 1 : 0, 0);
1842 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001843 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001844 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001845 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001846 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1847 if (l.mRemoteCallback != 0) {
1848 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001849 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001850 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001851 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001852}
1853
1854void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1855 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1856 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001857 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001858}
1859
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001860void Camera2Client::notifyShutter(const CaptureResultExtras& resultExtras,
1861 nsecs_t timestamp) {
1862 (void)resultExtras;
1863 (void)timestamp;
1864
1865 ALOGV("%s: Shutter notification for request id %" PRId32 " at time %" PRId64,
1866 __FUNCTION__, resultExtras.requestId, timestamp);
1867 mCaptureSequencer->notifyShutter(resultExtras, timestamp);
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07001868
1869 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
Yin-Chia Yeh216db742015-05-18 15:03:35 -07001870}
1871
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001872camera2::SharedParameters& Camera2Client::getParameters() {
1873 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001874}
1875
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001876int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001877 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001878}
1879
1880int Camera2Client::getCaptureStreamId() const {
1881 return mJpegProcessor->getStreamId();
1882}
1883
1884int Camera2Client::getCallbackStreamId() const {
1885 return mCallbackProcessor->getStreamId();
1886}
1887
1888int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001889 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001890}
1891
1892int Camera2Client::getZslStreamId() const {
1893 return mZslProcessor->getStreamId();
1894}
1895
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001896status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Zhijun He25a0aef2014-06-25 11:40:02 -07001897 wp<camera2::FrameProcessor::FilteredListener> listener, bool sendPartials) {
1898 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001899}
1900
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001901status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1902 wp<camera2::FrameProcessor::FilteredListener> listener) {
1903 return mFrameProcessor->removeListener(minId, maxId, listener);
1904}
1905
1906status_t Camera2Client::stopStream() {
1907 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001908}
1909
Yin-Chia Yeh355d9c62015-02-24 15:51:43 -08001910status_t Camera2Client::createJpegStreamL(Parameters &params) {
1911 status_t res = OK;
1912 int lastJpegStreamId = mJpegProcessor->getStreamId();
1913 if (lastJpegStreamId != NO_STREAM) {
1914 return INVALID_OPERATION;
1915 }
1916
1917 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1918 if (res != OK) {
1919 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1920 __FUNCTION__, mCameraId, strerror(-res), res);
1921 return res;
1922 }
1923
1924 res = mDevice->flush();
1925 if (res != OK) {
1926 ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
1927 __FUNCTION__, mCameraId, strerror(-res), res);
1928 return res;
1929 }
1930
1931 // Ideally we don't need this, but current camera device
1932 // status tracking mechanism demands it.
1933 res = mDevice->waitUntilDrained();
1934 if (res != OK) {
1935 ALOGE("%s: Camera %d: Waiting device drain failed: %s (%d)",
1936 __FUNCTION__, mCameraId, strerror(-res), res);
1937 }
1938
1939 res = updateProcessorStream(mJpegProcessor, params);
1940 return res;
1941}
1942
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001943const int32_t Camera2Client::kPreviewRequestIdStart;
1944const int32_t Camera2Client::kPreviewRequestIdEnd;
1945const int32_t Camera2Client::kRecordingRequestIdStart;
1946const int32_t Camera2Client::kRecordingRequestIdEnd;
1947const int32_t Camera2Client::kCaptureRequestIdStart;
1948const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001949
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001950/** Utility methods */
1951
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001952status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001953 status_t res;
1954
Igor Murashkin22d58d32012-10-02 19:07:14 -07001955 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1956
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001957 res = mStreamingProcessor->incrementStreamingIds();
1958 if (res != OK) {
1959 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1960 __FUNCTION__, mCameraId, strerror(-res), res);
1961 return res;
1962 }
1963
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001964 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001965 if (res != OK) {
1966 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1967 __FUNCTION__, mCameraId, strerror(-res), res);
1968 return res;
1969 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001970 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001971 if (res != OK) {
1972 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1973 __FUNCTION__, mCameraId, strerror(-res), res);
1974 return res;
1975 }
1976
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001977 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001978 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001979 if (res != OK) {
1980 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1981 __FUNCTION__, mCameraId, strerror(-res), res);
1982 return res;
1983 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001984 } else if (params.state == Parameters::RECORD ||
1985 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001986 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001987 if (res != OK) {
1988 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1989 __FUNCTION__, mCameraId, strerror(-res), res);
1990 return res;
1991 }
1992 }
1993 return res;
1994}
1995
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001996
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001997size_t Camera2Client::calculateBufferSize(int width, int height,
1998 int format, int stride) {
1999 switch (format) {
2000 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
2001 return width * height * 2;
2002 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
2003 return width * height * 3 / 2;
2004 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
2005 return width * height * 2;
2006 case HAL_PIXEL_FORMAT_YV12: { // YV12
2007 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07002008 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002009 size_t uvSize = uvStride * height / 2;
2010 return ySize + uvSize * 2;
2011 }
2012 case HAL_PIXEL_FORMAT_RGB_565:
2013 return width * height * 2;
2014 case HAL_PIXEL_FORMAT_RGBA_8888:
2015 return width * height * 4;
Eino-Ville Talvalaa97dfeb2015-02-19 16:26:13 -08002016 case HAL_PIXEL_FORMAT_RAW16:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07002017 return width * height * 2;
2018 default:
2019 ALOGE("%s: Unknown preview format: %x",
2020 __FUNCTION__, format);
2021 return 0;
2022 }
2023}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07002024
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002025status_t Camera2Client::syncWithDevice() {
2026 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07002027 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07002028 status_t res;
2029
2030 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
2031 if (activeRequestId == 0) return OK;
2032
2033 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
2034 if (res == TIMED_OUT) {
2035 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
2036 __FUNCTION__, mCameraId);
2037 } else if (res != OK) {
2038 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
2039 __FUNCTION__, mCameraId);
2040 }
2041 return res;
2042}
2043
Igor Murashkindca254a2013-05-13 14:53:44 -07002044template <typename ProcessorT>
2045status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2046 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07002047 // No default template arguments until C++11, so we need this overload
2048 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
2049 processor, params);
2050}
2051
2052template <typename ProcessorT,
2053 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
2054status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
2055 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07002056 status_t res;
2057
Igor Murashkin82db9e62013-05-21 11:38:49 -07002058 // Get raw pointer since sp<T> doesn't have operator->*
2059 ProcessorT *processorPtr = processor.get();
2060 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002061
2062 /**
2063 * Can't update the stream if it's busy?
2064 *
2065 * Then we need to stop the device (by temporarily clearing the request
2066 * queue) and then try again. Resume streaming once we're done.
2067 */
2068 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07002069 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
2070 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07002071 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
2072 if (res != OK) {
2073 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
2074 __FUNCTION__, mCameraId, strerror(-res), res);
2075 }
2076
2077 res = mDevice->waitUntilDrained();
2078 if (res != OK) {
2079 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
2080 __FUNCTION__, mCameraId, strerror(-res), res);
2081 }
2082
Igor Murashkin82db9e62013-05-21 11:38:49 -07002083 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07002084 if (res != OK) {
2085 ALOGE("%s: Camera %d: Failed to update processing stream "
2086 " despite having halted streaming first: %s (%d)",
2087 __FUNCTION__, mCameraId, strerror(-res), res);
2088 }
2089
2090 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
2091 if (res != OK) {
2092 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
2093 __FUNCTION__, mCameraId, strerror(-res), res);
2094 }
2095 }
2096
2097 return res;
2098}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08002099
Yin-Chia Yeha53021f2014-09-12 14:50:27 -07002100status_t Camera2Client::overrideVideoSnapshotSize(Parameters &params) {
2101 ALOGV("%s: Camera %d: configure still size to video size before recording"
2102 , __FUNCTION__, mCameraId);
2103 params.overrideJpegSizeByVideoSize();
2104 status_t res = updateProcessorStream(mJpegProcessor, params);
2105 if (res != OK) {
2106 ALOGE("%s: Camera %d: Can't override video snapshot size to video size: %s (%d)",
2107 __FUNCTION__, mCameraId, strerror(-res), res);
2108 }
2109 return res;
2110}
2111
Chien-Yu Chen8cca0752015-11-13 15:28:48 -08002112status_t Camera2Client::setVideoTarget(const sp<IGraphicBufferProducer>& bufferProducer) {
2113 ATRACE_CALL();
2114 ALOGV("%s: E", __FUNCTION__);
2115 Mutex::Autolock icl(mBinderSerializationLock);
2116 status_t res;
2117 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
2118
2119 sp<IBinder> binder = IInterface::asBinder(bufferProducer);
2120 if (binder == mVideoSurface) {
2121 ALOGV("%s: Camera %d: New video window is same as old video window",
2122 __FUNCTION__, mCameraId);
2123 return NO_ERROR;
2124 }
2125
2126 sp<Surface> window;
2127 int format;
2128 android_dataspace dataSpace;
2129
2130 if (bufferProducer != nullptr) {
2131 // Using controlledByApp flag to ensure that the buffer queue remains in
2132 // async mode for the old camera API, where many applications depend
2133 // on that behavior.
2134 window = new Surface(bufferProducer, /*controlledByApp*/ true);
2135
2136 ANativeWindow *anw = window.get();
2137
2138 if ((res = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) {
2139 ALOGE("%s: Failed to query Surface format", __FUNCTION__);
2140 return res;
2141 }
2142
2143 if ((res = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE,
2144 reinterpret_cast<int*>(&dataSpace))) != OK) {
2145 ALOGE("%s: Failed to query Surface dataSpace", __FUNCTION__);
2146 return res;
2147 }
2148 }
2149
2150 Parameters::State state;
2151 {
2152 SharedParameters::Lock l(mParameters);
2153 state = l.mParameters.state;
2154 }
2155
2156 switch (state) {
2157 case Parameters::STOPPED:
2158 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
2159 case Parameters::PREVIEW:
2160 // OK
2161 break;
2162 case Parameters::DISCONNECTED:
2163 case Parameters::RECORD:
2164 case Parameters::STILL_CAPTURE:
2165 case Parameters::VIDEO_SNAPSHOT:
2166 default:
2167 ALOGE("%s: Camera %d: Cannot set video target while in state %s",
2168 __FUNCTION__, mCameraId,
2169 Parameters::getStateName(state));
2170 return INVALID_OPERATION;
2171 }
2172
2173 mVideoSurface = binder;
2174 res = mStreamingProcessor->setRecordingWindow(window);
2175 if (res != OK) {
2176 ALOGE("%s: Unable to set new recording window: %s (%d)",
2177 __FUNCTION__, strerror(-res), res);
2178 return res;
2179 }
2180
2181 {
2182 SharedParameters::Lock l(mParameters);
2183 l.mParameters.videoFormat = format;
2184 l.mParameters.videoDataSpace = dataSpace;
2185 }
2186
2187 return OK;
2188}
2189
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07002190const char* Camera2Client::kAutofocusLabel = "autofocus";
2191const char* Camera2Client::kTakepictureLabel = "take_picture";
2192
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07002193} // namespace android