blob: 5eb51815ace0bdcb1580d4fdb43d7f9c2af18b46 [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 Talvala61ab9f92012-05-17 10:30:54 -070027
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070028#include "api1/Camera2Client.h"
29
30#include "api1/client2/StreamingProcessor.h"
31#include "api1/client2/JpegProcessor.h"
32#include "api1/client2/CaptureSequencer.h"
33#include "api1/client2/CallbackProcessor.h"
34#include "api1/client2/ZslProcessor.h"
35#include "api1/client2/ZslProcessor3.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,
50 const sp<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,
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070056 int servicePid):
Igor Murashkin44cfcf02013-03-01 16:22:28 -080057 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080058 cameraId, cameraFacing, clientPid, clientUid, servicePid),
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070059 mParameters(cameraId, cameraFacing)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070060{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070061 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070062
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070063 SharedParameters::Lock l(mParameters);
64 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070065}
66
67status_t Camera2Client::initialize(camera_module_t *module)
68{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070069 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070070 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070071 status_t res;
72
Igor Murashkine6800ce2013-03-04 17:25:57 -080073 res = Camera2ClientBase::initialize(module);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080074 if (res != OK) {
75 return res;
76 }
77
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070078 {
79 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070080
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -070081 res = l.mParameters.initialize(&(mDevice->info()), mDeviceVersion);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070082 if (res != OK) {
83 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
84 __FUNCTION__, mCameraId, strerror(-res), res);
85 return NO_INIT;
86 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070087 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070088
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070089 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070090
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070091 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -070092 threadName = String8::format("C2-%d-StreamProc",
93 mCameraId);
94 mStreamingProcessor->run(threadName.string());
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070095
Igor Murashkince124da2013-03-04 14:53:08 -080096 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -070097 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070098 mCameraId);
99 mFrameProcessor->run(threadName.string());
100
101 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700102 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700103 mCameraId);
104 mCaptureSequencer->run(threadName.string());
105
106 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700107 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700108 mCameraId);
109 mJpegProcessor->run(threadName.string());
110
Igor Murashkinae500e52013-04-22 14:03:54 -0700111 switch (mDeviceVersion) {
112 case CAMERA_DEVICE_API_VERSION_2_0: {
113 sp<ZslProcessor> zslProc =
114 new ZslProcessor(this, mCaptureSequencer);
115 mZslProcessor = zslProc;
116 mZslProcessorThread = zslProc;
117 break;
118 }
Zhijun He95dd5ba2014-03-26 18:18:00 -0700119 case CAMERA_DEVICE_API_VERSION_3_0:
120 case CAMERA_DEVICE_API_VERSION_3_1:
121 case CAMERA_DEVICE_API_VERSION_3_2: {
Igor Murashkinae500e52013-04-22 14:03:54 -0700122 sp<ZslProcessor3> zslProc =
123 new ZslProcessor3(this, mCaptureSequencer);
124 mZslProcessor = zslProc;
125 mZslProcessorThread = zslProc;
126 break;
127 }
128 default:
129 break;
130 }
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700131 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700132 mCameraId);
Igor Murashkinae500e52013-04-22 14:03:54 -0700133 mZslProcessorThread->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700134
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700135 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700136 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700137 mCameraId);
138 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700139
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700140 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700141 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700142 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
143 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700144 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700145 }
146
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700147 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700148}
149
150Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700151 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700152 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700153
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700154 mDestructionStarted = true;
155
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700156 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700157
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700158 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700159}
160
161status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700162 String8 result;
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700163 result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700164 mCameraId,
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800165 getRemoteCallback()->asBinder().get(),
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700166 String8(mClientPackageName).string(),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700167 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700168 result.append(" State: ");
169#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
170
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700171 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700172
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700173 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700174
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700175 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700176 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700177 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700178 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700179 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700180 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700181 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700182 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700183 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700184 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700185 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700186 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700187 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700189 p.jpegQuality, p.jpegThumbQuality);
190 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700191 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700192 p.gpsEnabled ? "enabled" : "disabled");
193 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700194 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700195 p.gpsCoordinates[0], p.gpsCoordinates[1],
196 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000197 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700198 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700199 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700200 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700201 }
202
203 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700204 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800205 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
206 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
207 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
210 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
211 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700213 default: result.append("UNKNOWN\n");
214 }
215
216 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700217 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800218 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
219 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
220 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700227 default: result.append("UNKNOWN\n");
228 }
229
230 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700231 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800232 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
233 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
234 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700236 default: result.append("UNKNOWN\n");
237 }
238
239 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700240 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800241 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700242 result.append("AUTO\n"); break;
243 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
244 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
245 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
258 default: result.append("UNKNOWN\n");
259 }
260
261 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700262 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700263 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
264 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
265 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
266 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
267 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
268 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
269 default: result.append("UNKNOWN\n");
270 }
271
272 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700273 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700274 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
275 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
276 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
279 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
280 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
282 default: result.append("UNKNOWN\n");
283 }
284
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700285 result.append(" Focus state: ");
286 switch (p.focusState) {
287 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
288 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
289 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700290 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700291 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
292 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
293 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
294 default: result.append("UNKNOWN\n");
295 }
296
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700297 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700298 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700299 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700300 p.focusingAreas[i].left,
301 p.focusingAreas[i].top,
302 p.focusingAreas[i].right,
303 p.focusingAreas[i].bottom,
304 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700305 }
306
307 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700308 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700309
310 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700311 p.autoExposureLock ? "enabled" : "disabled",
312 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700313
314 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700315 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700316 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700317 p.meteringAreas[i].left,
318 p.meteringAreas[i].top,
319 p.meteringAreas[i].right,
320 p.meteringAreas[i].bottom,
321 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700322 }
323
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700324 result.appendFormat(" Zoom index: %d\n", p.zoom);
325 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
326 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700327
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700328 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700329 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700330
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700331 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700332 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700333
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700334 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
335 p.fastInfo.bestStillCaptureFpsRange[0],
336 p.fastInfo.bestStillCaptureFpsRange[1]);
337
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700338 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700339 result.appendFormat(" Preview stream ID: %d\n",
340 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700341 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700342 getCaptureStreamId());
343 result.appendFormat(" Recording stream ID: %d\n",
344 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700345
346 result.append(" Quirks for this camera:\n");
347 bool haveQuirk = false;
348 if (p.quirks.triggerAfWithAuto) {
349 result.appendFormat(" triggerAfWithAuto\n");
350 haveQuirk = true;
351 }
352 if (p.quirks.useZslFormat) {
353 result.appendFormat(" useZslFormat\n");
354 haveQuirk = true;
355 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700356 if (p.quirks.meteringCropRegion) {
357 result.appendFormat(" meteringCropRegion\n");
358 haveQuirk = true;
359 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700360 if (p.quirks.partialResults) {
361 result.appendFormat(" usePartialResult\n");
362 haveQuirk = true;
363 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700364 if (!haveQuirk) {
365 result.appendFormat(" none\n");
366 }
367
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700368 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700369
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700370 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700371
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700372 mCaptureSequencer->dump(fd, args);
373
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700374 mFrameProcessor->dump(fd, args);
375
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700376 mZslProcessor->dump(fd, args);
377
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800378 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700379#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700380}
381
382// ICamera interface
383
384void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700385 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800386 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700387
388 // Allow both client and the media server to disconnect at all times
389 int callingPid = getCallingPid();
390 if (callingPid != mClientPid && callingPid != mServicePid) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700391
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700392 if (mDevice == 0) return;
393
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700394 ALOGV("Camera %d: Shutting down", mCameraId);
395
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700396 /**
397 * disconnect() cannot call any methods that might need to promote a
398 * wp<Camera2Client>, since disconnect can be called from the destructor, at
399 * which point all such promotions will fail.
400 */
401
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700402 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700403
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700404 {
405 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700406 if (l.mParameters.state == Parameters::DISCONNECTED) return;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700407 l.mParameters.state = Parameters::DISCONNECTED;
408 }
409
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700410 mStreamingProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700411 mFrameProcessor->requestExit();
412 mCaptureSequencer->requestExit();
413 mJpegProcessor->requestExit();
Igor Murashkinae500e52013-04-22 14:03:54 -0700414 mZslProcessorThread->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700415 mCallbackProcessor->requestExit();
416
417 ALOGV("Camera %d: Waiting for threads", mCameraId);
418
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700419 mStreamingProcessor->join();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700420 mFrameProcessor->join();
421 mCaptureSequencer->join();
422 mJpegProcessor->join();
Igor Murashkinae500e52013-04-22 14:03:54 -0700423 mZslProcessorThread->join();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700424 mCallbackProcessor->join();
425
Ruben Brunkdfe71552013-12-05 11:00:37 -0800426 ALOGV("Camera %d: Deleting streams", mCameraId);
427
428 mStreamingProcessor->deletePreviewStream();
429 mStreamingProcessor->deleteRecordingStream();
430 mJpegProcessor->deleteStream();
431 mCallbackProcessor->deleteStream();
432 mZslProcessor->deleteStream();
433
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700434 ALOGV("Camera %d: Disconnecting device", mCameraId);
435
436 mDevice->disconnect();
437
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700438 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700439
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700440 CameraService::Client::disconnect();
441}
442
443status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700444 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700445 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800446 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700447
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700448 if (mClientPid != 0 && getCallingPid() != mClientPid) {
449 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
450 "current locked to pid %d", __FUNCTION__,
451 mCameraId, getCallingPid(), mClientPid);
452 return BAD_VALUE;
453 }
454
455 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700456
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800457 mRemoteCallback = client;
458 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700459
460 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700461}
462
463status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700464 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700465 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800466 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700467 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
468 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700469
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700470 if (mClientPid == 0) {
471 mClientPid = getCallingPid();
472 return OK;
473 }
474
475 if (mClientPid != getCallingPid()) {
476 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
477 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
478 return EBUSY;
479 }
480
481 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700482}
483
484status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700485 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700486 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800487 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700488 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
489 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700490
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700491 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700492 SharedParameters::Lock l(mParameters);
493 if (l.mParameters.state == Parameters::RECORD ||
494 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
495 ALOGD("Not allowed to unlock camera during recording.");
496 return INVALID_OPERATION;
497 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700498 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800499 mRemoteCallback.clear();
500 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700501 return OK;
502 }
503
504 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
505 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
506 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700507}
508
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700509status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800510 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700511 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700512 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800513 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700514 status_t res;
515 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700516
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700517 sp<IBinder> binder;
518 sp<ANativeWindow> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800519 if (bufferProducer != 0) {
520 binder = bufferProducer->asBinder();
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700521 // Using controlledByApp flag to ensure that the buffer queue remains in
522 // async mode for the old camera API, where many applications depend
523 // on that behavior.
524 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700525 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700526 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700527}
528
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700529status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700530 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700531 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700532 status_t res;
533
534 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700535 ALOGV("%s: Camera %d: New window is same as old window",
536 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700537 return NO_ERROR;
538 }
539
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700540 Parameters::State state;
541 {
542 SharedParameters::Lock l(mParameters);
543 state = l.mParameters.state;
544 }
545 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700546 case Parameters::DISCONNECTED:
547 case Parameters::RECORD:
548 case Parameters::STILL_CAPTURE:
549 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700550 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700551 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700552 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700553 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700554 case Parameters::STOPPED:
555 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700556 // OK
557 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700558 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700559 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700560 res = stopStream();
561 if (res != OK) {
562 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
563 __FUNCTION__, strerror(-res), res);
564 return res;
565 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700566 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700567 break;
568 }
569
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700570 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700571 res = mStreamingProcessor->setPreviewWindow(window);
572 if (res != OK) {
573 ALOGE("%s: Unable to set new preview window: %s (%d)",
574 __FUNCTION__, strerror(-res), res);
575 return res;
576 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700577
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700578 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
579 SharedParameters::Lock l(mParameters);
580 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700581 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700582 }
583
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700584 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700585}
586
587void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700588 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700589 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800590 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700591
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700592 if ( checkPid(__FUNCTION__) != OK) return;
593
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700594 SharedParameters::Lock l(mParameters);
595 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700596}
597
598void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
599 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700600
601 switch(params.state) {
602 case Parameters::STOPPED:
603 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
604 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700605 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700606 // OK
607 break;
608 default:
609 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
610 ALOGE("%s: Camera %d: Can't use preview callbacks "
611 "in state %d", __FUNCTION__, mCameraId, params.state);
612 return;
613 }
614 }
615
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700616 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
617 ALOGV("%s: setting oneshot", __FUNCTION__);
618 params.previewCallbackOneShot = true;
619 }
620 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700621
Zhijun He527748a2013-09-15 21:06:10 -0700622 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700623 // Disable any existing preview callback window when enabling
624 // preview callback flags
625 res = mCallbackProcessor->setCallbackWindow(NULL);
626 if (res != OK) {
627 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
628 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
629 return;
630 }
631 params.previewCallbackSurface = false;
632 }
633
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700634 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700635
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700636 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700637 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700638 if (res != OK) {
639 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
640 __FUNCTION__, mCameraId,
641 Parameters::getStateName(params.state));
642 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700643 }
644 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700645}
646
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700647status_t Camera2Client::setPreviewCallbackTarget(
648 const sp<IGraphicBufferProducer>& callbackProducer) {
649 ATRACE_CALL();
650 ALOGV("%s: E", __FUNCTION__);
651 Mutex::Autolock icl(mBinderSerializationLock);
652 status_t res;
653 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
654
655 sp<ANativeWindow> window;
656 if (callbackProducer != 0) {
657 window = new Surface(callbackProducer);
658 }
659
660 res = mCallbackProcessor->setCallbackWindow(window);
661 if (res != OK) {
662 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
663 __FUNCTION__, mCameraId, strerror(-res), res);
664 return res;
665 }
666
667 SharedParameters::Lock l(mParameters);
668
669 if (window != NULL) {
670 // Disable traditional callbacks when a valid callback target is given
671 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
672 l.mParameters.previewCallbackOneShot = false;
673 l.mParameters.previewCallbackSurface = true;
674 } else {
675 // Disable callback target if given a NULL interface.
676 l.mParameters.previewCallbackSurface = false;
677 }
678
679 switch(l.mParameters.state) {
680 case Parameters::PREVIEW:
681 res = startPreviewL(l.mParameters, true);
682 break;
683 case Parameters::RECORD:
684 case Parameters::VIDEO_SNAPSHOT:
685 res = startRecordingL(l.mParameters, true);
686 break;
687 default:
688 break;
689 }
690 if (res != OK) {
691 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
692 __FUNCTION__, mCameraId,
693 Parameters::getStateName(l.mParameters.state));
694 }
695
696 return OK;
697}
698
699
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700700status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700701 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700702 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800703 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700704 status_t res;
705 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700706 SharedParameters::Lock l(mParameters);
707 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700708}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700709
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700710status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700711 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700712 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700713
714 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
715
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700716 if ( (params.state == Parameters::PREVIEW ||
717 params.state == Parameters::RECORD ||
718 params.state == Parameters::VIDEO_SNAPSHOT)
719 && !restart) {
720 // Succeed attempt to re-enter a streaming state
721 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
722 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700723 return OK;
724 }
725 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700726 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700727 __FUNCTION__,
728 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700729 return INVALID_OPERATION;
730 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700731
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700732 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700733 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700734 return OK;
735 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700736 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800737 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700738
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700739 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700740 if (res != OK) {
741 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
742 __FUNCTION__, mCameraId, strerror(-res), res);
743 return res;
744 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700745
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800746 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
747
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700748 // We could wait to create the JPEG output stream until first actual use
749 // (first takePicture call). However, this would substantially increase the
750 // first capture latency on HAL3 devices, and potentially on some HAL2
751 // devices. So create it unconditionally at preview start. As a drawback,
752 // this increases gralloc memory consumption for applications that don't
753 // ever take a picture.
754 // TODO: Find a better compromise, though this likely would involve HAL
755 // changes.
Zhijun Hee2d83752014-06-23 10:22:37 -0700756 int lastJpegStreamId = mJpegProcessor->getStreamId();
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700757 res = updateProcessorStream(mJpegProcessor, params);
758 if (res != OK) {
759 ALOGE("%s: Camera %d: Can't pre-configure still image "
760 "stream: %s (%d)",
761 __FUNCTION__, mCameraId, strerror(-res), res);
762 return res;
763 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700764 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700765
Zhijun Hed1d64672013-09-06 15:00:01 -0700766 Vector<int32_t> outputStreams;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700767 bool callbacksEnabled = (params.previewCallbackFlags &
768 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
769 params.previewCallbackSurface;
770
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700771 if (callbacksEnabled) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700772 // Can't have recording stream hanging around when enabling callbacks,
773 // since it exceeds the max stream count on some devices.
774 if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
775 ALOGV("%s: Camera %d: Clearing out recording stream before "
776 "creating callback stream", __FUNCTION__, mCameraId);
777 res = mStreamingProcessor->stopStream();
778 if (res != OK) {
779 ALOGE("%s: Camera %d: Can't stop streaming to delete "
780 "recording stream", __FUNCTION__, mCameraId);
781 return res;
782 }
783 res = mStreamingProcessor->deleteRecordingStream();
784 if (res != OK) {
785 ALOGE("%s: Camera %d: Unable to delete recording stream before "
786 "enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
787 strerror(-res), res);
788 return res;
789 }
790 }
791
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700792 res = mCallbackProcessor->updateStream(params);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700793 if (res != OK) {
794 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
795 __FUNCTION__, mCameraId, strerror(-res), res);
796 return res;
797 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700798 outputStreams.push(getCallbackStreamId());
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800799 } else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
800 /**
801 * Delete the unused callback stream when preview stream is changed and
802 * preview is not enabled. Don't need stop preview stream as preview is in
803 * STOPPED state now.
804 */
805 ALOGV("%s: Camera %d: Delete unused preview callback stream.", __FUNCTION__, mCameraId);
806 res = mCallbackProcessor->deleteStream();
807 if (res != OK) {
808 ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
809 __FUNCTION__, mCameraId, strerror(-res), res);
810 return res;
811 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700812 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -0700813
814 if (params.zslMode && !params.recordingHint &&
815 getRecordingStreamId() == NO_STREAM) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700816 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700817 if (res != OK) {
818 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
819 __FUNCTION__, mCameraId, strerror(-res), res);
820 return res;
821 }
Zhijun Hee2d83752014-06-23 10:22:37 -0700822
823 if (jpegStreamChanged) {
824 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
825 __FUNCTION__, mCameraId);
826 mZslProcessor->clearZslQueue();
827 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700828 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700829 } else {
830 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700831 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700832
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700833 outputStreams.push(getPreviewStreamId());
834
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700835 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700836 if (!restart) {
837 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700838 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700839 ALOGE("%s: Camera %d: Can't set up preview request: "
840 "%s (%d)", __FUNCTION__, mCameraId,
841 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700842 return res;
843 }
844 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700845 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
846 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700847 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700848 if (!restart) {
849 res = mStreamingProcessor->updateRecordingRequest(params);
850 if (res != OK) {
851 ALOGE("%s: Camera %d: Can't set up preview request with "
852 "record hint: %s (%d)", __FUNCTION__, mCameraId,
853 strerror(-res), res);
854 return res;
855 }
856 }
857 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
858 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700859 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700860 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700861 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700862 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700863 return res;
864 }
865
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700866 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700867 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700868}
869
870void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700871 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700872 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800873 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700874 status_t res;
875 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700876 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700877}
878
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700879void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700880 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700881 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700882 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700883 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700884 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700885 SharedParameters::Lock l(mParameters);
886 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700887 }
888
889 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700890 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800891 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700892 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700893 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700894 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700895 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700896 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
897 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700898 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700899 case Parameters::PREVIEW:
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700900 syncWithDevice();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700901 res = stopStream();
902 if (res != OK) {
903 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
904 __FUNCTION__, mCameraId, strerror(-res), res);
905 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700906 res = mDevice->waitUntilDrained();
907 if (res != OK) {
908 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
909 __FUNCTION__, mCameraId, strerror(-res), res);
910 }
Yin-Chia Yeh28d03272014-07-17 16:05:23 -0700911 // Clean up recording stream
912 res = mStreamingProcessor->deleteRecordingStream();
913 if (res != OK) {
914 ALOGE("%s: Camera %d: Unable to delete recording stream before "
915 "stop preview: %s (%d)",
916 __FUNCTION__, mCameraId, strerror(-res), res);
917 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700918 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700919 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
920 SharedParameters::Lock l(mParameters);
921 l.mParameters.state = Parameters::STOPPED;
922 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700923 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700924 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700925 default:
926 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700927 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700928 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700929}
930
931bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700932 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800933 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700934 status_t res;
935 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
936
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700937 SharedParameters::Lock l(mParameters);
938 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700939}
940
941status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700942 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800943 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700944 status_t res;
945 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
946
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700947 SharedParameters::Lock l(mParameters);
948 switch (l.mParameters.state) {
949 case Parameters::RECORD:
950 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700951 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700952 __FUNCTION__, mCameraId,
953 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700954 return INVALID_OPERATION;
955 default:
956 // OK
957 break;
958 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700959
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700960 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700961
962 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700963}
964
965status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700966 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700967 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800968 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700969 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700970 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700971 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700972
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700973 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700974}
975
976status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
977 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700978
979 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
980
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700981 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700982 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700983 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700984 if (res != OK) return res;
985 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700986 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700987 // Ready to go
988 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700989 case Parameters::RECORD:
990 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700991 // OK to call this when recording is already on, just skip unless
992 // we're looking to restart
993 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700994 break;
995 default:
996 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700997 __FUNCTION__, mCameraId,
998 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700999 return INVALID_OPERATION;
1000 };
1001
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001002 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -07001003 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
1004 "non-metadata recording mode requested!", __FUNCTION__,
1005 mCameraId);
1006 return INVALID_OPERATION;
1007 }
1008
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001009 if (!restart) {
1010 mCameraService->playSound(CameraService::SOUND_RECORDING);
1011 mStreamingProcessor->updateRecordingRequest(params);
1012 if (res != OK) {
1013 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1014 __FUNCTION__, mCameraId, strerror(-res), res);
1015 return res;
1016 }
1017 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001018
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001019 // Not all devices can support a preview callback stream and a recording
1020 // stream at the same time, so assume none of them can.
1021 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1022 ALOGV("%s: Camera %d: Clearing out callback stream before "
1023 "creating recording stream", __FUNCTION__, mCameraId);
1024 res = mStreamingProcessor->stopStream();
1025 if (res != OK) {
1026 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1027 __FUNCTION__, mCameraId);
1028 return res;
1029 }
1030 res = mCallbackProcessor->deleteStream();
1031 if (res != OK) {
1032 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1033 "record: %s (%d)", __FUNCTION__, mCameraId,
1034 strerror(-res), res);
1035 return res;
1036 }
1037 }
Yin-Chia Yehca05ebd2014-08-05 13:35:58 -07001038
1039 if (mZslProcessor->getStreamId() != NO_STREAM) {
1040 ALOGV("%s: Camera %d: Clearing out zsl stream before "
1041 "creating recording stream", __FUNCTION__, mCameraId);
1042 res = mStreamingProcessor->stopStream();
1043 if (res != OK) {
1044 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1045 __FUNCTION__, mCameraId);
1046 return res;
1047 }
1048 res = mDevice->waitUntilDrained();
1049 if (res != OK) {
1050 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1051 __FUNCTION__, mCameraId, strerror(-res), res);
1052 }
1053 res = mZslProcessor->clearZslQueue();
1054 if (res != OK) {
1055 ALOGE("%s: Camera %d: Can't clear zsl queue",
1056 __FUNCTION__, mCameraId);
1057 return res;
1058 }
1059 res = mZslProcessor->deleteStream();
1060 if (res != OK) {
1061 ALOGE("%s: Camera %d: Unable to delete zsl stream before "
1062 "record: %s (%d)", __FUNCTION__, mCameraId,
1063 strerror(-res), res);
1064 return res;
1065 }
1066 }
1067
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001068 // Disable callbacks if they're enabled; can't record and use callbacks,
1069 // and we can't fail record start without stagefright asserting.
1070 params.previewCallbackFlags = 0;
1071
Igor Murashkin82db9e62013-05-21 11:38:49 -07001072 res = updateProcessorStream<
1073 StreamingProcessor,
1074 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
1075 params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001076 if (res != OK) {
1077 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
1078 __FUNCTION__, mCameraId, strerror(-res), res);
1079 return res;
1080 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001081
Zhijun Hed1d64672013-09-06 15:00:01 -07001082 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001083 outputStreams.push(getPreviewStreamId());
1084 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001085
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001086 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1087 outputStreams);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001088 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001089 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001090 __FUNCTION__, mCameraId, strerror(-res), res);
1091 return res;
1092 }
1093
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001094 if (params.state < Parameters::RECORD) {
1095 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001096 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001097
1098 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001099}
1100
1101void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001102 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001103 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001104 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001105 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001106
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001107 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001108 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1109
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001110 switch (l.mParameters.state) {
1111 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001112 // OK to stop
1113 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001114 case Parameters::STOPPED:
1115 case Parameters::PREVIEW:
1116 case Parameters::STILL_CAPTURE:
1117 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001118 default:
1119 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001120 __FUNCTION__, mCameraId,
1121 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001122 return;
1123 };
1124
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001125 mCameraService->playSound(CameraService::SOUND_RECORDING);
1126
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001127 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001128 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001129 ALOGE("%s: Camera %d: Unable to return to preview",
1130 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001131 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001132}
1133
1134bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001135 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001136 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001137
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001138 if ( checkPid(__FUNCTION__) != OK) return false;
1139
James Dong8da4cd72012-08-04 19:58:07 -07001140 return recordingEnabledL();
1141}
1142
1143bool Camera2Client::recordingEnabledL() {
1144 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001145 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001146
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001147 return (l.mParameters.state == Parameters::RECORD
1148 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001149}
1150
1151void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001152 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001153 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001154 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001155
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001156 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001157}
1158
1159status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001160 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001161 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001162 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001163 status_t res;
1164 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1165
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001166 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001167 bool notifyImmediately = false;
1168 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001169 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001170 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001171 if (l.mParameters.state < Parameters::PREVIEW) {
1172 return INVALID_OPERATION;
1173 }
1174
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001175 /**
1176 * If the camera does not support auto-focus, it is a no-op and
1177 * onAutoFocus(boolean, Camera) callback will be called immediately
1178 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001179 *
1180 * Similarly, if focus mode is set to INFINITY, there's no reason to
1181 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001182 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001183 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1184 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001185 notifyImmediately = true;
1186 notifySuccess = true;
1187 }
1188 /**
1189 * If we're in CAF mode, and AF has already been locked, just fire back
1190 * the callback right away; the HAL would not send a notification since
1191 * no state change would happen on a AF trigger.
1192 */
1193 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1194 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1195 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1196 notifyImmediately = true;
1197 notifySuccess = true;
1198 }
1199 /**
1200 * Send immediate notification back to client
1201 */
1202 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001203 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1204 if (l.mRemoteCallback != 0) {
1205 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001206 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001207 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001208 return OK;
1209 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001210 /**
1211 * Handle quirk mode for AF in scene modes
1212 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001213 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001214 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001215 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1216 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001217 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1218 __FUNCTION__, l.mParameters.focusMode);
1219 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1220 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1221 updateRequests(l.mParameters);
1222 }
1223
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001224 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1225 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001226 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001227 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1228
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001229 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001230
1231 mDevice->triggerAutofocus(triggerId);
1232
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001233 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001234}
1235
1236status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001237 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001238 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001239 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001240 status_t res;
1241 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1242
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001243 int triggerId;
1244 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001245 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001246 // Canceling does nothing in FIXED or INFINITY modes
1247 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1248 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1249 return OK;
1250 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001251
1252 // An active AF trigger is canceled
1253 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1254 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1255 }
1256
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001257 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001258
1259 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001260 // the real state at this point. No need to cancel explicitly if
1261 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001262 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1263 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1264 l.mParameters.shadowFocusMode);
1265 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1266 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1267 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001268
1269 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001270 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001271 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001272 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001273
1274 mDevice->triggerCancelAutofocus(triggerId);
1275
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001276 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001277}
1278
Ben Murdochff823702012-11-28 13:58:29 +00001279status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001280 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001281 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001282 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001283 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001284
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001285 int takePictureCounter;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001286 {
1287 SharedParameters::Lock l(mParameters);
1288 switch (l.mParameters.state) {
1289 case Parameters::DISCONNECTED:
1290 case Parameters::STOPPED:
1291 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1292 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001293 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001294 return INVALID_OPERATION;
1295 case Parameters::PREVIEW:
1296 // Good to go for takePicture
1297 res = commandStopFaceDetectionL(l.mParameters);
1298 if (res != OK) {
1299 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1300 __FUNCTION__, mCameraId);
1301 return res;
1302 }
1303 l.mParameters.state = Parameters::STILL_CAPTURE;
1304 break;
1305 case Parameters::RECORD:
1306 // Good to go for video snapshot
1307 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1308 break;
1309 case Parameters::STILL_CAPTURE:
1310 case Parameters::VIDEO_SNAPSHOT:
1311 ALOGE("%s: Camera %d: Already taking a picture",
1312 __FUNCTION__, mCameraId);
1313 return INVALID_OPERATION;
1314 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001315
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001316 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001317
Zhijun Hee2d83752014-06-23 10:22:37 -07001318 int lastJpegStreamId = mJpegProcessor->getStreamId();
Igor Murashkindca254a2013-05-13 14:53:44 -07001319 res = updateProcessorStream(mJpegProcessor, l.mParameters);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001320 if (res != OK) {
1321 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1322 __FUNCTION__, mCameraId, strerror(-res), res);
1323 return res;
1324 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001325 takePictureCounter = ++l.mParameters.takePictureCounter;
Zhijun Hee2d83752014-06-23 10:22:37 -07001326
1327 // Clear ZSL buffer queue when Jpeg size is changed.
1328 bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;
1329 if (l.mParameters.zslMode && jpegStreamChanged) {
1330 ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
1331 __FUNCTION__, mCameraId);
1332 mZslProcessor->clearZslQueue();
1333 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001334 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001335
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001336 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1337
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001338 // Need HAL to have correct settings before (possibly) triggering precapture
1339 syncWithDevice();
1340
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001341 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001342 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001343 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001344 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001345 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001346
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001347 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001348}
1349
1350status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001351 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001352 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001353 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001354 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001355 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1356
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001357 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001358
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001359 res = l.mParameters.set(params);
1360 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001361
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001362 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001363
1364 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001365}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001366
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001367String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001368 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001369 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001370 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinebe865b2014-08-07 17:07:28 -07001371 // The camera service can unconditionally get the parameters at all times
1372 if (getCallingPid() != mServicePid && checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001373
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001374 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001375
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001376 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001377}
1378
1379status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001380 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001381 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001382 status_t res;
1383 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001384
1385 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1386 cmd, arg1, arg2);
1387
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001388 switch (cmd) {
1389 case CAMERA_CMD_START_SMOOTH_ZOOM:
1390 return commandStartSmoothZoomL();
1391 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1392 return commandStopSmoothZoomL();
1393 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1394 return commandSetDisplayOrientationL(arg1);
1395 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1396 return commandEnableShutterSoundL(arg1 == 1);
1397 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1398 return commandPlayRecordingSoundL();
1399 case CAMERA_CMD_START_FACE_DETECTION:
1400 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001401 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001402 SharedParameters::Lock l(mParameters);
1403 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001404 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001405 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1406 return commandEnableFocusMoveMsgL(arg1 == 1);
1407 case CAMERA_CMD_PING:
1408 return commandPingL();
1409 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1410 return commandSetVideoBufferCountL(arg1);
1411 default:
1412 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1413 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001414 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001415 }
1416}
James Dong983cf232012-08-01 16:39:55 -07001417
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001418status_t Camera2Client::commandStartSmoothZoomL() {
1419 ALOGE("%s: Unimplemented!", __FUNCTION__);
1420 return OK;
1421}
James Dong983cf232012-08-01 16:39:55 -07001422
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001423status_t Camera2Client::commandStopSmoothZoomL() {
1424 ALOGE("%s: Unimplemented!", __FUNCTION__);
1425 return OK;
1426}
James Dong983cf232012-08-01 16:39:55 -07001427
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001428status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001429 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001430 mCameraFacing == CAMERA_FACING_FRONT);
1431 if (transform == -1) {
1432 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1433 __FUNCTION__, mCameraId, degrees);
1434 return BAD_VALUE;
1435 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001436 SharedParameters::Lock l(mParameters);
1437 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001438 getPreviewStreamId() != NO_STREAM) {
1439 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001440 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001441 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001442 return OK;
1443}
1444
1445status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001446 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001447 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001448 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001449 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001450 }
1451
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001452 // Disabling shutter sound may not be allowed. In that case only
1453 // allow the mediaserver process to disable the sound.
1454 char value[PROPERTY_VALUE_MAX];
1455 property_get("ro.camera.sound.forced", value, "0");
1456 if (strncmp(value, "0", 2) != 0) {
1457 // Disabling shutter sound is not allowed. Deny if the current
1458 // process is not mediaserver.
1459 if (getCallingPid() != getpid()) {
1460 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1461 getCallingPid());
1462 return PERMISSION_DENIED;
1463 }
1464 }
1465
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001466 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001467 return OK;
1468}
1469
1470status_t Camera2Client::commandPlayRecordingSoundL() {
1471 mCameraService->playSound(CameraService::SOUND_RECORDING);
1472 return OK;
1473}
1474
Igor Murashkinddf3c502012-10-12 16:56:11 -07001475status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001476 ALOGV("%s: Camera %d: Starting face detection",
1477 __FUNCTION__, mCameraId);
1478 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001479 SharedParameters::Lock l(mParameters);
1480 switch (l.mParameters.state) {
1481 case Parameters::DISCONNECTED:
1482 case Parameters::STOPPED:
1483 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1484 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001485 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1486 __FUNCTION__, mCameraId);
1487 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001488 case Parameters::PREVIEW:
1489 case Parameters::RECORD:
1490 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001491 // Good to go for starting face detect
1492 break;
1493 }
1494 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001495 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001496 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001497 ALOGE("%s: Camera %d: Face detection not supported",
1498 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001499 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001500 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001501 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001502
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001503 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001504
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001505 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001506
1507 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001508}
1509
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001510status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001511 status_t res = OK;
1512 ALOGV("%s: Camera %d: Stopping face detection",
1513 __FUNCTION__, mCameraId);
1514
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001515 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001516
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001517 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001518
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001519 if (params.state == Parameters::PREVIEW
1520 || params.state == Parameters::RECORD
1521 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001522 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001523 }
1524
1525 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001526}
1527
1528status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001529 SharedParameters::Lock l(mParameters);
1530 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001531
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001532 return OK;
1533}
1534
1535status_t Camera2Client::commandPingL() {
1536 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001537 SharedParameters::Lock l(mParameters);
1538 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001539 return OK;
1540 } else {
1541 return NO_INIT;
1542 }
1543}
1544
1545status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001546 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001547 ALOGE("%s: Camera %d: Error setting video buffer count after "
1548 "recording was started", __FUNCTION__, mCameraId);
1549 return INVALID_OPERATION;
1550 }
1551
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001552 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001553}
1554
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001555/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001556void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1557 ALOGV("%s: Autofocus state now %d, last trigger %d",
1558 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001559 bool sendCompletedMessage = false;
1560 bool sendMovingMessage = false;
1561
1562 bool success = false;
1563 bool afInMotion = false;
1564 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001565 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001566 // Trace end of AF state
1567 char tmp[32];
1568 if (l.mParameters.afStateCounter > 0) {
1569 camera_metadata_enum_snprint(
1570 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1571 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1572 }
1573
1574 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001575 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001576 l.mParameters.afStateCounter++;
1577
1578 // Trace start of AF state
1579
1580 camera_metadata_enum_snprint(
1581 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1582 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1583
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001584 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001585 case Parameters::FOCUS_MODE_AUTO:
1586 case Parameters::FOCUS_MODE_MACRO:
1587 // Don't send notifications upstream if they're not for the current AF
1588 // trigger. For example, if cancel was called in between, or if we
1589 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001590 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001591 switch (newState) {
1592 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1593 success = true;
1594 // no break
1595 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1596 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001597 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001598 break;
1599 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1600 // Just starting focusing, ignore
1601 break;
1602 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1603 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1604 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001605 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001606 default:
1607 // Unexpected in AUTO/MACRO mode
1608 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1609 __FUNCTION__, newState);
1610 break;
1611 }
1612 break;
1613 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1614 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1615 switch (newState) {
1616 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1617 success = true;
1618 // no break
1619 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1620 // Don't send notifications upstream if they're not for
1621 // the current AF trigger. For example, if cancel was
1622 // called in between, or if we already sent a
1623 // notification about this AF call.
1624 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001625 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001626 sendCompletedMessage = true;
1627 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001628 if (l.mParameters.enableFocusMoveMessages &&
1629 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001630 sendMovingMessage = true;
1631 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001632 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001633 break;
1634 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1635 // Cancel was called, or we switched state; care if
1636 // currently moving
1637 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001638 if (l.mParameters.enableFocusMoveMessages &&
1639 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001640 sendMovingMessage = true;
1641 }
1642 break;
1643 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1644 // Start passive scan, inform upstream
1645 afInMotion = true;
1646 // no break
1647 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001648 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001649 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001650 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001651 sendMovingMessage = true;
1652 }
1653 break;
1654 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001655 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001656 break;
1657 case Parameters::FOCUS_MODE_EDOF:
1658 case Parameters::FOCUS_MODE_INFINITY:
1659 case Parameters::FOCUS_MODE_FIXED:
1660 default:
1661 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001662 ALOGE("%s: Unexpected AF state change %d "
1663 "(ID %d) in focus mode %d",
1664 __FUNCTION__, newState, triggerId,
1665 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001666 }
1667 }
1668 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001669 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001670 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1671 if (l.mRemoteCallback != 0) {
1672 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001673 afInMotion ? 1 : 0, 0);
1674 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001675 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001676 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001677 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001678 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1679 if (l.mRemoteCallback != 0) {
1680 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001681 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001682 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001683 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001684}
1685
1686void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1687 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1688 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001689 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001690}
1691
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001692camera2::SharedParameters& Camera2Client::getParameters() {
1693 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001694}
1695
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001696int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001697 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001698}
1699
1700int Camera2Client::getCaptureStreamId() const {
1701 return mJpegProcessor->getStreamId();
1702}
1703
1704int Camera2Client::getCallbackStreamId() const {
1705 return mCallbackProcessor->getStreamId();
1706}
1707
1708int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001709 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001710}
1711
1712int Camera2Client::getZslStreamId() const {
1713 return mZslProcessor->getStreamId();
1714}
1715
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001716status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Zhijun He25a0aef2014-06-25 11:40:02 -07001717 wp<camera2::FrameProcessor::FilteredListener> listener, bool sendPartials) {
1718 return mFrameProcessor->registerListener(minId, maxId, listener, sendPartials);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001719}
1720
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001721status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1722 wp<camera2::FrameProcessor::FilteredListener> listener) {
1723 return mFrameProcessor->removeListener(minId, maxId, listener);
1724}
1725
1726status_t Camera2Client::stopStream() {
1727 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001728}
1729
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001730const int32_t Camera2Client::kPreviewRequestIdStart;
1731const int32_t Camera2Client::kPreviewRequestIdEnd;
1732const int32_t Camera2Client::kRecordingRequestIdStart;
1733const int32_t Camera2Client::kRecordingRequestIdEnd;
1734const int32_t Camera2Client::kCaptureRequestIdStart;
1735const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001736
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001737/** Utility methods */
1738
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001739status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001740 status_t res;
1741
Igor Murashkin22d58d32012-10-02 19:07:14 -07001742 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1743
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001744 res = mStreamingProcessor->incrementStreamingIds();
1745 if (res != OK) {
1746 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1747 __FUNCTION__, mCameraId, strerror(-res), res);
1748 return res;
1749 }
1750
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001751 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001752 if (res != OK) {
1753 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1754 __FUNCTION__, mCameraId, strerror(-res), res);
1755 return res;
1756 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001757 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001758 if (res != OK) {
1759 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1760 __FUNCTION__, mCameraId, strerror(-res), res);
1761 return res;
1762 }
1763
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001764 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001765 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001766 if (res != OK) {
1767 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1768 __FUNCTION__, mCameraId, strerror(-res), res);
1769 return res;
1770 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001771 } else if (params.state == Parameters::RECORD ||
1772 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001773 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001774 if (res != OK) {
1775 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1776 __FUNCTION__, mCameraId, strerror(-res), res);
1777 return res;
1778 }
1779 }
1780 return res;
1781}
1782
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001783
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001784size_t Camera2Client::calculateBufferSize(int width, int height,
1785 int format, int stride) {
1786 switch (format) {
1787 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1788 return width * height * 2;
1789 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1790 return width * height * 3 / 2;
1791 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1792 return width * height * 2;
1793 case HAL_PIXEL_FORMAT_YV12: { // YV12
1794 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001795 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001796 size_t uvSize = uvStride * height / 2;
1797 return ySize + uvSize * 2;
1798 }
1799 case HAL_PIXEL_FORMAT_RGB_565:
1800 return width * height * 2;
1801 case HAL_PIXEL_FORMAT_RGBA_8888:
1802 return width * height * 4;
1803 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1804 return width * height * 2;
1805 default:
1806 ALOGE("%s: Unknown preview format: %x",
1807 __FUNCTION__, format);
1808 return 0;
1809 }
1810}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001811
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001812status_t Camera2Client::syncWithDevice() {
1813 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07001814 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001815 status_t res;
1816
1817 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1818 if (activeRequestId == 0) return OK;
1819
1820 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1821 if (res == TIMED_OUT) {
1822 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1823 __FUNCTION__, mCameraId);
1824 } else if (res != OK) {
1825 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1826 __FUNCTION__, mCameraId);
1827 }
1828 return res;
1829}
1830
Igor Murashkindca254a2013-05-13 14:53:44 -07001831template <typename ProcessorT>
1832status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1833 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07001834 // No default template arguments until C++11, so we need this overload
1835 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1836 processor, params);
1837}
1838
1839template <typename ProcessorT,
1840 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
1841status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1842 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07001843 status_t res;
1844
Igor Murashkin82db9e62013-05-21 11:38:49 -07001845 // Get raw pointer since sp<T> doesn't have operator->*
1846 ProcessorT *processorPtr = processor.get();
1847 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07001848
1849 /**
1850 * Can't update the stream if it's busy?
1851 *
1852 * Then we need to stop the device (by temporarily clearing the request
1853 * queue) and then try again. Resume streaming once we're done.
1854 */
1855 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001856 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
1857 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07001858 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1859 if (res != OK) {
1860 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1861 __FUNCTION__, mCameraId, strerror(-res), res);
1862 }
1863
1864 res = mDevice->waitUntilDrained();
1865 if (res != OK) {
1866 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1867 __FUNCTION__, mCameraId, strerror(-res), res);
1868 }
1869
Igor Murashkin82db9e62013-05-21 11:38:49 -07001870 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07001871 if (res != OK) {
1872 ALOGE("%s: Camera %d: Failed to update processing stream "
1873 " despite having halted streaming first: %s (%d)",
1874 __FUNCTION__, mCameraId, strerror(-res), res);
1875 }
1876
1877 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1878 if (res != OK) {
1879 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1880 __FUNCTION__, mCameraId, strerror(-res), res);
1881 }
1882 }
1883
1884 return res;
1885}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001886
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001887const char* Camera2Client::kAutofocusLabel = "autofocus";
1888const char* Camera2Client::kTakepictureLabel = "take_picture";
1889
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001890} // namespace android