1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * Contains implementation of a class EmulatedFakeCamera2 that encapsulates
19 * functionality of an advanced fake camera.
20 */
21
22 #include <algorithm>
23 #include <cstdint>
24 #include <iterator>
25
26 #define LOG_NDEBUG 0
27 #define LOG_TAG "EmulatedCamera_FakeCamera2"
28 #include <utils/Log.h>
29
30 #include "EmulatedCameraFactory.h"
31 #include "EmulatedFakeCamera2.h"
32 #include "GrallocModule.h"
33 #include "common/libs/auto_resources/auto_resources.h"
34 #include "guest/libs/platform_support/api_level_fixes.h"
35
36 #define ERROR_CAMERA_NOT_PRESENT -EPIPE
37
38 #define CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT 0xFFFFFFFF
39
40 namespace android {
41
42 const int64_t USEC = 1000LL;
43 const int64_t MSEC = USEC * 1000LL;
44 const int64_t SEC = MSEC * 1000LL;
45
46 const uint32_t EmulatedFakeCamera2::kAvailableFormats[] = {
47 #if VSOC_PLATFORM_SDK_AFTER(K)
48 HAL_PIXEL_FORMAT_RAW16,
49 #endif
50 HAL_PIXEL_FORMAT_BLOB, HAL_PIXEL_FORMAT_RGBA_8888,
51 // HAL_PIXEL_FORMAT_YV12,
52 HAL_PIXEL_FORMAT_YCrCb_420_SP};
53
54 const uint32_t EmulatedFakeCamera2::kAvailableRawSizes[2] = {
55 640, 480
56 // mSensorWidth, mSensorHeight
57 };
58
59 const uint64_t EmulatedFakeCamera2::kAvailableRawMinDurations[1] = {
60 static_cast<uint64_t>(Sensor::kFrameDurationRange[0])};
61
62 const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesBack[4] = {
63 640, 480, 320, 240
64 // mSensorWidth, mSensorHeight
65 };
66
67 const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesFront[4] = {
68 320, 240, 160, 120
69 // mSensorWidth, mSensorHeight
70 };
71
72 const uint64_t EmulatedFakeCamera2::kAvailableProcessedMinDurations[1] = {
73 static_cast<uint64_t>(Sensor::kFrameDurationRange[0])};
74
75 const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesBack[2] = {
76 640, 480
77 // mSensorWidth, mSensorHeight
78 };
79
80 const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesFront[2] = {
81 320, 240
82 // mSensorWidth, mSensorHeight
83 };
84
85 const uint64_t EmulatedFakeCamera2::kAvailableJpegMinDurations[1] = {
86 static_cast<uint64_t>(Sensor::kFrameDurationRange[0])};
87
EmulatedFakeCamera2(int cameraId,bool facingBack,struct hw_module_t * module)88 EmulatedFakeCamera2::EmulatedFakeCamera2(int cameraId, bool facingBack,
89 struct hw_module_t *module)
90 : EmulatedCamera2(cameraId, module),
91 mFacingBack(facingBack),
92 mIsConnected(false) {
93 ALOGD("Constructing emulated fake camera 2 facing %s",
94 facingBack ? "back" : "front");
95 }
96
~EmulatedFakeCamera2()97 EmulatedFakeCamera2::~EmulatedFakeCamera2() {
98 if (mCameraInfo != NULL) {
99 free_camera_metadata(mCameraInfo);
100 }
101 }
102
103 /****************************************************************************
104 * Public API overrides
105 ***************************************************************************/
106
Initialize(const cvd::CameraDefinition & params)107 status_t EmulatedFakeCamera2::Initialize(const cvd::CameraDefinition ¶ms) {
108 status_t res;
109
110 for (size_t index = 0; index < params.resolutions.size(); ++index) {
111 mAvailableRawSizes.push_back(params.resolutions[index].width);
112 mAvailableRawSizes.push_back(params.resolutions[index].height);
113 mAvailableProcessedSizes.push_back(params.resolutions[index].width);
114 mAvailableProcessedSizes.push_back(params.resolutions[index].height);
115 mAvailableJpegSizes.push_back(params.resolutions[index].width);
116 mAvailableJpegSizes.push_back(params.resolutions[index].height);
117 }
118
119 // Find max width/height
120 int32_t width = 0, height = 0;
121 for (size_t index = 0; index < params.resolutions.size(); ++index) {
122 if (width <= params.resolutions[index].width &&
123 height <= params.resolutions[index].height) {
124 width = params.resolutions[index].width;
125 height = params.resolutions[index].height;
126 }
127 }
128 if (width < 640 || height < 480) {
129 width = 640;
130 height = 480;
131 }
132 mSensorWidth = width;
133 mSensorHeight = height;
134
135 /* TODO(ender): probably should drop this. */
136 std::copy(kAvailableRawSizes,
137 kAvailableRawSizes + arraysize(kAvailableRawSizes),
138 std::back_inserter(mAvailableRawSizes));
139
140 if (params.orientation == cvd::CameraDefinition::kFront) {
141 std::copy(kAvailableProcessedSizesFront,
142 kAvailableProcessedSizesFront +
143 arraysize(kAvailableProcessedSizesFront),
144 std::back_inserter(mAvailableProcessedSizes));
145 std::copy(kAvailableJpegSizesFront,
146 kAvailableJpegSizesFront + arraysize(kAvailableJpegSizesFront),
147 std::back_inserter(mAvailableJpegSizes));
148 } else {
149 std::copy(
150 kAvailableProcessedSizesBack,
151 kAvailableProcessedSizesBack + arraysize(kAvailableProcessedSizesBack),
152 mAvailableProcessedSizes.begin());
153 std::copy(kAvailableJpegSizesBack,
154 kAvailableJpegSizesBack + arraysize(kAvailableJpegSizesBack),
155 mAvailableJpegSizes.begin());
156 }
157
158 res = constructStaticInfo(&mCameraInfo, true);
159 if (res != OK) {
160 ALOGE("%s: Unable to allocate static info: %s (%d)", __FUNCTION__,
161 strerror(-res), res);
162 return res;
163 }
164 res = constructStaticInfo(&mCameraInfo, false);
165 if (res != OK) {
166 ALOGE("%s: Unable to fill in static info: %s (%d)", __FUNCTION__,
167 strerror(-res), res);
168 return res;
169 }
170 if (res != OK) return res;
171
172 mNextStreamId = 1;
173 mNextReprocessStreamId = 1;
174 mRawStreamCount = 0;
175 mProcessedStreamCount = 0;
176 mJpegStreamCount = 0;
177 mReprocessStreamCount = 0;
178
179 return NO_ERROR;
180 }
181
182 /****************************************************************************
183 * Camera module API overrides
184 ***************************************************************************/
185
connectCamera(hw_device_t ** device)186 status_t EmulatedFakeCamera2::connectCamera(hw_device_t **device) {
187 status_t res;
188 ALOGV("%s", __FUNCTION__);
189
190 {
191 Mutex::Autolock l(mMutex);
192 if (!mStatusPresent) {
193 ALOGE("%s: Camera ID %d is unplugged", __FUNCTION__, mCameraID);
194 return -ENODEV;
195 }
196 }
197
198 mConfigureThread = new ConfigureThread(this);
199 mReadoutThread = new ReadoutThread(this);
200 mControlThread = new ControlThread(this);
201 mSensor = new Sensor(mSensorWidth, mSensorHeight);
202 mJpegCompressor = new JpegCompressor();
203
204 mNextStreamId = 1;
205 mNextReprocessStreamId = 1;
206
207 res = mSensor->startUp();
208 if (res != NO_ERROR) return res;
209
210 res = mConfigureThread->run("EmulatedFakeCamera2::configureThread");
211 if (res != NO_ERROR) return res;
212
213 res = mReadoutThread->run("EmulatedFakeCamera2::readoutThread");
214 if (res != NO_ERROR) return res;
215
216 res = mControlThread->run("EmulatedFakeCamera2::controlThread");
217 if (res != NO_ERROR) return res;
218
219 status_t ret = EmulatedCamera2::connectCamera(device);
220
221 if (ret >= 0) {
222 mIsConnected = true;
223 }
224
225 return ret;
226 }
227
plugCamera()228 status_t EmulatedFakeCamera2::plugCamera() {
229 {
230 Mutex::Autolock l(mMutex);
231
232 if (!mStatusPresent) {
233 ALOGI("%s: Plugged back in", __FUNCTION__);
234 mStatusPresent = true;
235 }
236 }
237
238 return NO_ERROR;
239 }
240
unplugCamera()241 status_t EmulatedFakeCamera2::unplugCamera() {
242 {
243 Mutex::Autolock l(mMutex);
244
245 if (mStatusPresent) {
246 ALOGI("%s: Unplugged camera", __FUNCTION__);
247 mStatusPresent = false;
248 }
249 }
250
251 return closeCamera();
252 }
253
getHotplugStatus()254 camera_device_status_t EmulatedFakeCamera2::getHotplugStatus() {
255 Mutex::Autolock l(mMutex);
256 return mStatusPresent ? CAMERA_DEVICE_STATUS_PRESENT
257 : CAMERA_DEVICE_STATUS_NOT_PRESENT;
258 }
259
closeCamera()260 status_t EmulatedFakeCamera2::closeCamera() {
261 {
262 Mutex::Autolock l(mMutex);
263
264 status_t res;
265 ALOGV("%s", __FUNCTION__);
266
267 if (!mIsConnected) {
268 return NO_ERROR;
269 }
270
271 res = mSensor->shutDown();
272 if (res != NO_ERROR) {
273 ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res);
274 return res;
275 }
276
277 mConfigureThread->requestExit();
278 mReadoutThread->requestExit();
279 mControlThread->requestExit();
280 mJpegCompressor->cancel();
281 }
282
283 // give up the lock since we will now block and the threads
284 // can call back into this object
285 mConfigureThread->join();
286 mReadoutThread->join();
287 mControlThread->join();
288
289 ALOGV("%s exit", __FUNCTION__);
290
291 {
292 Mutex::Autolock l(mMutex);
293 mIsConnected = false;
294 }
295
296 return NO_ERROR;
297 }
298
getCameraInfo(struct camera_info * info)299 status_t EmulatedFakeCamera2::getCameraInfo(struct camera_info *info) {
300 info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT;
301 info->orientation =
302 EmulatedCameraFactory::Instance().getFakeCameraOrientation();
303 return EmulatedCamera2::getCameraInfo(info);
304 }
305
306 /****************************************************************************
307 * Camera device API overrides
308 ***************************************************************************/
309
310 /** Request input queue */
311
requestQueueNotify()312 int EmulatedFakeCamera2::requestQueueNotify() {
313 ALOGV("Request queue notification received");
314
315 ALOG_ASSERT(mRequestQueueSrc != NULL,
316 "%s: Request queue src not set, but received queue notification!",
317 __FUNCTION__);
318 ALOG_ASSERT(mFrameQueueDst != NULL,
319 "%s: Request queue src not set, but received queue notification!",
320 __FUNCTION__);
321 ALOG_ASSERT(mStreams.size() != 0,
322 "%s: No streams allocated, but received queue notification!",
323 __FUNCTION__);
324 return mConfigureThread->newRequestAvailable();
325 }
326
getInProgressCount()327 int EmulatedFakeCamera2::getInProgressCount() {
328 Mutex::Autolock l(mMutex);
329
330 if (!mStatusPresent) {
331 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
332 return ERROR_CAMERA_NOT_PRESENT;
333 }
334
335 int requestCount = 0;
336 requestCount += mConfigureThread->getInProgressCount();
337 requestCount += mReadoutThread->getInProgressCount();
338 requestCount += mJpegCompressor->isBusy() ? 1 : 0;
339
340 return requestCount;
341 }
342
constructDefaultRequest(int request_template,camera_metadata_t ** request)343 int EmulatedFakeCamera2::constructDefaultRequest(int request_template,
344 camera_metadata_t **request) {
345 if (request == NULL) return BAD_VALUE;
346 if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT) {
347 return BAD_VALUE;
348 }
349
350 {
351 Mutex::Autolock l(mMutex);
352 if (!mStatusPresent) {
353 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
354 return ERROR_CAMERA_NOT_PRESENT;
355 }
356 }
357
358 status_t res;
359 // Pass 1, calculate size and allocate
360 res = constructDefaultRequest(request_template, request, true);
361 if (res != OK) {
362 return res;
363 }
364 // Pass 2, build request
365 res = constructDefaultRequest(request_template, request, false);
366 if (res != OK) {
367 ALOGE("Unable to populate new request for template %d", request_template);
368 }
369
370 return res;
371 }
372
allocateStream(uint32_t width,uint32_t height,int format,const camera2_stream_ops_t * stream_ops,uint32_t * stream_id,uint32_t * format_actual,uint32_t * usage,uint32_t * max_buffers)373 int EmulatedFakeCamera2::allocateStream(
374 uint32_t width, uint32_t height, int format,
375 const camera2_stream_ops_t *stream_ops, uint32_t *stream_id,
376 uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers) {
377 Mutex::Autolock l(mMutex);
378
379 if (!mStatusPresent) {
380 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
381 return ERROR_CAMERA_NOT_PRESENT;
382 }
383
384 // Temporary shim until FORMAT_ZSL is removed
385 if (format == CAMERA2_HAL_PIXEL_FORMAT_ZSL) {
386 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
387 }
388
389 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
390 unsigned int numFormats = sizeof(kAvailableFormats) / sizeof(uint32_t);
391 unsigned int formatIdx = 0;
392 for (; formatIdx < numFormats; formatIdx++) {
393 if (format == (int)kAvailableFormats[formatIdx]) break;
394 }
395 if (formatIdx == numFormats) {
396 ALOGE("%s: Format 0x%x is not supported", __FUNCTION__, format);
397 return BAD_VALUE;
398 }
399 }
400
401 const uint32_t *availableSizes;
402 size_t availableSizeCount;
403 switch (format) {
404 #if VSOC_PLATFORM_SDK_AFTER(K)
405 case HAL_PIXEL_FORMAT_RAW16:
406 availableSizes = &mAvailableRawSizes.front();
407 availableSizeCount = mAvailableRawSizes.size();
408 break;
409 #endif
410 case HAL_PIXEL_FORMAT_BLOB:
411 availableSizes = &mAvailableJpegSizes.front();
412 availableSizeCount = mAvailableJpegSizes.size();
413 break;
414 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
415 case HAL_PIXEL_FORMAT_RGBA_8888:
416 case HAL_PIXEL_FORMAT_YV12:
417 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
418 availableSizes = &mAvailableProcessedSizes.front();
419 availableSizeCount = mAvailableProcessedSizes.size();
420 break;
421 default:
422 ALOGE("%s: Unknown format 0x%x", __FUNCTION__, format);
423 return BAD_VALUE;
424 }
425
426 unsigned int resIdx = 0;
427 for (; resIdx < availableSizeCount; resIdx++) {
428 if (availableSizes[resIdx * 2] == width &&
429 availableSizes[resIdx * 2 + 1] == height)
430 break;
431 }
432 if (resIdx == availableSizeCount) {
433 ALOGE("%s: Format 0x%x does not support resolution %d, %d", __FUNCTION__,
434 format, width, height);
435 return BAD_VALUE;
436 }
437
438 switch (format) {
439 #if VSOC_PLATFORM_SDK_AFTER(K)
440 case HAL_PIXEL_FORMAT_RAW16:
441 if (mRawStreamCount >= kMaxRawStreamCount) {
442 ALOGE("%s: Cannot allocate another raw stream (%d already allocated)",
443 __FUNCTION__, mRawStreamCount);
444 return INVALID_OPERATION;
445 }
446 mRawStreamCount++;
447 break;
448 #endif
449 case HAL_PIXEL_FORMAT_BLOB:
450 if (mJpegStreamCount >= kMaxJpegStreamCount) {
451 ALOGE("%s: Cannot allocate another JPEG stream (%d already allocated)",
452 __FUNCTION__, mJpegStreamCount);
453 return INVALID_OPERATION;
454 }
455 mJpegStreamCount++;
456 break;
457 default:
458 if (mProcessedStreamCount >= kMaxProcessedStreamCount) {
459 ALOGE(
460 "%s: Cannot allocate another processed stream (%d already "
461 "allocated)",
462 __FUNCTION__, mProcessedStreamCount);
463 return INVALID_OPERATION;
464 }
465 mProcessedStreamCount++;
466 }
467
468 Stream newStream;
469 newStream.ops = stream_ops;
470 newStream.width = width;
471 newStream.height = height;
472 newStream.format = format;
473 // TODO: Query stride from gralloc
474 newStream.stride = width;
475
476 mStreams.add(mNextStreamId, newStream);
477
478 *stream_id = mNextStreamId;
479 if (format_actual) *format_actual = format;
480 *usage = GRALLOC_USAGE_HW_CAMERA_WRITE;
481 *max_buffers = kMaxBufferCount;
482
483 ALOGV("Stream allocated: %d, %d x %d, 0x%x. U: %x, B: %d", *stream_id, width,
484 height, format, *usage, *max_buffers);
485
486 mNextStreamId++;
487 return NO_ERROR;
488 }
489
registerStreamBuffers(uint32_t stream_id,int num_buffers,buffer_handle_t *)490 int EmulatedFakeCamera2::registerStreamBuffers(uint32_t stream_id,
491 int num_buffers,
492 buffer_handle_t * /*buffers*/) {
493 Mutex::Autolock l(mMutex);
494
495 if (!mStatusPresent) {
496 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
497 return ERROR_CAMERA_NOT_PRESENT;
498 }
499
500 ALOGV("%s: Stream %d registering %d buffers", __FUNCTION__, stream_id,
501 num_buffers);
502 // Need to find out what the final concrete pixel format for our stream is
503 // Assumes that all buffers have the same format.
504 if (num_buffers < 1) {
505 ALOGE("%s: Stream %d only has %d buffers!", __FUNCTION__, stream_id,
506 num_buffers);
507 return BAD_VALUE;
508 }
509
510 ssize_t streamIndex = mStreams.indexOfKey(stream_id);
511 if (streamIndex < 0) {
512 ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id);
513 return BAD_VALUE;
514 }
515
516 Stream &stream = mStreams.editValueAt(streamIndex);
517
518 int finalFormat = stream.format;
519
520 if (finalFormat == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
521 finalFormat = HAL_PIXEL_FORMAT_RGBA_8888;
522 }
523
524 ALOGV("%s: Stream %d format set to %x, previously %x", __FUNCTION__,
525 stream_id, finalFormat, stream.format);
526
527 stream.format = finalFormat;
528
529 return NO_ERROR;
530 }
531
releaseStream(uint32_t stream_id)532 int EmulatedFakeCamera2::releaseStream(uint32_t stream_id) {
533 Mutex::Autolock l(mMutex);
534
535 ssize_t streamIndex = mStreams.indexOfKey(stream_id);
536 if (streamIndex < 0) {
537 ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id);
538 return BAD_VALUE;
539 }
540
541 if (isStreamInUse(stream_id)) {
542 ALOGE("%s: Cannot release stream %d; in use!", __FUNCTION__, stream_id);
543 return BAD_VALUE;
544 }
545
546 switch (mStreams.valueAt(streamIndex).format) {
547 #if VSOC_PLATFORM_SDK_AFTER(K)
548 case HAL_PIXEL_FORMAT_RAW16:
549 mRawStreamCount--;
550 break;
551 #endif
552 case HAL_PIXEL_FORMAT_BLOB:
553 mJpegStreamCount--;
554 break;
555 default:
556 mProcessedStreamCount--;
557 break;
558 }
559
560 mStreams.removeItemsAt(streamIndex);
561
562 return NO_ERROR;
563 }
564
allocateReprocessStreamFromStream(uint32_t output_stream_id,const camera2_stream_in_ops_t * stream_ops,uint32_t * stream_id)565 int EmulatedFakeCamera2::allocateReprocessStreamFromStream(
566 uint32_t output_stream_id, const camera2_stream_in_ops_t *stream_ops,
567 uint32_t *stream_id) {
568 Mutex::Autolock l(mMutex);
569
570 if (!mStatusPresent) {
571 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
572 return ERROR_CAMERA_NOT_PRESENT;
573 }
574
575 ssize_t baseStreamIndex = mStreams.indexOfKey(output_stream_id);
576 if (baseStreamIndex < 0) {
577 ALOGE("%s: Unknown output stream id %d!", __FUNCTION__, output_stream_id);
578 return BAD_VALUE;
579 }
580
581 const Stream &baseStream = mStreams[baseStreamIndex];
582
583 // We'll reprocess anything we produced
584
585 if (mReprocessStreamCount >= kMaxReprocessStreamCount) {
586 ALOGE("%s: Cannot allocate another reprocess stream (%d already allocated)",
587 __FUNCTION__, mReprocessStreamCount);
588 return INVALID_OPERATION;
589 }
590 mReprocessStreamCount++;
591
592 ReprocessStream newStream;
593 newStream.ops = stream_ops;
594 newStream.width = baseStream.width;
595 newStream.height = baseStream.height;
596 newStream.format = baseStream.format;
597 newStream.stride = baseStream.stride;
598 newStream.sourceStreamId = output_stream_id;
599
600 *stream_id = mNextReprocessStreamId;
601 mReprocessStreams.add(mNextReprocessStreamId, newStream);
602
603 ALOGV("Reprocess stream allocated: %d: %d, %d, 0x%x. Parent stream: %d",
604 *stream_id, newStream.width, newStream.height, newStream.format,
605 output_stream_id);
606
607 mNextReprocessStreamId++;
608 return NO_ERROR;
609 }
610
releaseReprocessStream(uint32_t stream_id)611 int EmulatedFakeCamera2::releaseReprocessStream(uint32_t stream_id) {
612 Mutex::Autolock l(mMutex);
613
614 ssize_t streamIndex = mReprocessStreams.indexOfKey(stream_id);
615 if (streamIndex < 0) {
616 ALOGE("%s: Unknown reprocess stream id %d!", __FUNCTION__, stream_id);
617 return BAD_VALUE;
618 }
619
620 if (isReprocessStreamInUse(stream_id)) {
621 ALOGE("%s: Cannot release reprocessing stream %d; in use!", __FUNCTION__,
622 stream_id);
623 return BAD_VALUE;
624 }
625
626 mReprocessStreamCount--;
627 mReprocessStreams.removeItemsAt(streamIndex);
628
629 return NO_ERROR;
630 }
631
triggerAction(uint32_t trigger_id,int32_t ext1,int32_t ext2)632 int EmulatedFakeCamera2::triggerAction(uint32_t trigger_id, int32_t ext1,
633 int32_t ext2) {
634 Mutex::Autolock l(mMutex);
635
636 if (trigger_id == CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT) {
637 ALOGI("%s: Disconnect trigger - camera must be closed", __FUNCTION__);
638 mStatusPresent = false;
639
640 EmulatedCameraFactory::Instance().onStatusChanged(
641 mCameraID, CAMERA_DEVICE_STATUS_NOT_PRESENT);
642 }
643
644 if (!mStatusPresent) {
645 ALOGW("%s: Camera was physically disconnected", __FUNCTION__);
646 return ERROR_CAMERA_NOT_PRESENT;
647 }
648
649 return mControlThread->triggerAction(trigger_id, ext1, ext2);
650 }
651
652 /** Shutdown and debug methods */
653
dump(int fd)654 int EmulatedFakeCamera2::dump(int fd) {
655 String8 result;
656
657 result.appendFormat(" Camera HAL device: EmulatedFakeCamera2\n");
658 result.appendFormat(" Streams:\n");
659 for (size_t i = 0; i < mStreams.size(); i++) {
660 int id = mStreams.keyAt(i);
661 const Stream &s = mStreams.valueAt(i);
662 result.appendFormat(" Stream %d: %d x %d, format 0x%x, stride %d\n",
663 id, s.width, s.height, s.format, s.stride);
664 }
665
666 write(fd, result.string(), result.size());
667
668 return NO_ERROR;
669 }
670
signalError()671 void EmulatedFakeCamera2::signalError() {
672 // TODO: Let parent know so we can shut down cleanly
673 ALOGE("Worker thread is signaling a serious error");
674 }
675
676 /** Pipeline control worker thread methods */
677
ConfigureThread(EmulatedFakeCamera2 * parent)678 EmulatedFakeCamera2::ConfigureThread::ConfigureThread(
679 EmulatedFakeCamera2 *parent)
680 : Thread(false), mParent(parent), mRequestCount(0), mNextBuffers(NULL) {
681 mRunning = false;
682 }
683
~ConfigureThread()684 EmulatedFakeCamera2::ConfigureThread::~ConfigureThread() {}
685
readyToRun()686 status_t EmulatedFakeCamera2::ConfigureThread::readyToRun() {
687 Mutex::Autolock lock(mInputMutex);
688
689 ALOGV("Starting up ConfigureThread");
690 mRequest = NULL;
691 mActive = false;
692 mRunning = true;
693
694 mInputSignal.signal();
695 return NO_ERROR;
696 }
697
waitUntilRunning()698 status_t EmulatedFakeCamera2::ConfigureThread::waitUntilRunning() {
699 Mutex::Autolock lock(mInputMutex);
700 if (!mRunning) {
701 ALOGV("Waiting for configure thread to start");
702 mInputSignal.wait(mInputMutex);
703 }
704 return OK;
705 }
706
newRequestAvailable()707 status_t EmulatedFakeCamera2::ConfigureThread::newRequestAvailable() {
708 waitUntilRunning();
709
710 Mutex::Autolock lock(mInputMutex);
711
712 mActive = true;
713 mInputSignal.signal();
714
715 return OK;
716 }
717
isStreamInUse(uint32_t id)718 bool EmulatedFakeCamera2::ConfigureThread::isStreamInUse(uint32_t id) {
719 Mutex::Autolock lock(mInternalsMutex);
720
721 if (mNextBuffers == NULL) return false;
722 for (size_t i = 0; i < mNextBuffers->size(); i++) {
723 if ((*mNextBuffers)[i].streamId == (int)id) return true;
724 }
725 return false;
726 }
727
getInProgressCount()728 int EmulatedFakeCamera2::ConfigureThread::getInProgressCount() {
729 Mutex::Autolock lock(mInputMutex);
730 return mRequestCount;
731 }
732
threadLoop()733 bool EmulatedFakeCamera2::ConfigureThread::threadLoop() {
734 status_t res;
735
736 // Check if we're currently processing or just waiting
737 {
738 Mutex::Autolock lock(mInputMutex);
739 if (!mActive) {
740 // Inactive, keep waiting until we've been signaled
741 status_t res;
742 res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop);
743 if (res != NO_ERROR && res != TIMED_OUT) {
744 ALOGE("%s: Error waiting for input requests: %d", __FUNCTION__, res);
745 return false;
746 }
747 if (!mActive) return true;
748 ALOGV("New request available");
749 }
750 // Active
751 }
752
753 if (mRequest == NULL) {
754 Mutex::Autolock il(mInternalsMutex);
755
756 ALOGV("Configure: Getting next request");
757 res = mParent->mRequestQueueSrc->dequeue_request(mParent->mRequestQueueSrc,
758 &mRequest);
759 if (res != NO_ERROR) {
760 ALOGE("%s: Error dequeuing next request: %d", __FUNCTION__, res);
761 mParent->signalError();
762 return false;
763 }
764 if (mRequest == NULL) {
765 ALOGV("Configure: Request queue empty, going inactive");
766 // No requests available, go into inactive mode
767 Mutex::Autolock lock(mInputMutex);
768 mActive = false;
769 return true;
770 } else {
771 Mutex::Autolock lock(mInputMutex);
772 mRequestCount++;
773 }
774
775 camera_metadata_entry_t type;
776 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_TYPE, &type);
777 if (res != NO_ERROR) {
778 ALOGE("%s: error reading request type", __FUNCTION__);
779 mParent->signalError();
780 return false;
781 }
782 bool success = false;
783 ;
784 switch (type.data.u8[0]) {
785 case ANDROID_REQUEST_TYPE_CAPTURE:
786 success = setupCapture();
787 break;
788 case ANDROID_REQUEST_TYPE_REPROCESS:
789 success = setupReprocess();
790 break;
791 default:
792 ALOGE("%s: Unexpected request type %d", __FUNCTION__, type.data.u8[0]);
793 mParent->signalError();
794 break;
795 }
796 if (!success) return false;
797 }
798
799 if (mWaitingForReadout) {
800 bool readoutDone;
801 readoutDone = mParent->mReadoutThread->waitForReady(kWaitPerLoop);
802 if (!readoutDone) return true;
803
804 if (mNextNeedsJpeg) {
805 ALOGV("Configure: Waiting for JPEG compressor");
806 } else {
807 ALOGV("Configure: Waiting for sensor");
808 }
809 mWaitingForReadout = false;
810 }
811
812 if (mNextNeedsJpeg) {
813 bool jpegDone;
814 jpegDone = mParent->mJpegCompressor->waitForDone(kWaitPerLoop);
815 if (!jpegDone) return true;
816
817 ALOGV("Configure: Waiting for sensor");
818 mNextNeedsJpeg = false;
819 }
820
821 if (mNextIsCapture) {
822 return configureNextCapture();
823 } else {
824 return configureNextReprocess();
825 }
826 }
827
setupCapture()828 bool EmulatedFakeCamera2::ConfigureThread::setupCapture() {
829 status_t res;
830
831 mNextIsCapture = true;
832 // Get necessary parameters for sensor config
833 mParent->mControlThread->processRequest(mRequest);
834
835 camera_metadata_entry_t streams;
836 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
837 &streams);
838 if (res != NO_ERROR) {
839 ALOGE("%s: error reading output stream tag", __FUNCTION__);
840 mParent->signalError();
841 return false;
842 }
843
844 mNextBuffers = new Buffers;
845 mNextNeedsJpeg = false;
846 ALOGV("Configure: Setting up buffers for capture");
847 for (size_t i = 0; i < streams.count; i++) {
848 int streamId = streams.data.i32[i];
849 const Stream &s = mParent->getStreamInfo(streamId);
850 if (s.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
851 ALOGE(
852 "%s: Stream %d does not have a concrete pixel format, but "
853 "is included in a request!",
854 __FUNCTION__, streamId);
855 mParent->signalError();
856 return false;
857 }
858 StreamBuffer b;
859 b.streamId = streamId; // streams.data.u8[i];
860 b.width = s.width;
861 b.height = s.height;
862 b.format = s.format;
863 b.stride = s.stride;
864 mNextBuffers->push_back(b);
865 ALOGV(
866 "Configure: Buffer %zu: Stream %d, %d x %d, format 0x%x, "
867 "stride %d",
868 i, b.streamId, b.width, b.height, b.format, b.stride);
869 if (b.format == HAL_PIXEL_FORMAT_BLOB) {
870 mNextNeedsJpeg = true;
871 }
872 }
873
874 camera_metadata_entry_t e;
875 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &e);
876 if (res != NO_ERROR) {
877 ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__,
878 strerror(-res), res);
879 mParent->signalError();
880 return false;
881 }
882 mNextFrameNumber = *e.data.i32;
883
884 res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_EXPOSURE_TIME, &e);
885 if (res != NO_ERROR) {
886 ALOGE("%s: error reading exposure time tag: %s (%d)", __FUNCTION__,
887 strerror(-res), res);
888 mParent->signalError();
889 return false;
890 }
891 mNextExposureTime = *e.data.i64;
892
893 res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_FRAME_DURATION, &e);
894 if (res != NO_ERROR) {
895 ALOGE("%s: error reading frame duration tag", __FUNCTION__);
896 mParent->signalError();
897 return false;
898 }
899 mNextFrameDuration = *e.data.i64;
900
901 if (mNextFrameDuration < mNextExposureTime + Sensor::kMinVerticalBlank) {
902 mNextFrameDuration = mNextExposureTime + Sensor::kMinVerticalBlank;
903 }
904 res = find_camera_metadata_entry(mRequest, ANDROID_SENSOR_SENSITIVITY, &e);
905 if (res != NO_ERROR) {
906 ALOGE("%s: error reading sensitivity tag", __FUNCTION__);
907 mParent->signalError();
908 return false;
909 }
910 mNextSensitivity = *e.data.i32;
911
912 // Start waiting on readout thread
913 mWaitingForReadout = true;
914 ALOGV("Configure: Waiting for readout thread");
915
916 return true;
917 }
918
configureNextCapture()919 bool EmulatedFakeCamera2::ConfigureThread::configureNextCapture() {
920 bool vsync = mParent->mSensor->waitForVSync(kWaitPerLoop);
921 if (!vsync) return true;
922
923 Mutex::Autolock il(mInternalsMutex);
924 ALOGV("Configure: Configuring sensor for capture %d", mNextFrameNumber);
925 mParent->mSensor->setExposureTime(mNextExposureTime);
926 mParent->mSensor->setFrameDuration(mNextFrameDuration);
927 mParent->mSensor->setSensitivity(mNextSensitivity);
928
929 getBuffers();
930
931 ALOGV("Configure: Done configure for capture %d", mNextFrameNumber);
932 mParent->mReadoutThread->setNextOperation(true, mRequest, mNextBuffers);
933 mParent->mSensor->setDestinationBuffers(mNextBuffers);
934
935 mRequest = NULL;
936 mNextBuffers = NULL;
937
938 Mutex::Autolock lock(mInputMutex);
939 mRequestCount--;
940
941 return true;
942 }
943
setupReprocess()944 bool EmulatedFakeCamera2::ConfigureThread::setupReprocess() {
945 status_t res;
946
947 mNextNeedsJpeg = true;
948 mNextIsCapture = false;
949
950 camera_metadata_entry_t reprocessStreams;
951 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_INPUT_STREAMS,
952 &reprocessStreams);
953 if (res != NO_ERROR) {
954 ALOGE("%s: error reading output stream tag", __FUNCTION__);
955 mParent->signalError();
956 return false;
957 }
958
959 mNextBuffers = new Buffers;
960
961 ALOGV("Configure: Setting up input buffers for reprocess");
962 for (size_t i = 0; i < reprocessStreams.count; i++) {
963 int streamId = reprocessStreams.data.i32[i];
964 const ReprocessStream &s = mParent->getReprocessStreamInfo(streamId);
965 if (s.format != HAL_PIXEL_FORMAT_RGB_888) {
966 ALOGE("%s: Only ZSL reprocessing supported!", __FUNCTION__);
967 mParent->signalError();
968 return false;
969 }
970 StreamBuffer b;
971 b.streamId = -streamId;
972 b.width = s.width;
973 b.height = s.height;
974 b.format = s.format;
975 b.stride = s.stride;
976 mNextBuffers->push_back(b);
977 }
978
979 camera_metadata_entry_t streams;
980 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
981 &streams);
982 if (res != NO_ERROR) {
983 ALOGE("%s: error reading output stream tag", __FUNCTION__);
984 mParent->signalError();
985 return false;
986 }
987
988 ALOGV("Configure: Setting up output buffers for reprocess");
989 for (size_t i = 0; i < streams.count; i++) {
990 int streamId = streams.data.i32[i];
991 const Stream &s = mParent->getStreamInfo(streamId);
992 if (s.format != HAL_PIXEL_FORMAT_BLOB) {
993 // TODO: Support reprocess to YUV
994 ALOGE("%s: Non-JPEG output stream %d for reprocess not supported",
995 __FUNCTION__, streamId);
996 mParent->signalError();
997 return false;
998 }
999 StreamBuffer b;
1000 b.streamId = streams.data.u8[i];
1001 b.width = s.width;
1002 b.height = s.height;
1003 b.format = s.format;
1004 b.stride = s.stride;
1005 mNextBuffers->push_back(b);
1006 ALOGV(
1007 "Configure: Buffer %zu: Stream %d, %d x %d, format 0x%x, "
1008 "stride %d",
1009 i, b.streamId, b.width, b.height, b.format, b.stride);
1010 }
1011
1012 camera_metadata_entry_t e;
1013 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &e);
1014 if (res != NO_ERROR) {
1015 ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__,
1016 strerror(-res), res);
1017 mParent->signalError();
1018 return false;
1019 }
1020 mNextFrameNumber = *e.data.i32;
1021
1022 return true;
1023 }
1024
configureNextReprocess()1025 bool EmulatedFakeCamera2::ConfigureThread::configureNextReprocess() {
1026 Mutex::Autolock il(mInternalsMutex);
1027
1028 getBuffers();
1029
1030 ALOGV("Configure: Done configure for reprocess %d", mNextFrameNumber);
1031 mParent->mReadoutThread->setNextOperation(false, mRequest, mNextBuffers);
1032
1033 mRequest = NULL;
1034 mNextBuffers = NULL;
1035
1036 Mutex::Autolock lock(mInputMutex);
1037 mRequestCount--;
1038
1039 return true;
1040 }
1041
getBuffers()1042 bool EmulatedFakeCamera2::ConfigureThread::getBuffers() {
1043 status_t res;
1044 /** Get buffers to fill for this frame */
1045 for (size_t i = 0; i < mNextBuffers->size(); i++) {
1046 StreamBuffer &b = mNextBuffers->editItemAt(i);
1047
1048 if (b.streamId > 0) {
1049 ALOGV("Configure: Dequeing buffer from stream %d", b.streamId);
1050 Stream s = mParent->getStreamInfo(b.streamId);
1051 res = s.ops->dequeue_buffer(s.ops, &(b.buffer));
1052 if (res != NO_ERROR || b.buffer == NULL) {
1053 ALOGE("%s: Unable to dequeue buffer from stream %d: %s (%d)",
1054 __FUNCTION__, b.streamId, strerror(-res), res);
1055 mParent->signalError();
1056 return false;
1057 }
1058
1059 /* Lock the buffer from the perspective of the graphics mapper */
1060 res = GrallocModule::getInstance().lock(
1061 *(b.buffer), GRALLOC_USAGE_HW_CAMERA_WRITE, 0, 0, s.width, s.height,
1062 (void **)&(b.img));
1063
1064 if (res != NO_ERROR) {
1065 ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", __FUNCTION__,
1066 strerror(-res), res);
1067 s.ops->cancel_buffer(s.ops, b.buffer);
1068 mParent->signalError();
1069 return false;
1070 }
1071 } else {
1072 ALOGV("Configure: Acquiring buffer from reprocess stream %d",
1073 -b.streamId);
1074 ReprocessStream s = mParent->getReprocessStreamInfo(-b.streamId);
1075 res = s.ops->acquire_buffer(s.ops, &(b.buffer));
1076 if (res != NO_ERROR || b.buffer == NULL) {
1077 ALOGE(
1078 "%s: Unable to acquire buffer from reprocess stream %d: "
1079 "%s (%d)",
1080 __FUNCTION__, -b.streamId, strerror(-res), res);
1081 mParent->signalError();
1082 return false;
1083 }
1084
1085 /* Lock the buffer from the perspective of the graphics mapper */
1086 res = GrallocModule::getInstance().lock(
1087 *(b.buffer), GRALLOC_USAGE_HW_CAMERA_READ, 0, 0, s.width, s.height,
1088 (void **)&(b.img));
1089 if (res != NO_ERROR) {
1090 ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", __FUNCTION__,
1091 strerror(-res), res);
1092 s.ops->release_buffer(s.ops, b.buffer);
1093 mParent->signalError();
1094 return false;
1095 }
1096 }
1097 }
1098 return true;
1099 }
1100
ReadoutThread(EmulatedFakeCamera2 * parent)1101 EmulatedFakeCamera2::ReadoutThread::ReadoutThread(EmulatedFakeCamera2 *parent)
1102 : Thread(false),
1103 mParent(parent),
1104 mRunning(false),
1105 mActive(false),
1106 mRequestCount(0),
1107 mRequest(NULL),
1108 mBuffers(NULL) {
1109 mInFlightQueue = new InFlightQueue[kInFlightQueueSize];
1110 mInFlightHead = 0;
1111 mInFlightTail = 0;
1112 }
1113
~ReadoutThread()1114 EmulatedFakeCamera2::ReadoutThread::~ReadoutThread() {
1115 delete[] mInFlightQueue;
1116 }
1117
readyToRun()1118 status_t EmulatedFakeCamera2::ReadoutThread::readyToRun() {
1119 Mutex::Autolock lock(mInputMutex);
1120 ALOGV("Starting up ReadoutThread");
1121 mRunning = true;
1122 mInputSignal.signal();
1123 return NO_ERROR;
1124 }
1125
waitUntilRunning()1126 status_t EmulatedFakeCamera2::ReadoutThread::waitUntilRunning() {
1127 Mutex::Autolock lock(mInputMutex);
1128 if (!mRunning) {
1129 ALOGV("Waiting for readout thread to start");
1130 mInputSignal.wait(mInputMutex);
1131 }
1132 return OK;
1133 }
1134
waitForReady(nsecs_t timeout)1135 bool EmulatedFakeCamera2::ReadoutThread::waitForReady(nsecs_t timeout) {
1136 status_t res;
1137 Mutex::Autolock lock(mInputMutex);
1138 while (!readyForNextCapture()) {
1139 res = mReadySignal.waitRelative(mInputMutex, timeout);
1140 if (res == TIMED_OUT) return false;
1141 if (res != OK) {
1142 ALOGE("%s: Error waiting for ready: %s (%d)", __FUNCTION__,
1143 strerror(-res), res);
1144 return false;
1145 }
1146 }
1147 return true;
1148 }
1149
readyForNextCapture()1150 bool EmulatedFakeCamera2::ReadoutThread::readyForNextCapture() {
1151 return (mInFlightTail + 1) % kInFlightQueueSize != mInFlightHead;
1152 }
1153
setNextOperation(bool isCapture,camera_metadata_t * request,Buffers * buffers)1154 void EmulatedFakeCamera2::ReadoutThread::setNextOperation(
1155 bool isCapture, camera_metadata_t *request, Buffers *buffers) {
1156 Mutex::Autolock lock(mInputMutex);
1157 if (!readyForNextCapture()) {
1158 ALOGE("In flight queue full, dropping captures");
1159 mParent->signalError();
1160 return;
1161 }
1162 mInFlightQueue[mInFlightTail].isCapture = isCapture;
1163 mInFlightQueue[mInFlightTail].request = request;
1164 mInFlightQueue[mInFlightTail].buffers = buffers;
1165 mInFlightTail = (mInFlightTail + 1) % kInFlightQueueSize;
1166 mRequestCount++;
1167
1168 if (!mActive) {
1169 mActive = true;
1170 mInputSignal.signal();
1171 }
1172 }
1173
isStreamInUse(uint32_t id)1174 bool EmulatedFakeCamera2::ReadoutThread::isStreamInUse(uint32_t id) {
1175 // acquire in same order as threadLoop
1176 Mutex::Autolock iLock(mInternalsMutex);
1177 Mutex::Autolock lock(mInputMutex);
1178
1179 size_t i = mInFlightHead;
1180 while (i != mInFlightTail) {
1181 for (size_t j = 0; j < mInFlightQueue[i].buffers->size(); j++) {
1182 if ((*(mInFlightQueue[i].buffers))[j].streamId == (int)id) return true;
1183 }
1184 i = (i + 1) % kInFlightQueueSize;
1185 }
1186
1187 if (mBuffers != NULL) {
1188 for (i = 0; i < mBuffers->size(); i++) {
1189 if ((*mBuffers)[i].streamId == (int)id) return true;
1190 }
1191 }
1192
1193 return false;
1194 }
1195
getInProgressCount()1196 int EmulatedFakeCamera2::ReadoutThread::getInProgressCount() {
1197 Mutex::Autolock lock(mInputMutex);
1198
1199 return mRequestCount;
1200 }
1201
threadLoop()1202 bool EmulatedFakeCamera2::ReadoutThread::threadLoop() {
1203 static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms
1204 status_t res;
1205 int32_t frameNumber;
1206
1207 // Check if we're currently processing or just waiting
1208 {
1209 Mutex::Autolock lock(mInputMutex);
1210 if (!mActive) {
1211 // Inactive, keep waiting until we've been signaled
1212 res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop);
1213 if (res != NO_ERROR && res != TIMED_OUT) {
1214 ALOGE("%s: Error waiting for capture requests: %d", __FUNCTION__, res);
1215 mParent->signalError();
1216 return false;
1217 }
1218 if (!mActive) return true;
1219 }
1220 // Active, see if we need a new request
1221 if (mRequest == NULL) {
1222 if (mInFlightHead == mInFlightTail) {
1223 // Go inactive
1224 ALOGV("Waiting for sensor data");
1225 mActive = false;
1226 return true;
1227 } else {
1228 Mutex::Autolock iLock(mInternalsMutex);
1229 mReadySignal.signal();
1230 mIsCapture = mInFlightQueue[mInFlightHead].isCapture;
1231 mRequest = mInFlightQueue[mInFlightHead].request;
1232 mBuffers = mInFlightQueue[mInFlightHead].buffers;
1233 mInFlightQueue[mInFlightHead].request = NULL;
1234 mInFlightQueue[mInFlightHead].buffers = NULL;
1235 mInFlightHead = (mInFlightHead + 1) % kInFlightQueueSize;
1236 ALOGV("Ready to read out request %p, %zu buffers", mRequest,
1237 mBuffers->size());
1238 }
1239 }
1240 }
1241
1242 // Active with request, wait on sensor to complete
1243
1244 nsecs_t captureTime;
1245
1246 if (mIsCapture) {
1247 bool gotFrame;
1248 gotFrame = mParent->mSensor->waitForNewFrame(kWaitPerLoop, &captureTime);
1249
1250 if (!gotFrame) return true;
1251 }
1252
1253 Mutex::Autolock iLock(mInternalsMutex);
1254
1255 camera_metadata_entry_t entry;
1256 if (!mIsCapture) {
1257 res =
1258 find_camera_metadata_entry(mRequest, ANDROID_SENSOR_TIMESTAMP, &entry);
1259 if (res != NO_ERROR) {
1260 ALOGE("%s: error reading reprocessing timestamp: %s (%d)", __FUNCTION__,
1261 strerror(-res), res);
1262 mParent->signalError();
1263 return false;
1264 }
1265 captureTime = entry.data.i64[0];
1266 }
1267
1268 res =
1269 find_camera_metadata_entry(mRequest, ANDROID_REQUEST_FRAME_COUNT, &entry);
1270 if (res != NO_ERROR) {
1271 ALOGE("%s: error reading frame count tag: %s (%d)", __FUNCTION__,
1272 strerror(-res), res);
1273 mParent->signalError();
1274 return false;
1275 }
1276 frameNumber = *entry.data.i32;
1277
1278 res = find_camera_metadata_entry(mRequest, ANDROID_REQUEST_METADATA_MODE,
1279 &entry);
1280 if (res != NO_ERROR) {
1281 ALOGE("%s: error reading metadata mode tag: %s (%d)", __FUNCTION__,
1282 strerror(-res), res);
1283 mParent->signalError();
1284 return false;
1285 }
1286
1287 // Got sensor data and request, construct frame and send it out
1288 ALOGV("Readout: Constructing metadata and frames for request %d",
1289 frameNumber);
1290
1291 if (*entry.data.u8 == ANDROID_REQUEST_METADATA_MODE_FULL) {
1292 ALOGV("Readout: Metadata requested, constructing");
1293
1294 camera_metadata_t *frame = NULL;
1295
1296 size_t frame_entries = get_camera_metadata_entry_count(mRequest);
1297 size_t frame_data = get_camera_metadata_data_count(mRequest);
1298
1299 // TODO: Dynamically calculate based on enabled statistics, etc
1300 frame_entries += 10;
1301 frame_data += 100;
1302
1303 res = mParent->mFrameQueueDst->dequeue_frame(
1304 mParent->mFrameQueueDst, frame_entries, frame_data, &frame);
1305
1306 if (res != NO_ERROR || frame == NULL) {
1307 ALOGE("%s: Unable to dequeue frame metadata buffer", __FUNCTION__);
1308 mParent->signalError();
1309 return false;
1310 }
1311
1312 res = append_camera_metadata(frame, mRequest);
1313 if (res != NO_ERROR) {
1314 ALOGE("Unable to append request metadata");
1315 }
1316
1317 if (mIsCapture) {
1318 add_camera_metadata_entry(frame, ANDROID_SENSOR_TIMESTAMP, &captureTime,
1319 1);
1320
1321 collectStatisticsMetadata(frame);
1322 // TODO: Collect all final values used from sensor in addition to
1323 // timestamp
1324 }
1325
1326 ALOGV("Readout: Enqueue frame %d", frameNumber);
1327 mParent->mFrameQueueDst->enqueue_frame(mParent->mFrameQueueDst, frame);
1328 }
1329 ALOGV("Readout: Free request");
1330 res = mParent->mRequestQueueSrc->free_request(mParent->mRequestQueueSrc,
1331 mRequest);
1332 if (res != NO_ERROR) {
1333 ALOGE("%s: Unable to return request buffer to queue: %d", __FUNCTION__,
1334 res);
1335 mParent->signalError();
1336 return false;
1337 }
1338 mRequest = NULL;
1339
1340 int compressedBufferIndex = -1;
1341 ALOGV("Readout: Processing %zu buffers", mBuffers->size());
1342 for (size_t i = 0; i < mBuffers->size(); i++) {
1343 const StreamBuffer &b = (*mBuffers)[i];
1344 ALOGV("Readout: Buffer %zu: Stream %d, %d x %d, format 0x%x, stride %d",
1345 i, b.streamId, b.width, b.height, b.format, b.stride);
1346 if (b.streamId > 0) {
1347 if (b.format == HAL_PIXEL_FORMAT_BLOB) {
1348 // Assumes only one BLOB buffer type per capture
1349 compressedBufferIndex = i;
1350 } else {
1351 ALOGV("Readout: Sending image buffer %zu (%p) to output stream %d",
1352 i, (void *)*(b.buffer), b.streamId);
1353 GrallocModule::getInstance().unlock(*(b.buffer));
1354 const Stream &s = mParent->getStreamInfo(b.streamId);
1355 res = s.ops->enqueue_buffer(s.ops, captureTime, b.buffer);
1356 if (res != OK) {
1357 ALOGE("Error enqueuing image buffer %p: %s (%d)", b.buffer,
1358 strerror(-res), res);
1359 mParent->signalError();
1360 }
1361 }
1362 }
1363 }
1364
1365 if (compressedBufferIndex == -1) {
1366 delete mBuffers;
1367 } else {
1368 ALOGV("Readout: Starting JPEG compression for buffer %d, stream %d",
1369 compressedBufferIndex, (*mBuffers)[compressedBufferIndex].streamId);
1370 mJpegTimestamp = captureTime;
1371 // Takes ownership of mBuffers
1372 mParent->mJpegCompressor->start(mBuffers, this);
1373 }
1374 mBuffers = NULL;
1375
1376 Mutex::Autolock l(mInputMutex);
1377 mRequestCount--;
1378 ALOGV("Readout: Done with request %d", frameNumber);
1379 return true;
1380 }
1381
onJpegDone(const StreamBuffer & jpegBuffer,bool success)1382 void EmulatedFakeCamera2::ReadoutThread::onJpegDone(
1383 const StreamBuffer &jpegBuffer, bool success) {
1384 if (!success) {
1385 ALOGE("%s: Error queueing compressed image buffer %p", __FUNCTION__,
1386 jpegBuffer.buffer);
1387 mParent->signalError();
1388 return;
1389 }
1390
1391 // Write to JPEG output stream
1392 ALOGV("%s: Compression complete, pushing to stream %d", __FUNCTION__,
1393 jpegBuffer.streamId);
1394
1395 GrallocModule::getInstance().unlock(*(jpegBuffer.buffer));
1396 const Stream &s = mParent->getStreamInfo(jpegBuffer.streamId);
1397 s.ops->enqueue_buffer(s.ops, mJpegTimestamp, jpegBuffer.buffer);
1398 }
1399
onJpegInputDone(const StreamBuffer & inputBuffer)1400 void EmulatedFakeCamera2::ReadoutThread::onJpegInputDone(
1401 const StreamBuffer &inputBuffer) {
1402 status_t res;
1403 GrallocModule::getInstance().unlock(*(inputBuffer.buffer));
1404 const ReprocessStream &s =
1405 mParent->getReprocessStreamInfo(-inputBuffer.streamId);
1406 res = s.ops->release_buffer(s.ops, inputBuffer.buffer);
1407 if (res != OK) {
1408 ALOGE("Error releasing reprocess buffer %p: %s (%d)", inputBuffer.buffer,
1409 strerror(-res), res);
1410 mParent->signalError();
1411 }
1412 }
1413
collectStatisticsMetadata(camera_metadata_t * frame)1414 status_t EmulatedFakeCamera2::ReadoutThread::collectStatisticsMetadata(
1415 camera_metadata_t *frame) {
1416 // Completely fake face rectangles, don't correspond to real faces in scene
1417 ALOGV("Readout: Collecting statistics metadata");
1418
1419 status_t res;
1420 camera_metadata_entry_t entry;
1421 res = find_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_DETECT_MODE,
1422 &entry);
1423 if (res != OK) {
1424 ALOGE("%s: Unable to find face detect mode!", __FUNCTION__);
1425 return BAD_VALUE;
1426 }
1427
1428 if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) return OK;
1429
1430 // The coordinate system for the face regions is the raw sensor pixel
1431 // coordinates. Here, we map from the scene coordinates (0-19 in both axis)
1432 // to raw pixels, for the scene defined in fake-pipeline2/Scene.cpp. We
1433 // approximately place two faces on top of the windows of the house. No
1434 // actual faces exist there, but might one day. Note that this doesn't
1435 // account for the offsets used to account for aspect ratio differences, so
1436 // the rectangles don't line up quite right.
1437 const size_t numFaces = 2;
1438 int32_t rects[numFaces * 4] = {
1439 static_cast<int32_t>(mParent->mSensorWidth * 10 / 20),
1440 static_cast<int32_t>(mParent->mSensorHeight * 15 / 20),
1441 static_cast<int32_t>(mParent->mSensorWidth * 12 / 20),
1442 static_cast<int32_t>(mParent->mSensorHeight * 17 / 20),
1443
1444 static_cast<int32_t>(mParent->mSensorWidth * 16 / 20),
1445 static_cast<int32_t>(mParent->mSensorHeight * 15 / 20),
1446 static_cast<int32_t>(mParent->mSensorWidth * 18 / 20),
1447 static_cast<int32_t>(mParent->mSensorHeight * 17 / 20)};
1448 // To simulate some kind of real detection going on, we jitter the rectangles
1449 // on each frame by a few pixels in each dimension.
1450 for (size_t i = 0; i < numFaces * 4; i++) {
1451 rects[i] += (int32_t)(((float)rand() / RAND_MAX) * 6 - 3);
1452 }
1453 // The confidence scores (0-100) are similarly jittered.
1454 uint8_t scores[numFaces] = {85, 95};
1455 for (size_t i = 0; i < numFaces; i++) {
1456 scores[i] += (int32_t)(((float)rand() / RAND_MAX) * 10 - 5);
1457 }
1458
1459 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_RECTANGLES,
1460 rects, numFaces * 4);
1461 if (res != OK) {
1462 ALOGE("%s: Unable to add face rectangles!", __FUNCTION__);
1463 return BAD_VALUE;
1464 }
1465
1466 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_SCORES, scores,
1467 numFaces);
1468 if (res != OK) {
1469 ALOGE("%s: Unable to add face scores!", __FUNCTION__);
1470 return BAD_VALUE;
1471 }
1472
1473 if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE) return OK;
1474
1475 // Advanced face detection options - add eye/mouth coordinates. The
1476 // coordinates in order are (leftEyeX, leftEyeY, rightEyeX, rightEyeY,
1477 // mouthX, mouthY). The mapping is the same as the face rectangles.
1478 int32_t features[numFaces * 6] = {
1479 static_cast<int32_t>(mParent->mSensorWidth * 10.5 / 20),
1480 static_cast<int32_t>(mParent->mSensorHeight * 16 / 20),
1481 static_cast<int32_t>(mParent->mSensorWidth * 11.5 / 20),
1482 static_cast<int32_t>(mParent->mSensorHeight * 16 / 20),
1483 static_cast<int32_t>(mParent->mSensorWidth * 11 / 20),
1484 static_cast<int32_t>(mParent->mSensorHeight * 16.5 / 20),
1485
1486 static_cast<int32_t>(mParent->mSensorWidth * 16.5 / 20),
1487 static_cast<int32_t>(mParent->mSensorHeight * 16 / 20),
1488 static_cast<int32_t>(mParent->mSensorWidth * 17.5 / 20),
1489 static_cast<int32_t>(mParent->mSensorHeight * 16 / 20),
1490 static_cast<int32_t>(mParent->mSensorWidth * 17 / 20),
1491 static_cast<int32_t>(mParent->mSensorHeight * 16.5 / 20),
1492 };
1493 // Jitter these a bit less than the rects
1494 for (size_t i = 0; i < numFaces * 6; i++) {
1495 features[i] += (int32_t)(((float)rand() / RAND_MAX) * 4 - 2);
1496 }
1497 // These are unique IDs that are used to identify each face while it's
1498 // visible to the detector (if a face went away and came back, it'd get a
1499 // new ID).
1500 int32_t ids[numFaces] = {100, 200};
1501
1502 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_LANDMARKS,
1503 features, numFaces * 6);
1504 if (res != OK) {
1505 ALOGE("%s: Unable to add face landmarks!", __FUNCTION__);
1506 return BAD_VALUE;
1507 }
1508
1509 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_IDS, ids,
1510 numFaces);
1511 if (res != OK) {
1512 ALOGE("%s: Unable to add face scores!", __FUNCTION__);
1513 return BAD_VALUE;
1514 }
1515
1516 return OK;
1517 }
1518
ControlThread(EmulatedFakeCamera2 * parent)1519 EmulatedFakeCamera2::ControlThread::ControlThread(EmulatedFakeCamera2 *parent)
1520 : Thread(false), mParent(parent) {
1521 mRunning = false;
1522 }
1523
~ControlThread()1524 EmulatedFakeCamera2::ControlThread::~ControlThread() {}
1525
readyToRun()1526 status_t EmulatedFakeCamera2::ControlThread::readyToRun() {
1527 Mutex::Autolock lock(mInputMutex);
1528
1529 ALOGV("Starting up ControlThread");
1530 mRunning = true;
1531 mStartAf = false;
1532 mCancelAf = false;
1533 mStartPrecapture = false;
1534
1535 mControlMode = ANDROID_CONTROL_MODE_AUTO;
1536
1537 mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
1538 mSceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
1539
1540 mAfMode = ANDROID_CONTROL_AF_MODE_AUTO;
1541 mAfModeChange = false;
1542
1543 mAeMode = ANDROID_CONTROL_AE_MODE_ON;
1544 mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
1545
1546 mAfTriggerId = 0;
1547 mPrecaptureTriggerId = 0;
1548
1549 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE;
1550 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE;
1551 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE;
1552
1553 mExposureTime = kNormalExposureTime;
1554
1555 mInputSignal.signal();
1556 return NO_ERROR;
1557 }
1558
waitUntilRunning()1559 status_t EmulatedFakeCamera2::ControlThread::waitUntilRunning() {
1560 Mutex::Autolock lock(mInputMutex);
1561 if (!mRunning) {
1562 ALOGV("Waiting for control thread to start");
1563 mInputSignal.wait(mInputMutex);
1564 }
1565 return OK;
1566 }
1567
1568 // Override android.control.* fields with 3A values before sending request to
1569 // sensor
processRequest(camera_metadata_t * request)1570 status_t EmulatedFakeCamera2::ControlThread::processRequest(
1571 camera_metadata_t *request) {
1572 Mutex::Autolock lock(mInputMutex);
1573 // TODO: Add handling for all android.control.* fields here
1574 camera_metadata_entry_t mode;
1575 status_t res;
1576
1577 #define READ_IF_OK(res, what, def) (((res) == OK) ? (what) : (uint8_t)(def))
1578
1579 res = find_camera_metadata_entry(request, ANDROID_CONTROL_MODE, &mode);
1580 mControlMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_MODE_OFF);
1581
1582 // disable all 3A
1583 if (mControlMode == ANDROID_CONTROL_MODE_OFF) {
1584 mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
1585 #if VSOC_PLATFORM_SDK_AFTER(K)
1586 mSceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
1587 #else
1588 mSceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
1589 #endif
1590 mAfMode = ANDROID_CONTROL_AF_MODE_OFF;
1591 mAeLock = ANDROID_CONTROL_AE_LOCK_ON;
1592 mAeMode = ANDROID_CONTROL_AE_MODE_OFF;
1593 mAfModeChange = true;
1594 mStartAf = false;
1595 mCancelAf = true;
1596 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE;
1597 mAwbMode = ANDROID_CONTROL_AWB_MODE_OFF;
1598 return res;
1599 }
1600
1601 res = find_camera_metadata_entry(request, ANDROID_CONTROL_EFFECT_MODE, &mode);
1602 mEffectMode =
1603 READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_EFFECT_MODE_OFF);
1604
1605 res = find_camera_metadata_entry(request, ANDROID_CONTROL_SCENE_MODE, &mode);
1606 #if VSOC_PLATFORM_SDK_AFTER(K)
1607 mSceneMode =
1608 READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_SCENE_MODE_DISABLED);
1609 #else
1610 mSceneMode =
1611 READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED);
1612 #endif
1613
1614 res = find_camera_metadata_entry(request, ANDROID_CONTROL_AF_MODE, &mode);
1615 if (mAfMode != mode.data.u8[0]) {
1616 ALOGV("AF new mode: %d, old mode %d", mode.data.u8[0], mAfMode);
1617 mAfMode = mode.data.u8[0];
1618 mAfModeChange = true;
1619 mStartAf = false;
1620 mCancelAf = false;
1621 }
1622
1623 res = find_camera_metadata_entry(request, ANDROID_CONTROL_AE_MODE, &mode);
1624 mAeMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AE_MODE_OFF);
1625
1626 res = find_camera_metadata_entry(request, ANDROID_CONTROL_AE_LOCK, &mode);
1627 uint8_t aeLockVal =
1628 READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AE_LOCK_ON);
1629 bool aeLock = (aeLockVal == ANDROID_CONTROL_AE_LOCK_ON);
1630 if (mAeLock && !aeLock) {
1631 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE;
1632 }
1633 mAeLock = aeLock;
1634
1635 res = find_camera_metadata_entry(request, ANDROID_CONTROL_AWB_MODE, &mode);
1636 mAwbMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_AWB_MODE_OFF);
1637
1638 // TODO: Override more control fields
1639
1640 if (mAeMode != ANDROID_CONTROL_AE_MODE_OFF) {
1641 camera_metadata_entry_t exposureTime;
1642 res = find_camera_metadata_entry(request, ANDROID_SENSOR_EXPOSURE_TIME,
1643 &exposureTime);
1644 if (res == OK) {
1645 exposureTime.data.i64[0] = mExposureTime;
1646 }
1647 }
1648
1649 #undef READ_IF_OK
1650
1651 return OK;
1652 }
1653
triggerAction(uint32_t msgType,int32_t ext1,int32_t ext2)1654 status_t EmulatedFakeCamera2::ControlThread::triggerAction(uint32_t msgType,
1655 int32_t ext1,
1656 int32_t ext2) {
1657 ALOGV("%s: Triggering %d (%d, %d)", __FUNCTION__, msgType, ext1, ext2);
1658 Mutex::Autolock lock(mInputMutex);
1659 switch (msgType) {
1660 case CAMERA2_TRIGGER_AUTOFOCUS:
1661 mAfTriggerId = ext1;
1662 mStartAf = true;
1663 mCancelAf = false;
1664 break;
1665 case CAMERA2_TRIGGER_CANCEL_AUTOFOCUS:
1666 mAfTriggerId = ext1;
1667 mStartAf = false;
1668 mCancelAf = true;
1669 break;
1670 case CAMERA2_TRIGGER_PRECAPTURE_METERING:
1671 mPrecaptureTriggerId = ext1;
1672 mStartPrecapture = true;
1673 break;
1674 default:
1675 ALOGE("%s: Unknown action triggered: %d (arguments %d %d)", __FUNCTION__,
1676 msgType, ext1, ext2);
1677 return BAD_VALUE;
1678 }
1679 return OK;
1680 }
1681
1682 const nsecs_t EmulatedFakeCamera2::ControlThread::kControlCycleDelay =
1683 100 * MSEC;
1684 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAfDuration = 500 * MSEC;
1685 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAfDuration = 900 * MSEC;
1686 const float EmulatedFakeCamera2::ControlThread::kAfSuccessRate = 0.9;
1687 // Once every 5 seconds
1688 const float EmulatedFakeCamera2::ControlThread::kContinuousAfStartRate =
1689 kControlCycleDelay / 5.0 * SEC;
1690 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAeDuration = 500 * MSEC;
1691 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAeDuration = 2 * SEC;
1692 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinPrecaptureAeDuration =
1693 100 * MSEC;
1694 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxPrecaptureAeDuration =
1695 400 * MSEC;
1696 // Once every 3 seconds
1697 const float EmulatedFakeCamera2::ControlThread::kAeScanStartRate =
1698 kControlCycleDelay / 3000000000.0;
1699
1700 const nsecs_t EmulatedFakeCamera2::ControlThread::kNormalExposureTime =
1701 10 * MSEC;
1702 const nsecs_t EmulatedFakeCamera2::ControlThread::kExposureJump = 2 * MSEC;
1703 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinExposureTime = 1 * MSEC;
1704
threadLoop()1705 bool EmulatedFakeCamera2::ControlThread::threadLoop() {
1706 bool afModeChange = false;
1707 bool afTriggered = false;
1708 bool afCancelled = false;
1709 uint8_t afState;
1710 uint8_t afMode;
1711 int32_t afTriggerId;
1712 bool precaptureTriggered = false;
1713 uint8_t aeState;
1714 uint8_t aeMode;
1715 bool aeLock;
1716 int32_t precaptureTriggerId;
1717 nsecs_t nextSleep = kControlCycleDelay;
1718
1719 {
1720 Mutex::Autolock lock(mInputMutex);
1721 if (mStartAf) {
1722 ALOGD("Starting AF trigger processing");
1723 afTriggered = true;
1724 mStartAf = false;
1725 } else if (mCancelAf) {
1726 ALOGD("Starting cancel AF trigger processing");
1727 afCancelled = true;
1728 mCancelAf = false;
1729 }
1730 afState = mAfState;
1731 afMode = mAfMode;
1732 afModeChange = mAfModeChange;
1733 mAfModeChange = false;
1734
1735 afTriggerId = mAfTriggerId;
1736
1737 if (mStartPrecapture) {
1738 ALOGD("Starting precapture trigger processing");
1739 precaptureTriggered = true;
1740 mStartPrecapture = false;
1741 }
1742 aeState = mAeState;
1743 aeMode = mAeMode;
1744 aeLock = mAeLock;
1745 precaptureTriggerId = mPrecaptureTriggerId;
1746 }
1747
1748 if (afCancelled || afModeChange) {
1749 ALOGV("Resetting AF state due to cancel/mode change");
1750 afState = ANDROID_CONTROL_AF_STATE_INACTIVE;
1751 updateAfState(afState, afTriggerId);
1752 mAfScanDuration = 0;
1753 mLockAfterPassiveScan = false;
1754 }
1755
1756 if (afTriggered) {
1757 afState = processAfTrigger(afMode, afState);
1758 }
1759
1760 afState = maybeStartAfScan(afMode, afState);
1761 afState = updateAfScan(afMode, afState, &nextSleep);
1762 updateAfState(afState, afTriggerId);
1763
1764 if (precaptureTriggered) {
1765 aeState = processPrecaptureTrigger(aeMode, aeState);
1766 }
1767
1768 aeState = maybeStartAeScan(aeMode, aeLock, aeState);
1769 aeState = updateAeScan(aeMode, aeLock, aeState, &nextSleep);
1770 updateAeState(aeState, precaptureTriggerId);
1771
1772 int ret;
1773 timespec t;
1774 t.tv_sec = 0;
1775 t.tv_nsec = nextSleep;
1776 do {
1777 ret = nanosleep(&t, &t);
1778 } while (ret != 0);
1779
1780 if (mAfScanDuration > 0) {
1781 mAfScanDuration -= nextSleep;
1782 }
1783 if (mAeScanDuration > 0) {
1784 mAeScanDuration -= nextSleep;
1785 }
1786
1787 return true;
1788 }
1789
processAfTrigger(uint8_t afMode,uint8_t afState)1790 int EmulatedFakeCamera2::ControlThread::processAfTrigger(uint8_t afMode,
1791 uint8_t afState) {
1792 switch (afMode) {
1793 case ANDROID_CONTROL_AF_MODE_OFF:
1794 case ANDROID_CONTROL_AF_MODE_EDOF:
1795 // Do nothing
1796 break;
1797 case ANDROID_CONTROL_AF_MODE_MACRO:
1798 case ANDROID_CONTROL_AF_MODE_AUTO:
1799 switch (afState) {
1800 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1801 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1802 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1803 // Start new focusing cycle
1804 mAfScanDuration =
1805 ((double)rand() / RAND_MAX) * (kMaxAfDuration - kMinAfDuration) +
1806 kMinAfDuration;
1807 afState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN;
1808 ALOGV("%s: AF scan start, duration %" PRId64 " ms", __FUNCTION__,
1809 mAfScanDuration / 1000000);
1810 break;
1811 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
1812 // Ignore new request, already scanning
1813 break;
1814 default:
1815 ALOGE("Unexpected AF state in AUTO/MACRO AF mode: %d", afState);
1816 }
1817 break;
1818 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
1819 switch (afState) {
1820 // Picture mode waits for passive scan to complete
1821 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1822 mLockAfterPassiveScan = true;
1823 break;
1824 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1825 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
1826 break;
1827 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1828 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
1829 break;
1830 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1831 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1832 // Must cancel to get out of these states
1833 break;
1834 default:
1835 ALOGE("Unexpected AF state in CONTINUOUS_PICTURE AF mode: %d",
1836 afState);
1837 }
1838 break;
1839 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
1840 switch (afState) {
1841 // Video mode does not wait for passive scan to complete
1842 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
1843 case ANDROID_CONTROL_AF_STATE_INACTIVE:
1844 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
1845 break;
1846 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
1847 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
1848 break;
1849 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
1850 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
1851 // Must cancel to get out of these states
1852 break;
1853 default:
1854 ALOGE("Unexpected AF state in CONTINUOUS_VIDEO AF mode: %d", afState);
1855 }
1856 break;
1857 default:
1858 break;
1859 }
1860 return afState;
1861 }
1862
maybeStartAfScan(uint8_t afMode,uint8_t afState)1863 int EmulatedFakeCamera2::ControlThread::maybeStartAfScan(uint8_t afMode,
1864 uint8_t afState) {
1865 if ((afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO ||
1866 afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) &&
1867 (afState == ANDROID_CONTROL_AF_STATE_INACTIVE ||
1868 afState == ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)) {
1869 bool startScan = ((double)rand() / RAND_MAX) < kContinuousAfStartRate;
1870 if (startScan) {
1871 // Start new passive focusing cycle
1872 mAfScanDuration =
1873 ((double)rand() / RAND_MAX) * (kMaxAfDuration - kMinAfDuration) +
1874 kMinAfDuration;
1875 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN;
1876 ALOGV("%s: AF passive scan start, duration %" PRId64 " ms", __FUNCTION__,
1877 mAfScanDuration / 1000000);
1878 }
1879 }
1880 return afState;
1881 }
1882
updateAfScan(uint8_t afMode,uint8_t afState,nsecs_t * maxSleep)1883 int EmulatedFakeCamera2::ControlThread::updateAfScan(uint8_t afMode,
1884 uint8_t afState,
1885 nsecs_t *maxSleep) {
1886 if (!(afState == ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN ||
1887 afState == ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN)) {
1888 return afState;
1889 }
1890
1891 if (mAfScanDuration <= 0) {
1892 ALOGV("%s: AF scan done", __FUNCTION__);
1893 switch (afMode) {
1894 case ANDROID_CONTROL_AF_MODE_MACRO:
1895 case ANDROID_CONTROL_AF_MODE_AUTO: {
1896 bool success = ((double)rand() / RAND_MAX) < kAfSuccessRate;
1897 if (success) {
1898 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
1899 } else {
1900 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED;
1901 }
1902 break;
1903 }
1904 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
1905 if (mLockAfterPassiveScan) {
1906 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED;
1907 mLockAfterPassiveScan = false;
1908 } else {
1909 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED;
1910 }
1911 break;
1912 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
1913 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED;
1914 break;
1915 default:
1916 ALOGE("Unexpected AF mode in scan state");
1917 }
1918 } else {
1919 if (mAfScanDuration <= *maxSleep) {
1920 *maxSleep = mAfScanDuration;
1921 }
1922 }
1923 return afState;
1924 }
1925
updateAfState(uint8_t newState,int32_t triggerId)1926 void EmulatedFakeCamera2::ControlThread::updateAfState(uint8_t newState,
1927 int32_t triggerId) {
1928 Mutex::Autolock lock(mInputMutex);
1929 if (mAfState != newState) {
1930 ALOGV("%s: Autofocus state now %d, id %d", __FUNCTION__, newState,
1931 triggerId);
1932 mAfState = newState;
1933 mParent->sendNotification(CAMERA2_MSG_AUTOFOCUS, newState, triggerId, 0);
1934 }
1935 }
1936
processPrecaptureTrigger(uint8_t aeMode,uint8_t aeState)1937 int EmulatedFakeCamera2::ControlThread::processPrecaptureTrigger(
1938 uint8_t aeMode, uint8_t aeState) {
1939 switch (aeMode) {
1940 case ANDROID_CONTROL_AE_MODE_OFF:
1941 // Don't do anything for these
1942 return aeState;
1943 case ANDROID_CONTROL_AE_MODE_ON:
1944 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:
1945 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH:
1946 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE:
1947 // Trigger a precapture cycle
1948 aeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE;
1949 mAeScanDuration =
1950 ((double)rand() / RAND_MAX) *
1951 (kMaxPrecaptureAeDuration - kMinPrecaptureAeDuration) +
1952 kMinPrecaptureAeDuration;
1953 ALOGD("%s: AE precapture scan start, duration %" PRId64 " ms",
1954 __FUNCTION__, mAeScanDuration / 1000000);
1955 }
1956 return aeState;
1957 }
1958
maybeStartAeScan(uint8_t aeMode,bool aeLocked,uint8_t aeState)1959 int EmulatedFakeCamera2::ControlThread::maybeStartAeScan(uint8_t aeMode,
1960 bool aeLocked,
1961 uint8_t aeState) {
1962 if (aeLocked) return aeState;
1963 switch (aeMode) {
1964 case ANDROID_CONTROL_AE_MODE_OFF:
1965 break;
1966 case ANDROID_CONTROL_AE_MODE_ON:
1967 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:
1968 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH:
1969 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: {
1970 if (aeState != ANDROID_CONTROL_AE_STATE_INACTIVE &&
1971 aeState != ANDROID_CONTROL_AE_STATE_CONVERGED)
1972 break;
1973
1974 bool startScan = ((double)rand() / RAND_MAX) < kAeScanStartRate;
1975 if (startScan) {
1976 mAeScanDuration =
1977 ((double)rand() / RAND_MAX) * (kMaxAeDuration - kMinAeDuration) +
1978 kMinAeDuration;
1979 aeState = ANDROID_CONTROL_AE_STATE_SEARCHING;
1980 ALOGV("%s: AE scan start, duration %" PRId64 " ms", __FUNCTION__,
1981 mAeScanDuration / 1000000);
1982 }
1983 }
1984 }
1985
1986 return aeState;
1987 }
1988
updateAeScan(uint8_t,bool aeLock,uint8_t aeState,nsecs_t * maxSleep)1989 int EmulatedFakeCamera2::ControlThread::updateAeScan(uint8_t /*aeMode*/,
1990 bool aeLock,
1991 uint8_t aeState,
1992 nsecs_t *maxSleep) {
1993 if (aeLock && aeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
1994 mAeScanDuration = 0;
1995 aeState = ANDROID_CONTROL_AE_STATE_LOCKED;
1996 } else if ((aeState == ANDROID_CONTROL_AE_STATE_SEARCHING) ||
1997 (aeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE)) {
1998 if (mAeScanDuration <= 0) {
1999 ALOGV("%s: AE scan done", __FUNCTION__);
2000 aeState = aeLock ? ANDROID_CONTROL_AE_STATE_LOCKED
2001 : ANDROID_CONTROL_AE_STATE_CONVERGED;
2002
2003 Mutex::Autolock lock(mInputMutex);
2004 mExposureTime = kNormalExposureTime;
2005 } else {
2006 if (mAeScanDuration <= *maxSleep) {
2007 *maxSleep = mAeScanDuration;
2008 }
2009
2010 int64_t exposureDelta =
2011 ((double)rand() / RAND_MAX) * 2 * kExposureJump - kExposureJump;
2012 Mutex::Autolock lock(mInputMutex);
2013 mExposureTime = mExposureTime + exposureDelta;
2014 if (mExposureTime < kMinExposureTime) mExposureTime = kMinExposureTime;
2015 }
2016 }
2017
2018 return aeState;
2019 }
2020
updateAeState(uint8_t newState,int32_t triggerId)2021 void EmulatedFakeCamera2::ControlThread::updateAeState(uint8_t newState,
2022 int32_t triggerId) {
2023 Mutex::Autolock lock(mInputMutex);
2024 if (mAeState != newState) {
2025 ALOGV("%s: Autoexposure state now %d, id %d", __FUNCTION__, newState,
2026 triggerId);
2027 mAeState = newState;
2028 mParent->sendNotification(CAMERA2_MSG_AUTOEXPOSURE, newState, triggerId, 0);
2029 }
2030 }
2031
2032 /** Private methods */
2033
constructStaticInfo(camera_metadata_t ** info,bool sizeRequest) const2034 status_t EmulatedFakeCamera2::constructStaticInfo(camera_metadata_t **info,
2035 bool sizeRequest) const {
2036 size_t entryCount = 0;
2037 size_t dataCount = 0;
2038 status_t ret;
2039
2040 #define ADD_OR_SIZE(tag, data, count) \
2041 if ((ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, tag, data, \
2042 count)) != OK) \
2043 return ret
2044
2045 // android.lens
2046
2047 // 5 cm min focus distance for back camera, infinity (fixed focus) for front
2048 const float minFocusDistance = mFacingBack ? 1.0 / 0.05 : 0.0;
2049 ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &minFocusDistance, 1);
2050 // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front
2051 // const float hyperFocalDistance = mFacingBack ? 1.0 / 5.0 : 0.0;
2052 ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, &minFocusDistance, 1);
2053
2054 static const float focalLength = 3.30f; // mm
2055 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &focalLength, 1);
2056 static const float aperture = 2.8f;
2057 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES, &aperture, 1);
2058 static const float filterDensity = 0;
2059 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, &filterDensity, 1);
2060 static const uint8_t availableOpticalStabilization =
2061 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
2062 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
2063 &availableOpticalStabilization, 1);
2064
2065 static const int32_t lensShadingMapSize[] = {1, 1};
2066 ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize,
2067 sizeof(lensShadingMapSize) / sizeof(int32_t));
2068
2069 int32_t lensFacing =
2070 mFacingBack ? ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
2071 ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
2072
2073 // android.sensor
2074
2075 ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
2076 Sensor::kExposureTimeRange, 2);
2077
2078 ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
2079 &Sensor::kFrameDurationRange[1], 1);
2080
2081 ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, Sensor::kSensitivityRange,
2082 sizeof(Sensor::kSensitivityRange) / sizeof(int32_t));
2083
2084 ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
2085 &Sensor::kColorFilterArrangement, 1);
2086
2087 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm
2088 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, sensorPhysicalSize, 2);
2089
2090 const int32_t pixelArray[] = {mSensorWidth, mSensorHeight};
2091 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, pixelArray, 2);
2092
2093 ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, pixelArray, 2);
2094
2095 ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL, &Sensor::kMaxRawValue, 1);
2096
2097 static const int32_t blackLevelPattern[4] = {
2098 static_cast<int32_t>(Sensor::kBlackLevel),
2099 static_cast<int32_t>(Sensor::kBlackLevel),
2100 static_cast<int32_t>(Sensor::kBlackLevel),
2101 static_cast<int32_t>(Sensor::kBlackLevel)};
2102 ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, blackLevelPattern,
2103 sizeof(blackLevelPattern) / sizeof(int32_t));
2104
2105 // TODO: sensor color calibration fields
2106
2107 // android.flash
2108 static const uint8_t flashAvailable = 0;
2109 ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
2110
2111 static const int64_t flashChargeDuration = 0;
2112 ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
2113
2114 // android.tonemap
2115
2116 static const int32_t tonemapCurvePoints = 128;
2117 ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
2118
2119 // android.scaler
2120
2121 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS, kAvailableFormats,
2122 sizeof(kAvailableFormats) / sizeof(uint32_t));
2123
2124 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES, &mAvailableRawSizes.front(),
2125 mAvailableRawSizes.size());
2126
2127 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
2128 kAvailableRawMinDurations,
2129 sizeof(kAvailableRawMinDurations) / sizeof(uint64_t));
2130
2131 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
2132 &mAvailableProcessedSizes.front(),
2133 mAvailableProcessedSizes.size());
2134
2135 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
2136 kAvailableProcessedMinDurations,
2137 sizeof(kAvailableProcessedMinDurations) / sizeof(uint64_t));
2138
2139 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, &mAvailableJpegSizes.front(),
2140 mAvailableJpegSizes.size());
2141
2142 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
2143 kAvailableJpegMinDurations,
2144 sizeof(kAvailableJpegMinDurations) / sizeof(uint64_t));
2145
2146 static const float maxZoom = 10;
2147 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1);
2148
2149 // android.jpeg
2150
2151 static const int32_t jpegThumbnailSizes[] = {0, 0, 160, 120, 320, 240};
2152 ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, jpegThumbnailSizes,
2153 sizeof(jpegThumbnailSizes) / sizeof(int32_t));
2154
2155 static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize;
2156 ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
2157
2158 // android.stats
2159
2160 static const uint8_t availableFaceDetectModes[] = {
2161 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
2162 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE,
2163 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL};
2164
2165 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
2166 availableFaceDetectModes, sizeof(availableFaceDetectModes));
2167
2168 static const int32_t maxFaceCount = 8;
2169 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, &maxFaceCount, 1);
2170
2171 static const int32_t histogramSize = 64;
2172 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, &histogramSize,
2173 1);
2174
2175 static const int32_t maxHistogramCount = 1000;
2176 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, &maxHistogramCount,
2177 1);
2178
2179 static const int32_t sharpnessMapSize[2] = {64, 64};
2180 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, sharpnessMapSize,
2181 sizeof(sharpnessMapSize) / sizeof(int32_t));
2182
2183 static const int32_t maxSharpnessMapValue = 1000;
2184 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
2185 &maxSharpnessMapValue, 1);
2186
2187 // android.control
2188
2189 static const uint8_t availableSceneModes[] = {
2190 #if VSOC_PLATFORM_SDK_AFTER(K)
2191 ANDROID_CONTROL_SCENE_MODE_DISABLED
2192 #else
2193 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED
2194 #endif
2195 };
2196 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, availableSceneModes,
2197 sizeof(availableSceneModes));
2198
2199 static const uint8_t availableEffects[] = {ANDROID_CONTROL_EFFECT_MODE_OFF};
2200 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS, availableEffects,
2201 sizeof(availableEffects));
2202
2203 static const int32_t max3aRegions[] = {/*AE*/ 0, /*AWB*/ 0, /*AF*/ 0};
2204 ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS, max3aRegions,
2205 sizeof(max3aRegions) / sizeof(max3aRegions[0]));
2206
2207 static const uint8_t availableAeModes[] = {ANDROID_CONTROL_AE_MODE_OFF,
2208 ANDROID_CONTROL_AE_MODE_ON};
2209 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES, availableAeModes,
2210 sizeof(availableAeModes));
2211
2212 static const camera_metadata_rational exposureCompensationStep = {1, 3};
2213 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP, &exposureCompensationStep,
2214 1);
2215
2216 int32_t exposureCompensationRange[] = {-9, 9};
2217 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE, exposureCompensationRange,
2218 sizeof(exposureCompensationRange) / sizeof(int32_t));
2219
2220 static const int32_t availableTargetFpsRanges[] = {5, 30, 15, 30};
2221 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
2222 availableTargetFpsRanges,
2223 sizeof(availableTargetFpsRanges) / sizeof(int32_t));
2224
2225 static const uint8_t availableAntibandingModes[] = {
2226 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
2227 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO};
2228 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
2229 availableAntibandingModes, sizeof(availableAntibandingModes));
2230
2231 static const uint8_t availableAwbModes[] = {
2232 ANDROID_CONTROL_AWB_MODE_OFF,
2233 ANDROID_CONTROL_AWB_MODE_AUTO,
2234 ANDROID_CONTROL_AWB_MODE_INCANDESCENT,
2235 ANDROID_CONTROL_AWB_MODE_FLUORESCENT,
2236 ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
2237 ANDROID_CONTROL_AWB_MODE_SHADE};
2238 ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES, availableAwbModes,
2239 sizeof(availableAwbModes));
2240
2241 static const uint8_t availableAfModesBack[] = {
2242 ANDROID_CONTROL_AF_MODE_OFF, ANDROID_CONTROL_AF_MODE_AUTO,
2243 ANDROID_CONTROL_AF_MODE_MACRO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
2244 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE};
2245
2246 static const uint8_t availableAfModesFront[] = {ANDROID_CONTROL_AF_MODE_OFF};
2247
2248 if (mFacingBack) {
2249 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesBack,
2250 sizeof(availableAfModesBack));
2251 } else {
2252 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, availableAfModesFront,
2253 sizeof(availableAfModesFront));
2254 }
2255
2256 static const uint8_t availableVstabModes[] = {
2257 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF};
2258 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
2259 availableVstabModes, sizeof(availableVstabModes));
2260
2261 #undef ADD_OR_SIZE
2262 /** Allocate metadata if sizing */
2263 if (sizeRequest) {
2264 ALOGV(
2265 "Allocating %zu entries, %zu extra bytes for "
2266 "static camera info",
2267 entryCount, dataCount);
2268 *info = allocate_camera_metadata(entryCount, dataCount);
2269 if (*info == NULL) {
2270 ALOGE(
2271 "Unable to allocate camera static info"
2272 "(%zu entries, %zu bytes extra data)",
2273 entryCount, dataCount);
2274 return NO_MEMORY;
2275 }
2276 }
2277 return OK;
2278 }
2279
constructDefaultRequest(int request_template,camera_metadata_t ** request,bool sizeRequest) const2280 status_t EmulatedFakeCamera2::constructDefaultRequest(
2281 int request_template, camera_metadata_t **request, bool sizeRequest) const {
2282 size_t entryCount = 0;
2283 size_t dataCount = 0;
2284 status_t ret;
2285
2286 #define ADD_OR_SIZE(tag, data, count) \
2287 if ((ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, tag, \
2288 data, count)) != OK) \
2289 return ret
2290
2291 /** android.request */
2292
2293 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
2294 ADD_OR_SIZE(ANDROID_REQUEST_TYPE, &requestType, 1);
2295
2296 static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL;
2297 ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
2298
2299 static const int32_t id = 0;
2300 ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
2301
2302 static const int32_t frameCount = 0;
2303 ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
2304
2305 // OUTPUT_STREAMS set by user
2306 entryCount += 1;
2307 dataCount += 5; // TODO: Should be maximum stream number
2308
2309 /** android.lens */
2310
2311 static const float focusDistance = 0;
2312 ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
2313
2314 static const float aperture = 2.8f;
2315 ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1);
2316
2317 static const float focalLength = 5.0f;
2318 ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1);
2319
2320 static const float filterDensity = 0;
2321 ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
2322
2323 static const uint8_t opticalStabilizationMode =
2324 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
2325 ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
2326 &opticalStabilizationMode, 1);
2327
2328 // FOCUS_RANGE set only in frame
2329
2330 /** android.sensor */
2331
2332 static const int64_t exposureTime = 10 * MSEC;
2333 ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1);
2334
2335 static const int64_t frameDuration = 33333333L; // 1/30 s
2336 ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
2337
2338 static const int32_t sensitivity = 100;
2339 ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1);
2340
2341 // TIMESTAMP set only in frame
2342
2343 /** android.flash */
2344
2345 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
2346 ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
2347
2348 static const uint8_t flashPower = 10;
2349 ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
2350
2351 static const int64_t firingTime = 0;
2352 ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
2353
2354 /** Processing block modes */
2355 uint8_t hotPixelMode = 0;
2356 uint8_t demosaicMode = 0;
2357 uint8_t noiseMode = 0;
2358 uint8_t shadingMode = 0;
2359 uint8_t colorMode = 0;
2360 uint8_t tonemapMode = 0;
2361 uint8_t edgeMode = 0;
2362 switch (request_template) {
2363 case CAMERA2_TEMPLATE_STILL_CAPTURE:
2364 // fall-through
2365 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
2366 // fall-through
2367 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
2368 hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
2369 demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;
2370 noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
2371 shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY;
2372 colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY;
2373 tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
2374 edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY;
2375 break;
2376 case CAMERA2_TEMPLATE_PREVIEW:
2377 // fall-through
2378 case CAMERA2_TEMPLATE_VIDEO_RECORD:
2379 // fall-through
2380 default:
2381 hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
2382 demosaicMode = ANDROID_DEMOSAIC_MODE_FAST;
2383 noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST;
2384 shadingMode = ANDROID_SHADING_MODE_FAST;
2385 colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST;
2386 tonemapMode = ANDROID_TONEMAP_MODE_FAST;
2387 edgeMode = ANDROID_EDGE_MODE_FAST;
2388 break;
2389 }
2390 ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
2391 ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
2392 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1);
2393 ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
2394 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1);
2395 ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
2396 ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
2397
2398 /** android.noise */
2399 static const uint8_t noiseStrength = 5;
2400 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1);
2401
2402 /** android.color */
2403 static const float colorTransform[9] = {1.0f, 0.f, 0.f, 0.f, 1.f,
2404 0.f, 0.f, 0.f, 1.f};
2405 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9);
2406
2407 /** android.tonemap */
2408 static const float tonemapCurve[4] = {0.f, 0.f, 1.f, 1.f};
2409 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4);
2410 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4);
2411 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4);
2412
2413 /** android.edge */
2414 static const uint8_t edgeStrength = 5;
2415 ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
2416
2417 /** android.scaler */
2418 static const int32_t cropRegion[3] = {0, 0,
2419 static_cast<int32_t>(mSensorWidth)};
2420 ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
2421
2422 /** android.jpeg */
2423 static const int32_t jpegQuality = 80;
2424 ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
2425
2426 static const int32_t thumbnailSize[2] = {640, 480};
2427 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
2428
2429 static const int32_t thumbnailQuality = 80;
2430 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
2431
2432 static const double gpsCoordinates[2] = {0, 0};
2433 ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2);
2434
2435 static const uint8_t gpsProcessingMethod[32] = "None";
2436 ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
2437
2438 static const int64_t gpsTimestamp = 0;
2439 ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
2440
2441 static const int32_t jpegOrientation = 0;
2442 ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
2443
2444 /** android.stats */
2445
2446 static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
2447 ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
2448
2449 static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
2450 ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
2451
2452 static const uint8_t sharpnessMapMode =
2453 ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF;
2454 ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
2455
2456 // faceRectangles, faceScores, faceLandmarks, faceIds, histogram,
2457 // sharpnessMap only in frames
2458
2459 /** android.control */
2460
2461 uint8_t controlIntent = 0;
2462 switch (request_template) {
2463 case CAMERA2_TEMPLATE_PREVIEW:
2464 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
2465 break;
2466 case CAMERA2_TEMPLATE_STILL_CAPTURE:
2467 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
2468 break;
2469 case CAMERA2_TEMPLATE_VIDEO_RECORD:
2470 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
2471 break;
2472 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
2473 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
2474 break;
2475 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
2476 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
2477 break;
2478 default:
2479 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
2480 break;
2481 }
2482 ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
2483
2484 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
2485 ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
2486
2487 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
2488 ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
2489
2490 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
2491 ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
2492
2493 static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;
2494 ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2495
2496 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
2497 ADD_OR_SIZE(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
2498
2499 static const int32_t controlRegions[5] = {
2500 0, 0, static_cast<int32_t>(mSensorWidth),
2501 static_cast<int32_t>(mSensorHeight), 1000};
2502 ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
2503
2504 static const int32_t aeExpCompensation = 0;
2505 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1);
2506
2507 static const int32_t aeTargetFpsRange[2] = {10, 30};
2508 ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
2509
2510 static const uint8_t aeAntibandingMode =
2511 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
2512 ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
2513
2514 static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
2515 ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
2516
2517 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
2518 ADD_OR_SIZE(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1);
2519
2520 ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
2521
2522 uint8_t afMode = 0;
2523 switch (request_template) {
2524 case CAMERA2_TEMPLATE_PREVIEW:
2525 afMode = ANDROID_CONTROL_AF_MODE_AUTO;
2526 break;
2527 case CAMERA2_TEMPLATE_STILL_CAPTURE:
2528 afMode = ANDROID_CONTROL_AF_MODE_AUTO;
2529 break;
2530 case CAMERA2_TEMPLATE_VIDEO_RECORD:
2531 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
2532 break;
2533 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
2534 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
2535 break;
2536 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
2537 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
2538 break;
2539 default:
2540 afMode = ANDROID_CONTROL_AF_MODE_AUTO;
2541 break;
2542 }
2543 ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
2544
2545 ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
2546
2547 static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
2548 ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
2549
2550 // aeState, awbState, afState only in frame
2551
2552 /** Allocate metadata if sizing */
2553 if (sizeRequest) {
2554 ALOGV(
2555 "Allocating %zu entries, %zu extra bytes for "
2556 "request template type %d",
2557 entryCount, dataCount, request_template);
2558 *request = allocate_camera_metadata(entryCount, dataCount);
2559 if (*request == NULL) {
2560 ALOGE(
2561 "Unable to allocate new request template type %d "
2562 "(%zu entries, %zu bytes extra data)",
2563 request_template, entryCount, dataCount);
2564 return NO_MEMORY;
2565 }
2566 }
2567 return OK;
2568 #undef ADD_OR_SIZE
2569 }
2570
addOrSize(camera_metadata_t * request,bool sizeRequest,size_t * entryCount,size_t * dataCount,uint32_t tag,const void * entryData,size_t entryDataCount)2571 status_t EmulatedFakeCamera2::addOrSize(camera_metadata_t *request,
2572 bool sizeRequest, size_t *entryCount,
2573 size_t *dataCount, uint32_t tag,
2574 const void *entryData,
2575 size_t entryDataCount) {
2576 if (!sizeRequest) {
2577 return add_camera_metadata_entry(request, tag, entryData, entryDataCount);
2578 } else {
2579 int type = get_camera_metadata_tag_type(tag);
2580 if (type < 0) return BAD_VALUE;
2581 (*entryCount)++;
2582 (*dataCount) +=
2583 calculate_camera_metadata_entry_data_size(type, entryDataCount);
2584 return OK;
2585 }
2586 }
2587
isStreamInUse(uint32_t id)2588 bool EmulatedFakeCamera2::isStreamInUse(uint32_t id) {
2589 // Assumes mMutex is locked; otherwise new requests could enter
2590 // configureThread while readoutThread is being checked
2591
2592 // Order of isStreamInUse calls matters
2593 if (mConfigureThread->isStreamInUse(id) ||
2594 mReadoutThread->isStreamInUse(id) || mJpegCompressor->isStreamInUse(id)) {
2595 ALOGE("%s: Stream %d is in use in active requests!", __FUNCTION__, id);
2596 return true;
2597 }
2598 return false;
2599 }
2600
isReprocessStreamInUse(uint32_t)2601 bool EmulatedFakeCamera2::isReprocessStreamInUse(uint32_t /*id*/) {
2602 // TODO: implement
2603 return false;
2604 }
2605
getStreamInfo(uint32_t streamId)2606 const Stream &EmulatedFakeCamera2::getStreamInfo(uint32_t streamId) {
2607 Mutex::Autolock lock(mMutex);
2608
2609 return mStreams.valueFor(streamId);
2610 }
2611
getReprocessStreamInfo(uint32_t streamId)2612 const ReprocessStream &EmulatedFakeCamera2::getReprocessStreamInfo(
2613 uint32_t streamId) {
2614 Mutex::Autolock lock(mMutex);
2615
2616 return mReprocessStreams.valueFor(streamId);
2617 }
2618
2619 }; /* namespace android */
2620