Merge "Add power properties"
diff --git a/authsecret/1.0/IAuthSecret.hal b/authsecret/1.0/IAuthSecret.hal
index 6b573b3..9a0fd5f 100644
--- a/authsecret/1.0/IAuthSecret.hal
+++ b/authsecret/1.0/IAuthSecret.hal
@@ -42,5 +42,5 @@
*
* @param secret blob derived from the primary user's credential.
*/
- primaryUserCredential(vec<uint8_t> secret);
+ oneway primaryUserCredential(vec<uint8_t> secret);
};
diff --git a/automotive/evs/1.0/vts/functional/VtsHalEvsV1_0TargetTest.cpp b/automotive/evs/1.0/vts/functional/VtsHalEvsV1_0TargetTest.cpp
index 57050d7..d904ad0 100644
--- a/automotive/evs/1.0/vts/functional/VtsHalEvsV1_0TargetTest.cpp
+++ b/automotive/evs/1.0/vts/functional/VtsHalEvsV1_0TargetTest.cpp
@@ -54,7 +54,7 @@
#include <android/hardware/automotive/evs/1.0/IEvsDisplay.h>
#include <VtsHalHidlTargetTestBase.h>
-
+#include <VtsHalHidlTargetTestEnvBase.h>
using namespace ::android::hardware::automotive::evs::V1_0;
using ::android::hardware::Return;
@@ -64,13 +64,28 @@
using ::android::hardware::hidl_string;
using ::android::sp;
+// Test environment for Evs HIDL HAL.
+class EvsHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
+ public:
+ // get the test environment singleton
+ static EvsHidlEnvironment* Instance() {
+ static EvsHidlEnvironment* instance = new EvsHidlEnvironment;
+ return instance;
+ }
+
+ virtual void registerTestServices() override { registerTestService<IEvsEnumerator>(); }
+
+ private:
+ EvsHidlEnvironment() {}
+};
// The main test class for EVS
class EvsHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
virtual void SetUp() override {
// Make sure we can connect to the enumerator
- pEnumerator = IEvsEnumerator::getService(kEnumeratorName);
+ pEnumerator = getService<IEvsEnumerator>(
+ EvsHidlEnvironment::Instance()->getServiceName<IEvsEnumerator>(kEnumeratorName));
ASSERT_NE(pEnumerator.get(), nullptr);
}
@@ -480,3 +495,12 @@
// Explicitly release the display
pEnumerator->closeDisplay(pDisplay);
}
+
+int main(int argc, char** argv) {
+ ::testing::AddGlobalTestEnvironment(EvsHidlEnvironment::Instance());
+ ::testing::InitGoogleTest(&argc, argv);
+ EvsHidlEnvironment::Instance()->init(&argc, argv);
+ int status = RUN_ALL_TESTS();
+ ALOGI("Test result = %d", status);
+ return status;
+}
diff --git a/camera/device/3.4/default/ExternalCameraDevice.cpp b/camera/device/3.4/default/ExternalCameraDevice.cpp
index b6470f5..14f82bc 100644
--- a/camera/device/3.4/default/ExternalCameraDevice.cpp
+++ b/camera/device/3.4/default/ExternalCameraDevice.cpp
@@ -131,7 +131,7 @@
session = new ExternalCameraDeviceSession(
callback, mCfg, mSupportedFormats, mCroppingType,
- mCameraCharacteristics, std::move(fd));
+ mCameraCharacteristics, mCameraId, std::move(fd));
if (session == nullptr) {
ALOGE("%s: camera device session allocation failed", __FUNCTION__);
mLock.unlock();
diff --git a/camera/device/3.4/default/ExternalCameraDeviceSession.cpp b/camera/device/3.4/default/ExternalCameraDeviceSession.cpp
index d6d9ff8..5346f80 100644
--- a/camera/device/3.4/default/ExternalCameraDeviceSession.cpp
+++ b/camera/device/3.4/default/ExternalCameraDeviceSession.cpp
@@ -46,6 +46,21 @@
// bad frames. TODO: develop a better bad frame detection
// method
+bool tryLock(Mutex& mutex)
+{
+ static const int kDumpLockRetries = 50;
+ static const int kDumpLockSleep = 60000;
+ bool locked = false;
+ for (int i = 0; i < kDumpLockRetries; ++i) {
+ if (mutex.tryLock() == NO_ERROR) {
+ locked = true;
+ break;
+ }
+ usleep(kDumpLockSleep);
+ }
+ return locked;
+}
+
} // Anonymous namespace
// Static instances
@@ -59,12 +74,14 @@
const std::vector<SupportedV4L2Format>& sortedFormats,
const CroppingType& croppingType,
const common::V1_0::helper::CameraMetadata& chars,
+ const std::string& cameraId,
unique_fd v4l2Fd) :
mCallback(callback),
mCfg(cfg),
mCameraCharacteristics(chars),
mSupportedFormats(sortedFormats),
mCroppingType(croppingType),
+ mCameraId(cameraId),
mV4l2Fd(std::move(v4l2Fd)),
mOutputThread(new OutputThread(this, mCroppingType)),
mMaxThumbResolution(getMaxThumbResolution()),
@@ -119,8 +136,79 @@
}
}
-void ExternalCameraDeviceSession::dumpState(const native_handle_t*) {
- // TODO: b/72261676 dump more runtime information
+
+void ExternalCameraDeviceSession::dumpState(const native_handle_t* handle) {
+ if (handle->numFds != 1 || handle->numInts != 0) {
+ ALOGE("%s: handle must contain 1 FD and 0 integers! Got %d FDs and %d ints",
+ __FUNCTION__, handle->numFds, handle->numInts);
+ return;
+ }
+ int fd = handle->data[0];
+
+ bool intfLocked = tryLock(mInterfaceLock);
+ if (!intfLocked) {
+ dprintf(fd, "!! ExternalCameraDeviceSession interface may be deadlocked !!\n");
+ }
+
+ if (isClosed()) {
+ dprintf(fd, "External camera %s is closed\n", mCameraId.c_str());
+ return;
+ }
+
+ bool streaming = false;
+ size_t v4L2BufferCount = 0;
+ SupportedV4L2Format streamingFmt;
+ std::unordered_set<uint32_t> inflightFrames;
+ {
+ Mutex::Autolock _l(mLock);
+ bool sessionLocked = tryLock(mLock);
+ if (!sessionLocked) {
+ dprintf(fd, "!! ExternalCameraDeviceSession mLock may be deadlocked !!\n");
+ }
+ streaming = mV4l2Streaming;
+ streamingFmt = mV4l2StreamingFmt;
+ v4L2BufferCount = mV4L2BufferCount;
+ inflightFrames = mInflightFrames;
+ if (sessionLocked) {
+ mLock.unlock();
+ }
+ }
+
+ dprintf(fd, "External camera %s V4L2 FD %d, cropping type %s, %s\n",
+ mCameraId.c_str(), mV4l2Fd.get(),
+ (mCroppingType == VERTICAL) ? "vertical" : "horizontal",
+ streaming ? "streaming" : "not streaming");
+ if (streaming) {
+ // TODO: dump fps later
+ dprintf(fd, "Current V4L2 format %c%c%c%c %dx%d\n",
+ streamingFmt.fourcc & 0xFF,
+ (streamingFmt.fourcc >> 8) & 0xFF,
+ (streamingFmt.fourcc >> 16) & 0xFF,
+ (streamingFmt.fourcc >> 24) & 0xFF,
+ streamingFmt.width, streamingFmt.height);
+
+ size_t numDequeuedV4l2Buffers = 0;
+ {
+ std::lock_guard<std::mutex> lk(mV4l2BufferLock);
+ numDequeuedV4l2Buffers = mNumDequeuedV4l2Buffers;
+ }
+ dprintf(fd, "V4L2 buffer queue size %zu, dequeued %zu\n",
+ v4L2BufferCount, numDequeuedV4l2Buffers);
+ }
+
+ dprintf(fd, "In-flight frames (not sorted):");
+ for (const auto& frameNumber : inflightFrames) {
+ dprintf(fd, "%d, ", frameNumber);
+ }
+ dprintf(fd, "\n");
+ mOutputThread->dump(fd);
+ dprintf(fd, "\n");
+
+ if (intfLocked) {
+ mInterfaceLock.unlock();
+ }
+
+ return;
}
Return<void> ExternalCameraDeviceSession::constructDefaultRequestSettings(
@@ -281,21 +369,20 @@
Return<void> ExternalCameraDeviceSession::close() {
Mutex::Autolock _il(mInterfaceLock);
- Mutex::Autolock _l(mLock);
- if (!mClosed) {
- // TODO: b/72261676 Cleanup inflight buffers/V4L2 buffer queue
+ bool closed = isClosed();
+ if (!closed) {
+ mOutputThread->flush();
+ mOutputThread->requestExit();
+ mOutputThread->join();
+
+ Mutex::Autolock _l(mLock);
+ // free all buffers
+ for(auto pair : mStreamMap) {
+ cleanupBuffersLocked(/*Stream ID*/pair.first);
+ }
+ v4l2StreamOffLocked();
ALOGV("%s: closing V4L2 camera FD %d", __FUNCTION__, mV4l2Fd.get());
mV4l2Fd.reset();
- mOutputThread->requestExit(); // TODO: join?
-
- // free all imported buffers
- for(auto& pair : mCirculatingBuffers) {
- CirculatingBuffers& buffers = pair.second;
- for (auto& p2 : buffers) {
- sHandleImporter.freeBuffer(p2.second);
- }
- }
-
mClosed = true;
}
return Void();
@@ -431,25 +518,22 @@
// TODO: program fps range per capture request here
// or limit the set of availableFpsRange
- sp<V4L2Frame> frameIn = dequeueV4l2FrameLocked();
+
+ nsecs_t shutterTs = 0;
+ sp<V4L2Frame> frameIn = dequeueV4l2FrameLocked(&shutterTs);
if ( frameIn == nullptr) {
ALOGE("%s: V4L2 deque frame failed!", __FUNCTION__);
return Status::INTERNAL_ERROR;
}
- // TODO: This can probably be replaced by use v4lbuffer timestamp
- // if the device supports it
- nsecs_t shutterTs = systemTime(SYSTEM_TIME_MONOTONIC);
-
- // TODO: reduce object copy in this path
- HalRequest halReq = {
- .frameNumber = request.frameNumber,
- .setting = mLatestReqSetting,
- .frameIn = frameIn,
- .shutterTs = shutterTs};
- halReq.buffers.resize(numOutputBufs);
+ std::shared_ptr<HalRequest> halReq = std::make_shared<HalRequest>();
+ halReq->frameNumber = request.frameNumber;
+ halReq->setting = mLatestReqSetting;
+ halReq->frameIn = frameIn;
+ halReq->shutterTs = shutterTs;
+ halReq->buffers.resize(numOutputBufs);
for (size_t i = 0; i < numOutputBufs; i++) {
- HalStreamBuffer& halBuf = halReq.buffers[i];
+ HalStreamBuffer& halBuf = halReq->buffers[i];
int streamId = halBuf.streamId = request.outputBuffers[i].streamId;
halBuf.bufferId = request.outputBuffers[i].bufferId;
const Stream& stream = mStreamMap[streamId];
@@ -461,7 +545,7 @@
halBuf.acquireFence = allFences[i];
halBuf.fenceTimeout = false;
}
- mInflightFrames.insert(halReq.frameNumber);
+ mInflightFrames.insert(halReq->frameNumber);
// Send request to OutputThread for the rest of processing
mOutputThread->submitRequest(halReq);
mFirstRequest = false;
@@ -487,30 +571,31 @@
}
//TODO: refactor with processCaptureResult
-Status ExternalCameraDeviceSession::processCaptureRequestError(const HalRequest& req) {
+Status ExternalCameraDeviceSession::processCaptureRequestError(
+ const std::shared_ptr<HalRequest>& req) {
// Return V4L2 buffer to V4L2 buffer queue
- enqueueV4l2Frame(req.frameIn);
+ enqueueV4l2Frame(req->frameIn);
// NotifyShutter
- notifyShutter(req.frameNumber, req.shutterTs);
+ notifyShutter(req->frameNumber, req->shutterTs);
- notifyError(/*frameNum*/req.frameNumber, /*stream*/-1, ErrorCode::ERROR_REQUEST);
+ notifyError(/*frameNum*/req->frameNumber, /*stream*/-1, ErrorCode::ERROR_REQUEST);
// Fill output buffers
hidl_vec<CaptureResult> results;
results.resize(1);
CaptureResult& result = results[0];
- result.frameNumber = req.frameNumber;
+ result.frameNumber = req->frameNumber;
result.partialResult = 1;
result.inputBuffer.streamId = -1;
- result.outputBuffers.resize(req.buffers.size());
- for (size_t i = 0; i < req.buffers.size(); i++) {
- result.outputBuffers[i].streamId = req.buffers[i].streamId;
- result.outputBuffers[i].bufferId = req.buffers[i].bufferId;
+ result.outputBuffers.resize(req->buffers.size());
+ for (size_t i = 0; i < req->buffers.size(); i++) {
+ result.outputBuffers[i].streamId = req->buffers[i].streamId;
+ result.outputBuffers[i].bufferId = req->buffers[i].bufferId;
result.outputBuffers[i].status = BufferStatus::ERROR;
- if (req.buffers[i].acquireFence >= 0) {
+ if (req->buffers[i].acquireFence >= 0) {
native_handle_t* handle = native_handle_create(/*numFds*/1, /*numInts*/0);
- handle->data[0] = req.buffers[i].acquireFence;
+ handle->data[0] = req->buffers[i].acquireFence;
result.outputBuffers[i].releaseFence.setTo(handle, /*shouldOwn*/false);
}
}
@@ -518,7 +603,7 @@
// update inflight records
{
Mutex::Autolock _l(mLock);
- mInflightFrames.erase(req.frameNumber);
+ mInflightFrames.erase(req->frameNumber);
}
// Callback into framework
@@ -527,51 +612,51 @@
return Status::OK;
}
-Status ExternalCameraDeviceSession::processCaptureResult(HalRequest& req) {
+Status ExternalCameraDeviceSession::processCaptureResult(std::shared_ptr<HalRequest>& req) {
// Return V4L2 buffer to V4L2 buffer queue
- enqueueV4l2Frame(req.frameIn);
+ enqueueV4l2Frame(req->frameIn);
// NotifyShutter
- notifyShutter(req.frameNumber, req.shutterTs);
+ notifyShutter(req->frameNumber, req->shutterTs);
// Fill output buffers
hidl_vec<CaptureResult> results;
results.resize(1);
CaptureResult& result = results[0];
- result.frameNumber = req.frameNumber;
+ result.frameNumber = req->frameNumber;
result.partialResult = 1;
result.inputBuffer.streamId = -1;
- result.outputBuffers.resize(req.buffers.size());
- for (size_t i = 0; i < req.buffers.size(); i++) {
- result.outputBuffers[i].streamId = req.buffers[i].streamId;
- result.outputBuffers[i].bufferId = req.buffers[i].bufferId;
- if (req.buffers[i].fenceTimeout) {
+ result.outputBuffers.resize(req->buffers.size());
+ for (size_t i = 0; i < req->buffers.size(); i++) {
+ result.outputBuffers[i].streamId = req->buffers[i].streamId;
+ result.outputBuffers[i].bufferId = req->buffers[i].bufferId;
+ if (req->buffers[i].fenceTimeout) {
result.outputBuffers[i].status = BufferStatus::ERROR;
native_handle_t* handle = native_handle_create(/*numFds*/1, /*numInts*/0);
- handle->data[0] = req.buffers[i].acquireFence;
+ handle->data[0] = req->buffers[i].acquireFence;
result.outputBuffers[i].releaseFence.setTo(handle, /*shouldOwn*/false);
- notifyError(req.frameNumber, req.buffers[i].streamId, ErrorCode::ERROR_BUFFER);
+ notifyError(req->frameNumber, req->buffers[i].streamId, ErrorCode::ERROR_BUFFER);
} else {
result.outputBuffers[i].status = BufferStatus::OK;
// TODO: refactor
- if (req.buffers[i].acquireFence > 0) {
+ if (req->buffers[i].acquireFence > 0) {
native_handle_t* handle = native_handle_create(/*numFds*/1, /*numInts*/0);
- handle->data[0] = req.buffers[i].acquireFence;
+ handle->data[0] = req->buffers[i].acquireFence;
result.outputBuffers[i].releaseFence.setTo(handle, /*shouldOwn*/false);
}
}
}
// Fill capture result metadata
- fillCaptureResult(req.setting, req.shutterTs);
- const camera_metadata_t *rawResult = req.setting.getAndLock();
+ fillCaptureResult(req->setting, req->shutterTs);
+ const camera_metadata_t *rawResult = req->setting.getAndLock();
V3_2::implementation::convertToHidl(rawResult, &result.result);
- req.setting.unlock(rawResult);
+ req->setting.unlock(rawResult);
// update inflight records
{
Mutex::Autolock _l(mLock);
- mInflightFrames.erase(req.frameNumber);
+ mInflightFrames.erase(req->frameNumber);
}
// Callback into framework
@@ -1302,7 +1387,7 @@
int ExternalCameraDeviceSession::OutputThread::createJpegLocked(
HalStreamBuffer &halBuf,
- HalRequest &req)
+ const std::shared_ptr<HalRequest>& req)
{
int ret;
auto lfail = [&](auto... args) {
@@ -1329,17 +1414,17 @@
int jpegQuality, thumbQuality;
Size thumbSize;
- if (req.setting.exists(ANDROID_JPEG_QUALITY)) {
+ if (req->setting.exists(ANDROID_JPEG_QUALITY)) {
camera_metadata_entry entry =
- req.setting.find(ANDROID_JPEG_QUALITY);
+ req->setting.find(ANDROID_JPEG_QUALITY);
jpegQuality = entry.data.u8[0];
} else {
return lfail("%s: ANDROID_JPEG_QUALITY not set",__FUNCTION__);
}
- if (req.setting.exists(ANDROID_JPEG_THUMBNAIL_QUALITY)) {
+ if (req->setting.exists(ANDROID_JPEG_THUMBNAIL_QUALITY)) {
camera_metadata_entry entry =
- req.setting.find(ANDROID_JPEG_THUMBNAIL_QUALITY);
+ req->setting.find(ANDROID_JPEG_THUMBNAIL_QUALITY);
thumbQuality = entry.data.u8[0];
} else {
return lfail(
@@ -1347,9 +1432,9 @@
__FUNCTION__);
}
- if (req.setting.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
+ if (req->setting.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
camera_metadata_entry entry =
- req.setting.find(ANDROID_JPEG_THUMBNAIL_SIZE);
+ req->setting.find(ANDROID_JPEG_THUMBNAIL_SIZE);
thumbSize = Size { static_cast<uint32_t>(entry.data.i32[0]),
static_cast<uint32_t>(entry.data.i32[1])
};
@@ -1409,7 +1494,7 @@
/* Combine camera characteristics with request settings to form EXIF
* metadata */
common::V1_0::helper::CameraMetadata meta(parent->mCameraCharacteristics);
- meta.append(req.setting);
+ meta.append(req->setting);
/* Generate EXIF object */
std::unique_ptr<ExifUtils> utils(ExifUtils::create());
@@ -1473,7 +1558,7 @@
}
bool ExternalCameraDeviceSession::OutputThread::threadLoop() {
- HalRequest req;
+ std::shared_ptr<HalRequest> req;
auto parent = mParent.promote();
if (parent == nullptr) {
ALOGE("%s: session has been disconnected!", __FUNCTION__);
@@ -1484,7 +1569,7 @@
// regularly to prevent v4l buffer queue filled with stale buffers
// when app doesn't program a preveiw request
waitForNextRequest(&req);
- if (req.frameIn == nullptr) {
+ if (req == nullptr) {
// No new request, wait again
return true;
}
@@ -1492,17 +1577,17 @@
auto onDeviceError = [&](auto... args) {
ALOGE(args...);
parent->notifyError(
- req.frameNumber, /*stream*/-1, ErrorCode::ERROR_DEVICE);
+ req->frameNumber, /*stream*/-1, ErrorCode::ERROR_DEVICE);
signalRequestDone();
return false;
};
- if (req.frameIn->mFourcc != V4L2_PIX_FMT_MJPEG) {
+ if (req->frameIn->mFourcc != V4L2_PIX_FMT_MJPEG) {
return onDeviceError("%s: do not support V4L2 format %c%c%c%c", __FUNCTION__,
- req.frameIn->mFourcc & 0xFF,
- (req.frameIn->mFourcc >> 8) & 0xFF,
- (req.frameIn->mFourcc >> 16) & 0xFF,
- (req.frameIn->mFourcc >> 24) & 0xFF);
+ req->frameIn->mFourcc & 0xFF,
+ (req->frameIn->mFourcc >> 8) & 0xFF,
+ (req->frameIn->mFourcc >> 16) & 0xFF,
+ (req->frameIn->mFourcc >> 24) & 0xFF);
}
std::unique_lock<std::mutex> lk(mBufferLock);
@@ -1510,7 +1595,7 @@
// TODO: see if we can save some computation by converting to YV12 here
uint8_t* inData;
size_t inDataSize;
- req.frameIn->map(&inData, &inDataSize);
+ req->frameIn->map(&inData, &inDataSize);
// TODO: profile
// TODO: in some special case maybe we can decode jpg directly to gralloc output?
int res = libyuv::MJPGToI420(
@@ -1538,7 +1623,7 @@
ALOGV("%s processing new request", __FUNCTION__);
const int kSyncWaitTimeoutMs = 500;
- for (auto& halBuf : req.buffers) {
+ for (auto& halBuf : req->buffers) {
if (halBuf.acquireFence != -1) {
int ret = sync_wait(halBuf.acquireFence, kSyncWaitTimeoutMs);
if (ret) {
@@ -1695,9 +1780,9 @@
return Status::OK;
}
-Status ExternalCameraDeviceSession::OutputThread::submitRequest(const HalRequest& req) {
+Status ExternalCameraDeviceSession::OutputThread::submitRequest(
+ const std::shared_ptr<HalRequest>& req) {
std::unique_lock<std::mutex> lk(mRequestListLock);
- // TODO: reduce object copy in this path
mRequestList.push_back(req);
lk.unlock();
mRequestCond.notify_one();
@@ -1712,10 +1797,10 @@
}
std::unique_lock<std::mutex> lk(mRequestListLock);
- std::list<HalRequest> reqs = mRequestList;
+ std::list<std::shared_ptr<HalRequest>> reqs = std::move(mRequestList);
mRequestList.clear();
if (mProcessingRequest) {
- std::chrono::seconds timeout = std::chrono::seconds(kReqWaitTimeoutSec);
+ std::chrono::seconds timeout = std::chrono::seconds(kFlushWaitTimeoutSec);
auto st = mRequestDoneCond.wait_for(lk, timeout);
if (st == std::cv_status::timeout) {
ALOGE("%s: wait for inflight request finish timeout!", __FUNCTION__);
@@ -1728,33 +1813,57 @@
}
}
-void ExternalCameraDeviceSession::OutputThread::waitForNextRequest(HalRequest* out) {
+void ExternalCameraDeviceSession::OutputThread::waitForNextRequest(
+ std::shared_ptr<HalRequest>* out) {
if (out == nullptr) {
ALOGE("%s: out is null", __FUNCTION__);
return;
}
std::unique_lock<std::mutex> lk(mRequestListLock);
+ int waitTimes = 0;
while (mRequestList.empty()) {
- std::chrono::seconds timeout = std::chrono::seconds(kReqWaitTimeoutSec);
+ if (exitPending()) {
+ return;
+ }
+ std::chrono::milliseconds timeout = std::chrono::milliseconds(kReqWaitTimeoutMs);
auto st = mRequestCond.wait_for(lk, timeout);
if (st == std::cv_status::timeout) {
- // no new request, return
- return;
+ waitTimes++;
+ if (waitTimes == kReqWaitTimesMax) {
+ // no new request, return
+ return;
+ }
}
}
*out = mRequestList.front();
mRequestList.pop_front();
mProcessingRequest = true;
+ mProcessingFrameNumer = (*out)->frameNumber;
}
void ExternalCameraDeviceSession::OutputThread::signalRequestDone() {
std::unique_lock<std::mutex> lk(mRequestListLock);
mProcessingRequest = false;
+ mProcessingFrameNumer = 0;
lk.unlock();
mRequestDoneCond.notify_one();
}
+void ExternalCameraDeviceSession::OutputThread::dump(int fd) {
+ std::lock_guard<std::mutex> lk(mRequestListLock);
+ if (mProcessingRequest) {
+ dprintf(fd, "OutputThread processing frame %d\n", mProcessingFrameNumer);
+ } else {
+ dprintf(fd, "OutputThread not processing any frames\n");
+ }
+ dprintf(fd, "OutputThread request list contains frame: ");
+ for (const auto& req : mRequestList) {
+ dprintf(fd, "%d, ", req->frameNumber);
+ }
+ dprintf(fd, "\n");
+}
+
void ExternalCameraDeviceSession::cleanupBuffersLocked(int id) {
for (auto& pair : mCirculatingBuffers.at(id)) {
sHandleImporter.freeBuffer(pair.second);
@@ -2016,15 +2125,25 @@
return OK;
}
-sp<V4L2Frame> ExternalCameraDeviceSession::dequeueV4l2FrameLocked() {
+sp<V4L2Frame> ExternalCameraDeviceSession::dequeueV4l2FrameLocked(/*out*/nsecs_t* shutterTs) {
sp<V4L2Frame> ret = nullptr;
+ if (shutterTs == nullptr) {
+ ALOGE("%s: shutterTs must not be null!", __FUNCTION__);
+ return ret;
+ }
+
{
std::unique_lock<std::mutex> lk(mV4l2BufferLock);
if (mNumDequeuedV4l2Buffers == mV4L2BufferCount) {
std::chrono::seconds timeout = std::chrono::seconds(kBufferWaitTimeoutSec);
mLock.unlock();
auto st = mV4L2BufferReturned.wait_for(lk, timeout);
+ // Here we introduce a case where mV4l2BufferLock is acquired before mLock, while
+ // the normal lock acquisition order is reversed, but this is fine because in most of
+ // cases we are protected by mInterfaceLock. The only thread that can compete these
+ // locks are the OutputThread, where we do need to make sure we don't acquire mLock then
+ // mV4l2BufferLock
mLock.lock();
if (st == std::cv_status::timeout) {
ALOGE("%s: wait for V4L2 buffer return timeout!", __FUNCTION__);
@@ -2051,6 +2170,15 @@
// TODO: try to dequeue again
}
+ if (buffer.flags & V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC) {
+ // Ideally we should also check for V4L2_BUF_FLAG_TSTAMP_SRC_SOE, but
+ // even V4L2_BUF_FLAG_TSTAMP_SRC_EOF is better than capture a timestamp now
+ *shutterTs = static_cast<nsecs_t>(buffer.timestamp.tv_sec)*1000000000LL +
+ buffer.timestamp.tv_usec * 1000LL;
+ } else {
+ *shutterTs = systemTime(SYSTEM_TIME_MONOTONIC);
+ }
+
{
std::lock_guard<std::mutex> lk(mV4l2BufferLock);
mNumDequeuedV4l2Buffers++;
@@ -2061,15 +2189,20 @@
}
void ExternalCameraDeviceSession::enqueueV4l2Frame(const sp<V4L2Frame>& frame) {
- Mutex::Autolock _l(mLock);
- frame->unmap();
- v4l2_buffer buffer{};
- buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- buffer.memory = V4L2_MEMORY_MMAP;
- buffer.index = frame->mBufferIndex;
- if (TEMP_FAILURE_RETRY(ioctl(mV4l2Fd.get(), VIDIOC_QBUF, &buffer)) < 0) {
- ALOGE("%s: QBUF index %d fails: %s", __FUNCTION__, frame->mBufferIndex, strerror(errno));
- return;
+ {
+ // Release mLock before acquiring mV4l2BufferLock to avoid potential
+ // deadlock
+ Mutex::Autolock _l(mLock);
+ frame->unmap();
+ v4l2_buffer buffer{};
+ buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ buffer.memory = V4L2_MEMORY_MMAP;
+ buffer.index = frame->mBufferIndex;
+ if (TEMP_FAILURE_RETRY(ioctl(mV4l2Fd.get(), VIDIOC_QBUF, &buffer)) < 0) {
+ ALOGE("%s: QBUF index %d fails: %s", __FUNCTION__,
+ frame->mBufferIndex, strerror(errno));
+ return;
+ }
}
{
diff --git a/camera/device/3.4/default/include/ext_device_v3_4_impl/ExternalCameraDeviceSession.h b/camera/device/3.4/default/include/ext_device_v3_4_impl/ExternalCameraDeviceSession.h
index 43656c8..9c0ad7f 100644
--- a/camera/device/3.4/default/include/ext_device_v3_4_impl/ExternalCameraDeviceSession.h
+++ b/camera/device/3.4/default/include/ext_device_v3_4_impl/ExternalCameraDeviceSession.h
@@ -91,6 +91,7 @@
const std::vector<SupportedV4L2Format>& sortedFormats,
const CroppingType& croppingType,
const common::V1_0::helper::CameraMetadata& chars,
+ const std::string& cameraId,
unique_fd v4l2Fd);
virtual ~ExternalCameraDeviceSession();
// Call by CameraDevice to dump active device states
@@ -180,7 +181,7 @@
int v4l2StreamOffLocked();
// TODO: change to unique_ptr for better tracking
- sp<V4L2Frame> dequeueV4l2FrameLocked(); // Called with mLock hold
+ sp<V4L2Frame> dequeueV4l2FrameLocked(/*out*/nsecs_t* shutterTs); // Called with mLock hold
void enqueueV4l2Frame(const sp<V4L2Frame>&);
// Check if input Stream is one of supported stream setting on this device
@@ -198,8 +199,8 @@
Status processOneCaptureRequest(const CaptureRequest& request);
- Status processCaptureResult(HalRequest&);
- Status processCaptureRequestError(const HalRequest&);
+ Status processCaptureResult(std::shared_ptr<HalRequest>&);
+ Status processCaptureRequestError(const std::shared_ptr<HalRequest>&);
void notifyShutter(uint32_t frameNumber, nsecs_t shutterTs);
void notifyError(uint32_t frameNumber, int32_t streamId, ErrorCode ec);
void invokeProcessCaptureResultCallback(
@@ -219,8 +220,9 @@
Status allocateIntermediateBuffers(
const Size& v4lSize, const Size& thumbSize,
const hidl_vec<Stream>& streams);
- Status submitRequest(const HalRequest&);
+ Status submitRequest(const std::shared_ptr<HalRequest>&);
void flush();
+ void dump(int fd);
virtual bool threadLoop() override;
private:
@@ -232,9 +234,11 @@
static int getCropRect(
CroppingType ct, const Size& inSize, const Size& outSize, IMapper::Rect* out);
- static const int kReqWaitTimeoutSec = 3;
+ static const int kFlushWaitTimeoutSec = 3; // 3 sec
+ static const int kReqWaitTimeoutMs = 33; // 33ms
+ static const int kReqWaitTimesMax = 90; // 33ms * 90 ~= 3 sec
- void waitForNextRequest(HalRequest* out);
+ void waitForNextRequest(std::shared_ptr<HalRequest>* out);
void signalRequestDone();
int cropAndScaleLocked(
@@ -254,16 +258,18 @@
void *out, size_t maxOutSize,
size_t &actualCodeSize);
- int createJpegLocked(HalStreamBuffer &halBuf, HalRequest &req);
+ int createJpegLocked(HalStreamBuffer &halBuf, const std::shared_ptr<HalRequest>& req);
const wp<ExternalCameraDeviceSession> mParent;
const CroppingType mCroppingType;
- mutable std::mutex mRequestListLock; // Protect acccess to mRequestList
+ mutable std::mutex mRequestListLock; // Protect acccess to mRequestList,
+ // mProcessingRequest and mProcessingFrameNumer
std::condition_variable mRequestCond; // signaled when a new request is submitted
std::condition_variable mRequestDoneCond; // signaled when a request is done processing
- std::list<HalRequest> mRequestList;
+ std::list<std::shared_ptr<HalRequest>> mRequestList;
bool mProcessingRequest = false;
+ uint32_t mProcessingFrameNumer = 0;
// V4L2 frameIn
// (MJPG decode)-> mYu12Frame
@@ -287,7 +293,9 @@
const common::V1_0::helper::CameraMetadata mCameraCharacteristics;
const std::vector<SupportedV4L2Format> mSupportedFormats;
const CroppingType mCroppingType;
+ const std::string& mCameraId;
unique_fd mV4l2Fd;
+
// device is closed either
// - closed by user
// - init failed
diff --git a/gnss/1.1/Android.bp b/gnss/1.1/Android.bp
index 417b4f5..4ae4439 100644
--- a/gnss/1.1/Android.bp
+++ b/gnss/1.1/Android.bp
@@ -11,6 +11,7 @@
"IGnssCallback.hal",
"IGnssConfiguration.hal",
"IGnssMeasurement.hal",
+ "IGnssMeasurementCallback.hal",
],
interfaces: [
"android.hardware.gnss@1.0",
diff --git a/gnss/1.1/IGnssMeasurement.hal b/gnss/1.1/IGnssMeasurement.hal
index 75df5a8..cd83ae3 100644
--- a/gnss/1.1/IGnssMeasurement.hal
+++ b/gnss/1.1/IGnssMeasurement.hal
@@ -17,7 +17,7 @@
package android.hardware.gnss@1.1;
import @1.0::IGnssMeasurement;
-import @1.0::IGnssMeasurementCallback;
+import IGnssMeasurementCallback;
/**
* Extended interface for GNSS Measurements support.
diff --git a/gnss/1.1/IGnssMeasurementCallback.hal b/gnss/1.1/IGnssMeasurementCallback.hal
new file mode 100644
index 0000000..5a60a56
--- /dev/null
+++ b/gnss/1.1/IGnssMeasurementCallback.hal
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.gnss@1.1;
+
+import @1.0::IGnssMeasurementCallback;
+
+/** The callback interface to report measurements from the HAL. */
+interface IGnssMeasurementCallback extends @1.0::IGnssMeasurementCallback {
+ /**
+ * Flags indicating the Accumulated Delta Range's states.
+ */
+ enum GnssAccumulatedDeltaRangeState
+ : @1.0::IGnssMeasurementCallback.GnssAccumulatedDeltaRangeState {
+ ADR_STATE_HALF_CYCLE_RESOLVED = 1 << 3, // Carrier-phase half-cycle ambiguity resolved
+ };
+
+ /**
+ * Extends a GNSS Measurement, adding the new enum.
+ */
+ struct GnssMeasurement {
+ /**
+ * GNSS measurement information for a single satellite and frequency, as in the 1.0
+ * version of the HAL.
+ *
+ * In this version of the HAL, these fields of the
+ * @1.0::IGnssMeasurementCallback.GnssMeasurement v1_0 struct are deprecated, and
+ * are no longer used by the framework:
+ * carrierCycles
+ * carrierPhase
+ * carrierPhaseUncertainty
+ *
+ * Similar information about carrier phase signal tracking is still reported in these
+ * fields of @1.0::IGnssMeasurementCallback.GnssMeasurement v1_0:
+ * accumulatedDeltaRangeM
+ * accumulatedDeltaRangeUncertaintyM
+ */
+ @1.0::IGnssMeasurementCallback.GnssMeasurement v1_0;
+
+ /**
+ * Provides the state of Accumulated Delta Range values, including additional information
+ * beyond version 1.0 of the HAL. See GnssAccumulatedDeltaRangeState.
+ *
+ * In this (1.1) version of the HAL, this value is used by the framework, not the
+ * value provided by v1_0.accumulatedDeltaRangeState.
+ */
+ bitfield<GnssAccumulatedDeltaRangeState> accumulatedDeltaRangeState;
+ };
+
+ /**
+ * Complete set of GNSS Measurement data, same as 1.0 with additional enum in measurements.
+ */
+ struct GnssData {
+ /** The full set of satellite measurement observations. */
+ vec<GnssMeasurement> measurements;
+
+ /** The GNSS clock time reading. */
+ GnssClock clock;
+ };
+
+ /**
+ * Callback for the hal to pass a GnssData structure back to the client.
+ *
+ * @param data Contains a reading of GNSS measurements.
+ */
+ gnssMeasurementCb(GnssData data);
+};
diff --git a/gnss/1.1/vts/functional/gnss_hal_test_cases.cpp b/gnss/1.1/vts/functional/gnss_hal_test_cases.cpp
index 264a11d..a0a1c73 100644
--- a/gnss/1.1/vts/functional/gnss_hal_test_cases.cpp
+++ b/gnss/1.1/vts/functional/gnss_hal_test_cases.cpp
@@ -396,6 +396,10 @@
ASSERT_TRUE(result.isOk());
EXPECT_TRUE(result);
+
+ auto resultVoid = gnss_hal_->deleteAidingData(IGnss::GnssAidingData::DELETE_ALL);
+
+ ASSERT_TRUE(resultVoid.isOk());
}
/*
diff --git a/neuralnetworks/1.1/types.hal b/neuralnetworks/1.1/types.hal
index 18863d3..fae5dd0 100644
--- a/neuralnetworks/1.1/types.hal
+++ b/neuralnetworks/1.1/types.hal
@@ -330,4 +330,12 @@
* equals OperandLifeTime::CONSTANT_REFERENCE.
*/
vec<memory> pools;
+
+ /**
+ * 'true' indicates TENSOR_FLOAT32 may be calculated with range and/or
+ * precision as low as that of the IEEE 754 16-bit floating-point format.
+ * 'false' indicates TENSOR_FLOAT32 must be calculated using at least the
+ * range and precision of the IEEE 754 32-bit floating-point format.
+ */
+ bool relaxComputationFloat32toFloat16;
};