blob: a6214ccc9e2863ef45f4eb51b455d8dda100041f [file] [log] [blame]
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001/*
2 * Copyright (C) 2013 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
17#define LOG_TAG "Camera3-Device"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20//#define LOG_NNDEBUG 0 // Per-frame verbose logging
21
22#ifdef LOG_NNDEBUG
23#define ALOGVV(...) ALOGV(__VA_ARGS__)
24#else
25#define ALOGVV(...) ((void)0)
26#endif
27
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -070028// Convenience macro for transient errors
29#define CLOGE(fmt, ...) ALOGE("Camera %d: %s: " fmt, mId, __FUNCTION__, \
30 ##__VA_ARGS__)
31
32// Convenience macros for transitioning to the error state
33#define SET_ERR(fmt, ...) setErrorState( \
34 "%s: " fmt, __FUNCTION__, \
35 ##__VA_ARGS__)
36#define SET_ERR_L(fmt, ...) setErrorStateLocked( \
37 "%s: " fmt, __FUNCTION__, \
38 ##__VA_ARGS__)
39
Colin Crosse5729fa2014-03-21 15:04:25 -070040#include <inttypes.h>
41
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080042#include <utils/Log.h>
43#include <utils/Trace.h>
44#include <utils/Timers.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070045
Igor Murashkinff3e31d2013-10-23 16:40:06 -070046#include "utils/CameraTraces.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070047#include "device3/Camera3Device.h"
48#include "device3/Camera3OutputStream.h"
49#include "device3/Camera3InputStream.h"
50#include "device3/Camera3ZslStream.h"
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -070051#include "CameraService.h"
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080052
53using namespace android::camera3;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080054
55namespace android {
56
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080057Camera3Device::Camera3Device(int id):
58 mId(id),
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080059 mHal3Device(NULL),
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -070060 mStatus(STATUS_UNINITIALIZED),
Zhijun He204e3292014-07-14 17:09:23 -070061 mUsePartialResult(false),
62 mNumPartialResults(1),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -070063 mNextResultFrameNumber(0),
64 mNextShutterFrameNumber(0),
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -070065 mListener(NULL)
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080066{
67 ATRACE_CALL();
68 camera3_callback_ops::notify = &sNotify;
69 camera3_callback_ops::process_capture_result = &sProcessCaptureResult;
70 ALOGV("%s: Created device for camera %d", __FUNCTION__, id);
71}
72
73Camera3Device::~Camera3Device()
74{
75 ATRACE_CALL();
76 ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId);
77 disconnect();
78}
79
Igor Murashkin71381052013-03-04 14:53:08 -080080int Camera3Device::getId() const {
81 return mId;
82}
83
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080084/**
85 * CameraDeviceBase interface
86 */
87
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080088status_t Camera3Device::initialize(camera_module_t *module)
89{
90 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -070091 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080092 Mutex::Autolock l(mLock);
93
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080094 ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080095 if (mStatus != STATUS_UNINITIALIZED) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -070096 CLOGE("Already initialized!");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080097 return INVALID_OPERATION;
98 }
99
100 /** Open HAL device */
101
102 status_t res;
103 String8 deviceName = String8::format("%d", mId);
104
105 camera3_device_t *device;
106
Zhijun He213ce792013-11-19 08:45:15 -0800107 ATRACE_BEGIN("camera3->open");
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700108 res = CameraService::filterOpenErrorCode(module->common.methods->open(
109 &module->common, deviceName.string(),
110 reinterpret_cast<hw_device_t**>(&device)));
Zhijun He213ce792013-11-19 08:45:15 -0800111 ATRACE_END();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800112
113 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700114 SET_ERR_L("Could not open camera: %s (%d)", strerror(-res), res);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800115 return res;
116 }
117
118 /** Cross-check device version */
Zhijun He95dd5ba2014-03-26 18:18:00 -0700119 if (device->common.version < CAMERA_DEVICE_API_VERSION_3_0) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700120 SET_ERR_L("Could not open camera: "
Zhijun He95dd5ba2014-03-26 18:18:00 -0700121 "Camera device should be at least %x, reports %x instead",
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700122 CAMERA_DEVICE_API_VERSION_3_0,
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800123 device->common.version);
124 device->common.close(&device->common);
125 return BAD_VALUE;
126 }
127
128 camera_info info;
Eino-Ville Talvalaf67e23e2014-07-23 17:17:59 -0700129 res = CameraService::filterGetInfoErrorCode(module->get_camera_info(
130 mId, &info));
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800131 if (res != OK) return res;
132
133 if (info.device_version != device->common.version) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700134 SET_ERR_L("HAL reporting mismatched camera_info version (%x)"
135 " and device version (%x).",
Zhijun He95dd5ba2014-03-26 18:18:00 -0700136 info.device_version, device->common.version);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800137 device->common.close(&device->common);
138 return BAD_VALUE;
139 }
140
141 /** Initialize device with callback functions */
142
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -0700143 ATRACE_BEGIN("camera3->initialize");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800144 res = device->ops->initialize(device, this);
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -0700145 ATRACE_END();
146
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800147 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700148 SET_ERR_L("Unable to initialize HAL device: %s (%d)",
149 strerror(-res), res);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800150 device->common.close(&device->common);
151 return BAD_VALUE;
152 }
153
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700154 /** Start up status tracker thread */
155 mStatusTracker = new StatusTracker(this);
156 res = mStatusTracker->run(String8::format("C3Dev-%d-Status", mId).string());
157 if (res != OK) {
158 SET_ERR_L("Unable to start status tracking thread: %s (%d)",
159 strerror(-res), res);
160 device->common.close(&device->common);
161 mStatusTracker.clear();
162 return res;
163 }
164
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800165 /** Start up request queue thread */
166
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700167 mRequestThread = new RequestThread(this, mStatusTracker, device);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800168 res = mRequestThread->run(String8::format("C3Dev-%d-ReqQueue", mId).string());
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800169 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700170 SET_ERR_L("Unable to start request queue thread: %s (%d)",
171 strerror(-res), res);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800172 device->common.close(&device->common);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800173 mRequestThread.clear();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800174 return res;
175 }
176
177 /** Everything is good to go */
178
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700179 mDeviceVersion = device->common.version;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800180 mDeviceInfo = info.static_camera_characteristics;
181 mHal3Device = device;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700182 mStatus = STATUS_UNCONFIGURED;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800183 mNextStreamId = 0;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700184 mNeedConfig = true;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700185 mPauseStateNotify = false;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800186
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700187 // Will the HAL be sending in early partial result metadata?
Zhijun He204e3292014-07-14 17:09:23 -0700188 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
189 camera_metadata_entry partialResultsCount =
190 mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
191 if (partialResultsCount.count > 0) {
192 mNumPartialResults = partialResultsCount.data.i32[0];
193 mUsePartialResult = (mNumPartialResults > 1);
194 }
195 } else {
196 camera_metadata_entry partialResultsQuirk =
197 mDeviceInfo.find(ANDROID_QUIRKS_USE_PARTIAL_RESULT);
198 if (partialResultsQuirk.count > 0 && partialResultsQuirk.data.u8[0] == 1) {
199 mUsePartialResult = true;
200 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700201 }
202
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800203 return OK;
204}
205
206status_t Camera3Device::disconnect() {
207 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700208 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800209
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800210 ALOGV("%s: E", __FUNCTION__);
211
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700212 status_t res = OK;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800213
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700214 {
215 Mutex::Autolock l(mLock);
216 if (mStatus == STATUS_UNINITIALIZED) return res;
217
218 if (mStatus == STATUS_ACTIVE ||
219 (mStatus == STATUS_ERROR && mRequestThread != NULL)) {
220 res = mRequestThread->clearRepeatingRequests();
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700221 if (res != OK) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700222 SET_ERR_L("Can't stop streaming");
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700223 // Continue to close device even in case of error
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700224 } else {
225 res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
226 if (res != OK) {
227 SET_ERR_L("Timeout waiting for HAL to drain");
228 // Continue to close device even in case of error
229 }
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700230 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800231 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800232
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700233 if (mStatus == STATUS_ERROR) {
234 CLOGE("Shutting down in an error state");
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700235 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700236
237 if (mStatusTracker != NULL) {
238 mStatusTracker->requestExit();
239 }
240
241 if (mRequestThread != NULL) {
242 mRequestThread->requestExit();
243 }
244
245 mOutputStreams.clear();
246 mInputStream.clear();
247 }
248
249 // Joining done without holding mLock, otherwise deadlocks may ensue
250 // as the threads try to access parent state
251 if (mRequestThread != NULL && mStatus != STATUS_ERROR) {
252 // HAL may be in a bad state, so waiting for request thread
253 // (which may be stuck in the HAL processCaptureRequest call)
254 // could be dangerous.
255 mRequestThread->join();
256 }
257
258 if (mStatusTracker != NULL) {
259 mStatusTracker->join();
260 }
261
262 {
263 Mutex::Autolock l(mLock);
264
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800265 mRequestThread.clear();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700266 mStatusTracker.clear();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800267
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700268 if (mHal3Device != NULL) {
Zhijun He213ce792013-11-19 08:45:15 -0800269 ATRACE_BEGIN("camera3->close");
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700270 mHal3Device->common.close(&mHal3Device->common);
Zhijun He213ce792013-11-19 08:45:15 -0800271 ATRACE_END();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700272 mHal3Device = NULL;
273 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800274
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700275 mStatus = STATUS_UNINITIALIZED;
276 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800277
278 ALOGV("%s: X", __FUNCTION__);
Eino-Ville Talvala214a17f2013-06-13 12:20:02 -0700279 return res;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800280}
281
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700282// For dumping/debugging only -
283// try to acquire a lock a few times, eventually give up to proceed with
284// debug/dump operations
285bool Camera3Device::tryLockSpinRightRound(Mutex& lock) {
286 bool gotLock = false;
287 for (size_t i = 0; i < kDumpLockAttempts; ++i) {
288 if (lock.tryLock() == NO_ERROR) {
289 gotLock = true;
290 break;
291 } else {
292 usleep(kDumpSleepDuration);
293 }
294 }
295 return gotLock;
296}
297
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700298Camera3Device::Size Camera3Device::getMaxJpegResolution() const {
299 int32_t maxJpegWidth = 0, maxJpegHeight = 0;
300 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
301 const int STREAM_CONFIGURATION_SIZE = 4;
302 const int STREAM_FORMAT_OFFSET = 0;
303 const int STREAM_WIDTH_OFFSET = 1;
304 const int STREAM_HEIGHT_OFFSET = 2;
305 const int STREAM_IS_INPUT_OFFSET = 3;
306 camera_metadata_ro_entry_t availableStreamConfigs =
307 mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
308 if (availableStreamConfigs.count == 0 ||
309 availableStreamConfigs.count % STREAM_CONFIGURATION_SIZE != 0) {
310 return Size(0, 0);
311 }
312
313 // Get max jpeg size (area-wise).
314 for (size_t i=0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) {
315 int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET];
316 int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET];
317 int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET];
318 int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET];
319 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT
320 && format == HAL_PIXEL_FORMAT_BLOB &&
321 (width * height > maxJpegWidth * maxJpegHeight)) {
322 maxJpegWidth = width;
323 maxJpegHeight = height;
324 }
325 }
326 } else {
327 camera_metadata_ro_entry availableJpegSizes =
328 mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
329 if (availableJpegSizes.count == 0 || availableJpegSizes.count % 2 != 0) {
330 return Size(0, 0);
331 }
332
333 // Get max jpeg size (area-wise).
334 for (size_t i = 0; i < availableJpegSizes.count; i += 2) {
335 if ((availableJpegSizes.data.i32[i] * availableJpegSizes.data.i32[i + 1])
336 > (maxJpegWidth * maxJpegHeight)) {
337 maxJpegWidth = availableJpegSizes.data.i32[i];
338 maxJpegHeight = availableJpegSizes.data.i32[i + 1];
339 }
340 }
341 }
342 return Size(maxJpegWidth, maxJpegHeight);
343}
344
Zhijun Hef7da0962014-04-24 13:27:56 -0700345ssize_t Camera3Device::getJpegBufferSize(uint32_t width, uint32_t height) const {
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700346 // Get max jpeg size (area-wise).
347 Size maxJpegResolution = getMaxJpegResolution();
348 if (maxJpegResolution.width == 0) {
Zhijun Hef7da0962014-04-24 13:27:56 -0700349 ALOGE("%s: Camera %d: Can't find find valid available jpeg sizes in static metadata!",
350 __FUNCTION__, mId);
351 return BAD_VALUE;
352 }
353
Zhijun Hef7da0962014-04-24 13:27:56 -0700354 // Get max jpeg buffer size
355 ssize_t maxJpegBufferSize = 0;
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700356 camera_metadata_ro_entry jpegBufMaxSize = mDeviceInfo.find(ANDROID_JPEG_MAX_SIZE);
357 if (jpegBufMaxSize.count == 0) {
Zhijun Hef7da0962014-04-24 13:27:56 -0700358 ALOGE("%s: Camera %d: Can't find maximum JPEG size in static metadata!", __FUNCTION__, mId);
359 return BAD_VALUE;
360 }
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700361 maxJpegBufferSize = jpegBufMaxSize.data.i32[0];
Zhijun Hef7da0962014-04-24 13:27:56 -0700362
363 // Calculate final jpeg buffer size for the given resolution.
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700364 float scaleFactor = ((float) (width * height)) /
365 (maxJpegResolution.width * maxJpegResolution.height);
Zhijun Hef7da0962014-04-24 13:27:56 -0700366 ssize_t jpegBufferSize = scaleFactor * maxJpegBufferSize;
367 // Bound the buffer size to [MIN_JPEG_BUFFER_SIZE, maxJpegBufferSize].
368 if (jpegBufferSize > maxJpegBufferSize) {
369 jpegBufferSize = maxJpegBufferSize;
370 } else if (jpegBufferSize < kMinJpegBufferSize) {
371 jpegBufferSize = kMinJpegBufferSize;
372 }
373
374 return jpegBufferSize;
375}
376
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800377status_t Camera3Device::dump(int fd, const Vector<String16> &args) {
378 ATRACE_CALL();
379 (void)args;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700380
381 // Try to lock, but continue in case of failure (to avoid blocking in
382 // deadlocks)
383 bool gotInterfaceLock = tryLockSpinRightRound(mInterfaceLock);
384 bool gotLock = tryLockSpinRightRound(mLock);
385
386 ALOGW_IF(!gotInterfaceLock,
387 "Camera %d: %s: Unable to lock interface lock, proceeding anyway",
388 mId, __FUNCTION__);
389 ALOGW_IF(!gotLock,
390 "Camera %d: %s: Unable to lock main lock, proceeding anyway",
391 mId, __FUNCTION__);
392
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800393 String8 lines;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800394
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800395 const char *status =
396 mStatus == STATUS_ERROR ? "ERROR" :
397 mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" :
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700398 mStatus == STATUS_UNCONFIGURED ? "UNCONFIGURED" :
399 mStatus == STATUS_CONFIGURED ? "CONFIGURED" :
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800400 mStatus == STATUS_ACTIVE ? "ACTIVE" :
401 "Unknown";
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700402
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800403 lines.appendFormat(" Device status: %s\n", status);
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700404 if (mStatus == STATUS_ERROR) {
405 lines.appendFormat(" Error cause: %s\n", mErrorCause.string());
406 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800407 lines.appendFormat(" Stream configuration:\n");
408
409 if (mInputStream != NULL) {
410 write(fd, lines.string(), lines.size());
411 mInputStream->dump(fd, args);
412 } else {
413 lines.appendFormat(" No input stream.\n");
414 write(fd, lines.string(), lines.size());
415 }
416 for (size_t i = 0; i < mOutputStreams.size(); i++) {
417 mOutputStreams[i]->dump(fd,args);
418 }
419
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700420 lines = String8(" In-flight requests:\n");
421 if (mInFlightMap.size() == 0) {
422 lines.append(" None\n");
423 } else {
424 for (size_t i = 0; i < mInFlightMap.size(); i++) {
425 InFlightRequest r = mInFlightMap.valueAt(i);
Colin Crosse5729fa2014-03-21 15:04:25 -0700426 lines.appendFormat(" Frame %d | Timestamp: %" PRId64 ", metadata"
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700427 " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i),
428 r.captureTimestamp, r.haveResultMetadata ? "true" : "false",
429 r.numBuffersLeft);
430 }
431 }
432 write(fd, lines.string(), lines.size());
433
Igor Murashkin1e479c02013-09-06 16:55:14 -0700434 {
435 lines = String8(" Last request sent:\n");
436 write(fd, lines.string(), lines.size());
437
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700438 CameraMetadata lastRequest = getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700439 lastRequest.dump(fd, /*verbosity*/2, /*indentation*/6);
440 }
441
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800442 if (mHal3Device != NULL) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700443 lines = String8(" HAL device dump:\n");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800444 write(fd, lines.string(), lines.size());
445 mHal3Device->ops->dump(mHal3Device, fd);
446 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800447
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700448 if (gotLock) mLock.unlock();
449 if (gotInterfaceLock) mInterfaceLock.unlock();
450
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800451 return OK;
452}
453
454const CameraMetadata& Camera3Device::info() const {
455 ALOGVV("%s: E", __FUNCTION__);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800456 if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED ||
457 mStatus == STATUS_ERROR)) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700458 ALOGW("%s: Access to static info %s!", __FUNCTION__,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800459 mStatus == STATUS_ERROR ?
460 "when in error state" : "before init");
461 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800462 return mDeviceInfo;
463}
464
Jianing Wei90e59c92014-03-12 18:29:36 -0700465status_t Camera3Device::checkStatusOkToCaptureLocked() {
466 switch (mStatus) {
467 case STATUS_ERROR:
468 CLOGE("Device has encountered a serious error");
469 return INVALID_OPERATION;
470 case STATUS_UNINITIALIZED:
471 CLOGE("Device not initialized");
472 return INVALID_OPERATION;
473 case STATUS_UNCONFIGURED:
474 case STATUS_CONFIGURED:
475 case STATUS_ACTIVE:
476 // OK
477 break;
478 default:
479 SET_ERR_L("Unexpected status: %d", mStatus);
480 return INVALID_OPERATION;
481 }
482 return OK;
483}
484
485status_t Camera3Device::convertMetadataListToRequestListLocked(
486 const List<const CameraMetadata> &metadataList, RequestList *requestList) {
487 if (requestList == NULL) {
488 CLOGE("requestList cannot be NULL.");
489 return BAD_VALUE;
490 }
491
Jianing Weicb0652e2014-03-12 18:29:36 -0700492 int32_t burstId = 0;
Jianing Wei90e59c92014-03-12 18:29:36 -0700493 for (List<const CameraMetadata>::const_iterator it = metadataList.begin();
494 it != metadataList.end(); ++it) {
495 sp<CaptureRequest> newRequest = setUpRequestLocked(*it);
496 if (newRequest == 0) {
497 CLOGE("Can't create capture request");
498 return BAD_VALUE;
499 }
Jianing Weicb0652e2014-03-12 18:29:36 -0700500
501 // Setup burst Id and request Id
502 newRequest->mResultExtras.burstId = burstId++;
503 if (it->exists(ANDROID_REQUEST_ID)) {
504 if (it->find(ANDROID_REQUEST_ID).count == 0) {
505 CLOGE("RequestID entry exists; but must not be empty in metadata");
506 return BAD_VALUE;
507 }
508 newRequest->mResultExtras.requestId = it->find(ANDROID_REQUEST_ID).data.i32[0];
509 } else {
510 CLOGE("RequestID does not exist in metadata");
511 return BAD_VALUE;
512 }
513
Jianing Wei90e59c92014-03-12 18:29:36 -0700514 requestList->push_back(newRequest);
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700515
516 ALOGV("%s: requestId = %" PRId32, __FUNCTION__, newRequest->mResultExtras.requestId);
Jianing Wei90e59c92014-03-12 18:29:36 -0700517 }
518 return OK;
519}
520
Jianing Weicb0652e2014-03-12 18:29:36 -0700521status_t Camera3Device::capture(CameraMetadata &request, int64_t* /*lastFrameNumber*/) {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800522 ATRACE_CALL();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800523
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700524 List<const CameraMetadata> requests;
525 requests.push_back(request);
526 return captureList(requests, /*lastFrameNumber*/NULL);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800527}
528
Jianing Wei90e59c92014-03-12 18:29:36 -0700529status_t Camera3Device::submitRequestsHelper(
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700530 const List<const CameraMetadata> &requests, bool repeating,
531 /*out*/
532 int64_t *lastFrameNumber) {
Jianing Wei90e59c92014-03-12 18:29:36 -0700533 ATRACE_CALL();
534 Mutex::Autolock il(mInterfaceLock);
535 Mutex::Autolock l(mLock);
536
537 status_t res = checkStatusOkToCaptureLocked();
538 if (res != OK) {
539 // error logged by previous call
540 return res;
541 }
542
543 RequestList requestList;
544
545 res = convertMetadataListToRequestListLocked(requests, /*out*/&requestList);
546 if (res != OK) {
547 // error logged by previous call
548 return res;
549 }
550
551 if (repeating) {
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700552 res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber);
Jianing Wei90e59c92014-03-12 18:29:36 -0700553 } else {
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700554 res = mRequestThread->queueRequestList(requestList, lastFrameNumber);
Jianing Wei90e59c92014-03-12 18:29:36 -0700555 }
556
557 if (res == OK) {
558 waitUntilStateThenRelock(/*active*/true, kActiveTimeout);
559 if (res != OK) {
560 SET_ERR_L("Can't transition to active in %f seconds!",
561 kActiveTimeout/1e9);
562 }
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700563 ALOGV("Camera %d: Capture request %" PRId32 " enqueued", mId,
564 (*(requestList.begin()))->mResultExtras.requestId);
Jianing Wei90e59c92014-03-12 18:29:36 -0700565 } else {
566 CLOGE("Cannot queue request. Impossible.");
567 return BAD_VALUE;
568 }
569
570 return res;
571}
572
Jianing Weicb0652e2014-03-12 18:29:36 -0700573status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,
574 int64_t *lastFrameNumber) {
Jianing Wei90e59c92014-03-12 18:29:36 -0700575 ATRACE_CALL();
576
Jianing Weicb0652e2014-03-12 18:29:36 -0700577 return submitRequestsHelper(requests, /*repeating*/false, lastFrameNumber);
Jianing Wei90e59c92014-03-12 18:29:36 -0700578}
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800579
Jianing Weicb0652e2014-03-12 18:29:36 -0700580status_t Camera3Device::setStreamingRequest(const CameraMetadata &request,
581 int64_t* /*lastFrameNumber*/) {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800582 ATRACE_CALL();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800583
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700584 List<const CameraMetadata> requests;
585 requests.push_back(request);
586 return setStreamingRequestList(requests, /*lastFrameNumber*/NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800587}
588
Jianing Weicb0652e2014-03-12 18:29:36 -0700589status_t Camera3Device::setStreamingRequestList(const List<const CameraMetadata> &requests,
590 int64_t *lastFrameNumber) {
Jianing Wei90e59c92014-03-12 18:29:36 -0700591 ATRACE_CALL();
592
Jianing Weicb0652e2014-03-12 18:29:36 -0700593 return submitRequestsHelper(requests, /*repeating*/true, lastFrameNumber);
Jianing Wei90e59c92014-03-12 18:29:36 -0700594}
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800595
596sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(
597 const CameraMetadata &request) {
598 status_t res;
599
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700600 if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800601 res = configureStreamsLocked();
602 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700603 SET_ERR_L("Can't set up streams: %s (%d)", strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800604 return NULL;
605 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700606 if (mStatus == STATUS_UNCONFIGURED) {
607 CLOGE("No streams configured");
608 return NULL;
609 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800610 }
611
612 sp<CaptureRequest> newRequest = createCaptureRequest(request);
613 return newRequest;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800614}
615
Jianing Weicb0652e2014-03-12 18:29:36 -0700616status_t Camera3Device::clearStreamingRequest(int64_t *lastFrameNumber) {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800617 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700618 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800619 Mutex::Autolock l(mLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800620
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800621 switch (mStatus) {
622 case STATUS_ERROR:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700623 CLOGE("Device has encountered a serious error");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800624 return INVALID_OPERATION;
625 case STATUS_UNINITIALIZED:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700626 CLOGE("Device not initialized");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800627 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700628 case STATUS_UNCONFIGURED:
629 case STATUS_CONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800630 case STATUS_ACTIVE:
631 // OK
632 break;
633 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700634 SET_ERR_L("Unexpected status: %d", mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800635 return INVALID_OPERATION;
636 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700637 ALOGV("Camera %d: Clearing repeating request", mId);
Jianing Weicb0652e2014-03-12 18:29:36 -0700638
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700639 return mRequestThread->clearRepeatingRequests(lastFrameNumber);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800640}
641
642status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) {
643 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700644 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800645
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700646 return mRequestThread->waitUntilRequestProcessed(requestId, timeout);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800647}
648
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700649status_t Camera3Device::createInputStream(
650 uint32_t width, uint32_t height, int format, int *id) {
651 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700652 Mutex::Autolock il(mInterfaceLock);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700653 Mutex::Autolock l(mLock);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700654 ALOGV("Camera %d: Creating new input stream %d: %d x %d, format %d",
655 mId, mNextStreamId, width, height, format);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700656
657 status_t res;
658 bool wasActive = false;
659
660 switch (mStatus) {
661 case STATUS_ERROR:
662 ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
663 return INVALID_OPERATION;
664 case STATUS_UNINITIALIZED:
665 ALOGE("%s: Device not initialized", __FUNCTION__);
666 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700667 case STATUS_UNCONFIGURED:
668 case STATUS_CONFIGURED:
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700669 // OK
670 break;
671 case STATUS_ACTIVE:
672 ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700673 res = internalPauseAndWaitLocked();
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700674 if (res != OK) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700675 SET_ERR_L("Can't pause captures to reconfigure streams!");
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700676 return res;
677 }
678 wasActive = true;
679 break;
680 default:
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700681 SET_ERR_L("%s: Unexpected status: %d", mStatus);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700682 return INVALID_OPERATION;
683 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700684 assert(mStatus != STATUS_ACTIVE);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700685
686 if (mInputStream != 0) {
687 ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
688 return INVALID_OPERATION;
689 }
690
691 sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId,
692 width, height, format);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700693 newStream->setStatusTracker(mStatusTracker);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700694
695 mInputStream = newStream;
696
697 *id = mNextStreamId++;
698
699 // Continue captures if active at start
700 if (wasActive) {
701 ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
702 res = configureStreamsLocked();
703 if (res != OK) {
704 ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
705 __FUNCTION__, mNextStreamId, strerror(-res), res);
706 return res;
707 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700708 internalResumeLocked();
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700709 }
710
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700711 ALOGV("Camera %d: Created input stream", mId);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700712 return OK;
713}
714
Igor Murashkin2fba5842013-04-22 14:03:54 -0700715
716status_t Camera3Device::createZslStream(
717 uint32_t width, uint32_t height,
718 int depth,
719 /*out*/
720 int *id,
721 sp<Camera3ZslStream>* zslStream) {
722 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700723 Mutex::Autolock il(mInterfaceLock);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700724 Mutex::Autolock l(mLock);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700725 ALOGV("Camera %d: Creating ZSL stream %d: %d x %d, depth %d",
726 mId, mNextStreamId, width, height, depth);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700727
728 status_t res;
729 bool wasActive = false;
730
731 switch (mStatus) {
732 case STATUS_ERROR:
733 ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
734 return INVALID_OPERATION;
735 case STATUS_UNINITIALIZED:
736 ALOGE("%s: Device not initialized", __FUNCTION__);
737 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700738 case STATUS_UNCONFIGURED:
739 case STATUS_CONFIGURED:
Igor Murashkin2fba5842013-04-22 14:03:54 -0700740 // OK
741 break;
742 case STATUS_ACTIVE:
743 ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700744 res = internalPauseAndWaitLocked();
Igor Murashkin2fba5842013-04-22 14:03:54 -0700745 if (res != OK) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700746 SET_ERR_L("Can't pause captures to reconfigure streams!");
Igor Murashkin2fba5842013-04-22 14:03:54 -0700747 return res;
748 }
749 wasActive = true;
750 break;
751 default:
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700752 SET_ERR_L("Unexpected status: %d", mStatus);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700753 return INVALID_OPERATION;
754 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700755 assert(mStatus != STATUS_ACTIVE);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700756
757 if (mInputStream != 0) {
758 ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
759 return INVALID_OPERATION;
760 }
761
762 sp<Camera3ZslStream> newStream = new Camera3ZslStream(mNextStreamId,
763 width, height, depth);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700764 newStream->setStatusTracker(mStatusTracker);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700765
766 res = mOutputStreams.add(mNextStreamId, newStream);
767 if (res < 0) {
768 ALOGE("%s: Can't add new stream to set: %s (%d)",
769 __FUNCTION__, strerror(-res), res);
770 return res;
771 }
772 mInputStream = newStream;
773
Yuvraj Pasie5e3d082014-04-15 18:37:45 +0530774 mNeedConfig = true;
775
Igor Murashkin2fba5842013-04-22 14:03:54 -0700776 *id = mNextStreamId++;
777 *zslStream = newStream;
778
779 // Continue captures if active at start
780 if (wasActive) {
781 ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
782 res = configureStreamsLocked();
783 if (res != OK) {
784 ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
785 __FUNCTION__, mNextStreamId, strerror(-res), res);
786 return res;
787 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700788 internalResumeLocked();
Igor Murashkin2fba5842013-04-22 14:03:54 -0700789 }
790
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700791 ALOGV("Camera %d: Created ZSL stream", mId);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700792 return OK;
793}
794
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800795status_t Camera3Device::createStream(sp<ANativeWindow> consumer,
796 uint32_t width, uint32_t height, int format, size_t size, int *id) {
797 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700798 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800799 Mutex::Autolock l(mLock);
Colin Crosse5729fa2014-03-21 15:04:25 -0700800 ALOGV("Camera %d: Creating new stream %d: %d x %d, format %d, size %zu",
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700801 mId, mNextStreamId, width, height, format, size);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800802
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800803 status_t res;
804 bool wasActive = false;
805
806 switch (mStatus) {
807 case STATUS_ERROR:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700808 CLOGE("Device has encountered a serious error");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800809 return INVALID_OPERATION;
810 case STATUS_UNINITIALIZED:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700811 CLOGE("Device not initialized");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800812 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700813 case STATUS_UNCONFIGURED:
814 case STATUS_CONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800815 // OK
816 break;
817 case STATUS_ACTIVE:
818 ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700819 res = internalPauseAndWaitLocked();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800820 if (res != OK) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700821 SET_ERR_L("Can't pause captures to reconfigure streams!");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800822 return res;
823 }
824 wasActive = true;
825 break;
826 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700827 SET_ERR_L("Unexpected status: %d", mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800828 return INVALID_OPERATION;
829 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700830 assert(mStatus != STATUS_ACTIVE);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800831
832 sp<Camera3OutputStream> newStream;
833 if (format == HAL_PIXEL_FORMAT_BLOB) {
Zhijun Hef7da0962014-04-24 13:27:56 -0700834 ssize_t jpegBufferSize = getJpegBufferSize(width, height);
835 if (jpegBufferSize > 0) {
836 ALOGV("%s: Overwrite Jpeg output buffer size from %zu to %zu",
837 __FUNCTION__, size, jpegBufferSize);
838 } else {
839 SET_ERR_L("Invalid jpeg buffer size %zd", jpegBufferSize);
840 return BAD_VALUE;
841 }
842
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800843 newStream = new Camera3OutputStream(mNextStreamId, consumer,
Zhijun Hef7da0962014-04-24 13:27:56 -0700844 width, height, jpegBufferSize, format);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800845 } else {
846 newStream = new Camera3OutputStream(mNextStreamId, consumer,
847 width, height, format);
848 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700849 newStream->setStatusTracker(mStatusTracker);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800850
851 res = mOutputStreams.add(mNextStreamId, newStream);
852 if (res < 0) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700853 SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800854 return res;
855 }
856
857 *id = mNextStreamId++;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700858 mNeedConfig = true;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800859
860 // Continue captures if active at start
861 if (wasActive) {
862 ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
863 res = configureStreamsLocked();
864 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700865 CLOGE("Can't reconfigure device for new stream %d: %s (%d)",
866 mNextStreamId, strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800867 return res;
868 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700869 internalResumeLocked();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800870 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700871 ALOGV("Camera %d: Created new stream", mId);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800872 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800873}
874
875status_t Camera3Device::createReprocessStreamFromStream(int outputId, int *id) {
876 ATRACE_CALL();
877 (void)outputId; (void)id;
878
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700879 CLOGE("Unimplemented");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800880 return INVALID_OPERATION;
881}
882
883
884status_t Camera3Device::getStreamInfo(int id,
885 uint32_t *width, uint32_t *height, uint32_t *format) {
886 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700887 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800888 Mutex::Autolock l(mLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800889
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800890 switch (mStatus) {
891 case STATUS_ERROR:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700892 CLOGE("Device has encountered a serious error");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800893 return INVALID_OPERATION;
894 case STATUS_UNINITIALIZED:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700895 CLOGE("Device not initialized!");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800896 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700897 case STATUS_UNCONFIGURED:
898 case STATUS_CONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800899 case STATUS_ACTIVE:
900 // OK
901 break;
902 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700903 SET_ERR_L("Unexpected status: %d", mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800904 return INVALID_OPERATION;
905 }
906
907 ssize_t idx = mOutputStreams.indexOfKey(id);
908 if (idx == NAME_NOT_FOUND) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700909 CLOGE("Stream %d is unknown", id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800910 return idx;
911 }
912
913 if (width) *width = mOutputStreams[idx]->getWidth();
914 if (height) *height = mOutputStreams[idx]->getHeight();
915 if (format) *format = mOutputStreams[idx]->getFormat();
916
917 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800918}
919
920status_t Camera3Device::setStreamTransform(int id,
921 int transform) {
922 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700923 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800924 Mutex::Autolock l(mLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800925
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800926 switch (mStatus) {
927 case STATUS_ERROR:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700928 CLOGE("Device has encountered a serious error");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800929 return INVALID_OPERATION;
930 case STATUS_UNINITIALIZED:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700931 CLOGE("Device not initialized");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800932 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700933 case STATUS_UNCONFIGURED:
934 case STATUS_CONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800935 case STATUS_ACTIVE:
936 // OK
937 break;
938 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700939 SET_ERR_L("Unexpected status: %d", mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800940 return INVALID_OPERATION;
941 }
942
943 ssize_t idx = mOutputStreams.indexOfKey(id);
944 if (idx == NAME_NOT_FOUND) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700945 CLOGE("Stream %d does not exist",
946 id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800947 return BAD_VALUE;
948 }
949
950 return mOutputStreams.editValueAt(idx)->setTransform(transform);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800951}
952
953status_t Camera3Device::deleteStream(int id) {
954 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700955 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800956 Mutex::Autolock l(mLock);
957 status_t res;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800958
Igor Murashkine2172be2013-05-28 15:31:39 -0700959 ALOGV("%s: Camera %d: Deleting stream %d", __FUNCTION__, mId, id);
960
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800961 // CameraDevice semantics require device to already be idle before
962 // deleteStream is called, unlike for createStream.
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700963 if (mStatus == STATUS_ACTIVE) {
Igor Murashkin52827132013-05-13 14:53:44 -0700964 ALOGV("%s: Camera %d: Device not idle", __FUNCTION__, mId);
965 return -EBUSY;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800966 }
967
Igor Murashkin2fba5842013-04-22 14:03:54 -0700968 sp<Camera3StreamInterface> deletedStream;
Zhijun He5f446352014-01-22 09:49:33 -0800969 ssize_t outputStreamIdx = mOutputStreams.indexOfKey(id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800970 if (mInputStream != NULL && id == mInputStream->getId()) {
971 deletedStream = mInputStream;
972 mInputStream.clear();
973 } else {
Zhijun He5f446352014-01-22 09:49:33 -0800974 if (outputStreamIdx == NAME_NOT_FOUND) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700975 CLOGE("Stream %d does not exist", id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800976 return BAD_VALUE;
977 }
Zhijun He5f446352014-01-22 09:49:33 -0800978 }
979
980 // Delete output stream or the output part of a bi-directional stream.
981 if (outputStreamIdx != NAME_NOT_FOUND) {
982 deletedStream = mOutputStreams.editValueAt(outputStreamIdx);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800983 mOutputStreams.removeItem(id);
984 }
985
986 // Free up the stream endpoint so that it can be used by some other stream
987 res = deletedStream->disconnect();
988 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700989 SET_ERR_L("Can't disconnect deleted stream %d", id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800990 // fall through since we want to still list the stream as deleted.
991 }
992 mDeletedStreams.add(deletedStream);
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700993 mNeedConfig = true;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800994
995 return res;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800996}
997
998status_t Camera3Device::deleteReprocessStream(int id) {
999 ATRACE_CALL();
1000 (void)id;
1001
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001002 CLOGE("Unimplemented");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001003 return INVALID_OPERATION;
1004}
1005
1006
1007status_t Camera3Device::createDefaultRequest(int templateId,
1008 CameraMetadata *request) {
1009 ATRACE_CALL();
Alex Rayfe7e0c62013-05-30 00:12:13 -07001010 ALOGV("%s: for template %d", __FUNCTION__, templateId);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001011 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001012 Mutex::Autolock l(mLock);
1013
1014 switch (mStatus) {
1015 case STATUS_ERROR:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001016 CLOGE("Device has encountered a serious error");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001017 return INVALID_OPERATION;
1018 case STATUS_UNINITIALIZED:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001019 CLOGE("Device is not initialized!");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001020 return INVALID_OPERATION;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001021 case STATUS_UNCONFIGURED:
1022 case STATUS_CONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001023 case STATUS_ACTIVE:
1024 // OK
1025 break;
1026 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001027 SET_ERR_L("Unexpected status: %d", mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001028 return INVALID_OPERATION;
1029 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001030
1031 const camera_metadata_t *rawRequest;
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07001032 ATRACE_BEGIN("camera3->construct_default_request_settings");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001033 rawRequest = mHal3Device->ops->construct_default_request_settings(
1034 mHal3Device, templateId);
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07001035 ATRACE_END();
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001036 if (rawRequest == NULL) {
1037 SET_ERR_L("HAL is unable to construct default settings for template %d",
1038 templateId);
1039 return DEAD_OBJECT;
1040 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001041 *request = rawRequest;
1042
1043 return OK;
1044}
1045
1046status_t Camera3Device::waitUntilDrained() {
1047 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001048 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001049 Mutex::Autolock l(mLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001050
Zhijun He69a37482014-03-23 18:44:49 -07001051 return waitUntilDrainedLocked();
1052}
1053
1054status_t Camera3Device::waitUntilDrainedLocked() {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001055 switch (mStatus) {
1056 case STATUS_UNINITIALIZED:
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001057 case STATUS_UNCONFIGURED:
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001058 ALOGV("%s: Already idle", __FUNCTION__);
1059 return OK;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001060 case STATUS_CONFIGURED:
1061 // To avoid race conditions, check with tracker to be sure
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001062 case STATUS_ERROR:
1063 case STATUS_ACTIVE:
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001064 // Need to verify shut down
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001065 break;
1066 default:
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001067 SET_ERR_L("Unexpected status: %d",mStatus);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001068 return INVALID_OPERATION;
1069 }
1070
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001071 ALOGV("%s: Camera %d: Waiting until idle", __FUNCTION__, mId);
1072 status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1073 return res;
1074}
1075
1076// Pause to reconfigure
1077status_t Camera3Device::internalPauseAndWaitLocked() {
1078 mRequestThread->setPaused(true);
1079 mPauseStateNotify = true;
1080
1081 ALOGV("%s: Camera %d: Internal wait until idle", __FUNCTION__, mId);
1082 status_t res = waitUntilStateThenRelock(/*active*/ false, kShutdownTimeout);
1083 if (res != OK) {
1084 SET_ERR_L("Can't idle device in %f seconds!",
1085 kShutdownTimeout/1e9);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001086 }
1087
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001088 return res;
1089}
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001090
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001091// Resume after internalPauseAndWaitLocked
1092status_t Camera3Device::internalResumeLocked() {
1093 status_t res;
1094
1095 mRequestThread->setPaused(false);
1096
1097 res = waitUntilStateThenRelock(/*active*/ true, kActiveTimeout);
1098 if (res != OK) {
1099 SET_ERR_L("Can't transition to active in %f seconds!",
1100 kActiveTimeout/1e9);
1101 }
1102 mPauseStateNotify = false;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001103 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001104}
1105
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001106status_t Camera3Device::waitUntilStateThenRelock(bool active,
1107 nsecs_t timeout) {
1108 status_t res = OK;
1109 if (active == (mStatus == STATUS_ACTIVE)) {
1110 // Desired state already reached
1111 return res;
1112 }
1113
1114 bool stateSeen = false;
1115 do {
1116 mRecentStatusUpdates.clear();
1117
1118 res = mStatusChanged.waitRelative(mLock, timeout);
1119 if (res != OK) break;
1120
1121 // Check state change history during wait
1122 for (size_t i = 0; i < mRecentStatusUpdates.size(); i++) {
1123 if (active == (mRecentStatusUpdates[i] == STATUS_ACTIVE) ) {
1124 stateSeen = true;
1125 break;
1126 }
1127 }
1128 } while (!stateSeen);
1129
1130 return res;
1131}
1132
1133
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001134status_t Camera3Device::setNotifyCallback(NotificationListener *listener) {
1135 ATRACE_CALL();
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001136 Mutex::Autolock l(mOutputLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001137
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001138 if (listener != NULL && mListener != NULL) {
1139 ALOGW("%s: Replacing old callback listener", __FUNCTION__);
1140 }
1141 mListener = listener;
1142
1143 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001144}
1145
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -07001146bool Camera3Device::willNotify3A() {
1147 return false;
1148}
1149
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001150status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001151 status_t res;
1152 Mutex::Autolock l(mOutputLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001153
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001154 while (mResultQueue.empty()) {
1155 res = mResultSignal.waitRelative(mOutputLock, timeout);
1156 if (res == TIMED_OUT) {
1157 return res;
1158 } else if (res != OK) {
Colin Crosse5729fa2014-03-21 15:04:25 -07001159 ALOGW("%s: Camera %d: No frame in %" PRId64 " ns: %s (%d)",
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001160 __FUNCTION__, mId, timeout, strerror(-res), res);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001161 return res;
1162 }
1163 }
1164 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001165}
1166
Jianing Weicb0652e2014-03-12 18:29:36 -07001167status_t Camera3Device::getNextResult(CaptureResult *frame) {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001168 ATRACE_CALL();
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001169 Mutex::Autolock l(mOutputLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001170
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001171 if (mResultQueue.empty()) {
1172 return NOT_ENOUGH_DATA;
1173 }
1174
Jianing Weicb0652e2014-03-12 18:29:36 -07001175 if (frame == NULL) {
1176 ALOGE("%s: argument cannot be NULL", __FUNCTION__);
1177 return BAD_VALUE;
1178 }
1179
1180 CaptureResult &result = *(mResultQueue.begin());
1181 frame->mResultExtras = result.mResultExtras;
1182 frame->mMetadata.acquire(result.mMetadata);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001183 mResultQueue.erase(mResultQueue.begin());
1184
1185 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001186}
1187
1188status_t Camera3Device::triggerAutofocus(uint32_t id) {
1189 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001190 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001191
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001192 ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id);
1193 // Mix-in this trigger into the next request and only the next request.
1194 RequestTrigger trigger[] = {
1195 {
1196 ANDROID_CONTROL_AF_TRIGGER,
1197 ANDROID_CONTROL_AF_TRIGGER_START
1198 },
1199 {
1200 ANDROID_CONTROL_AF_TRIGGER_ID,
1201 static_cast<int32_t>(id)
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001202 }
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001203 };
1204
1205 return mRequestThread->queueTrigger(trigger,
1206 sizeof(trigger)/sizeof(trigger[0]));
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001207}
1208
1209status_t Camera3Device::triggerCancelAutofocus(uint32_t id) {
1210 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001211 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001212
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001213 ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id);
1214 // Mix-in this trigger into the next request and only the next request.
1215 RequestTrigger trigger[] = {
1216 {
1217 ANDROID_CONTROL_AF_TRIGGER,
1218 ANDROID_CONTROL_AF_TRIGGER_CANCEL
1219 },
1220 {
1221 ANDROID_CONTROL_AF_TRIGGER_ID,
1222 static_cast<int32_t>(id)
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001223 }
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001224 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001225
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001226 return mRequestThread->queueTrigger(trigger,
1227 sizeof(trigger)/sizeof(trigger[0]));
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001228}
1229
1230status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) {
1231 ATRACE_CALL();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001232 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001233
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001234 ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id);
1235 // Mix-in this trigger into the next request and only the next request.
1236 RequestTrigger trigger[] = {
1237 {
1238 ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
1239 ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START
1240 },
1241 {
1242 ANDROID_CONTROL_AE_PRECAPTURE_ID,
1243 static_cast<int32_t>(id)
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001244 }
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001245 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001246
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001247 return mRequestThread->queueTrigger(trigger,
1248 sizeof(trigger)/sizeof(trigger[0]));
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001249}
1250
1251status_t Camera3Device::pushReprocessBuffer(int reprocessStreamId,
1252 buffer_handle_t *buffer, wp<BufferReleasedListener> listener) {
1253 ATRACE_CALL();
1254 (void)reprocessStreamId; (void)buffer; (void)listener;
1255
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001256 CLOGE("Unimplemented");
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001257 return INVALID_OPERATION;
1258}
1259
Jianing Weicb0652e2014-03-12 18:29:36 -07001260status_t Camera3Device::flush(int64_t *frameNumber) {
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001261 ATRACE_CALL();
1262 ALOGV("%s: Camera %d: Flushing all requests", __FUNCTION__, mId);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001263 Mutex::Autolock il(mInterfaceLock);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001264
Zhijun He7ef20392014-04-21 16:04:17 -07001265 {
1266 Mutex::Autolock l(mLock);
1267 mRequestThread->clear(/*out*/frameNumber);
1268 }
1269
Zhijun He491e3412013-12-27 10:57:44 -08001270 status_t res;
1271 if (mHal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_1) {
1272 res = mHal3Device->ops->flush(mHal3Device);
1273 } else {
Zhijun He7ef20392014-04-21 16:04:17 -07001274 Mutex::Autolock l(mLock);
Zhijun He69a37482014-03-23 18:44:49 -07001275 res = waitUntilDrainedLocked();
Zhijun He491e3412013-12-27 10:57:44 -08001276 }
1277
1278 return res;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001279}
1280
Zhijun He204e3292014-07-14 17:09:23 -07001281uint32_t Camera3Device::getDeviceVersion() {
1282 ATRACE_CALL();
1283 Mutex::Autolock il(mInterfaceLock);
1284 return mDeviceVersion;
1285}
1286
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001287/**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001288 * Methods called by subclasses
1289 */
1290
1291void Camera3Device::notifyStatus(bool idle) {
1292 {
1293 // Need mLock to safely update state and synchronize to current
1294 // state of methods in flight.
1295 Mutex::Autolock l(mLock);
1296 // We can get various system-idle notices from the status tracker
1297 // while starting up. Only care about them if we've actually sent
1298 // in some requests recently.
1299 if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) {
1300 return;
1301 }
1302 ALOGV("%s: Camera %d: Now %s", __FUNCTION__, mId,
1303 idle ? "idle" : "active");
1304 mStatus = idle ? STATUS_CONFIGURED : STATUS_ACTIVE;
1305 mRecentStatusUpdates.add(mStatus);
1306 mStatusChanged.signal();
1307
1308 // Skip notifying listener if we're doing some user-transparent
1309 // state changes
1310 if (mPauseStateNotify) return;
1311 }
1312 NotificationListener *listener;
1313 {
1314 Mutex::Autolock l(mOutputLock);
1315 listener = mListener;
1316 }
1317 if (idle && listener != NULL) {
1318 listener->notifyIdle();
1319 }
1320}
1321
1322/**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001323 * Camera3Device private methods
1324 */
1325
1326sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(
1327 const CameraMetadata &request) {
1328 ATRACE_CALL();
1329 status_t res;
1330
1331 sp<CaptureRequest> newRequest = new CaptureRequest;
1332 newRequest->mSettings = request;
1333
1334 camera_metadata_entry_t inputStreams =
1335 newRequest->mSettings.find(ANDROID_REQUEST_INPUT_STREAMS);
1336 if (inputStreams.count > 0) {
1337 if (mInputStream == NULL ||
Zhijun Hed1d64672013-09-06 15:00:01 -07001338 mInputStream->getId() != inputStreams.data.i32[0]) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001339 CLOGE("Request references unknown input stream %d",
1340 inputStreams.data.u8[0]);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001341 return NULL;
1342 }
1343 // Lazy completion of stream configuration (allocation/registration)
1344 // on first use
1345 if (mInputStream->isConfiguring()) {
1346 res = mInputStream->finishConfiguration(mHal3Device);
1347 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001348 SET_ERR_L("Unable to finish configuring input stream %d:"
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001349 " %s (%d)",
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001350 mInputStream->getId(), strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001351 return NULL;
1352 }
1353 }
1354
1355 newRequest->mInputStream = mInputStream;
1356 newRequest->mSettings.erase(ANDROID_REQUEST_INPUT_STREAMS);
1357 }
1358
1359 camera_metadata_entry_t streams =
1360 newRequest->mSettings.find(ANDROID_REQUEST_OUTPUT_STREAMS);
1361 if (streams.count == 0) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001362 CLOGE("Zero output streams specified!");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001363 return NULL;
1364 }
1365
1366 for (size_t i = 0; i < streams.count; i++) {
Zhijun Hed1d64672013-09-06 15:00:01 -07001367 int idx = mOutputStreams.indexOfKey(streams.data.i32[i]);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001368 if (idx == NAME_NOT_FOUND) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001369 CLOGE("Request references unknown stream %d",
1370 streams.data.u8[i]);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001371 return NULL;
1372 }
Igor Murashkin2fba5842013-04-22 14:03:54 -07001373 sp<Camera3OutputStreamInterface> stream =
1374 mOutputStreams.editValueAt(idx);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001375
1376 // Lazy completion of stream configuration (allocation/registration)
1377 // on first use
1378 if (stream->isConfiguring()) {
1379 res = stream->finishConfiguration(mHal3Device);
1380 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001381 SET_ERR_L("Unable to finish configuring stream %d: %s (%d)",
1382 stream->getId(), strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001383 return NULL;
1384 }
1385 }
1386
1387 newRequest->mOutputStreams.push(stream);
1388 }
1389 newRequest->mSettings.erase(ANDROID_REQUEST_OUTPUT_STREAMS);
1390
1391 return newRequest;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001392}
1393
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001394status_t Camera3Device::configureStreamsLocked() {
1395 ATRACE_CALL();
1396 status_t res;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001397
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001398 if (mStatus != STATUS_UNCONFIGURED && mStatus != STATUS_CONFIGURED) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001399 CLOGE("Not idle");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001400 return INVALID_OPERATION;
1401 }
1402
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -07001403 if (!mNeedConfig) {
1404 ALOGV("%s: Skipping config, no stream changes", __FUNCTION__);
1405 return OK;
1406 }
1407
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001408 // Start configuring the streams
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001409 ALOGV("%s: Camera %d: Starting stream configuration", __FUNCTION__, mId);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001410
1411 camera3_stream_configuration config;
1412
1413 config.num_streams = (mInputStream != NULL) + mOutputStreams.size();
1414
1415 Vector<camera3_stream_t*> streams;
1416 streams.setCapacity(config.num_streams);
1417
1418 if (mInputStream != NULL) {
1419 camera3_stream_t *inputStream;
1420 inputStream = mInputStream->startConfiguration();
1421 if (inputStream == NULL) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001422 SET_ERR_L("Can't start input stream configuration");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001423 return INVALID_OPERATION;
1424 }
1425 streams.add(inputStream);
1426 }
1427
1428 for (size_t i = 0; i < mOutputStreams.size(); i++) {
Igor Murashkin2fba5842013-04-22 14:03:54 -07001429
1430 // Don't configure bidi streams twice, nor add them twice to the list
1431 if (mOutputStreams[i].get() ==
1432 static_cast<Camera3StreamInterface*>(mInputStream.get())) {
1433
1434 config.num_streams--;
1435 continue;
1436 }
1437
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001438 camera3_stream_t *outputStream;
1439 outputStream = mOutputStreams.editValueAt(i)->startConfiguration();
1440 if (outputStream == NULL) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001441 SET_ERR_L("Can't start output stream configuration");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001442 return INVALID_OPERATION;
1443 }
1444 streams.add(outputStream);
1445 }
1446
1447 config.streams = streams.editArray();
1448
1449 // Do the HAL configuration; will potentially touch stream
1450 // max_buffers, usage, priv fields.
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07001451 ATRACE_BEGIN("camera3->configure_streams");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001452 res = mHal3Device->ops->configure_streams(mHal3Device, &config);
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07001453 ATRACE_END();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001454
1455 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001456 SET_ERR_L("Unable to configure streams with HAL: %s (%d)",
1457 strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001458 return res;
1459 }
1460
Eino-Ville Talvala4c956762013-04-19 17:26:13 -07001461 // Finish all stream configuration immediately.
1462 // TODO: Try to relax this later back to lazy completion, which should be
1463 // faster
1464
Igor Murashkin073f8572013-05-02 14:59:28 -07001465 if (mInputStream != NULL && mInputStream->isConfiguring()) {
Eino-Ville Talvala4c956762013-04-19 17:26:13 -07001466 res = mInputStream->finishConfiguration(mHal3Device);
1467 if (res != OK) {
1468 SET_ERR_L("Can't finish configuring input stream %d: %s (%d)",
1469 mInputStream->getId(), strerror(-res), res);
1470 return res;
1471 }
1472 }
1473
1474 for (size_t i = 0; i < mOutputStreams.size(); i++) {
Igor Murashkin073f8572013-05-02 14:59:28 -07001475 sp<Camera3OutputStreamInterface> outputStream =
1476 mOutputStreams.editValueAt(i);
1477 if (outputStream->isConfiguring()) {
1478 res = outputStream->finishConfiguration(mHal3Device);
1479 if (res != OK) {
1480 SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
1481 outputStream->getId(), strerror(-res), res);
1482 return res;
1483 }
Eino-Ville Talvala4c956762013-04-19 17:26:13 -07001484 }
1485 }
1486
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001487 // Request thread needs to know to avoid using repeat-last-settings protocol
1488 // across configure_streams() calls
1489 mRequestThread->configurationComplete();
1490
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001491 // Update device state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001492
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -07001493 mNeedConfig = false;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001494
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001495 if (config.num_streams > 0) {
1496 mStatus = STATUS_CONFIGURED;
1497 } else {
1498 mStatus = STATUS_UNCONFIGURED;
1499 }
1500
1501 ALOGV("%s: Camera %d: Stream configuration complete", __FUNCTION__, mId);
1502
Zhijun He0a210512014-07-24 13:45:15 -07001503 // tear down the deleted streams after configure streams.
1504 mDeletedStreams.clear();
1505
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001506 return OK;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001507}
1508
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001509void Camera3Device::setErrorState(const char *fmt, ...) {
1510 Mutex::Autolock l(mLock);
1511 va_list args;
1512 va_start(args, fmt);
1513
1514 setErrorStateLockedV(fmt, args);
1515
1516 va_end(args);
1517}
1518
1519void Camera3Device::setErrorStateV(const char *fmt, va_list args) {
1520 Mutex::Autolock l(mLock);
1521 setErrorStateLockedV(fmt, args);
1522}
1523
1524void Camera3Device::setErrorStateLocked(const char *fmt, ...) {
1525 va_list args;
1526 va_start(args, fmt);
1527
1528 setErrorStateLockedV(fmt, args);
1529
1530 va_end(args);
1531}
1532
1533void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001534 // Print out all error messages to log
1535 String8 errorCause = String8::formatV(fmt, args);
1536 ALOGE("Camera %d: %s", mId, errorCause.string());
1537
1538 // But only do error state transition steps for the first error
Zhijun Heb05eeae2013-06-06 13:51:22 -07001539 if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001540
Igor Murashkinff3e31d2013-10-23 16:40:06 -07001541 // Save stack trace. View by dumping it later.
1542 CameraTraces::saveTrace();
1543 // TODO: consider adding errorCause and client pid/procname
1544
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001545 mErrorCause = errorCause;
1546
1547 mRequestThread->setPaused(true);
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001548 mStatus = STATUS_ERROR;
1549}
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001550
1551/**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001552 * In-flight request management
1553 */
1554
Jianing Weicb0652e2014-03-12 18:29:36 -07001555status_t Camera3Device::registerInFlight(uint32_t frameNumber,
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001556 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001557 ATRACE_CALL();
1558 Mutex::Autolock l(mInFlightLock);
1559
1560 ssize_t res;
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001561 res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers, resultExtras, hasInput));
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001562 if (res < 0) return res;
1563
1564 return OK;
1565}
1566
1567/**
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001568 * Check if all 3A fields are ready, and send off a partial 3A-only result
1569 * to the output frame queue
1570 */
Zhijun He204e3292014-07-14 17:09:23 -07001571bool Camera3Device::processPartial3AResult(
Jianing Weicb0652e2014-03-12 18:29:36 -07001572 uint32_t frameNumber,
1573 const CameraMetadata& partial, const CaptureResultExtras& resultExtras) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001574
1575 // Check if all 3A states are present
1576 // The full list of fields is
1577 // android.control.afMode
1578 // android.control.awbMode
1579 // android.control.aeState
1580 // android.control.awbState
1581 // android.control.afState
1582 // android.control.afTriggerID
1583 // android.control.aePrecaptureID
1584 // TODO: Add android.control.aeMode
1585
1586 bool gotAllStates = true;
1587
1588 uint8_t afMode;
1589 uint8_t awbMode;
1590 uint8_t aeState;
1591 uint8_t afState;
1592 uint8_t awbState;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001593
1594 gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_MODE,
1595 &afMode, frameNumber);
1596
1597 gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_MODE,
1598 &awbMode, frameNumber);
1599
1600 gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AE_STATE,
1601 &aeState, frameNumber);
1602
1603 gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AF_STATE,
1604 &afState, frameNumber);
1605
1606 gotAllStates &= get3AResult(partial, ANDROID_CONTROL_AWB_STATE,
1607 &awbState, frameNumber);
1608
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001609 if (!gotAllStates) return false;
1610
Eino-Ville Talvala184dfe42013-11-07 15:13:16 -08001611 ALOGVV("%s: Camera %d: Frame %d, Request ID %d: AF mode %d, AWB mode %d, "
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001612 "AF state %d, AE state %d, AWB state %d, "
1613 "AF trigger %d, AE precapture trigger %d",
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07001614 __FUNCTION__, mId, frameNumber, resultExtras.requestId,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001615 afMode, awbMode,
1616 afState, aeState, awbState,
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001617 resultExtras.afTriggerId, resultExtras.precaptureTriggerId);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001618
1619 // Got all states, so construct a minimal result to send
1620 // In addition to the above fields, this means adding in
1621 // android.request.frameCount
Eino-Ville Talvala184dfe42013-11-07 15:13:16 -08001622 // android.request.requestId
Zhijun He204e3292014-07-14 17:09:23 -07001623 // android.quirks.partialResult (for HAL version below HAL3.2)
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001624
Eino-Ville Talvala184dfe42013-11-07 15:13:16 -08001625 const size_t kMinimal3AResultEntries = 10;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001626
1627 Mutex::Autolock l(mOutputLock);
1628
Jianing Weicb0652e2014-03-12 18:29:36 -07001629 CaptureResult captureResult;
1630 captureResult.mResultExtras = resultExtras;
1631 captureResult.mMetadata = CameraMetadata(kMinimal3AResultEntries, /*dataCapacity*/ 0);
1632 // TODO: change this to sp<CaptureResult>. This will need other changes, including,
1633 // but not limited to CameraDeviceBase::getNextResult
1634 CaptureResult& min3AResult =
1635 *mResultQueue.insert(mResultQueue.end(), captureResult);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001636
Jianing Weicb0652e2014-03-12 18:29:36 -07001637 if (!insert3AResult(min3AResult.mMetadata, ANDROID_REQUEST_FRAME_COUNT,
1638 // TODO: This is problematic casting. Need to fix CameraMetadata.
1639 reinterpret_cast<int32_t*>(&frameNumber), frameNumber)) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001640 return false;
1641 }
1642
Jianing Weicb0652e2014-03-12 18:29:36 -07001643 int32_t requestId = resultExtras.requestId;
1644 if (!insert3AResult(min3AResult.mMetadata, ANDROID_REQUEST_ID,
Eino-Ville Talvala184dfe42013-11-07 15:13:16 -08001645 &requestId, frameNumber)) {
1646 return false;
1647 }
1648
Zhijun He204e3292014-07-14 17:09:23 -07001649 if (mDeviceVersion < CAMERA_DEVICE_API_VERSION_3_2) {
1650 static const uint8_t partialResult = ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL;
1651 if (!insert3AResult(min3AResult.mMetadata, ANDROID_QUIRKS_PARTIAL_RESULT,
1652 &partialResult, frameNumber)) {
1653 return false;
1654 }
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001655 }
1656
Jianing Weicb0652e2014-03-12 18:29:36 -07001657 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_MODE,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001658 &afMode, frameNumber)) {
1659 return false;
1660 }
1661
Jianing Weicb0652e2014-03-12 18:29:36 -07001662 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AWB_MODE,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001663 &awbMode, frameNumber)) {
1664 return false;
1665 }
1666
Jianing Weicb0652e2014-03-12 18:29:36 -07001667 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AE_STATE,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001668 &aeState, frameNumber)) {
1669 return false;
1670 }
1671
Jianing Weicb0652e2014-03-12 18:29:36 -07001672 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_STATE,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001673 &afState, frameNumber)) {
1674 return false;
1675 }
1676
Jianing Weicb0652e2014-03-12 18:29:36 -07001677 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AWB_STATE,
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001678 &awbState, frameNumber)) {
1679 return false;
1680 }
1681
Jianing Weicb0652e2014-03-12 18:29:36 -07001682 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AF_TRIGGER_ID,
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001683 &resultExtras.afTriggerId, frameNumber)) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001684 return false;
1685 }
1686
Jianing Weicb0652e2014-03-12 18:29:36 -07001687 if (!insert3AResult(min3AResult.mMetadata, ANDROID_CONTROL_AE_PRECAPTURE_ID,
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07001688 &resultExtras.precaptureTriggerId, frameNumber)) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001689 return false;
1690 }
1691
Zhijun He204e3292014-07-14 17:09:23 -07001692 // We only send the aggregated partial when all 3A related metadata are available
1693 // For both API1 and API2.
1694 // TODO: we probably should pass through all partials to API2 unconditionally.
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001695 mResultSignal.signal();
1696
1697 return true;
1698}
1699
1700template<typename T>
1701bool Camera3Device::get3AResult(const CameraMetadata& result, int32_t tag,
Jianing Weicb0652e2014-03-12 18:29:36 -07001702 T* value, uint32_t frameNumber) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001703 (void) frameNumber;
1704
1705 camera_metadata_ro_entry_t entry;
1706
1707 entry = result.find(tag);
1708 if (entry.count == 0) {
1709 ALOGVV("%s: Camera %d: Frame %d: No %s provided by HAL!", __FUNCTION__,
1710 mId, frameNumber, get_camera_metadata_tag_name(tag));
1711 return false;
1712 }
1713
1714 if (sizeof(T) == sizeof(uint8_t)) {
1715 *value = entry.data.u8[0];
1716 } else if (sizeof(T) == sizeof(int32_t)) {
1717 *value = entry.data.i32[0];
1718 } else {
1719 ALOGE("%s: Unexpected type", __FUNCTION__);
1720 return false;
1721 }
1722 return true;
1723}
1724
1725template<typename T>
1726bool Camera3Device::insert3AResult(CameraMetadata& result, int32_t tag,
Jianing Weicb0652e2014-03-12 18:29:36 -07001727 const T* value, uint32_t frameNumber) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001728 if (result.update(tag, value, 1) != NO_ERROR) {
1729 mResultQueue.erase(--mResultQueue.end(), mResultQueue.end());
1730 SET_ERR("Frame %d: Failed to set %s in partial metadata",
1731 frameNumber, get_camera_metadata_tag_name(tag));
1732 return false;
1733 }
1734 return true;
1735}
1736
1737/**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001738 * Camera HAL device callback methods
1739 */
1740
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001741void Camera3Device::processCaptureResult(const camera3_capture_result *result) {
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001742 ATRACE_CALL();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001743
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001744 status_t res;
1745
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001746 uint32_t frameNumber = result->frame_number;
Zhijun Hef0d962a2014-06-30 10:24:11 -07001747 if (result->result == NULL && result->num_output_buffers == 0 &&
1748 result->input_buffer == NULL) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001749 SET_ERR("No result data provided by HAL for frame %d",
1750 frameNumber);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001751 return;
1752 }
Zhijun He204e3292014-07-14 17:09:23 -07001753
1754 // For HAL3.2 or above, If HAL doesn't support partial, it must always set
1755 // partial_result to 1 when metadata is included in this result.
1756 if (!mUsePartialResult &&
1757 mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2 &&
1758 result->result != NULL &&
1759 result->partial_result != 1) {
1760 SET_ERR("Result is malformed for frame %d: partial_result %u must be 1"
1761 " if partial result is not supported",
1762 frameNumber, result->partial_result);
1763 return;
1764 }
1765
1766 bool isPartialResult = false;
1767 CameraMetadata collectedPartialResult;
Jianing Weicb0652e2014-03-12 18:29:36 -07001768 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001769 bool hasInputBufferInRequest = false;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001770
Jianing Weicb0652e2014-03-12 18:29:36 -07001771 // Get capture timestamp and resultExtras from list of in-flight requests,
1772 // where it was added by the shutter notification for this frame.
1773 // Then update the in-flight status and remove the in-flight entry if
1774 // all result data has been received.
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001775 nsecs_t timestamp = 0;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001776 {
1777 Mutex::Autolock l(mInFlightLock);
1778 ssize_t idx = mInFlightMap.indexOfKey(frameNumber);
1779 if (idx == NAME_NOT_FOUND) {
1780 SET_ERR("Unknown frame number for capture result: %d",
1781 frameNumber);
1782 return;
1783 }
1784 InFlightRequest &request = mInFlightMap.editValueAt(idx);
Jianing Weicb0652e2014-03-12 18:29:36 -07001785 ALOGVV("%s: got InFlightRequest requestId = %" PRId32 ", frameNumber = %" PRId64
1786 ", burstId = %" PRId32,
1787 __FUNCTION__, request.resultExtras.requestId, request.resultExtras.frameNumber,
1788 request.resultExtras.burstId);
Zhijun He204e3292014-07-14 17:09:23 -07001789 // Always update the partial count to the latest one. When framework aggregates adjacent
1790 // partial results into one, the latest partial count will be used.
1791 request.resultExtras.partialResultCount = result->partial_result;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001792
1793 // Check if this result carries only partial metadata
Zhijun He204e3292014-07-14 17:09:23 -07001794 if (mUsePartialResult && result->result != NULL) {
1795 if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
1796 if (result->partial_result > mNumPartialResults || result->partial_result < 1) {
1797 SET_ERR("Result is malformed for frame %d: partial_result %u must be in"
1798 " the range of [1, %d] when metadata is included in the result",
1799 frameNumber, result->partial_result, mNumPartialResults);
1800 return;
1801 }
1802 isPartialResult = (result->partial_result < mNumPartialResults);
Zhijun He5d76e1a2014-07-22 16:08:13 -07001803 if (isPartialResult) {
1804 request.partialResult.collectedResult.append(result->result);
1805 }
Zhijun He204e3292014-07-14 17:09:23 -07001806 } else {
1807 camera_metadata_ro_entry_t partialResultEntry;
1808 res = find_camera_metadata_ro_entry(result->result,
1809 ANDROID_QUIRKS_PARTIAL_RESULT, &partialResultEntry);
1810 if (res != NAME_NOT_FOUND &&
1811 partialResultEntry.count > 0 &&
1812 partialResultEntry.data.u8[0] ==
1813 ANDROID_QUIRKS_PARTIAL_RESULT_PARTIAL) {
1814 // A partial result. Flag this as such, and collect this
1815 // set of metadata into the in-flight entry.
1816 isPartialResult = true;
1817 request.partialResult.collectedResult.append(
1818 result->result);
1819 request.partialResult.collectedResult.erase(
1820 ANDROID_QUIRKS_PARTIAL_RESULT);
1821 }
1822 }
1823
1824 if (isPartialResult) {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001825 // Fire off a 3A-only result if possible
Zhijun He204e3292014-07-14 17:09:23 -07001826 if (!request.partialResult.haveSent3A) {
1827 request.partialResult.haveSent3A =
1828 processPartial3AResult(frameNumber,
1829 request.partialResult.collectedResult,
Jianing Weicb0652e2014-03-12 18:29:36 -07001830 request.resultExtras);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001831 }
1832 }
1833 }
1834
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001835 timestamp = request.captureTimestamp;
Jianing Weicb0652e2014-03-12 18:29:36 -07001836 resultExtras = request.resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001837 hasInputBufferInRequest = request.hasInputBuffer;
Jianing Weicb0652e2014-03-12 18:29:36 -07001838
Zhijun He1d1f8462013-10-02 16:29:51 -07001839 /**
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001840 * One of the following must happen before it's legal to call process_capture_result,
1841 * unless partial metadata is being provided:
Zhijun He1d1f8462013-10-02 16:29:51 -07001842 * - CAMERA3_MSG_SHUTTER (expected during normal operation)
1843 * - CAMERA3_MSG_ERROR (expected during flush)
1844 */
Zhijun He204e3292014-07-14 17:09:23 -07001845 if (request.requestStatus == OK && timestamp == 0 && !isPartialResult) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001846 SET_ERR("Called before shutter notify for frame %d",
1847 frameNumber);
1848 return;
1849 }
1850
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001851 // Did we get the (final) result metadata for this capture?
Zhijun He204e3292014-07-14 17:09:23 -07001852 if (result->result != NULL && !isPartialResult) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001853 if (request.haveResultMetadata) {
1854 SET_ERR("Called multiple times with metadata for frame %d",
1855 frameNumber);
1856 return;
1857 }
Zhijun He204e3292014-07-14 17:09:23 -07001858 if (mUsePartialResult &&
1859 !request.partialResult.collectedResult.isEmpty()) {
1860 collectedPartialResult.acquire(
1861 request.partialResult.collectedResult);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001862 }
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001863 request.haveResultMetadata = true;
1864 }
1865
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001866 uint32_t numBuffersReturned = result->num_output_buffers;
1867 if (result->input_buffer != NULL) {
1868 if (hasInputBufferInRequest) {
1869 numBuffersReturned += 1;
1870 } else {
1871 ALOGW("%s: Input buffer should be NULL if there is no input"
1872 " buffer sent in the request",
1873 __FUNCTION__);
1874 }
1875 }
1876 request.numBuffersLeft -= numBuffersReturned;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001877 if (request.numBuffersLeft < 0) {
1878 SET_ERR("Too many buffers returned for frame %d",
1879 frameNumber);
1880 return;
1881 }
1882
Zhijun He1b05dfc2013-11-21 12:57:51 -08001883 // Check if everything has arrived for this result (buffers and metadata), remove it from
1884 // InFlightMap if both arrived or HAL reports error for this request (i.e. during flush).
1885 if ((request.requestStatus != OK) ||
1886 (request.haveResultMetadata && request.numBuffersLeft == 0)) {
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07001887 ATRACE_ASYNC_END("frame capture", frameNumber);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001888 mInFlightMap.removeItemsAt(idx, 1);
1889 }
1890
1891 // Sanity check - if we have too many in-flight frames, something has
1892 // likely gone wrong
1893 if (mInFlightMap.size() > kInFlightWarnLimit) {
Colin Crosse5729fa2014-03-21 15:04:25 -07001894 CLOGE("In-flight list too large: %zu", mInFlightMap.size());
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001895 }
1896
1897 }
1898
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001899 // Process the result metadata, if provided
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001900 bool gotResult = false;
Zhijun He204e3292014-07-14 17:09:23 -07001901 if (result->result != NULL && !isPartialResult) {
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001902 Mutex::Autolock l(mOutputLock);
1903
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001904 gotResult = true;
1905
Jianing Wei3c76fa32014-04-21 11:34:34 -07001906 // TODO: need to track errors for tighter bounds on expected frame number
1907 if (frameNumber < mNextResultFrameNumber) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001908 SET_ERR("Out-of-order capture result metadata submitted! "
1909 "(got frame number %d, expecting %d)",
1910 frameNumber, mNextResultFrameNumber);
1911 return;
1912 }
Jianing Wei3c76fa32014-04-21 11:34:34 -07001913 mNextResultFrameNumber = frameNumber + 1;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001914
Jianing Weicb0652e2014-03-12 18:29:36 -07001915 CaptureResult captureResult;
1916 captureResult.mResultExtras = resultExtras;
1917 captureResult.mMetadata = result->result;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001918
Jianing Weicb0652e2014-03-12 18:29:36 -07001919 if (captureResult.mMetadata.update(ANDROID_REQUEST_FRAME_COUNT,
1920 (int32_t*)&frameNumber, 1) != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001921 SET_ERR("Failed to set frame# in metadata (%d)",
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001922 frameNumber);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001923 gotResult = false;
Igor Murashkind2c90692013-04-02 12:32:32 -07001924 } else {
1925 ALOGVV("%s: Camera %d: Set frame# in metadata (%d)",
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001926 __FUNCTION__, mId, frameNumber);
Igor Murashkind2c90692013-04-02 12:32:32 -07001927 }
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001928
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001929 // Append any previous partials to form a complete result
Zhijun He204e3292014-07-14 17:09:23 -07001930 if (mUsePartialResult && !collectedPartialResult.isEmpty()) {
1931 captureResult.mMetadata.append(collectedPartialResult);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001932 }
1933
Jianing Weicb0652e2014-03-12 18:29:36 -07001934 captureResult.mMetadata.sort();
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001935
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001936 // Check that there's a timestamp in the result metadata
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001937
1938 camera_metadata_entry entry =
Jianing Weicb0652e2014-03-12 18:29:36 -07001939 captureResult.mMetadata.find(ANDROID_SENSOR_TIMESTAMP);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001940 if (entry.count == 0) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001941 SET_ERR("No timestamp provided by HAL for frame %d!",
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001942 frameNumber);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001943 gotResult = false;
Alex Rayfe7e0c62013-05-30 00:12:13 -07001944 } else if (timestamp != entry.data.i64[0]) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001945 SET_ERR("Timestamp mismatch between shutter notify and result"
Colin Crosse5729fa2014-03-21 15:04:25 -07001946 " metadata for frame %d (%" PRId64 " vs %" PRId64 " respectively)",
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001947 frameNumber, timestamp, entry.data.i64[0]);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001948 gotResult = false;
1949 }
1950
1951 if (gotResult) {
1952 // Valid result, insert into queue
Jianing Weicb0652e2014-03-12 18:29:36 -07001953 List<CaptureResult>::iterator queuedResult =
1954 mResultQueue.insert(mResultQueue.end(), CaptureResult(captureResult));
1955 ALOGVV("%s: result requestId = %" PRId32 ", frameNumber = %" PRId64
1956 ", burstId = %" PRId32, __FUNCTION__,
1957 queuedResult->mResultExtras.requestId,
1958 queuedResult->mResultExtras.frameNumber,
1959 queuedResult->mResultExtras.burstId);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001960 }
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001961 } // scope for mOutputLock
1962
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001963 // Return completed buffers to their streams with the timestamp
1964
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001965 for (size_t i = 0; i < result->num_output_buffers; i++) {
1966 Camera3Stream *stream =
1967 Camera3Stream::cast(result->output_buffers[i].stream);
1968 res = stream->returnBuffer(result->output_buffers[i], timestamp);
1969 // Note: stream may be deallocated at this point, if this buffer was the
1970 // last reference to it.
1971 if (res != OK) {
Colin Crosse5729fa2014-03-21 15:04:25 -07001972 ALOGE("Can't return buffer %zu for frame %d to its stream: "
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001973 " %s (%d)", i, frameNumber, strerror(-res), res);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001974 }
1975 }
1976
Zhijun Hef0d962a2014-06-30 10:24:11 -07001977 if (result->input_buffer != NULL) {
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001978 if (hasInputBufferInRequest) {
1979 Camera3Stream *stream =
1980 Camera3Stream::cast(result->input_buffer->stream);
1981 res = stream->returnInputBuffer(*(result->input_buffer));
1982 // Note: stream may be deallocated at this point, if this buffer was the
1983 // last reference to it.
1984 if (res != OK) {
1985 ALOGE("%s: RequestThread: Can't return input buffer for frame %d to"
1986 " its stream:%s (%d)", __FUNCTION__,
1987 frameNumber, strerror(-res), res);
Zhijun He0ea8fa42014-07-07 17:05:38 -07001988 }
1989 } else {
1990 ALOGW("%s: Input buffer should be NULL if there is no input"
1991 " buffer sent in the request, skipping input buffer return.",
1992 __FUNCTION__);
Zhijun Hef0d962a2014-06-30 10:24:11 -07001993 }
1994 }
1995
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -07001996 // Finally, signal any waiters for new frames
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001997
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001998 if (gotResult) {
Igor Murashkin4345d5b2013-05-17 14:39:53 -07001999 mResultSignal.signal();
2000 }
2001
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08002002}
2003
2004void Camera3Device::notify(const camera3_notify_msg *msg) {
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07002005 ATRACE_CALL();
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002006 NotificationListener *listener;
2007 {
2008 Mutex::Autolock l(mOutputLock);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002009 listener = mListener;
2010 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08002011
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002012 if (msg == NULL) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002013 SET_ERR("HAL sent NULL notify message!");
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002014 return;
2015 }
2016
2017 switch (msg->type) {
2018 case CAMERA3_MSG_ERROR: {
2019 int streamId = 0;
2020 if (msg->message.error.error_stream != NULL) {
2021 Camera3Stream *stream =
2022 Camera3Stream::cast(
2023 msg->message.error.error_stream);
2024 streamId = stream->getId();
2025 }
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07002026 ALOGV("Camera %d: %s: HAL error, frame %d, stream %d: %d",
2027 mId, __FUNCTION__, msg->message.error.frame_number,
2028 streamId, msg->message.error.error_code);
Zhijun He1d1f8462013-10-02 16:29:51 -07002029
Jianing Weicb0652e2014-03-12 18:29:36 -07002030 CaptureResultExtras resultExtras;
Zhijun He1d1f8462013-10-02 16:29:51 -07002031 // Set request error status for the request in the in-flight tracking
2032 {
2033 Mutex::Autolock l(mInFlightLock);
2034 ssize_t idx = mInFlightMap.indexOfKey(msg->message.error.frame_number);
2035 if (idx >= 0) {
Jianing Weicb0652e2014-03-12 18:29:36 -07002036 InFlightRequest &r = mInFlightMap.editValueAt(idx);
2037 r.requestStatus = msg->message.error.error_code;
2038 resultExtras = r.resultExtras;
2039 } else {
2040 resultExtras.frameNumber = msg->message.error.frame_number;
2041 ALOGE("Camera %d: %s: cannot find in-flight request on frame %" PRId64
2042 " error", mId, __FUNCTION__, resultExtras.frameNumber);
Zhijun He1d1f8462013-10-02 16:29:51 -07002043 }
2044 }
2045
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002046 if (listener != NULL) {
Jianing Weicb0652e2014-03-12 18:29:36 -07002047 if (msg->message.error.error_code == CAMERA3_MSG_ERROR_DEVICE) {
2048 listener->notifyError(ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE,
2049 resultExtras);
Jianing Weicb0652e2014-03-12 18:29:36 -07002050 }
2051 } else {
2052 ALOGE("Camera %d: %s: no listener available", mId, __FUNCTION__);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002053 }
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002054 break;
2055 }
2056 case CAMERA3_MSG_SHUTTER: {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002057 ssize_t idx;
2058 uint32_t frameNumber = msg->message.shutter.frame_number;
2059 nsecs_t timestamp = msg->message.shutter.timestamp;
2060 // Verify ordering of shutter notifications
2061 {
2062 Mutex::Autolock l(mOutputLock);
Jianing Wei3c76fa32014-04-21 11:34:34 -07002063 // TODO: need to track errors for tighter bounds on expected frame number.
2064 if (frameNumber < mNextShutterFrameNumber) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002065 SET_ERR("Shutter notification out-of-order. Expected "
2066 "notification for frame %d, got frame %d",
2067 mNextShutterFrameNumber, frameNumber);
2068 break;
2069 }
Jianing Wei3c76fa32014-04-21 11:34:34 -07002070 mNextShutterFrameNumber = frameNumber + 1;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002071 }
2072
Jianing Weicb0652e2014-03-12 18:29:36 -07002073 CaptureResultExtras resultExtras;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002074
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002075 // Set timestamp for the request in the in-flight tracking
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002076 // and get the request ID to send upstream
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002077 {
2078 Mutex::Autolock l(mInFlightLock);
2079 idx = mInFlightMap.indexOfKey(frameNumber);
2080 if (idx >= 0) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002081 InFlightRequest &r = mInFlightMap.editValueAt(idx);
2082 r.captureTimestamp = timestamp;
Jianing Weicb0652e2014-03-12 18:29:36 -07002083 resultExtras = r.resultExtras;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002084 }
2085 }
2086 if (idx < 0) {
2087 SET_ERR("Shutter notification for non-existent frame number %d",
2088 frameNumber);
2089 break;
2090 }
Colin Crosse5729fa2014-03-21 15:04:25 -07002091 ALOGVV("Camera %d: %s: Shutter fired for frame %d (id %d) at %" PRId64,
Jianing Weicb0652e2014-03-12 18:29:36 -07002092 mId, __FUNCTION__, frameNumber, resultExtras.requestId, timestamp);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002093 // Call listener, if any
2094 if (listener != NULL) {
Jianing Weicb0652e2014-03-12 18:29:36 -07002095 listener->notifyShutter(resultExtras, timestamp);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002096 }
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002097 break;
2098 }
2099 default:
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002100 SET_ERR("Unknown notify message from HAL: %d",
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07002101 msg->type);
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07002102 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08002103}
2104
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002105CameraMetadata Camera3Device::getLatestRequestLocked() {
Igor Murashkin1e479c02013-09-06 16:55:14 -07002106 ALOGV("%s", __FUNCTION__);
2107
Igor Murashkin1e479c02013-09-06 16:55:14 -07002108 CameraMetadata retVal;
2109
2110 if (mRequestThread != NULL) {
2111 retVal = mRequestThread->getLatestRequest();
2112 }
2113
Igor Murashkin1e479c02013-09-06 16:55:14 -07002114 return retVal;
2115}
2116
Jianing Weicb0652e2014-03-12 18:29:36 -07002117
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08002118/**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002119 * RequestThread inner class methods
2120 */
2121
2122Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002123 sp<StatusTracker> statusTracker,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002124 camera3_device_t *hal3Device) :
2125 Thread(false),
2126 mParent(parent),
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002127 mStatusTracker(statusTracker),
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002128 mHal3Device(hal3Device),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002129 mId(getId(parent)),
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002130 mReconfigured(false),
2131 mDoPause(false),
2132 mPaused(true),
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002133 mFrameNumber(0),
Jianing Weicb0652e2014-03-12 18:29:36 -07002134 mLatestRequestId(NAME_NOT_FOUND),
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002135 mRepeatingLastFrameNumber(NO_IN_FLIGHT_REPEATING_FRAMES) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002136 mStatusId = statusTracker->addComponent();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002137}
2138
2139void Camera3Device::RequestThread::configurationComplete() {
2140 Mutex::Autolock l(mRequestLock);
2141 mReconfigured = true;
2142}
2143
Jianing Wei90e59c92014-03-12 18:29:36 -07002144status_t Camera3Device::RequestThread::queueRequestList(
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002145 List<sp<CaptureRequest> > &requests,
2146 /*out*/
2147 int64_t *lastFrameNumber) {
Jianing Wei90e59c92014-03-12 18:29:36 -07002148 Mutex::Autolock l(mRequestLock);
2149 for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end();
2150 ++it) {
2151 mRequestQueue.push_back(*it);
2152 }
2153
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002154 if (lastFrameNumber != NULL) {
2155 *lastFrameNumber = mFrameNumber + mRequestQueue.size() - 1;
2156 ALOGV("%s: requestId %d, mFrameNumber %" PRId32 ", lastFrameNumber %" PRId64 ".",
2157 __FUNCTION__, (*(requests.begin()))->mResultExtras.requestId, mFrameNumber,
2158 *lastFrameNumber);
2159 }
Jianing Weicb0652e2014-03-12 18:29:36 -07002160
Jianing Wei90e59c92014-03-12 18:29:36 -07002161 unpauseForNewRequests();
2162
2163 return OK;
2164}
2165
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002166
2167status_t Camera3Device::RequestThread::queueTrigger(
2168 RequestTrigger trigger[],
2169 size_t count) {
2170
2171 Mutex::Autolock l(mTriggerMutex);
2172 status_t ret;
2173
2174 for (size_t i = 0; i < count; ++i) {
2175 ret = queueTriggerLocked(trigger[i]);
2176
2177 if (ret != OK) {
2178 return ret;
2179 }
2180 }
2181
2182 return OK;
2183}
2184
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002185int Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
2186 sp<Camera3Device> d = device.promote();
2187 if (d != NULL) return d->mId;
2188 return 0;
2189}
2190
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002191status_t Camera3Device::RequestThread::queueTriggerLocked(
2192 RequestTrigger trigger) {
2193
2194 uint32_t tag = trigger.metadataTag;
2195 ssize_t index = mTriggerMap.indexOfKey(tag);
2196
2197 switch (trigger.getTagType()) {
2198 case TYPE_BYTE:
2199 // fall-through
2200 case TYPE_INT32:
2201 break;
2202 default:
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002203 ALOGE("%s: Type not supported: 0x%x", __FUNCTION__,
2204 trigger.getTagType());
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002205 return INVALID_OPERATION;
2206 }
2207
2208 /**
2209 * Collect only the latest trigger, since we only have 1 field
2210 * in the request settings per trigger tag, and can't send more than 1
2211 * trigger per request.
2212 */
2213 if (index != NAME_NOT_FOUND) {
2214 mTriggerMap.editValueAt(index) = trigger;
2215 } else {
2216 mTriggerMap.add(tag, trigger);
2217 }
2218
2219 return OK;
2220}
2221
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002222status_t Camera3Device::RequestThread::setRepeatingRequests(
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002223 const RequestList &requests,
2224 /*out*/
2225 int64_t *lastFrameNumber) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002226 Mutex::Autolock l(mRequestLock);
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002227 if (lastFrameNumber != NULL) {
2228 *lastFrameNumber = mRepeatingLastFrameNumber;
2229 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002230 mRepeatingRequests.clear();
2231 mRepeatingRequests.insert(mRepeatingRequests.begin(),
2232 requests.begin(), requests.end());
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07002233
2234 unpauseForNewRequests();
2235
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002236 mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002237 return OK;
2238}
2239
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -07002240bool Camera3Device::RequestThread::isRepeatingRequestLocked(const sp<CaptureRequest> requestIn) {
2241 if (mRepeatingRequests.empty()) {
2242 return false;
2243 }
2244 int32_t requestId = requestIn->mResultExtras.requestId;
2245 const RequestList &repeatRequests = mRepeatingRequests;
2246 // All repeating requests are guaranteed to have same id so only check first quest
2247 const sp<CaptureRequest> firstRequest = *repeatRequests.begin();
2248 return (firstRequest->mResultExtras.requestId == requestId);
2249}
2250
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002251status_t Camera3Device::RequestThread::clearRepeatingRequests(/*out*/int64_t *lastFrameNumber) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002252 Mutex::Autolock l(mRequestLock);
2253 mRepeatingRequests.clear();
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002254 if (lastFrameNumber != NULL) {
2255 *lastFrameNumber = mRepeatingLastFrameNumber;
2256 }
2257 mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002258 return OK;
2259}
2260
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002261status_t Camera3Device::RequestThread::clear(/*out*/int64_t *lastFrameNumber) {
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07002262 Mutex::Autolock l(mRequestLock);
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002263 ALOGV("RequestThread::%s:", __FUNCTION__);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07002264 mRepeatingRequests.clear();
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -07002265
2266 // Decrement repeating frame count for those requests never sent to device
2267 // TODO: Remove this after we have proper error handling so these requests
2268 // will generate an error callback. This might be the only place calling
2269 // isRepeatingRequestLocked. If so, isRepeatingRequestLocked should also be removed.
2270 const RequestList &requests = mRequestQueue;
2271 for (RequestList::const_iterator it = requests.begin();
2272 it != requests.end(); ++it) {
2273 if (isRepeatingRequestLocked(*it)) {
2274 mRepeatingLastFrameNumber--;
2275 }
2276 }
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07002277 mRequestQueue.clear();
2278 mTriggerMap.clear();
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002279 if (lastFrameNumber != NULL) {
2280 *lastFrameNumber = mRepeatingLastFrameNumber;
2281 }
2282 mRepeatingLastFrameNumber = NO_IN_FLIGHT_REPEATING_FRAMES;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07002283 return OK;
2284}
2285
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002286void Camera3Device::RequestThread::setPaused(bool paused) {
2287 Mutex::Autolock l(mPauseLock);
2288 mDoPause = paused;
2289 mDoPauseSignal.signal();
2290}
2291
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002292status_t Camera3Device::RequestThread::waitUntilRequestProcessed(
2293 int32_t requestId, nsecs_t timeout) {
2294 Mutex::Autolock l(mLatestRequestMutex);
2295 status_t res;
2296 while (mLatestRequestId != requestId) {
2297 nsecs_t startTime = systemTime();
2298
2299 res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
2300 if (res != OK) return res;
2301
2302 timeout -= (systemTime() - startTime);
2303 }
2304
2305 return OK;
2306}
2307
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002308void Camera3Device::RequestThread::requestExit() {
2309 // Call parent to set up shutdown
2310 Thread::requestExit();
2311 // The exit from any possible waits
2312 mDoPauseSignal.signal();
2313 mRequestSignal.signal();
2314}
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002315
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002316bool Camera3Device::RequestThread::threadLoop() {
2317
2318 status_t res;
2319
2320 // Handle paused state.
2321 if (waitIfPaused()) {
2322 return true;
2323 }
2324
2325 // Get work to do
2326
2327 sp<CaptureRequest> nextRequest = waitForNextRequest();
2328 if (nextRequest == NULL) {
2329 return true;
2330 }
2331
2332 // Create request to HAL
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002333 camera3_capture_request_t request = camera3_capture_request_t();
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002334 request.frame_number = nextRequest->mResultExtras.frameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002335 Vector<camera3_stream_buffer_t> outputBuffers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002336
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002337 // Get the request ID, if any
2338 int requestId;
2339 camera_metadata_entry_t requestIdEntry =
2340 nextRequest->mSettings.find(ANDROID_REQUEST_ID);
2341 if (requestIdEntry.count > 0) {
2342 requestId = requestIdEntry.data.i32[0];
2343 } else {
2344 ALOGW("%s: Did not have android.request.id set in the request",
2345 __FUNCTION__);
2346 requestId = NAME_NOT_FOUND;
2347 }
2348
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002349 // Insert any queued triggers (before metadata is locked)
2350 int32_t triggerCount;
2351 res = insertTriggers(nextRequest);
2352 if (res < 0) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07002353 SET_ERR("RequestThread: Unable to insert triggers "
2354 "(capture request %d, HAL device: %s (%d)",
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002355 request.frame_number, strerror(-res), res);
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002356 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2357 return false;
2358 }
2359 triggerCount = res;
2360
2361 bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0);
2362
2363 // If the request is the same as last, or we had triggers last time
2364 if (mPrevRequest != nextRequest || triggersMixedIn) {
2365 /**
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -07002366 * HAL workaround:
2367 * Insert a dummy trigger ID if a trigger is set but no trigger ID is
2368 */
2369 res = addDummyTriggerIds(nextRequest);
2370 if (res != OK) {
2371 SET_ERR("RequestThread: Unable to insert dummy trigger IDs "
2372 "(capture request %d, HAL device: %s (%d)",
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002373 request.frame_number, strerror(-res), res);
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -07002374 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2375 return false;
2376 }
2377
2378 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002379 * The request should be presorted so accesses in HAL
2380 * are O(logn). Sidenote, sorting a sorted metadata is nop.
2381 */
2382 nextRequest->mSettings.sort();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002383 request.settings = nextRequest->mSettings.getAndLock();
2384 mPrevRequest = nextRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002385 ALOGVV("%s: Request settings are NEW", __FUNCTION__);
2386
2387 IF_ALOGV() {
2388 camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
2389 find_camera_metadata_ro_entry(
2390 request.settings,
2391 ANDROID_CONTROL_AF_TRIGGER,
2392 &e
2393 );
2394 if (e.count > 0) {
2395 ALOGV("%s: Request (frame num %d) had AF trigger 0x%x",
2396 __FUNCTION__,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002397 request.frame_number,
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002398 e.data.u8[0]);
2399 }
2400 }
2401 } else {
2402 // leave request.settings NULL to indicate 'reuse latest given'
2403 ALOGVV("%s: Request settings are REUSED",
2404 __FUNCTION__);
2405 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002406
2407 camera3_stream_buffer_t inputBuffer;
Zhijun Hef0d962a2014-06-30 10:24:11 -07002408 uint32_t totalNumBuffers = 0;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002409
2410 // Fill in buffers
2411
2412 if (nextRequest->mInputStream != NULL) {
2413 request.input_buffer = &inputBuffer;
Igor Murashkin5a269fa2013-04-15 14:59:22 -07002414 res = nextRequest->mInputStream->getInputBuffer(&inputBuffer);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002415 if (res != OK) {
Eino-Ville Talvala07d21692013-09-24 18:04:19 -07002416 ALOGE("RequestThread: Can't get input buffer, skipping request:"
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002417 " %s (%d)", strerror(-res), res);
2418 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2419 return true;
2420 }
Zhijun Hef0d962a2014-06-30 10:24:11 -07002421 totalNumBuffers += 1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002422 } else {
2423 request.input_buffer = NULL;
2424 }
2425
2426 outputBuffers.insertAt(camera3_stream_buffer_t(), 0,
2427 nextRequest->mOutputStreams.size());
2428 request.output_buffers = outputBuffers.array();
2429 for (size_t i = 0; i < nextRequest->mOutputStreams.size(); i++) {
2430 res = nextRequest->mOutputStreams.editItemAt(i)->
2431 getBuffer(&outputBuffers.editItemAt(i));
2432 if (res != OK) {
Eino-Ville Talvala07d21692013-09-24 18:04:19 -07002433 ALOGE("RequestThread: Can't get output buffer, skipping request:"
2434 " %s (%d)", strerror(-res), res);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002435 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2436 return true;
2437 }
2438 request.num_output_buffers++;
2439 }
Zhijun Hef0d962a2014-06-30 10:24:11 -07002440 totalNumBuffers += request.num_output_buffers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002441
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002442 // Log request in the in-flight queue
2443 sp<Camera3Device> parent = mParent.promote();
2444 if (parent == NULL) {
2445 CLOGE("RequestThread: Parent is gone");
2446 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2447 return false;
2448 }
2449
Jianing Weicb0652e2014-03-12 18:29:36 -07002450 res = parent->registerInFlight(request.frame_number,
Zhijun Hec98bd8d2014-07-07 12:44:10 -07002451 totalNumBuffers, nextRequest->mResultExtras,
2452 /*hasInput*/request.input_buffer != NULL);
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002453 ALOGVV("%s: registered in flight requestId = %" PRId32 ", frameNumber = %" PRId64
2454 ", burstId = %" PRId32 ".",
Jianing Weicb0652e2014-03-12 18:29:36 -07002455 __FUNCTION__,
2456 nextRequest->mResultExtras.requestId, nextRequest->mResultExtras.frameNumber,
2457 nextRequest->mResultExtras.burstId);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07002458 if (res != OK) {
2459 SET_ERR("RequestThread: Unable to register new in-flight request:"
2460 " %s (%d)", strerror(-res), res);
2461 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2462 return false;
2463 }
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002464
Zhijun Hecc27e112013-10-03 16:12:43 -07002465 // Inform waitUntilRequestProcessed thread of a new request ID
2466 {
2467 Mutex::Autolock al(mLatestRequestMutex);
2468
2469 mLatestRequestId = requestId;
2470 mLatestRequestSignal.signal();
2471 }
2472
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002473 // Submit request and block until ready for next one
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07002474 ATRACE_ASYNC_BEGIN("frame capture", request.frame_number);
2475 ATRACE_BEGIN("camera3->process_capture_request");
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002476 res = mHal3Device->ops->process_capture_request(mHal3Device, &request);
Eino-Ville Talvala17a61ad2013-06-03 16:53:32 -07002477 ATRACE_END();
2478
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002479 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07002480 SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002481 " device: %s (%d)", request.frame_number, strerror(-res), res);
2482 cleanUpFailedRequest(request, nextRequest, outputBuffers);
2483 return false;
2484 }
2485
Igor Murashkin1e479c02013-09-06 16:55:14 -07002486 // Update the latest request sent to HAL
2487 if (request.settings != NULL) { // Don't update them if they were unchanged
2488 Mutex::Autolock al(mLatestRequestMutex);
2489
2490 camera_metadata_t* cloned = clone_camera_metadata(request.settings);
2491 mLatestRequest.acquire(cloned);
2492 }
2493
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002494 if (request.settings != NULL) {
2495 nextRequest->mSettings.unlock(request.settings);
2496 }
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002497
2498 // Remove any previously queued triggers (after unlock)
2499 res = removeTriggers(mPrevRequest);
2500 if (res != OK) {
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07002501 SET_ERR("RequestThread: Unable to remove triggers "
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002502 "(capture request %d, HAL device: %s (%d)",
2503 request.frame_number, strerror(-res), res);
2504 return false;
2505 }
2506 mPrevTriggers = triggerCount;
2507
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002508 return true;
2509}
2510
Igor Murashkin1e479c02013-09-06 16:55:14 -07002511CameraMetadata Camera3Device::RequestThread::getLatestRequest() const {
2512 Mutex::Autolock al(mLatestRequestMutex);
2513
2514 ALOGV("RequestThread::%s", __FUNCTION__);
2515
2516 return mLatestRequest;
2517}
2518
Jianing Weicb0652e2014-03-12 18:29:36 -07002519
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002520void Camera3Device::RequestThread::cleanUpFailedRequest(
2521 camera3_capture_request_t &request,
2522 sp<CaptureRequest> &nextRequest,
2523 Vector<camera3_stream_buffer_t> &outputBuffers) {
2524
2525 if (request.settings != NULL) {
2526 nextRequest->mSettings.unlock(request.settings);
2527 }
2528 if (request.input_buffer != NULL) {
2529 request.input_buffer->status = CAMERA3_BUFFER_STATUS_ERROR;
Igor Murashkin5a269fa2013-04-15 14:59:22 -07002530 nextRequest->mInputStream->returnInputBuffer(*(request.input_buffer));
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002531 }
2532 for (size_t i = 0; i < request.num_output_buffers; i++) {
2533 outputBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
2534 nextRequest->mOutputStreams.editItemAt(i)->returnBuffer(
2535 outputBuffers[i], 0);
2536 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002537}
2538
2539sp<Camera3Device::CaptureRequest>
2540 Camera3Device::RequestThread::waitForNextRequest() {
2541 status_t res;
2542 sp<CaptureRequest> nextRequest;
2543
2544 // Optimized a bit for the simple steady-state case (single repeating
2545 // request), to avoid putting that request in the queue temporarily.
2546 Mutex::Autolock l(mRequestLock);
2547
2548 while (mRequestQueue.empty()) {
2549 if (!mRepeatingRequests.empty()) {
2550 // Always atomically enqueue all requests in a repeating request
2551 // list. Guarantees a complete in-sequence set of captures to
2552 // application.
2553 const RequestList &requests = mRepeatingRequests;
2554 RequestList::const_iterator firstRequest =
2555 requests.begin();
2556 nextRequest = *firstRequest;
2557 mRequestQueue.insert(mRequestQueue.end(),
2558 ++firstRequest,
2559 requests.end());
2560 // No need to wait any longer
Jianing Weicb0652e2014-03-12 18:29:36 -07002561
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002562 mRepeatingLastFrameNumber = mFrameNumber + requests.size() - 1;
Jianing Weicb0652e2014-03-12 18:29:36 -07002563
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002564 break;
2565 }
2566
2567 res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);
2568
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002569 if ((mRequestQueue.empty() && mRepeatingRequests.empty()) ||
2570 exitPending()) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002571 Mutex::Autolock pl(mPauseLock);
2572 if (mPaused == false) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002573 ALOGV("%s: RequestThread: Going idle", __FUNCTION__);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002574 mPaused = true;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002575 // Let the tracker know
2576 sp<StatusTracker> statusTracker = mStatusTracker.promote();
2577 if (statusTracker != 0) {
2578 statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
2579 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002580 }
2581 // Stop waiting for now and let thread management happen
2582 return NULL;
2583 }
2584 }
2585
2586 if (nextRequest == NULL) {
2587 // Don't have a repeating request already in hand, so queue
2588 // must have an entry now.
2589 RequestList::iterator firstRequest =
2590 mRequestQueue.begin();
2591 nextRequest = *firstRequest;
2592 mRequestQueue.erase(firstRequest);
2593 }
2594
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07002595 // In case we've been unpaused by setPaused clearing mDoPause, need to
2596 // update internal pause state (capture/setRepeatingRequest unpause
2597 // directly).
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002598 Mutex::Autolock pl(mPauseLock);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002599 if (mPaused) {
2600 ALOGV("%s: RequestThread: Unpaused", __FUNCTION__);
2601 sp<StatusTracker> statusTracker = mStatusTracker.promote();
2602 if (statusTracker != 0) {
2603 statusTracker->markComponentActive(mStatusId);
2604 }
2605 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002606 mPaused = false;
2607
2608 // Check if we've reconfigured since last time, and reset the preview
2609 // request if so. Can't use 'NULL request == repeat' across configure calls.
2610 if (mReconfigured) {
2611 mPrevRequest.clear();
2612 mReconfigured = false;
2613 }
2614
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07002615 if (nextRequest != NULL) {
2616 nextRequest->mResultExtras.frameNumber = mFrameNumber++;
2617 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002618 return nextRequest;
2619}
2620
2621bool Camera3Device::RequestThread::waitIfPaused() {
2622 status_t res;
2623 Mutex::Autolock l(mPauseLock);
2624 while (mDoPause) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002625 if (mPaused == false) {
2626 mPaused = true;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002627 ALOGV("%s: RequestThread: Paused", __FUNCTION__);
2628 // Let the tracker know
2629 sp<StatusTracker> statusTracker = mStatusTracker.promote();
2630 if (statusTracker != 0) {
2631 statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
2632 }
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002633 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002634
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002635 res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002636 if (res == TIMED_OUT || exitPending()) {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002637 return true;
2638 }
2639 }
2640 // We don't set mPaused to false here, because waitForNextRequest needs
2641 // to further manage the paused state in case of starvation.
2642 return false;
2643}
2644
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07002645void Camera3Device::RequestThread::unpauseForNewRequests() {
2646 // With work to do, mark thread as unpaused.
2647 // If paused by request (setPaused), don't resume, to avoid
2648 // extra signaling/waiting overhead to waitUntilPaused
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002649 mRequestSignal.signal();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07002650 Mutex::Autolock p(mPauseLock);
2651 if (!mDoPause) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07002652 ALOGV("%s: RequestThread: Going active", __FUNCTION__);
2653 if (mPaused) {
2654 sp<StatusTracker> statusTracker = mStatusTracker.promote();
2655 if (statusTracker != 0) {
2656 statusTracker->markComponentActive(mStatusId);
2657 }
2658 }
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07002659 mPaused = false;
2660 }
2661}
2662
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07002663void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) {
2664 sp<Camera3Device> parent = mParent.promote();
2665 if (parent != NULL) {
2666 va_list args;
2667 va_start(args, fmt);
2668
2669 parent->setErrorStateV(fmt, args);
2670
2671 va_end(args);
2672 }
2673}
2674
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002675status_t Camera3Device::RequestThread::insertTriggers(
2676 const sp<CaptureRequest> &request) {
2677
2678 Mutex::Autolock al(mTriggerMutex);
2679
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07002680 sp<Camera3Device> parent = mParent.promote();
2681 if (parent == NULL) {
2682 CLOGE("RequestThread: Parent is gone");
2683 return DEAD_OBJECT;
2684 }
2685
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002686 CameraMetadata &metadata = request->mSettings;
2687 size_t count = mTriggerMap.size();
2688
2689 for (size_t i = 0; i < count; ++i) {
2690 RequestTrigger trigger = mTriggerMap.valueAt(i);
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002691 uint32_t tag = trigger.metadataTag;
Yin-Chia Yeh741ace82014-06-23 14:07:56 -07002692
2693 if (tag == ANDROID_CONTROL_AF_TRIGGER_ID || tag == ANDROID_CONTROL_AE_PRECAPTURE_ID) {
2694 bool isAeTrigger = (trigger.metadataTag == ANDROID_CONTROL_AE_PRECAPTURE_ID);
2695 uint32_t triggerId = static_cast<uint32_t>(trigger.entryValue);
2696 isAeTrigger ? request->mResultExtras.precaptureTriggerId = triggerId :
2697 request->mResultExtras.afTriggerId = triggerId;
2698 if (parent->mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
2699 continue; // Trigger ID tag is deprecated since device HAL 3.2
2700 }
2701 }
2702
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002703 camera_metadata_entry entry = metadata.find(tag);
2704
2705 if (entry.count > 0) {
2706 /**
2707 * Already has an entry for this trigger in the request.
2708 * Rewrite it with our requested trigger value.
2709 */
2710 RequestTrigger oldTrigger = trigger;
2711
2712 oldTrigger.entryValue = entry.data.u8[0];
2713
2714 mTriggerReplacedMap.add(tag, oldTrigger);
2715 } else {
2716 /**
2717 * More typical, no trigger entry, so we just add it
2718 */
2719 mTriggerRemovedMap.add(tag, trigger);
2720 }
2721
2722 status_t res;
2723
2724 switch (trigger.getTagType()) {
2725 case TYPE_BYTE: {
2726 uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
2727 res = metadata.update(tag,
2728 &entryValue,
2729 /*count*/1);
2730 break;
2731 }
2732 case TYPE_INT32:
2733 res = metadata.update(tag,
2734 &trigger.entryValue,
2735 /*count*/1);
2736 break;
2737 default:
2738 ALOGE("%s: Type not supported: 0x%x",
2739 __FUNCTION__,
2740 trigger.getTagType());
2741 return INVALID_OPERATION;
2742 }
2743
2744 if (res != OK) {
2745 ALOGE("%s: Failed to update request metadata with trigger tag %s"
2746 ", value %d", __FUNCTION__, trigger.getTagName(),
2747 trigger.entryValue);
2748 return res;
2749 }
2750
2751 ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__,
2752 trigger.getTagName(),
2753 trigger.entryValue);
2754 }
2755
2756 mTriggerMap.clear();
2757
2758 return count;
2759}
2760
2761status_t Camera3Device::RequestThread::removeTriggers(
2762 const sp<CaptureRequest> &request) {
2763 Mutex::Autolock al(mTriggerMutex);
2764
2765 CameraMetadata &metadata = request->mSettings;
2766
2767 /**
2768 * Replace all old entries with their old values.
2769 */
2770 for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) {
2771 RequestTrigger trigger = mTriggerReplacedMap.valueAt(i);
2772
2773 status_t res;
2774
2775 uint32_t tag = trigger.metadataTag;
2776 switch (trigger.getTagType()) {
2777 case TYPE_BYTE: {
2778 uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
2779 res = metadata.update(tag,
2780 &entryValue,
2781 /*count*/1);
2782 break;
2783 }
2784 case TYPE_INT32:
2785 res = metadata.update(tag,
2786 &trigger.entryValue,
2787 /*count*/1);
2788 break;
2789 default:
2790 ALOGE("%s: Type not supported: 0x%x",
2791 __FUNCTION__,
2792 trigger.getTagType());
2793 return INVALID_OPERATION;
2794 }
2795
2796 if (res != OK) {
2797 ALOGE("%s: Failed to restore request metadata with trigger tag %s"
2798 ", trigger value %d", __FUNCTION__,
2799 trigger.getTagName(), trigger.entryValue);
2800 return res;
2801 }
2802 }
2803 mTriggerReplacedMap.clear();
2804
2805 /**
2806 * Remove all new entries.
2807 */
2808 for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) {
2809 RequestTrigger trigger = mTriggerRemovedMap.valueAt(i);
2810 status_t res = metadata.erase(trigger.metadataTag);
2811
2812 if (res != OK) {
2813 ALOGE("%s: Failed to erase metadata with trigger tag %s"
2814 ", trigger value %d", __FUNCTION__,
2815 trigger.getTagName(), trigger.entryValue);
2816 return res;
2817 }
2818 }
2819 mTriggerRemovedMap.clear();
2820
2821 return OK;
2822}
2823
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -07002824status_t Camera3Device::RequestThread::addDummyTriggerIds(
2825 const sp<CaptureRequest> &request) {
2826 // Trigger ID 0 has special meaning in the HAL2 spec, so avoid it here
2827 static const int32_t dummyTriggerId = 1;
2828 status_t res;
2829
2830 CameraMetadata &metadata = request->mSettings;
2831
2832 // If AF trigger is active, insert a dummy AF trigger ID if none already
2833 // exists
2834 camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER);
2835 camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID);
2836 if (afTrigger.count > 0 &&
2837 afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE &&
2838 afId.count == 0) {
2839 res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &dummyTriggerId, 1);
2840 if (res != OK) return res;
2841 }
2842
2843 // If AE precapture trigger is active, insert a dummy precapture trigger ID
2844 // if none already exists
2845 camera_metadata_entry pcTrigger =
2846 metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
2847 camera_metadata_entry pcId = metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_ID);
2848 if (pcTrigger.count > 0 &&
2849 pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE &&
2850 pcId.count == 0) {
2851 res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
2852 &dummyTriggerId, 1);
2853 if (res != OK) return res;
2854 }
2855
2856 return OK;
2857}
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07002858
2859
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08002860/**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08002861 * Static callback forwarding methods from HAL to instance
2862 */
2863
2864void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb,
2865 const camera3_capture_result *result) {
2866 Camera3Device *d =
2867 const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
2868 d->processCaptureResult(result);
2869}
2870
2871void Camera3Device::sNotify(const camera3_callback_ops *cb,
2872 const camera3_notify_msg *msg) {
2873 Camera3Device *d =
2874 const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb));
2875 d->notify(msg);
2876}
2877
2878}; // namespace android