blob: 0447979008ec944e239456e17e9a511a257563c1 [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,
Eino-Ville Talvalab99c5b82013-02-06 17:20:07 -080056 int servicePid,
57 int deviceVersion):
Igor Murashkin44cfcf02013-03-01 16:22:28 -080058 Camera2ClientBase(cameraService, cameraClient, clientPackageName,
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080059 cameraId, cameraFacing, clientPid, clientUid, servicePid),
Igor Murashkinae500e52013-04-22 14:03:54 -070060 mParameters(cameraId, cameraFacing),
61 mDeviceVersion(deviceVersion)
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070062{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070063 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -070064
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070065 SharedParameters::Lock l(mParameters);
66 l.mParameters.state = Parameters::DISCONNECTED;
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070067}
68
69status_t Camera2Client::initialize(camera_module_t *module)
70{
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -070071 ATRACE_CALL();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -070072 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070073 status_t res;
74
Igor Murashkine6800ce2013-03-04 17:25:57 -080075 res = Camera2ClientBase::initialize(module);
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -080076 if (res != OK) {
77 return res;
78 }
79
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070080 {
81 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -070082
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -070083 res = l.mParameters.initialize(&(mDevice->info()));
84 if (res != OK) {
85 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
86 __FUNCTION__, mCameraId, strerror(-res), res);
87 return NO_INIT;
88 }
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -070089 }
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -070090
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -070091 String8 threadName;
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -070092
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070093 mStreamingProcessor = new StreamingProcessor(this);
Eino-Ville Talvala254446a2013-06-04 16:34:35 -070094 threadName = String8::format("C2-%d-StreamProc",
95 mCameraId);
96 mStreamingProcessor->run(threadName.string());
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -070097
Igor Murashkince124da2013-03-04 14:53:08 -080098 mFrameProcessor = new FrameProcessor(mDevice, this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -070099 threadName = String8::format("C2-%d-FrameProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700100 mCameraId);
101 mFrameProcessor->run(threadName.string());
102
103 mCaptureSequencer = new CaptureSequencer(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700104 threadName = String8::format("C2-%d-CaptureSeq",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700105 mCameraId);
106 mCaptureSequencer->run(threadName.string());
107
108 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700109 threadName = String8::format("C2-%d-JpegProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700110 mCameraId);
111 mJpegProcessor->run(threadName.string());
112
Igor Murashkinae500e52013-04-22 14:03:54 -0700113 switch (mDeviceVersion) {
114 case CAMERA_DEVICE_API_VERSION_2_0: {
115 sp<ZslProcessor> zslProc =
116 new ZslProcessor(this, mCaptureSequencer);
117 mZslProcessor = zslProc;
118 mZslProcessorThread = zslProc;
119 break;
120 }
Zhijun He95dd5ba2014-03-26 18:18:00 -0700121 case CAMERA_DEVICE_API_VERSION_3_0:
122 case CAMERA_DEVICE_API_VERSION_3_1:
123 case CAMERA_DEVICE_API_VERSION_3_2: {
Igor Murashkinae500e52013-04-22 14:03:54 -0700124 sp<ZslProcessor3> zslProc =
125 new ZslProcessor3(this, mCaptureSequencer);
126 mZslProcessor = zslProc;
127 mZslProcessorThread = zslProc;
128 break;
129 }
130 default:
131 break;
132 }
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700133 threadName = String8::format("C2-%d-ZslProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700134 mCameraId);
Igor Murashkinae500e52013-04-22 14:03:54 -0700135 mZslProcessorThread->run(threadName.string());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700136
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700137 mCallbackProcessor = new CallbackProcessor(this);
Eino-Ville Talvala4bb81182012-09-24 09:46:53 -0700138 threadName = String8::format("C2-%d-CallbkProc",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700139 mCameraId);
140 mCallbackProcessor->run(threadName.string());
Eino-Ville Talvalad86a6882012-08-28 11:34:14 -0700141
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700142 if (gLogLevel >= 1) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700143 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700144 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
145 mCameraId);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700146 ALOGD("%s", l.mParameters.paramsFlattened.string());
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700147 }
148
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700149 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700150}
151
152Camera2Client::~Camera2Client() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700153 ATRACE_CALL();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700154 ALOGV("~Camera2Client");
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700155
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700156 mDestructionStarted = true;
157
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700158 disconnect();
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700159
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700160 ALOGI("Camera %d: Closed", mCameraId);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700161}
162
163status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700164 String8 result;
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700165 result.appendFormat("Client2[%d] (%p) Client: %s PID: %d, dump:\n",
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700166 mCameraId,
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800167 getRemoteCallback()->asBinder().get(),
Eino-Ville Talvalad0158c32013-03-11 14:13:50 -0700168 String8(mClientPackageName).string(),
Eino-Ville Talvala611f6192012-05-31 12:28:23 -0700169 mClientPid);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700170 result.append(" State: ");
171#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
172
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700173 const Parameters& p = mParameters.unsafeAccess();
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700174
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700175 result.append(Parameters::getStateName(p.state));
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700176
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700177 result.append("\n Current parameters:\n");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700178 result.appendFormat(" Preview size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700179 p.previewWidth, p.previewHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700180 result.appendFormat(" Preview FPS range: %d - %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700181 p.previewFpsRange[0], p.previewFpsRange[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700182 result.appendFormat(" Preview HAL pixel format: 0x%x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700183 p.previewFormat);
Eino-Ville Talvala11b7cde2012-06-15 12:37:35 -0700184 result.appendFormat(" Preview transform: %x\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700185 p.previewTransform);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700186 result.appendFormat(" Picture size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700187 p.pictureWidth, p.pictureHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700188 result.appendFormat(" Jpeg thumbnail size: %d x %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700189 p.jpegThumbSize[0], p.jpegThumbSize[1]);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700190 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700191 p.jpegQuality, p.jpegThumbQuality);
192 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700193 result.appendFormat(" GPS tags %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700194 p.gpsEnabled ? "enabled" : "disabled");
195 if (p.gpsEnabled) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700196 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700197 p.gpsCoordinates[0], p.gpsCoordinates[1],
198 p.gpsCoordinates[2]);
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000199 result.appendFormat(" GPS timestamp: %" PRId64 "\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700200 p.gpsTimestamp);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700201 result.appendFormat(" GPS processing method: %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700202 p.gpsProcessingMethod.string());
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700203 }
204
205 result.append(" White balance mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700206 switch (p.wbMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800207 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_AUTO)
208 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_INCANDESCENT)
209 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_FLUORESCENT)
210 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT)
211 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_DAYLIGHT)
212 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT)
213 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_TWILIGHT)
214 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_MODE_SHADE)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700215 default: result.append("UNKNOWN\n");
216 }
217
218 result.append(" Effect mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700219 switch (p.effectMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800220 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_OFF)
221 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_MONO)
222 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_NEGATIVE)
223 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SOLARIZE)
224 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_SEPIA)
225 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_POSTERIZE)
226 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD)
227 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD)
228 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MODE_AQUA)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700229 default: result.append("UNKNOWN\n");
230 }
231
232 result.append(" Antibanding mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700233 switch (p.antibandingMode) {
Igor Murashkind32b99b2012-11-27 16:25:46 -0800234 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO)
235 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF)
236 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ)
237 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ)
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700238 default: result.append("UNKNOWN\n");
239 }
240
241 result.append(" Scene mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700242 switch (p.sceneMode) {
Ruben Brunkc69b91c2014-01-17 17:12:10 -0800243 case ANDROID_CONTROL_SCENE_MODE_DISABLED:
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700244 result.append("AUTO\n"); break;
245 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
246 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
247 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
248 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
249 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
250 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
251 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
252 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
253 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
254 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
255 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
256 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
257 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
258 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
259 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
260 default: result.append("UNKNOWN\n");
261 }
262
263 result.append(" Flash mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700264 switch (p.flashMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700265 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
266 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
267 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
268 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
269 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
270 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
271 default: result.append("UNKNOWN\n");
272 }
273
274 result.append(" Focus mode: ");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700275 switch (p.focusMode) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700276 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
277 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
278 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
279 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
280 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
281 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
282 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
283 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
284 default: result.append("UNKNOWN\n");
285 }
286
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700287 result.append(" Focus state: ");
288 switch (p.focusState) {
289 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE)
290 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)
291 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -0700292 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED)
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -0700293 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN)
294 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED)
295 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED)
296 default: result.append("UNKNOWN\n");
297 }
298
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700299 result.append(" Focusing areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700300 for (size_t i = 0; i < p.focusingAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700301 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700302 p.focusingAreas[i].left,
303 p.focusingAreas[i].top,
304 p.focusingAreas[i].right,
305 p.focusingAreas[i].bottom,
306 p.focusingAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700307 }
308
309 result.appendFormat(" Exposure compensation index: %d\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700310 p.exposureCompensation);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700311
312 result.appendFormat(" AE lock %s, AWB lock %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700313 p.autoExposureLock ? "enabled" : "disabled",
314 p.autoWhiteBalanceLock ? "enabled" : "disabled" );
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700315
316 result.appendFormat(" Metering areas:\n");
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700317 for (size_t i = 0; i < p.meteringAreas.size(); i++) {
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700318 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700319 p.meteringAreas[i].left,
320 p.meteringAreas[i].top,
321 p.meteringAreas[i].right,
322 p.meteringAreas[i].bottom,
323 p.meteringAreas[i].weight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700324 }
325
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700326 result.appendFormat(" Zoom index: %d\n", p.zoom);
327 result.appendFormat(" Video size: %d x %d\n", p.videoWidth,
328 p.videoHeight);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700329
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700330 result.appendFormat(" Recording hint is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700331 p.recordingHint ? "set" : "not set");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700332
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700333 result.appendFormat(" Video stabilization is %s\n",
Eino-Ville Talvala836b81f2012-07-27 11:35:21 -0700334 p.videoStabilization ? "enabled" : "disabled");
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700335
Eino-Ville Talvala0181fde2013-09-20 10:12:32 -0700336 result.appendFormat(" Selected still capture FPS range: %d - %d\n",
337 p.fastInfo.bestStillCaptureFpsRange[0],
338 p.fastInfo.bestStillCaptureFpsRange[1]);
339
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700340 result.append(" Current streams:\n");
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700341 result.appendFormat(" Preview stream ID: %d\n",
342 getPreviewStreamId());
Eino-Ville Talvalaea0d51b2012-08-28 01:25:43 -0700343 result.appendFormat(" Capture stream ID: %d\n",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700344 getCaptureStreamId());
345 result.appendFormat(" Recording stream ID: %d\n",
346 getRecordingStreamId());
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700347
348 result.append(" Quirks for this camera:\n");
349 bool haveQuirk = false;
350 if (p.quirks.triggerAfWithAuto) {
351 result.appendFormat(" triggerAfWithAuto\n");
352 haveQuirk = true;
353 }
354 if (p.quirks.useZslFormat) {
355 result.appendFormat(" useZslFormat\n");
356 haveQuirk = true;
357 }
Igor Murashkin7373cbe2012-09-28 15:30:03 -0700358 if (p.quirks.meteringCropRegion) {
359 result.appendFormat(" meteringCropRegion\n");
360 haveQuirk = true;
361 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700362 if (p.quirks.partialResults) {
363 result.appendFormat(" usePartialResult\n");
364 haveQuirk = true;
365 }
Eino-Ville Talvalae382ee22012-10-02 18:14:49 -0700366 if (!haveQuirk) {
367 result.appendFormat(" none\n");
368 }
369
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700370 write(fd, result.string(), result.size());
Eino-Ville Talvala3297daa2012-06-14 10:49:45 -0700371
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700372 mStreamingProcessor->dump(fd, args);
Eino-Ville Talvala428b77a2012-07-30 09:55:30 -0700373
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700374 mCaptureSequencer->dump(fd, args);
375
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -0700376 mFrameProcessor->dump(fd, args);
377
Eino-Ville Talvala97b38a82012-09-17 17:55:07 -0700378 mZslProcessor->dump(fd, args);
379
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800380 return dumpDevice(fd, args);
Eino-Ville Talvala7f610842012-06-07 10:20:51 -0700381#undef CASE_APPEND_ENUM
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700382}
383
384// ICamera interface
385
386void Camera2Client::disconnect() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700387 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800388 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700389
390 // Allow both client and the media server to disconnect at all times
391 int callingPid = getCallingPid();
392 if (callingPid != mClientPid && callingPid != mServicePid) return;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700393
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -0700394 if (mDevice == 0) return;
395
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700396 ALOGV("Camera %d: Shutting down", mCameraId);
397
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700398 /**
399 * disconnect() cannot call any methods that might need to promote a
400 * wp<Camera2Client>, since disconnect can be called from the destructor, at
401 * which point all such promotions will fail.
402 */
403
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700404 stopPreviewL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700405
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700406 {
407 SharedParameters::Lock l(mParameters);
Eino-Ville Talvalac0379202012-10-09 22:16:58 -0700408 if (l.mParameters.state == Parameters::DISCONNECTED) return;
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700409 l.mParameters.state = Parameters::DISCONNECTED;
410 }
411
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700412 mStreamingProcessor->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700413 mFrameProcessor->requestExit();
414 mCaptureSequencer->requestExit();
415 mJpegProcessor->requestExit();
Igor Murashkinae500e52013-04-22 14:03:54 -0700416 mZslProcessorThread->requestExit();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700417 mCallbackProcessor->requestExit();
418
419 ALOGV("Camera %d: Waiting for threads", mCameraId);
420
Eino-Ville Talvala254446a2013-06-04 16:34:35 -0700421 mStreamingProcessor->join();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700422 mFrameProcessor->join();
423 mCaptureSequencer->join();
424 mJpegProcessor->join();
Igor Murashkinae500e52013-04-22 14:03:54 -0700425 mZslProcessorThread->join();
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700426 mCallbackProcessor->join();
427
Ruben Brunkdfe71552013-12-05 11:00:37 -0800428 ALOGV("Camera %d: Deleting streams", mCameraId);
429
430 mStreamingProcessor->deletePreviewStream();
431 mStreamingProcessor->deleteRecordingStream();
432 mJpegProcessor->deleteStream();
433 mCallbackProcessor->deleteStream();
434 mZslProcessor->deleteStream();
435
Eino-Ville Talvala98bb82d2012-09-20 14:44:20 -0700436 ALOGV("Camera %d: Disconnecting device", mCameraId);
437
438 mDevice->disconnect();
439
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700440 mDevice.clear();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700441
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700442 CameraService::Client::disconnect();
443}
444
445status_t Camera2Client::connect(const sp<ICameraClient>& client) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700446 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700447 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800448 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700449
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700450 if (mClientPid != 0 && getCallingPid() != mClientPid) {
451 ALOGE("%s: Camera %d: Connection attempt from pid %d; "
452 "current locked to pid %d", __FUNCTION__,
453 mCameraId, getCallingPid(), mClientPid);
454 return BAD_VALUE;
455 }
456
457 mClientPid = getCallingPid();
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -0700458
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800459 mRemoteCallback = client;
460 mSharedCameraCallbacks = client;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700461
462 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700463}
464
465status_t Camera2Client::lock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700466 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700467 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800468 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700469 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
470 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700471
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700472 if (mClientPid == 0) {
473 mClientPid = getCallingPid();
474 return OK;
475 }
476
477 if (mClientPid != getCallingPid()) {
478 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
479 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
480 return EBUSY;
481 }
482
483 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700484}
485
486status_t Camera2Client::unlock() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700487 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700488 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800489 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700490 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
491 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700492
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700493 if (mClientPid == getCallingPid()) {
Eino-Ville Talvala907e5652012-10-10 15:28:53 -0700494 SharedParameters::Lock l(mParameters);
495 if (l.mParameters.state == Parameters::RECORD ||
496 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
497 ALOGD("Not allowed to unlock camera during recording.");
498 return INVALID_OPERATION;
499 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700500 mClientPid = 0;
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800501 mRemoteCallback.clear();
502 mSharedCameraCallbacks.clear();
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700503 return OK;
504 }
505
506 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
507 __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
508 return EBUSY;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700509}
510
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700511status_t Camera2Client::setPreviewTarget(
Andy McFadden8ba01022012-12-18 09:46:54 -0800512 const sp<IGraphicBufferProducer>& bufferProducer) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700513 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700514 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800515 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700516 status_t res;
517 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700518
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700519 sp<IBinder> binder;
520 sp<ANativeWindow> window;
Andy McFadden8ba01022012-12-18 09:46:54 -0800521 if (bufferProducer != 0) {
522 binder = bufferProducer->asBinder();
Eino-Ville Talvala1ce7c342013-08-21 13:57:21 -0700523 // Using controlledByApp flag to ensure that the buffer queue remains in
524 // async mode for the old camera API, where many applications depend
525 // on that behavior.
526 window = new Surface(bufferProducer, /*controlledByApp*/ true);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700527 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700528 return setPreviewWindowL(binder, window);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700529}
530
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700531status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700532 sp<ANativeWindow> window) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700533 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700534 status_t res;
535
536 if (binder == mPreviewSurface) {
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700537 ALOGV("%s: Camera %d: New window is same as old window",
538 __FUNCTION__, mCameraId);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700539 return NO_ERROR;
540 }
541
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700542 Parameters::State state;
543 {
544 SharedParameters::Lock l(mParameters);
545 state = l.mParameters.state;
546 }
547 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700548 case Parameters::DISCONNECTED:
549 case Parameters::RECORD:
550 case Parameters::STILL_CAPTURE:
551 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700552 ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700553 __FUNCTION__, mCameraId,
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700554 Parameters::getStateName(state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700555 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700556 case Parameters::STOPPED:
557 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700558 // OK
559 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700560 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700561 // Already running preview - need to stop and create a new stream
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700562 res = stopStream();
563 if (res != OK) {
564 ALOGE("%s: Unable to stop preview to swap windows: %s (%d)",
565 __FUNCTION__, strerror(-res), res);
566 return res;
567 }
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700568 state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700569 break;
570 }
571
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700572 mPreviewSurface = binder;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700573 res = mStreamingProcessor->setPreviewWindow(window);
574 if (res != OK) {
575 ALOGE("%s: Unable to set new preview window: %s (%d)",
576 __FUNCTION__, strerror(-res), res);
577 return res;
578 }
Eino-Ville Talvalabd47b7b2012-06-07 10:34:20 -0700579
Eino-Ville Talvalaf1945f02012-10-17 16:32:34 -0700580 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) {
581 SharedParameters::Lock l(mParameters);
582 l.mParameters.state = state;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700583 return startPreviewL(l.mParameters, false);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700584 }
585
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700586 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700587}
588
589void Camera2Client::setPreviewCallbackFlag(int flag) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700590 ATRACE_CALL();
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700591 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800592 Mutex::Autolock icl(mBinderSerializationLock);
Igor Murashkinddf3c502012-10-12 16:56:11 -0700593
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700594 if ( checkPid(__FUNCTION__) != OK) return;
595
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700596 SharedParameters::Lock l(mParameters);
597 setPreviewCallbackFlagL(l.mParameters, flag);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700598}
599
600void Camera2Client::setPreviewCallbackFlagL(Parameters &params, int flag) {
601 status_t res = OK;
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700602
603 switch(params.state) {
604 case Parameters::STOPPED:
605 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
606 case Parameters::PREVIEW:
Zhijun Hea2520db2013-07-08 16:12:32 -0700607 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700608 // OK
609 break;
610 default:
611 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
612 ALOGE("%s: Camera %d: Can't use preview callbacks "
613 "in state %d", __FUNCTION__, mCameraId, params.state);
614 return;
615 }
616 }
617
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700618 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) {
619 ALOGV("%s: setting oneshot", __FUNCTION__);
620 params.previewCallbackOneShot = true;
621 }
622 if (params.previewCallbackFlags != (uint32_t)flag) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700623
Zhijun He527748a2013-09-15 21:06:10 -0700624 if (params.previewCallbackSurface && flag != CAMERA_FRAME_CALLBACK_FLAG_NOOP) {
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700625 // Disable any existing preview callback window when enabling
626 // preview callback flags
627 res = mCallbackProcessor->setCallbackWindow(NULL);
628 if (res != OK) {
629 ALOGE("%s: Camera %d: Unable to clear preview callback surface:"
630 " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
631 return;
632 }
633 params.previewCallbackSurface = false;
634 }
635
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700636 params.previewCallbackFlags = flag;
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700637
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700638 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700639 res = startPreviewL(params, true);
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -0700640 if (res != OK) {
641 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
642 __FUNCTION__, mCameraId,
643 Parameters::getStateName(params.state));
644 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700645 }
646 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700647}
648
Eino-Ville Talvala3ee35502013-04-02 15:45:11 -0700649status_t Camera2Client::setPreviewCallbackTarget(
650 const sp<IGraphicBufferProducer>& callbackProducer) {
651 ATRACE_CALL();
652 ALOGV("%s: E", __FUNCTION__);
653 Mutex::Autolock icl(mBinderSerializationLock);
654 status_t res;
655 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
656
657 sp<ANativeWindow> window;
658 if (callbackProducer != 0) {
659 window = new Surface(callbackProducer);
660 }
661
662 res = mCallbackProcessor->setCallbackWindow(window);
663 if (res != OK) {
664 ALOGE("%s: Camera %d: Unable to set preview callback surface: %s (%d)",
665 __FUNCTION__, mCameraId, strerror(-res), res);
666 return res;
667 }
668
669 SharedParameters::Lock l(mParameters);
670
671 if (window != NULL) {
672 // Disable traditional callbacks when a valid callback target is given
673 l.mParameters.previewCallbackFlags = CAMERA_FRAME_CALLBACK_FLAG_NOOP;
674 l.mParameters.previewCallbackOneShot = false;
675 l.mParameters.previewCallbackSurface = true;
676 } else {
677 // Disable callback target if given a NULL interface.
678 l.mParameters.previewCallbackSurface = false;
679 }
680
681 switch(l.mParameters.state) {
682 case Parameters::PREVIEW:
683 res = startPreviewL(l.mParameters, true);
684 break;
685 case Parameters::RECORD:
686 case Parameters::VIDEO_SNAPSHOT:
687 res = startRecordingL(l.mParameters, true);
688 break;
689 default:
690 break;
691 }
692 if (res != OK) {
693 ALOGE("%s: Camera %d: Unable to refresh request in state %s",
694 __FUNCTION__, mCameraId,
695 Parameters::getStateName(l.mParameters.state));
696 }
697
698 return OK;
699}
700
701
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700702status_t Camera2Client::startPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700703 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700704 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800705 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700706 status_t res;
707 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700708 SharedParameters::Lock l(mParameters);
709 return startPreviewL(l.mParameters, false);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700710}
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700711
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700712status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700713 ATRACE_CALL();
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700714 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700715
716 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
717
Eino-Ville Talvalaa14be592012-10-10 17:17:01 -0700718 if ( (params.state == Parameters::PREVIEW ||
719 params.state == Parameters::RECORD ||
720 params.state == Parameters::VIDEO_SNAPSHOT)
721 && !restart) {
722 // Succeed attempt to re-enter a streaming state
723 ALOGI("%s: Camera %d: Preview already active, ignoring restart",
724 __FUNCTION__, mCameraId);
Alex Ray77449ad2012-09-26 15:52:50 -0700725 return OK;
726 }
727 if (params.state > Parameters::PREVIEW && !restart) {
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700728 ALOGE("%s: Can't start preview in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700729 __FUNCTION__,
730 Parameters::getStateName(params.state));
Eino-Ville Talvala4ecfec32012-06-12 17:13:48 -0700731 return INVALID_OPERATION;
732 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700733
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700734 if (!mStreamingProcessor->haveValidPreviewWindow()) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700735 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700736 return OK;
737 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700738 params.state = Parameters::STOPPED;
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800739 int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700740
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700741 res = mStreamingProcessor->updatePreviewStream(params);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700742 if (res != OK) {
743 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
744 __FUNCTION__, mCameraId, strerror(-res), res);
745 return res;
746 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700747
Zhijun Hec1b7cc42014-01-21 12:15:56 -0800748 bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;
749
Eino-Ville Talvalaa9c64a92013-06-10 15:12:01 -0700750 // We could wait to create the JPEG output stream until first actual use
751 // (first takePicture call). However, this would substantially increase the
752 // first capture latency on HAL3 devices, and potentially on some HAL2
753 // devices. So create it unconditionally at preview start. As a drawback,
754 // this increases gralloc memory consumption for applications that don't
755 // ever take a picture.
756 // TODO: Find a better compromise, though this likely would involve HAL
757 // changes.
758 res = updateProcessorStream(mJpegProcessor, params);
759 if (res != OK) {
760 ALOGE("%s: Camera %d: Can't pre-configure still image "
761 "stream: %s (%d)",
762 __FUNCTION__, mCameraId, strerror(-res), res);
763 return res;
764 }
765
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 }
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700813 if (params.zslMode && !params.recordingHint) {
Igor Murashkindca254a2013-05-13 14:53:44 -0700814 res = updateProcessorStream(mZslProcessor, params);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700815 if (res != OK) {
816 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
817 __FUNCTION__, mCameraId, strerror(-res), res);
818 return res;
819 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700820 outputStreams.push(getZslStreamId());
Zhijun He66107622013-11-01 11:05:56 -0700821 } else {
822 mZslProcessor->deleteStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -0700823 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700824
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700825 outputStreams.push(getPreviewStreamId());
826
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700827 if (!params.recordingHint) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700828 if (!restart) {
829 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700830 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700831 ALOGE("%s: Camera %d: Can't set up preview request: "
832 "%s (%d)", __FUNCTION__, mCameraId,
833 strerror(-res), res);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700834 return res;
835 }
836 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700837 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
838 outputStreams);
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -0700839 } else {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700840 if (!restart) {
841 res = mStreamingProcessor->updateRecordingRequest(params);
842 if (res != OK) {
843 ALOGE("%s: Camera %d: Can't set up preview request with "
844 "record hint: %s (%d)", __FUNCTION__, mCameraId,
845 strerror(-res), res);
846 return res;
847 }
848 }
849 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
850 outputStreams);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700851 }
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700852 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700853 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -0700854 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700855 return res;
856 }
857
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700858 params.state = Parameters::PREVIEW;
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -0700859 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700860}
861
862void Camera2Client::stopPreview() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700863 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700864 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800865 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700866 status_t res;
867 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700868 stopPreviewL();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700869}
870
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -0700871void Camera2Client::stopPreviewL() {
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -0700872 ATRACE_CALL();
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700873 status_t res;
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700874 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700875 Parameters::State state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700876 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700877 SharedParameters::Lock l(mParameters);
878 state = l.mParameters.state;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700879 }
880
881 switch (state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700882 case Parameters::DISCONNECTED:
Eino-Ville Talvalaceb388d2013-02-19 10:40:14 -0800883 // Nothing to do.
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700884 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700885 case Parameters::STOPPED:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700886 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700887 case Parameters::STILL_CAPTURE:
Eino-Ville Talvalad5087f92012-10-05 12:03:10 -0700888 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout);
889 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700890 case Parameters::RECORD:
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700891 case Parameters::PREVIEW:
Ruben Brunka27c4aa2013-09-04 18:18:26 -0700892 syncWithDevice();
Eino-Ville Talvalad09801b2013-04-23 15:16:57 -0700893 res = stopStream();
894 if (res != OK) {
895 ALOGE("%s: Camera %d: Can't stop streaming: %s (%d)",
896 __FUNCTION__, mCameraId, strerror(-res), res);
897 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -0700898 res = mDevice->waitUntilDrained();
899 if (res != OK) {
900 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
901 __FUNCTION__, mCameraId, strerror(-res), res);
902 }
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700903 // no break
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700904 case Parameters::WAITING_FOR_PREVIEW_WINDOW: {
905 SharedParameters::Lock l(mParameters);
906 l.mParameters.state = Parameters::STOPPED;
907 commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700908 break;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700909 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700910 default:
911 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700912 state);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -0700913 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700914}
915
916bool Camera2Client::previewEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700917 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800918 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700919 status_t res;
920 if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
921
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700922 SharedParameters::Lock l(mParameters);
923 return l.mParameters.state == Parameters::PREVIEW;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700924}
925
926status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700927 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800928 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700929 status_t res;
930 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
931
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700932 SharedParameters::Lock l(mParameters);
933 switch (l.mParameters.state) {
934 case Parameters::RECORD:
935 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700936 ALOGE("%s: Camera %d: Can't be called in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700937 __FUNCTION__, mCameraId,
938 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700939 return INVALID_OPERATION;
940 default:
941 // OK
942 break;
943 }
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700944
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700945 l.mParameters.storeMetadataInBuffers = enabled;
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700946
947 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -0700948}
949
950status_t Camera2Client::startRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -0700951 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -0700952 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -0800953 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700954 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700955 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700956 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -0700957
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700958 return startRecordingL(l.mParameters, false);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700959}
960
961status_t Camera2Client::startRecordingL(Parameters &params, bool restart) {
962 status_t res;
Igor Murashkin22d58d32012-10-02 19:07:14 -0700963
964 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);
965
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700966 switch (params.state) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700967 case Parameters::STOPPED:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700968 res = startPreviewL(params, false);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700969 if (res != OK) return res;
970 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700971 case Parameters::PREVIEW:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700972 // Ready to go
973 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700974 case Parameters::RECORD:
975 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700976 // OK to call this when recording is already on, just skip unless
977 // we're looking to restart
978 if (!restart) return OK;
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700979 break;
980 default:
981 ALOGE("%s: Camera %d: Can't start recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -0700982 __FUNCTION__, mCameraId,
983 Parameters::getStateName(params.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -0700984 return INVALID_OPERATION;
985 };
986
Eino-Ville Talvala228a5382012-08-13 12:16:06 -0700987 if (!params.storeMetadataInBuffers) {
Eino-Ville Talvala78822d72012-07-18 17:52:18 -0700988 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
989 "non-metadata recording mode requested!", __FUNCTION__,
990 mCameraId);
991 return INVALID_OPERATION;
992 }
993
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -0700994 if (!restart) {
995 mCameraService->playSound(CameraService::SOUND_RECORDING);
996 mStreamingProcessor->updateRecordingRequest(params);
997 if (res != OK) {
998 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
999 __FUNCTION__, mCameraId, strerror(-res), res);
1000 return res;
1001 }
1002 }
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001003
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001004 // Not all devices can support a preview callback stream and a recording
1005 // stream at the same time, so assume none of them can.
1006 if (mCallbackProcessor->getStreamId() != NO_STREAM) {
1007 ALOGV("%s: Camera %d: Clearing out callback stream before "
1008 "creating recording stream", __FUNCTION__, mCameraId);
1009 res = mStreamingProcessor->stopStream();
1010 if (res != OK) {
1011 ALOGE("%s: Camera %d: Can't stop streaming to delete callback stream",
1012 __FUNCTION__, mCameraId);
1013 return res;
1014 }
1015 res = mCallbackProcessor->deleteStream();
1016 if (res != OK) {
1017 ALOGE("%s: Camera %d: Unable to delete callback stream before "
1018 "record: %s (%d)", __FUNCTION__, mCameraId,
1019 strerror(-res), res);
1020 return res;
1021 }
1022 }
1023 // Disable callbacks if they're enabled; can't record and use callbacks,
1024 // and we can't fail record start without stagefright asserting.
1025 params.previewCallbackFlags = 0;
1026
Igor Murashkin82db9e62013-05-21 11:38:49 -07001027 res = updateProcessorStream<
1028 StreamingProcessor,
1029 &StreamingProcessor::updateRecordingStream>(mStreamingProcessor,
1030 params);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001031 if (res != OK) {
1032 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
1033 __FUNCTION__, mCameraId, strerror(-res), res);
1034 return res;
1035 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001036
Zhijun Hed1d64672013-09-06 15:00:01 -07001037 Vector<int32_t> outputStreams;
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001038 outputStreams.push(getPreviewStreamId());
1039 outputStreams.push(getRecordingStreamId());
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001040
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001041 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
1042 outputStreams);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001043 if (res != OK) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001044 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)",
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001045 __FUNCTION__, mCameraId, strerror(-res), res);
1046 return res;
1047 }
1048
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001049 if (params.state < Parameters::RECORD) {
1050 params.state = Parameters::RECORD;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001051 }
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001052
1053 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001054}
1055
1056void Camera2Client::stopRecording() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001057 ATRACE_CALL();
Eino-Ville Talvala9e4c3db2012-07-20 11:07:52 -07001058 ALOGV("%s: E", __FUNCTION__);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001059 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001060 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001061
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001062 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001063 if ( (res = checkPid(__FUNCTION__) ) != OK) return;
1064
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001065 switch (l.mParameters.state) {
1066 case Parameters::RECORD:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001067 // OK to stop
1068 break;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001069 case Parameters::STOPPED:
1070 case Parameters::PREVIEW:
1071 case Parameters::STILL_CAPTURE:
1072 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001073 default:
1074 ALOGE("%s: Camera %d: Can't stop recording in state %s",
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001075 __FUNCTION__, mCameraId,
1076 Parameters::getStateName(l.mParameters.state));
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001077 return;
1078 };
1079
Eino-Ville Talvala609acc02012-09-06 18:26:58 -07001080 mCameraService->playSound(CameraService::SOUND_RECORDING);
1081
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001082 res = startPreviewL(l.mParameters, true);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001083 if (res != OK) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001084 ALOGE("%s: Camera %d: Unable to return to preview",
1085 __FUNCTION__, mCameraId);
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001086 }
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001087}
1088
1089bool Camera2Client::recordingEnabled() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001090 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001091 Mutex::Autolock icl(mBinderSerializationLock);
James Dong8da4cd72012-08-04 19:58:07 -07001092
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001093 if ( checkPid(__FUNCTION__) != OK) return false;
1094
James Dong8da4cd72012-08-04 19:58:07 -07001095 return recordingEnabledL();
1096}
1097
1098bool Camera2Client::recordingEnabledL() {
1099 ATRACE_CALL();
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001100 SharedParameters::Lock l(mParameters);
James Dong8da4cd72012-08-04 19:58:07 -07001101
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001102 return (l.mParameters.state == Parameters::RECORD
1103 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001104}
1105
1106void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001107 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001108 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001109 if ( checkPid(__FUNCTION__) != OK) return;
Eino-Ville Talvala30e65e72012-08-21 13:30:45 -07001110
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001111 mStreamingProcessor->releaseRecordingFrame(mem);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001112}
1113
1114status_t Camera2Client::autoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001115 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001116 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001117 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001118 status_t res;
1119 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1120
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001121 int triggerId;
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001122 bool notifyImmediately = false;
1123 bool notifySuccess = false;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001124 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001125 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001126 if (l.mParameters.state < Parameters::PREVIEW) {
1127 return INVALID_OPERATION;
1128 }
1129
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001130 /**
1131 * If the camera does not support auto-focus, it is a no-op and
1132 * onAutoFocus(boolean, Camera) callback will be called immediately
1133 * with a fake value of success set to true.
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001134 *
1135 * Similarly, if focus mode is set to INFINITY, there's no reason to
1136 * bother the HAL.
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001137 */
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001138 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1139 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001140 notifyImmediately = true;
1141 notifySuccess = true;
1142 }
1143 /**
1144 * If we're in CAF mode, and AF has already been locked, just fire back
1145 * the callback right away; the HAL would not send a notification since
1146 * no state change would happen on a AF trigger.
1147 */
1148 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE ||
1149 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) &&
1150 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) {
1151 notifyImmediately = true;
1152 notifySuccess = true;
1153 }
1154 /**
1155 * Send immediate notification back to client
1156 */
1157 if (notifyImmediately) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001158 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1159 if (l.mRemoteCallback != 0) {
1160 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001161 notifySuccess ? 1 : 0, 0);
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001162 }
Igor Murashkin5f0714e2012-10-08 18:05:12 -07001163 return OK;
1164 }
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001165 /**
1166 * Handle quirk mode for AF in scene modes
1167 */
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001168 if (l.mParameters.quirks.triggerAfWithAuto &&
Ruben Brunkc69b91c2014-01-17 17:12:10 -08001169 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_DISABLED &&
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001170 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO &&
1171 !l.mParameters.focusingAreas[0].isEmpty()) {
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001172 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO",
1173 __FUNCTION__, l.mParameters.focusMode);
1174 l.mParameters.shadowFocusMode = l.mParameters.focusMode;
1175 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
1176 updateRequests(l.mParameters);
1177 }
1178
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001179 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter;
1180 triggerId = l.mParameters.currentAfTriggerId;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001181 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001182 ATRACE_ASYNC_BEGIN(kAutofocusLabel, triggerId);
1183
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001184 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001185
1186 mDevice->triggerAutofocus(triggerId);
1187
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001188 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001189}
1190
1191status_t Camera2Client::cancelAutoFocus() {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001192 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001193 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001194 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001195 status_t res;
1196 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1197
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001198 int triggerId;
1199 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001200 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala9454a972013-06-03 16:50:53 -07001201 // Canceling does nothing in FIXED or INFINITY modes
1202 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED ||
1203 l.mParameters.focusMode == Parameters::FOCUS_MODE_INFINITY) {
1204 return OK;
1205 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001206
1207 // An active AF trigger is canceled
1208 if (l.mParameters.afTriggerCounter == l.mParameters.currentAfTriggerId) {
1209 ATRACE_ASYNC_END(kAutofocusLabel, l.mParameters.currentAfTriggerId);
1210 }
1211
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001212 triggerId = ++l.mParameters.afTriggerCounter;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001213
1214 // When using triggerAfWithAuto quirk, may need to reset focus mode to
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001215 // the real state at this point. No need to cancel explicitly if
1216 // changing the AF mode.
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001217 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) {
1218 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__,
1219 l.mParameters.shadowFocusMode);
1220 l.mParameters.focusMode = l.mParameters.shadowFocusMode;
1221 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID;
1222 updateRequests(l.mParameters);
Eino-Ville Talvalaac0cd562012-10-16 12:58:21 -07001223
1224 return OK;
Eino-Ville Talvala95069fe2012-10-04 00:56:40 -07001225 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001226 }
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001227 syncWithDevice();
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001228
1229 mDevice->triggerCancelAutofocus(triggerId);
1230
Eino-Ville Talvala6db981c2012-05-21 18:54:30 -07001231 return OK;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001232}
1233
Ben Murdochff823702012-11-28 13:58:29 +00001234status_t Camera2Client::takePicture(int msgType) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001235 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001236 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001237 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001238 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001239
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001240 int takePictureCounter;
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001241 {
1242 SharedParameters::Lock l(mParameters);
1243 switch (l.mParameters.state) {
1244 case Parameters::DISCONNECTED:
1245 case Parameters::STOPPED:
1246 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1247 ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001248 __FUNCTION__, mCameraId);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001249 return INVALID_OPERATION;
1250 case Parameters::PREVIEW:
1251 // Good to go for takePicture
1252 res = commandStopFaceDetectionL(l.mParameters);
1253 if (res != OK) {
1254 ALOGE("%s: Camera %d: Unable to stop face detection for still capture",
1255 __FUNCTION__, mCameraId);
1256 return res;
1257 }
1258 l.mParameters.state = Parameters::STILL_CAPTURE;
1259 break;
1260 case Parameters::RECORD:
1261 // Good to go for video snapshot
1262 l.mParameters.state = Parameters::VIDEO_SNAPSHOT;
1263 break;
1264 case Parameters::STILL_CAPTURE:
1265 case Parameters::VIDEO_SNAPSHOT:
1266 ALOGE("%s: Camera %d: Already taking a picture",
1267 __FUNCTION__, mCameraId);
1268 return INVALID_OPERATION;
1269 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001270
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001271 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001272
Igor Murashkindca254a2013-05-13 14:53:44 -07001273 res = updateProcessorStream(mJpegProcessor, l.mParameters);
Eino-Ville Talvalab8d6efb2012-10-24 17:30:30 -07001274 if (res != OK) {
1275 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
1276 __FUNCTION__, mCameraId, strerror(-res), res);
1277 return res;
1278 }
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001279 takePictureCounter = ++l.mParameters.takePictureCounter;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001280 }
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001281
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001282 ATRACE_ASYNC_BEGIN(kTakepictureLabel, takePictureCounter);
1283
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001284 // Need HAL to have correct settings before (possibly) triggering precapture
1285 syncWithDevice();
1286
Igor Murashkinaa9e3e02012-11-26 10:50:55 -08001287 res = mCaptureSequencer->startCapture(msgType);
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001288 if (res != OK) {
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001289 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)",
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001290 __FUNCTION__, mCameraId, strerror(-res), res);
Eino-Ville Talvalabe0573b2012-06-15 12:42:30 -07001291 }
Eino-Ville Talvalad4bcfde2012-06-07 17:12:38 -07001292
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001293 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001294}
1295
1296status_t Camera2Client::setParameters(const String8& params) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001297 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001298 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001299 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001300 status_t res;
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001301 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1302
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001303 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001304
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001305 res = l.mParameters.set(params);
1306 if (res != OK) return res;
Eino-Ville Talvala6861a4e2012-06-07 10:32:12 -07001307
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001308 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001309
1310 return res;
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001311}
Eino-Ville Talvalaf69c70d2012-05-20 15:59:14 -07001312
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001313String8 Camera2Client::getParameters() const {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001314 ATRACE_CALL();
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001315 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001316 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001317 if ( checkPid(__FUNCTION__) != OK) return String8();
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001318
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001319 SharedParameters::ReadLock l(mParameters);
Eino-Ville Talvalaac45eb32012-06-07 10:24:51 -07001320
Eino-Ville Talvala8a42dd82012-10-02 13:30:04 -07001321 return l.mParameters.get();
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001322}
1323
1324status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
Eino-Ville Talvalaa1890972012-05-31 11:18:52 -07001325 ATRACE_CALL();
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001326 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvala3a609142012-07-31 14:36:26 -07001327 status_t res;
1328 if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001329
1330 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1331 cmd, arg1, arg2);
1332
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001333 switch (cmd) {
1334 case CAMERA_CMD_START_SMOOTH_ZOOM:
1335 return commandStartSmoothZoomL();
1336 case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1337 return commandStopSmoothZoomL();
1338 case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1339 return commandSetDisplayOrientationL(arg1);
1340 case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1341 return commandEnableShutterSoundL(arg1 == 1);
1342 case CAMERA_CMD_PLAY_RECORDING_SOUND:
1343 return commandPlayRecordingSoundL();
1344 case CAMERA_CMD_START_FACE_DETECTION:
1345 return commandStartFaceDetectionL(arg1);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001346 case CAMERA_CMD_STOP_FACE_DETECTION: {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001347 SharedParameters::Lock l(mParameters);
1348 return commandStopFaceDetectionL(l.mParameters);
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001349 }
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001350 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1351 return commandEnableFocusMoveMsgL(arg1 == 1);
1352 case CAMERA_CMD_PING:
1353 return commandPingL();
1354 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1355 return commandSetVideoBufferCountL(arg1);
1356 default:
1357 ALOGE("%s: Unknown command %d (arguments %d, %d)",
1358 __FUNCTION__, cmd, arg1, arg2);
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001359 return BAD_VALUE;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001360 }
1361}
James Dong983cf232012-08-01 16:39:55 -07001362
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001363status_t Camera2Client::commandStartSmoothZoomL() {
1364 ALOGE("%s: Unimplemented!", __FUNCTION__);
1365 return OK;
1366}
James Dong983cf232012-08-01 16:39:55 -07001367
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001368status_t Camera2Client::commandStopSmoothZoomL() {
1369 ALOGE("%s: Unimplemented!", __FUNCTION__);
1370 return OK;
1371}
James Dong983cf232012-08-01 16:39:55 -07001372
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001373status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001374 int transform = Parameters::degToTransform(degrees,
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001375 mCameraFacing == CAMERA_FACING_FRONT);
1376 if (transform == -1) {
1377 ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1378 __FUNCTION__, mCameraId, degrees);
1379 return BAD_VALUE;
1380 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001381 SharedParameters::Lock l(mParameters);
1382 if (transform != l.mParameters.previewTransform &&
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001383 getPreviewStreamId() != NO_STREAM) {
1384 mDevice->setStreamTransform(getPreviewStreamId(), transform);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001385 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001386 l.mParameters.previewTransform = transform;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001387 return OK;
1388}
1389
1390status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001391 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001392 if (enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001393 l.mParameters.playShutterSound = true;
James Dong983cf232012-08-01 16:39:55 -07001394 return OK;
Eino-Ville Talvalac94cd192012-06-15 12:47:42 -07001395 }
1396
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001397 // Disabling shutter sound may not be allowed. In that case only
1398 // allow the mediaserver process to disable the sound.
1399 char value[PROPERTY_VALUE_MAX];
1400 property_get("ro.camera.sound.forced", value, "0");
1401 if (strncmp(value, "0", 2) != 0) {
1402 // Disabling shutter sound is not allowed. Deny if the current
1403 // process is not mediaserver.
1404 if (getCallingPid() != getpid()) {
1405 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1406 getCallingPid());
1407 return PERMISSION_DENIED;
1408 }
1409 }
1410
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001411 l.mParameters.playShutterSound = false;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001412 return OK;
1413}
1414
1415status_t Camera2Client::commandPlayRecordingSoundL() {
1416 mCameraService->playSound(CameraService::SOUND_RECORDING);
1417 return OK;
1418}
1419
Igor Murashkinddf3c502012-10-12 16:56:11 -07001420status_t Camera2Client::commandStartFaceDetectionL(int /*type*/) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001421 ALOGV("%s: Camera %d: Starting face detection",
1422 __FUNCTION__, mCameraId);
1423 status_t res;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001424 SharedParameters::Lock l(mParameters);
1425 switch (l.mParameters.state) {
1426 case Parameters::DISCONNECTED:
1427 case Parameters::STOPPED:
1428 case Parameters::WAITING_FOR_PREVIEW_WINDOW:
1429 case Parameters::STILL_CAPTURE:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001430 ALOGE("%s: Camera %d: Cannot start face detection without preview active",
1431 __FUNCTION__, mCameraId);
1432 return INVALID_OPERATION;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001433 case Parameters::PREVIEW:
1434 case Parameters::RECORD:
1435 case Parameters::VIDEO_SNAPSHOT:
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001436 // Good to go for starting face detect
1437 break;
1438 }
1439 // Ignoring type
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001440 if (l.mParameters.fastInfo.bestFaceDetectMode ==
Igor Murashkind32b99b2012-11-27 16:25:46 -08001441 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001442 ALOGE("%s: Camera %d: Face detection not supported",
1443 __FUNCTION__, mCameraId);
Ziv Hendelcaf3a9c2013-03-21 03:25:32 +02001444 return BAD_VALUE;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001445 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001446 if (l.mParameters.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001447
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001448 l.mParameters.enableFaceDetect = true;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001449
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001450 res = updateRequests(l.mParameters);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001451
1452 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001453}
1454
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001455status_t Camera2Client::commandStopFaceDetectionL(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001456 status_t res = OK;
1457 ALOGV("%s: Camera %d: Stopping face detection",
1458 __FUNCTION__, mCameraId);
1459
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001460 if (!params.enableFaceDetect) return OK;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001461
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001462 params.enableFaceDetect = false;
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001463
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001464 if (params.state == Parameters::PREVIEW
1465 || params.state == Parameters::RECORD
1466 || params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001467 res = updateRequests(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001468 }
1469
1470 return res;
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001471}
1472
1473status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001474 SharedParameters::Lock l(mParameters);
1475 l.mParameters.enableFocusMoveMessages = enable;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001476
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001477 return OK;
1478}
1479
1480status_t Camera2Client::commandPingL() {
1481 // Always ping back if access is proper and device is alive
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001482 SharedParameters::Lock l(mParameters);
1483 if (l.mParameters.state != Parameters::DISCONNECTED) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001484 return OK;
1485 } else {
1486 return NO_INIT;
1487 }
1488}
1489
1490status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
James Dong8da4cd72012-08-04 19:58:07 -07001491 if (recordingEnabledL()) {
Eino-Ville Talvala36cdfb12012-08-02 17:34:15 -07001492 ALOGE("%s: Camera %d: Error setting video buffer count after "
1493 "recording was started", __FUNCTION__, mCameraId);
1494 return INVALID_OPERATION;
1495 }
1496
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001497 return mStreamingProcessor->setRecordingBufferCount(count);
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001498}
1499
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001500/** Device-related methods */
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001501void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1502 ALOGV("%s: Autofocus state now %d, last trigger %d",
1503 __FUNCTION__, newState, triggerId);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001504 bool sendCompletedMessage = false;
1505 bool sendMovingMessage = false;
1506
1507 bool success = false;
1508 bool afInMotion = false;
1509 {
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001510 SharedParameters::Lock l(mParameters);
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001511 // Trace end of AF state
1512 char tmp[32];
1513 if (l.mParameters.afStateCounter > 0) {
1514 camera_metadata_enum_snprint(
1515 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1516 ATRACE_ASYNC_END(tmp, l.mParameters.afStateCounter);
1517 }
1518
1519 // Update state
Eino-Ville Talvalad6cc4a62012-10-16 10:17:30 -07001520 l.mParameters.focusState = newState;
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001521 l.mParameters.afStateCounter++;
1522
1523 // Trace start of AF state
1524
1525 camera_metadata_enum_snprint(
1526 ANDROID_CONTROL_AF_STATE, l.mParameters.focusState, tmp, sizeof(tmp));
1527 ATRACE_ASYNC_BEGIN(tmp, l.mParameters.afStateCounter);
1528
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001529 switch (l.mParameters.focusMode) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001530 case Parameters::FOCUS_MODE_AUTO:
1531 case Parameters::FOCUS_MODE_MACRO:
1532 // Don't send notifications upstream if they're not for the current AF
1533 // trigger. For example, if cancel was called in between, or if we
1534 // already sent a notification about this AF call.
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001535 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001536 switch (newState) {
1537 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1538 success = true;
1539 // no break
1540 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1541 sendCompletedMessage = true;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001542 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001543 break;
1544 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1545 // Just starting focusing, ignore
1546 break;
1547 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1548 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1549 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001550 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001551 default:
1552 // Unexpected in AUTO/MACRO mode
1553 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d",
1554 __FUNCTION__, newState);
1555 break;
1556 }
1557 break;
1558 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
1559 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
1560 switch (newState) {
1561 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1562 success = true;
1563 // no break
1564 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1565 // Don't send notifications upstream if they're not for
1566 // the current AF trigger. For example, if cancel was
1567 // called in between, or if we already sent a
1568 // notification about this AF call.
1569 // Send both a 'AF done' callback and a 'AF move' callback
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001570 if (triggerId != l.mParameters.currentAfTriggerId) break;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001571 sendCompletedMessage = true;
1572 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001573 if (l.mParameters.enableFocusMoveMessages &&
1574 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001575 sendMovingMessage = true;
1576 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001577 l.mParameters.currentAfTriggerId = -1;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001578 break;
1579 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1580 // Cancel was called, or we switched state; care if
1581 // currently moving
1582 afInMotion = false;
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001583 if (l.mParameters.enableFocusMoveMessages &&
1584 l.mParameters.afInMotion) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001585 sendMovingMessage = true;
1586 }
1587 break;
1588 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1589 // Start passive scan, inform upstream
1590 afInMotion = true;
1591 // no break
1592 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
Eino-Ville Talvala4ad28ea2013-09-20 17:21:18 -07001593 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001594 // Stop passive scan, inform upstream
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001595 if (l.mParameters.enableFocusMoveMessages) {
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001596 sendMovingMessage = true;
1597 }
1598 break;
1599 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001600 l.mParameters.afInMotion = afInMotion;
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001601 break;
1602 case Parameters::FOCUS_MODE_EDOF:
1603 case Parameters::FOCUS_MODE_INFINITY:
1604 case Parameters::FOCUS_MODE_FIXED:
1605 default:
1606 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) {
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001607 ALOGE("%s: Unexpected AF state change %d "
1608 "(ID %d) in focus mode %d",
1609 __FUNCTION__, newState, triggerId,
1610 l.mParameters.focusMode);
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001611 }
1612 }
1613 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001614 if (sendMovingMessage) {
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001615 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1616 if (l.mRemoteCallback != 0) {
1617 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS_MOVE,
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001618 afInMotion ? 1 : 0, 0);
1619 }
Eino-Ville Talvala174181e2012-08-03 13:53:39 -07001620 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001621 if (sendCompletedMessage) {
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001622 ATRACE_ASYNC_END(kAutofocusLabel, triggerId);
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001623 SharedCameraCallbacks::Lock l(mSharedCameraCallbacks);
1624 if (l.mRemoteCallback != 0) {
1625 l.mRemoteCallback->notifyCallback(CAMERA_MSG_FOCUS,
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001626 success ? 1 : 0, 0);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001627 }
Eino-Ville Talvala603b12e2012-08-08 09:25:58 -07001628 }
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001629}
1630
1631void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1632 ALOGV("%s: Autoexposure state now %d, last trigger %d",
1633 __FUNCTION__, newState, triggerId);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001634 mCaptureSequencer->notifyAutoExposure(newState, triggerId);
Eino-Ville Talvala160d4af2012-08-03 09:40:16 -07001635}
1636
Eino-Ville Talvalaa16733e2012-08-27 23:41:56 -07001637camera2::SharedParameters& Camera2Client::getParameters() {
1638 return mParameters;
Eino-Ville Talvalac8474b62012-08-24 16:30:44 -07001639}
1640
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001641int Camera2Client::getPreviewStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001642 return mStreamingProcessor->getPreviewStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001643}
1644
1645int Camera2Client::getCaptureStreamId() const {
1646 return mJpegProcessor->getStreamId();
1647}
1648
1649int Camera2Client::getCallbackStreamId() const {
1650 return mCallbackProcessor->getStreamId();
1651}
1652
1653int Camera2Client::getRecordingStreamId() const {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001654 return mStreamingProcessor->getRecordingStreamId();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001655}
1656
1657int Camera2Client::getZslStreamId() const {
1658 return mZslProcessor->getStreamId();
1659}
1660
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001661status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId,
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001662 wp<camera2::FrameProcessor::FilteredListener> listener) {
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001663 return mFrameProcessor->registerListener(minId, maxId, listener);
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001664}
1665
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001666status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId,
1667 wp<camera2::FrameProcessor::FilteredListener> listener) {
1668 return mFrameProcessor->removeListener(minId, maxId, listener);
1669}
1670
1671status_t Camera2Client::stopStream() {
1672 return mStreamingProcessor->stopStream();
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001673}
1674
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001675const int32_t Camera2Client::kPreviewRequestIdStart;
1676const int32_t Camera2Client::kPreviewRequestIdEnd;
1677const int32_t Camera2Client::kRecordingRequestIdStart;
1678const int32_t Camera2Client::kRecordingRequestIdEnd;
1679const int32_t Camera2Client::kCaptureRequestIdStart;
1680const int32_t Camera2Client::kCaptureRequestIdEnd;
Eino-Ville Talvalada6665c2012-08-29 17:37:16 -07001681
Eino-Ville Talvala3cca1362012-06-07 10:07:18 -07001682/** Utility methods */
1683
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001684status_t Camera2Client::updateRequests(Parameters &params) {
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001685 status_t res;
1686
Igor Murashkin22d58d32012-10-02 19:07:14 -07001687 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state);
1688
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001689 res = mStreamingProcessor->incrementStreamingIds();
1690 if (res != OK) {
1691 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)",
1692 __FUNCTION__, mCameraId, strerror(-res), res);
1693 return res;
1694 }
1695
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001696 res = mStreamingProcessor->updatePreviewRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001697 if (res != OK) {
1698 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1699 __FUNCTION__, mCameraId, strerror(-res), res);
1700 return res;
1701 }
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001702 res = mStreamingProcessor->updateRecordingRequest(params);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001703 if (res != OK) {
1704 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1705 __FUNCTION__, mCameraId, strerror(-res), res);
1706 return res;
1707 }
1708
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001709 if (params.state == Parameters::PREVIEW) {
Eino-Ville Talvala5a4f93e2012-08-29 18:06:32 -07001710 res = startPreviewL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001711 if (res != OK) {
1712 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1713 __FUNCTION__, mCameraId, strerror(-res), res);
1714 return res;
1715 }
Eino-Ville Talvala2e19c3c2012-08-26 09:29:28 -07001716 } else if (params.state == Parameters::RECORD ||
1717 params.state == Parameters::VIDEO_SNAPSHOT) {
Eino-Ville Talvala73bbd1f2012-09-26 10:45:47 -07001718 res = startRecordingL(params, true);
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001719 if (res != OK) {
1720 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1721 __FUNCTION__, mCameraId, strerror(-res), res);
1722 return res;
1723 }
1724 }
1725 return res;
1726}
1727
Eino-Ville Talvala9cca4c62012-06-15 15:41:44 -07001728
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001729size_t Camera2Client::calculateBufferSize(int width, int height,
1730 int format, int stride) {
1731 switch (format) {
1732 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
1733 return width * height * 2;
1734 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
1735 return width * height * 3 / 2;
1736 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
1737 return width * height * 2;
1738 case HAL_PIXEL_FORMAT_YV12: { // YV12
1739 size_t ySize = stride * height;
Eino-Ville Talvalaf17b6cf2012-08-25 17:12:18 -07001740 size_t uvStride = (stride / 2 + 0xF) & ~0xF;
Eino-Ville Talvala228a5382012-08-13 12:16:06 -07001741 size_t uvSize = uvStride * height / 2;
1742 return ySize + uvSize * 2;
1743 }
1744 case HAL_PIXEL_FORMAT_RGB_565:
1745 return width * height * 2;
1746 case HAL_PIXEL_FORMAT_RGBA_8888:
1747 return width * height * 4;
1748 case HAL_PIXEL_FORMAT_RAW_SENSOR:
1749 return width * height * 2;
1750 default:
1751 ALOGE("%s: Unknown preview format: %x",
1752 __FUNCTION__, format);
1753 return 0;
1754 }
1755}
Eino-Ville Talvala8ce89d92012-08-10 08:40:26 -07001756
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001757status_t Camera2Client::syncWithDevice() {
1758 ATRACE_CALL();
Eino-Ville Talvala43b7ac62012-10-23 09:09:01 -07001759 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms
Eino-Ville Talvala4865c522012-10-02 13:30:28 -07001760 status_t res;
1761
1762 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId();
1763 if (activeRequestId == 0) return OK;
1764
1765 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout);
1766 if (res == TIMED_OUT) {
1767 ALOGE("%s: Camera %d: Timed out waiting sync with HAL",
1768 __FUNCTION__, mCameraId);
1769 } else if (res != OK) {
1770 ALOGE("%s: Camera %d: Error while waiting to sync with HAL",
1771 __FUNCTION__, mCameraId);
1772 }
1773 return res;
1774}
1775
Igor Murashkindca254a2013-05-13 14:53:44 -07001776template <typename ProcessorT>
1777status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1778 camera2::Parameters params) {
Igor Murashkin82db9e62013-05-21 11:38:49 -07001779 // No default template arguments until C++11, so we need this overload
1780 return updateProcessorStream<ProcessorT, &ProcessorT::updateStream>(
1781 processor, params);
1782}
1783
1784template <typename ProcessorT,
1785 status_t (ProcessorT::*updateStreamF)(const Parameters &)>
1786status_t Camera2Client::updateProcessorStream(sp<ProcessorT> processor,
1787 Parameters params) {
Igor Murashkindca254a2013-05-13 14:53:44 -07001788 status_t res;
1789
Igor Murashkin82db9e62013-05-21 11:38:49 -07001790 // Get raw pointer since sp<T> doesn't have operator->*
1791 ProcessorT *processorPtr = processor.get();
1792 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07001793
1794 /**
1795 * Can't update the stream if it's busy?
1796 *
1797 * Then we need to stop the device (by temporarily clearing the request
1798 * queue) and then try again. Resume streaming once we're done.
1799 */
1800 if (res == -EBUSY) {
Eino-Ville Talvalaa691ff32013-06-26 18:23:23 -07001801 ALOGV("%s: Camera %d: Pausing to update stream", __FUNCTION__,
1802 mCameraId);
Igor Murashkindca254a2013-05-13 14:53:44 -07001803 res = mStreamingProcessor->togglePauseStream(/*pause*/true);
1804 if (res != OK) {
1805 ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
1806 __FUNCTION__, mCameraId, strerror(-res), res);
1807 }
1808
1809 res = mDevice->waitUntilDrained();
1810 if (res != OK) {
1811 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)",
1812 __FUNCTION__, mCameraId, strerror(-res), res);
1813 }
1814
Igor Murashkin82db9e62013-05-21 11:38:49 -07001815 res = (processorPtr->*updateStreamF)(params);
Igor Murashkindca254a2013-05-13 14:53:44 -07001816 if (res != OK) {
1817 ALOGE("%s: Camera %d: Failed to update processing stream "
1818 " despite having halted streaming first: %s (%d)",
1819 __FUNCTION__, mCameraId, strerror(-res), res);
1820 }
1821
1822 res = mStreamingProcessor->togglePauseStream(/*pause*/false);
1823 if (res != OK) {
1824 ALOGE("%s: Camera %d: Can't unpause streaming: %s (%d)",
1825 __FUNCTION__, mCameraId, strerror(-res), res);
1826 }
1827 }
1828
1829 return res;
1830}
Igor Murashkin44cfcf02013-03-01 16:22:28 -08001831
Eino-Ville Talvala2b07e022013-10-10 15:13:09 -07001832const char* Camera2Client::kAutofocusLabel = "autofocus";
1833const char* Camera2Client::kTakepictureLabel = "take_picture";
1834
Eino-Ville Talvala61ab9f92012-05-17 10:30:54 -07001835} // namespace android