Merge changes Ifa9c05c0,I7c74af89,I6b3ed72c,I216e2746
* changes:
AudioRecord: Add client side track id for logging
AudioTrack: Add client side track id for logging
AudioFlinger: Use track ids in log messages
AudioFlinger: Replace track name with id
diff --git a/camera/CameraMetadata.cpp b/camera/CameraMetadata.cpp
index e143e05..92fe84b 100644
--- a/camera/CameraMetadata.cpp
+++ b/camera/CameraMetadata.cpp
@@ -22,7 +22,6 @@
#include <binder/Parcel.h>
#include <camera/CameraMetadata.h>
-#include <camera/VendorTagDescriptor.h>
namespace android {
@@ -409,6 +408,79 @@
return res;
}
+status_t CameraMetadata::removePermissionEntries(metadata_vendor_id_t vendorId,
+ std::vector<int32_t> *tagsRemoved) {
+ uint32_t tagCount = 0;
+ std::vector<uint32_t> tagsToRemove;
+
+ if (tagsRemoved == nullptr) {
+ return BAD_VALUE;
+ }
+
+ sp<VendorTagDescriptor> vTags = VendorTagDescriptor::getGlobalVendorTagDescriptor();
+ if ((nullptr == vTags.get()) || (0 >= vTags->getTagCount())) {
+ sp<VendorTagDescriptorCache> cache =
+ VendorTagDescriptorCache::getGlobalVendorTagCache();
+ if (cache.get()) {
+ cache->getVendorTagDescriptor(vendorId, &vTags);
+ }
+ }
+
+ if ((nullptr != vTags.get()) && (vTags->getTagCount() > 0)) {
+ tagCount = vTags->getTagCount();
+ uint32_t *vendorTags = new uint32_t[tagCount];
+ if (nullptr == vendorTags) {
+ return NO_MEMORY;
+ }
+ vTags->getTagArray(vendorTags);
+
+ tagsToRemove.reserve(tagCount);
+ tagsToRemove.insert(tagsToRemove.begin(), vendorTags, vendorTags + tagCount);
+
+ delete [] vendorTags;
+ tagCount = 0;
+ }
+
+ auto tagsNeedingPermission = get_camera_metadata_permission_needed(&tagCount);
+ if (tagCount > 0) {
+ tagsToRemove.reserve(tagsToRemove.capacity() + tagCount);
+ tagsToRemove.insert(tagsToRemove.end(), tagsNeedingPermission,
+ tagsNeedingPermission + tagCount);
+ }
+
+ tagsRemoved->reserve(tagsToRemove.size());
+ for (const auto &it : tagsToRemove) {
+ if (exists(it)) {
+ auto rc = erase(it);
+ if (NO_ERROR != rc) {
+ ALOGE("%s: Failed to erase tag: %x", __func__, it);
+ return rc;
+ }
+ tagsRemoved->push_back(it);
+ }
+ }
+
+ // Update the available characterstics accordingly
+ if (exists(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS)) {
+ std::vector<uint32_t> currentKeys;
+
+ std::sort(tagsRemoved->begin(), tagsRemoved->end());
+ auto keys = find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+ currentKeys.reserve(keys.count);
+ currentKeys.insert(currentKeys.end(), keys.data.i32, keys.data.i32 + keys.count);
+ std::sort(currentKeys.begin(), currentKeys.end());
+
+ std::vector<int32_t> newKeys(keys.count);
+ auto end = std::set_difference(currentKeys.begin(), currentKeys.end(), tagsRemoved->begin(),
+ tagsRemoved->end(), newKeys.begin());
+ newKeys.resize(end - newKeys.begin());
+
+ update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, newKeys.data(), newKeys.size());
+ }
+
+ return NO_ERROR;
+}
+
void CameraMetadata::dump(int fd, int verbosity, int indentation) const {
dump_indented_camera_metadata(mBuffer, fd, verbosity, indentation);
}
diff --git a/camera/aidl/android/hardware/ICameraService.aidl b/camera/aidl/android/hardware/ICameraService.aidl
index 9c0f28b..c038314 100644
--- a/camera/aidl/android/hardware/ICameraService.aidl
+++ b/camera/aidl/android/hardware/ICameraService.aidl
@@ -149,8 +149,10 @@
const int API_VERSION_1 = 1;
const int API_VERSION_2 = 2;
- // Determines if a particular API version is supported directly
+ // Determines if a particular API version is supported directly for a cameraId.
boolean supportsCameraApi(String cameraId, int apiVersion);
+ // Determines if a cameraId is a hidden physical camera of a logical multi-camera.
+ boolean isHiddenPhysicalCamera(String cameraId);
void setTorchMode(String cameraId, boolean enabled, IBinder clientBinder);
diff --git a/camera/include/camera/CameraMetadata.h b/camera/include/camera/CameraMetadata.h
index d284477..844bb80 100644
--- a/camera/include/camera/CameraMetadata.h
+++ b/camera/include/camera/CameraMetadata.h
@@ -22,6 +22,7 @@
#include <utils/String8.h>
#include <utils/Vector.h>
#include <binder/Parcelable.h>
+#include <camera/VendorTagDescriptor.h>
namespace android {
@@ -170,6 +171,12 @@
status_t erase(uint32_t tag);
/**
+ * Remove metadata entries that need additional permissions.
+ */
+ status_t removePermissionEntries(metadata_vendor_id_t vendorId,
+ std::vector<int32_t> *tagsRemoved /*out*/);
+
+ /**
* Swap the underlying camera metadata between this and the other
* metadata object.
*/
diff --git a/camera/ndk/include/camera/NdkCameraMetadataTags.h b/camera/ndk/include/camera/NdkCameraMetadataTags.h
index c1f5ddc..6ebd850 100644
--- a/camera/ndk/include/camera/NdkCameraMetadataTags.h
+++ b/camera/ndk/include/camera/NdkCameraMetadataTags.h
@@ -7209,8 +7209,14 @@
ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING = 10,
/**
- * <p>The camera device is a logical camera backed by two or more physical cameras that are
- * also exposed to the application.</p>
+ * <p>The camera device is a logical camera backed by two or more physical cameras. In
+ * API level 28, the physical cameras must also be exposed to the application via
+ * <a href="https://developer.android.com/reference/android/hardware/camera2/CameraManager.html#getCameraIdList">CameraManager#getCameraIdList</a>. Starting from API
+ * level 29, some or all physical cameras may not be independently exposed to the
+ * application, in which case the physical camera IDs will not be available in
+ * <a href="https://developer.android.com/reference/android/hardware/camera2/CameraManager.html#getCameraIdList">CameraManager#getCameraIdList</a>. But the application
+ * can still query the physical cameras' characteristics by calling
+ * <a href="https://developer.android.com/reference/android/hardware/camera2/CameraManager.html#getCameraCharacteristics">CameraManager#getCameraCharacteristics</a>.</p>
* <p>Camera application shouldn't assume that there are at most 1 rear camera and 1 front
* camera in the system. For an application that switches between front and back cameras,
* the recommendation is to switch between the first rear camera and the first front
diff --git a/camera/tests/Android.mk b/camera/tests/Android.mk
index 659484f..e5c1631 100644
--- a/camera/tests/Android.mk
+++ b/camera/tests/Android.mk
@@ -19,7 +19,8 @@
LOCAL_SRC_FILES:= \
VendorTagDescriptorTests.cpp \
CameraBinderTests.cpp \
- CameraZSLTests.cpp
+ CameraZSLTests.cpp \
+ CameraCharacteristicsPermission.cpp
LOCAL_SHARED_LIBRARIES := \
liblog \
diff --git a/camera/tests/CameraCharacteristicsPermission.cpp b/camera/tests/CameraCharacteristicsPermission.cpp
new file mode 100644
index 0000000..135d2a3
--- /dev/null
+++ b/camera/tests/CameraCharacteristicsPermission.cpp
@@ -0,0 +1,96 @@
+/*
+ * 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.
+ */
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "CameraCharacteristicsPermission"
+
+#include <gtest/gtest.h>
+
+#include <binder/ProcessState.h>
+#include <utils/Errors.h>
+#include <utils/Log.h>
+#include <camera/CameraMetadata.h>
+#include <camera/Camera.h>
+#include <android/hardware/ICameraService.h>
+
+using namespace android;
+using namespace android::hardware;
+
+class CameraCharacteristicsPermission : public ::testing::Test {
+protected:
+
+ CameraCharacteristicsPermission() : numCameras(0){}
+ //Gtest interface
+ void SetUp() override;
+ void TearDown() override;
+
+ int32_t numCameras;
+ sp<ICameraService> mCameraService;
+};
+
+void CameraCharacteristicsPermission::SetUp() {
+ ::android::binder::Status rc;
+ ProcessState::self()->startThreadPool();
+ sp<IServiceManager> sm = defaultServiceManager();
+ sp<IBinder> binder = sm->getService(String16("media.camera"));
+ mCameraService = interface_cast<ICameraService>(binder);
+ rc = mCameraService->getNumberOfCameras(
+ hardware::ICameraService::CAMERA_TYPE_ALL, &numCameras);
+ EXPECT_TRUE(rc.isOk());
+}
+
+void CameraCharacteristicsPermission::TearDown() {
+ mCameraService.clear();
+}
+
+// Revoking and acquiring permissions automatically might not be possible.
+// Test the functionality for removal of camera characteristics needing
+// a camera permission.
+TEST_F(CameraCharacteristicsPermission, TestCameraPermission) {
+ for (int32_t cameraId = 0; cameraId < numCameras; cameraId++) {
+
+ String16 cameraIdStr = String16(String8::format("%d", cameraId));
+ bool isSupported = false;
+ auto rc = mCameraService->supportsCameraApi(cameraIdStr,
+ hardware::ICameraService::API_VERSION_2, &isSupported);
+ EXPECT_TRUE(rc.isOk());
+ if (!isSupported) {
+ continue;
+ }
+
+ CameraMetadata metadata;
+ std::vector<int32_t> tagsNeedingPermission;
+ rc = mCameraService->getCameraCharacteristics(cameraIdStr, &metadata);
+ ASSERT_TRUE(rc.isOk());
+ EXPECT_FALSE(metadata.isEmpty());
+ EXPECT_EQ(metadata.removePermissionEntries(CAMERA_METADATA_INVALID_VENDOR_ID,
+ &tagsNeedingPermission), NO_ERROR);
+ camera_metadata_entry_t availableCharacteristics =
+ metadata.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
+ EXPECT_TRUE(0 < availableCharacteristics.count);
+
+ std::vector<uint32_t> availableKeys;
+ availableKeys.reserve(availableCharacteristics.count);
+ availableKeys.insert(availableKeys.begin(), availableCharacteristics.data.i32,
+ availableCharacteristics.data.i32 + availableCharacteristics.count);
+
+ for (const auto &key : tagsNeedingPermission) {
+ ASSERT_FALSE(metadata.exists(key));
+ auto it = std::find(availableKeys.begin(), availableKeys.end(), key);
+ ASSERT_TRUE(it == availableKeys.end());
+ }
+ }
+}
diff --git a/media/libmediaplayer2/MediaPlayer2AudioOutput.cpp b/media/libmediaplayer2/MediaPlayer2AudioOutput.cpp
index a8e1d1f..eba78ed 100644
--- a/media/libmediaplayer2/MediaPlayer2AudioOutput.cpp
+++ b/media/libmediaplayer2/MediaPlayer2AudioOutput.cpp
@@ -559,7 +559,7 @@
}
status_t MediaPlayer2AudioOutput::getPlaybackRate(AudioPlaybackRate *rate) {
- ALOGV("setPlaybackRate");
+ ALOGV("getPlaybackRate");
Mutex::Autolock lock(mLock);
if (mTrack == 0) {
return NO_INIT;
diff --git a/media/libmediaplayer2/nuplayer2/Android.bp b/media/libmediaplayer2/nuplayer2/Android.bp
index dd91628..7cf4522 100644
--- a/media/libmediaplayer2/nuplayer2/Android.bp
+++ b/media/libmediaplayer2/nuplayer2/Android.bp
@@ -16,6 +16,7 @@
],
header_libs: [
+ "libbase_headers",
"libmediaplayer2_headers",
"media_plugin_headers",
],
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
index 4d799b8..d3be53a 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
@@ -17,6 +17,7 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "NuPlayer2Driver"
#include <inttypes.h>
+#include <android-base/macros.h>
#include <utils/Log.h>
#include <cutils/properties.h>
@@ -291,8 +292,7 @@
case STATE_PREPARED:
{
mPlayer->start();
-
- // fall through
+ FALLTHROUGH_INTENDED;
}
case STATE_RUNNING:
@@ -888,7 +888,7 @@
mPlayer->pause();
mState = STATE_PAUSED;
}
- // fall through
+ FALLTHROUGH_INTENDED;
}
case MEDIA2_ERROR:
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
index 3e5bdd6..f2c8f64 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
@@ -17,6 +17,7 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "NuPlayerDriver"
#include <inttypes.h>
+#include <android-base/macros.h>
#include <utils/Log.h>
#include <cutils/properties.h>
@@ -344,7 +345,7 @@
CHECK_EQ(mState, STATE_PREPARED);
- // fall through
+ FALLTHROUGH_INTENDED;
}
case STATE_PAUSED:
@@ -353,7 +354,7 @@
{
mPlayer->start();
- // fall through
+ FALLTHROUGH_INTENDED;
}
case STATE_RUNNING:
@@ -382,7 +383,7 @@
switch (mState) {
case STATE_RUNNING:
mPlayer->pause();
- // fall through
+ FALLTHROUGH_INTENDED;
case STATE_PAUSED:
mState = STATE_STOPPED;
@@ -991,7 +992,7 @@
mPlayer->pause();
mState = STATE_PAUSED;
}
- // fall through
+ FALLTHROUGH_INTENDED;
}
case MEDIA_ERROR:
diff --git a/media/libnblog/PerformanceAnalysis.cpp b/media/libnblog/PerformanceAnalysis.cpp
index ca9bc2c..94ad114 100644
--- a/media/libnblog/PerformanceAnalysis.cpp
+++ b/media/libnblog/PerformanceAnalysis.cpp
@@ -80,7 +80,7 @@
std::string Histogram::toString() const {
std::stringstream ss;
static constexpr char kDivider = '|';
- ss << mBinSize << "," << mNumBins << "," << mLow << ",{";
+ ss << kVersion << "," << mBinSize << "," << mNumBins << "," << mLow << ",{";
bool first = true;
if (mLowCount != 0) {
ss << "-1" << kDivider << mLowCount;
diff --git a/media/libnblog/include/media/nblog/PerformanceAnalysis.h b/media/libnblog/include/media/nblog/PerformanceAnalysis.h
index 80eddb1..6893fee 100644
--- a/media/libnblog/include/media/nblog/PerformanceAnalysis.h
+++ b/media/libnblog/include/media/nblog/PerformanceAnalysis.h
@@ -112,6 +112,9 @@
std::string toString() const;
private:
+ // Histogram version number.
+ static constexpr int kVersion = 1;
+
const double mBinSize; // Size of each bucket
const size_t mNumBins; // Number of buckets in histogram range
const double mLow; // Lower bound of values
diff --git a/media/libstagefright/codecs/mpeg2dec/Android.bp b/media/libstagefright/codecs/mpeg2dec/Android.bp
index fb0db8f..cd83db0 100644
--- a/media/libstagefright/codecs/mpeg2dec/Android.bp
+++ b/media/libstagefright/codecs/mpeg2dec/Android.bp
@@ -1,9 +1,6 @@
cc_library_shared {
name: "libstagefright_soft_mpeg2dec",
vendor_available: true,
- vndk: {
- enabled: true,
- },
static_libs: ["libmpeg2dec"],
srcs: ["SoftMPEG2.cpp"],
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index 7b165a1..538a0eb 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -598,7 +598,7 @@
// add latency if it exists
double latencyMs;
if (getLatencyMs(&latencyMs) == OK) {
- result.appendFormat(" latency: %.2lf", latencyMs);
+ result.appendFormat(" latency: %.2lf ms", latencyMs);
}
return result;
}
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 60bce9c..dd2158b 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -2696,6 +2696,19 @@
mPolicyMixes.dump(fd);
mAudioSources.dump(fd);
+ if (!mSurroundFormats.empty()) {
+ result = String8("\nManually Enabled Surround Formats:\n");
+ size_t i = 0;
+ for (const auto& fmt : mSurroundFormats) {
+ result.append(i++ == 0 ? " " : ", ");
+ std::string sfmt;
+ FormatConverter::toString(fmt, sfmt);
+ result.appendFormat("%s", sfmt.c_str());
+ }
+ result.append("\n");
+ write(fd, result.string(), result.size());
+ }
+
return NO_ERROR;
}
@@ -3594,8 +3607,8 @@
(surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
return BAD_VALUE;
}
- ALOGV("getSurroundFormats() numSurroundFormats %d surroundFormats %p surroundFormatsEnabled %p",
- *numSurroundFormats, surroundFormats, surroundFormatsEnabled);
+ ALOGV("getSurroundFormats() numSurroundFormats %d surroundFormats %p surroundFormatsEnabled %p"
+ " reported %d", *numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
// Only return value if there is HDMI output.
if ((mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_HDMI) == 0) {
@@ -3698,6 +3711,7 @@
status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
{
+ ALOGV("%s() format 0x%X enabled %d", __func__, audioFormat, enabled);
// Check if audio format is a surround formats.
bool isSurroundFormat = false;
for (size_t i = 0; i < ARRAY_SIZE(SURROUND_FORMATS); i++) {
@@ -3707,6 +3721,7 @@
}
}
if (!isSurroundFormat) {
+ ALOGW("%s() format 0x%X is not a known surround format", __func__, audioFormat);
return BAD_VALUE;
}
@@ -3714,6 +3729,7 @@
audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
if (forceUse != AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
+ ALOGW("%s() not in manual mode for surround sound format selection", __func__);
return INVALID_OPERATION;
}
@@ -3724,6 +3740,7 @@
// The operation is valid only when there is HDMI output available.
if ((mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_HDMI) == 0) {
+ ALOGW("%s() no HDMI out devices found", __func__);
return INVALID_OPERATION;
}
@@ -3788,6 +3805,7 @@
// Undo the surround formats change due to no audio profiles updated.
if (!profileUpdated) {
+ ALOGW("%s() no audio profiles updated, undoing surround formats change", __func__);
if (enabled) {
if (audioFormat == AUDIO_FORMAT_AAC_LC) {
for (size_t i = 0; i < ARRAY_SIZE(AAC_FORMATS); i++) {
diff --git a/services/camera/libcameraservice/Android.bp b/services/camera/libcameraservice/Android.bp
index eccbe54..706ce3a 100644
--- a/services/camera/libcameraservice/Android.bp
+++ b/services/camera/libcameraservice/Android.bp
@@ -82,6 +82,7 @@
"android.hardware.camera.device@3.2",
"android.hardware.camera.device@3.3",
"android.hardware.camera.device@3.4",
+ "android.hardware.camera.device@3.5",
],
export_shared_lib_headers: [
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index f9240db..fbd80e6 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -491,6 +491,34 @@
strerror(-res), res);
}
+ int callingPid = getCallingPid();
+ int callingUid = getCallingUid();
+ std::vector<int32_t> tagsRemoved;
+ // If it's not calling from cameraserver, check the permission.
+ if ((callingPid != getpid()) &&
+ !checkPermission(String16("android.permission.CAMERA"), callingPid, callingUid)) {
+ res = cameraInfo->removePermissionEntries(
+ mCameraProviderManager->getProviderTagIdLocked(String8(cameraId).string()),
+ &tagsRemoved);
+ if (res != OK) {
+ cameraInfo->clear();
+ return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to remove camera"
+ " characteristics needing camera permission for device %s: %s (%d)",
+ String8(cameraId).string(), strerror(-res), res);
+ }
+ }
+
+ if (!tagsRemoved.empty()) {
+ res = cameraInfo->update(ANDROID_REQUEST_CHARACTERISTIC_KEYS_NEEDING_PERMISSION,
+ tagsRemoved.data(), tagsRemoved.size());
+ if (res != OK) {
+ cameraInfo->clear();
+ return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION, "Failed to insert camera "
+ "keys needing permission for device %s: %s (%d)", String8(cameraId).string(),
+ strerror(-res), res);
+ }
+ }
+
return ret;
}
@@ -607,6 +635,7 @@
case CAMERA_DEVICE_API_VERSION_3_2:
case CAMERA_DEVICE_API_VERSION_3_3:
case CAMERA_DEVICE_API_VERSION_3_4:
+ case CAMERA_DEVICE_API_VERSION_3_5:
if (effectiveApiLevel == API_1) { // Camera1 API route
sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());
*client = new Camera2Client(cameraService, tmp, packageName,
@@ -1687,7 +1716,7 @@
}
int deviceVersion = getDeviceVersion(id);
- switch(deviceVersion) {
+ switch (deviceVersion) {
case CAMERA_DEVICE_API_VERSION_1_0:
case CAMERA_DEVICE_API_VERSION_3_0:
case CAMERA_DEVICE_API_VERSION_3_1:
@@ -1704,6 +1733,7 @@
case CAMERA_DEVICE_API_VERSION_3_2:
case CAMERA_DEVICE_API_VERSION_3_3:
case CAMERA_DEVICE_API_VERSION_3_4:
+ case CAMERA_DEVICE_API_VERSION_3_5:
ALOGV("%s: Camera id %s uses HAL3.2 or newer, supports api1/api2 directly",
__FUNCTION__, id.string());
*isSupported = true;
@@ -1724,6 +1754,18 @@
return Status::ok();
}
+Status CameraService::isHiddenPhysicalCamera(const String16& cameraId,
+ /*out*/ bool *isSupported) {
+ ATRACE_CALL();
+
+ const String8 id = String8(cameraId);
+
+ ALOGV("%s: for camera ID = %s", __FUNCTION__, id.string());
+ *isSupported = mCameraProviderManager->isHiddenPhysicalCamera(id.string());
+
+ return Status::ok();
+}
+
void CameraService::removeByClient(const BasicClient* client) {
Mutex::Autolock lock(mServiceLock);
for (auto& i : mActiveClientManager.getAll()) {
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index e4a18d3..47ad8af 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -159,6 +159,11 @@
/*out*/
bool *isSupported);
+ virtual binder::Status isHiddenPhysicalCamera(
+ const String16& cameraId,
+ /*out*/
+ bool *isSupported);
+
// Extra permissions checks
virtual status_t onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags);
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
index 3be6399..c4944a6 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.cpp
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -20,9 +20,12 @@
#include "CameraProviderManager.h"
+#include <android/hardware/camera/device/3.5/ICameraDevice.h>
+
#include <algorithm>
#include <chrono>
#include <inttypes.h>
+#include <hardware/camera_common.h>
#include <hidl/ServiceManagement.h>
#include <functional>
#include <camera_metadata_hidden.h>
@@ -424,6 +427,48 @@
return true;
}
+bool CameraProviderManager::isHiddenPhysicalCamera(const std::string& cameraId) {
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ if (deviceInfo->mId == cameraId) {
+ // cameraId is found in public camera IDs advertised by the
+ // provider.
+ return false;
+ }
+ }
+ }
+
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ CameraMetadata info;
+ status_t res = deviceInfo->getCameraCharacteristics(&info);
+ if (res != OK) {
+ ALOGE("%s: Failed to getCameraCharacteristics for id %s", __FUNCTION__,
+ deviceInfo->mId.c_str());
+ return false;
+ }
+
+ std::vector<std::string> physicalIds;
+ if (isLogicalCamera(info, &physicalIds)) {
+ if (std::find(physicalIds.begin(), physicalIds.end(), cameraId) !=
+ physicalIds.end()) {
+ int deviceVersion = HARDWARE_DEVICE_API_VERSION(
+ deviceInfo->mVersion.get_major(), deviceInfo->mVersion.get_minor());
+ if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_5) {
+ ALOGE("%s: Wrong deviceVersion %x for hiddenPhysicalCameraId %s",
+ __FUNCTION__, deviceVersion, cameraId.c_str());
+ return false;
+ } else {
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
status_t CameraProviderManager::addProviderLocked(const std::string& newProvider, bool expected) {
for (const auto& providerInfo : mProviders) {
if (providerInfo->mProviderName == newProvider) {
@@ -544,13 +589,22 @@
// Get initial list of camera devices, if any
std::vector<std::string> devices;
- hardware::Return<void> ret = mInterface->getCameraIdList([&status, &devices](
+ hardware::Return<void> ret = mInterface->getCameraIdList([&status, this, &devices](
Status idStatus,
const hardware::hidl_vec<hardware::hidl_string>& cameraDeviceNames) {
status = idStatus;
if (status == Status::OK) {
- for (size_t i = 0; i < cameraDeviceNames.size(); i++) {
- devices.push_back(cameraDeviceNames[i]);
+ for (auto& name : cameraDeviceNames) {
+ uint16_t major, minor;
+ std::string type, id;
+ status_t res = parseDeviceName(name, &major, &minor, &type, &id);
+ if (res != OK) {
+ ALOGE("%s: Error parsing deviceName: %s: %d", __FUNCTION__, name.c_str(), res);
+ status = Status::INTERNAL_ERROR;
+ } else {
+ devices.push_back(name);
+ mProviderPublicCameraIds.push_back(id);
+ }
}
} });
if (!ret.isOk()) {
@@ -705,6 +759,25 @@
info2.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
}
+ // Dump characteristics of non-standalone physical camera
+ std::vector<std::string> physicalIds;
+ if (isLogicalCamera(info2, &physicalIds)) {
+ for (auto& id : physicalIds) {
+ // Skip if physical id is an independent camera
+ if (std::find(mProviderPublicCameraIds.begin(), mProviderPublicCameraIds.end(), id)
+ != mProviderPublicCameraIds.end()) {
+ continue;
+ }
+
+ CameraMetadata physicalInfo;
+ status_t status = device->getPhysicalCameraCharacteristics(id, &physicalInfo);
+ if (status == OK) {
+ dprintf(fd, " Physical camera %s characteristics:\n", id.c_str());
+ physicalInfo.dump(fd, /*verbosity*/ 2, /*indentation*/ 4);
+ }
+ }
+ }
+
dprintf(fd, "== Camera HAL device %s (v%d.%d) dumpState: ==\n", device->mName.c_str(),
device->mVersion.get_major(), device->mVersion.get_minor());
res = device->dumpState(fd);
@@ -838,7 +911,7 @@
return std::unique_ptr<DeviceInfo>(
new DeviceInfoT(name, tagId, id, minorVersion, resourceCost,
- cameraInterface));
+ mProviderPublicCameraIds, cameraInterface));
}
template<class InterfaceT>
@@ -912,9 +985,10 @@
const metadata_vendor_id_t tagId, const std::string &id,
uint16_t minorVersion,
const CameraResourceCost& resourceCost,
+ const std::vector<std::string>& publicCameraIds,
sp<InterfaceT> interface) :
DeviceInfo(name, tagId, id, hardware::hidl_version{1, minorVersion},
- resourceCost),
+ publicCameraIds, resourceCost),
mInterface(interface) {
// Get default parameters and initialize flash unit availability
// Requires powering on the camera device
@@ -1011,9 +1085,10 @@
const metadata_vendor_id_t tagId, const std::string &id,
uint16_t minorVersion,
const CameraResourceCost& resourceCost,
+ const std::vector<std::string>& publicCameraIds,
sp<InterfaceT> interface) :
DeviceInfo(name, tagId, id, hardware::hidl_version{3, minorVersion},
- resourceCost),
+ publicCameraIds, resourceCost),
mInterface(interface) {
// Get camera characteristics and initialize flash unit availability
Status status;
@@ -1054,6 +1129,59 @@
} else {
mHasFlashUnit = false;
}
+
+ // Get physical camera characteristics if applicable
+ auto castResult = device::V3_5::ICameraDevice::castFrom(mInterface);
+ if (!castResult.isOk()) {
+ ALOGV("%s: Unable to convert ICameraDevice instance to version 3.5", __FUNCTION__);
+ return;
+ }
+ sp<hardware::camera::device::V3_5::ICameraDevice> interface_3_5 = castResult;
+ if (interface_3_5 == nullptr) {
+ ALOGE("%s: Converted ICameraDevice instance to nullptr", __FUNCTION__);
+ return;
+ }
+
+ std::vector<std::string> physicalIds;
+ if (CameraProviderManager::isLogicalCamera(mCameraCharacteristics, &physicalIds)) {
+ for (auto& id : physicalIds) {
+ if (std::find(mPublicCameraIds.begin(), mPublicCameraIds.end(), id) !=
+ mPublicCameraIds.end()) {
+ continue;
+ }
+
+ hardware::hidl_string hidlId(id);
+ ret = interface_3_5->getPhysicalCameraCharacteristics(hidlId,
+ [&status, &id, this](Status s, device::V3_2::CameraMetadata metadata) {
+ status = s;
+ if (s == Status::OK) {
+ camera_metadata_t *buffer =
+ reinterpret_cast<camera_metadata_t*>(metadata.data());
+ size_t expectedSize = metadata.size();
+ int res = validate_camera_metadata_structure(buffer, &expectedSize);
+ if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
+ set_camera_metadata_vendor_id(buffer, mProviderTagid);
+ mPhysicalCameraCharacteristics[id] = buffer;
+ } else {
+ ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
+ status = Status::INTERNAL_ERROR;
+ }
+ }
+ });
+
+ if (!ret.isOk()) {
+ ALOGE("%s: Transaction error getting physical camera %s characteristics for %s: %s",
+ __FUNCTION__, id.c_str(), mId.c_str(), ret.description().c_str());
+ return;
+ }
+ if (status != Status::OK) {
+ ALOGE("%s: Unable to get physical camera %s characteristics for device %s: %s (%d)",
+ __FUNCTION__, id.c_str(), mId.c_str(),
+ CameraProviderManager::statusToString(status), status);
+ return;
+ }
+ }
+ }
}
CameraProviderManager::ProviderInfo::DeviceInfo3::~DeviceInfo3() {}
@@ -1129,6 +1257,18 @@
return OK;
}
+status_t CameraProviderManager::ProviderInfo::DeviceInfo3::getPhysicalCameraCharacteristics(
+ const std::string& physicalCameraId, CameraMetadata *characteristics) const {
+ if (characteristics == nullptr) return BAD_VALUE;
+ if (mPhysicalCameraCharacteristics.find(physicalCameraId) ==
+ mPhysicalCameraCharacteristics.end()) {
+ return NAME_NOT_FOUND;
+ }
+
+ *characteristics = mPhysicalCameraCharacteristics.at(physicalCameraId);
+ return OK;
+}
+
status_t CameraProviderManager::ProviderInfo::parseProviderName(const std::string& name,
std::string *type, uint32_t *id) {
// Format must be "<type>/<id>"
@@ -1460,10 +1600,20 @@
status_t CameraProviderManager::getCameraCharacteristicsLocked(const std::string &id,
CameraMetadata* characteristics) const {
- auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {4,0});
- if (deviceInfo == nullptr) return NAME_NOT_FOUND;
+ auto deviceInfo = findDeviceInfoLocked(id, /*minVersion*/ {3,0}, /*maxVersion*/ {5,0});
+ if (deviceInfo != nullptr) {
+ return deviceInfo->getCameraCharacteristics(characteristics);
+ }
- return deviceInfo->getCameraCharacteristics(characteristics);
+ // Find hidden physical camera characteristics
+ for (auto& provider : mProviders) {
+ for (auto& deviceInfo : provider->mDevices) {
+ status_t res = deviceInfo->getPhysicalCameraCharacteristics(id, characteristics);
+ if (res != NAME_NOT_FOUND) return res;
+ }
+ }
+
+ return NAME_NOT_FOUND;
}
void CameraProviderManager::filterLogicalCameraIdsLocked(
@@ -1482,7 +1632,7 @@
// idCombo contains the ids of a logical camera and its physical cameras
std::vector<std::string> idCombo;
- bool logicalCamera = CameraProviderManager::isLogicalCamera(info, &idCombo);
+ bool logicalCamera = isLogicalCamera(info, &idCombo);
if (!logicalCamera) {
continue;
}
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.h b/services/camera/libcameraservice/common/CameraProviderManager.h
index c523c2d..61e21b4 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.h
+++ b/services/camera/libcameraservice/common/CameraProviderManager.h
@@ -237,6 +237,7 @@
static bool isLogicalCamera(const CameraMetadata& staticInfo,
std::vector<std::string>* physicalCameraIds);
+ bool isHiddenPhysicalCamera(const std::string& cameraId);
private:
// All private members, unless otherwise noted, expect mInterfaceMutex to be locked before use
mutable std::mutex mInterfaceMutex;
@@ -306,17 +307,25 @@
(void) characteristics;
return INVALID_OPERATION;
}
+ virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId,
+ CameraMetadata *characteristics) const {
+ (void) physicalCameraId;
+ (void) characteristics;
+ return INVALID_OPERATION;
+ }
DeviceInfo(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, const hardware::hidl_version& version,
+ const std::vector<std::string>& publicCameraIds,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost) :
mName(name), mId(id), mVersion(version), mProviderTagid(tagId),
mResourceCost(resourceCost),
mStatus(hardware::camera::common::V1_0::CameraDeviceStatus::PRESENT),
- mHasFlashUnit(false) {}
+ mHasFlashUnit(false), mPublicCameraIds(publicCameraIds) {}
virtual ~DeviceInfo();
protected:
bool mHasFlashUnit;
+ const std::vector<std::string>& mPublicCameraIds;
template<class InterfaceT>
static status_t setTorchMode(InterfaceT& interface, bool enabled);
@@ -325,6 +334,12 @@
std::unordered_set<std::string> mUniqueCameraIds;
int mUniqueDeviceCount;
std::vector<std::string> mUniqueAPI1CompatibleCameraIds;
+ // The initial public camera IDs published by the camera provider.
+ // Currently logical multi-camera is not supported for hot-plug camera.
+ // And we use this list to keep track of initial public camera IDs
+ // advertised by the provider, and to distinguish against "hidden"
+ // physical camera IDs.
+ std::vector<std::string> mProviderPublicCameraIds;
// HALv1-specific camera fields, including the actual device interface
struct DeviceInfo1 : public DeviceInfo {
@@ -339,6 +354,7 @@
DeviceInfo1(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
+ const std::vector<std::string>& publicCameraIds,
sp<InterfaceT> interface);
virtual ~DeviceInfo1();
private:
@@ -356,14 +372,17 @@
virtual status_t dumpState(int fd) const override;
virtual status_t getCameraCharacteristics(
CameraMetadata *characteristics) const override;
+ virtual status_t getPhysicalCameraCharacteristics(const std::string& physicalCameraId,
+ CameraMetadata *characteristics) const override;
DeviceInfo3(const std::string& name, const metadata_vendor_id_t tagId,
const std::string &id, uint16_t minorVersion,
const hardware::camera::common::V1_0::CameraResourceCost& resourceCost,
- sp<InterfaceT> interface);
+ const std::vector<std::string>& publicCameraIds, sp<InterfaceT> interface);
virtual ~DeviceInfo3();
private:
CameraMetadata mCameraCharacteristics;
+ std::unordered_map<std::string, CameraMetadata> mPhysicalCameraCharacteristics;
};
private:
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index cbcc85b..73e8a36 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -4891,6 +4891,15 @@
captureRequest->mOutputStreams.size());
halRequest->output_buffers = outputBuffers->array();
std::set<String8> requestedPhysicalCameras;
+
+ sp<Camera3Device> parent = mParent.promote();
+ if (parent == NULL) {
+ // Should not happen, and nowhere to send errors to, so just log it
+ CLOGE("RequestThread: Parent is gone");
+ return INVALID_OPERATION;
+ }
+ nsecs_t waitDuration = kBaseGetBufferWait + parent->getExpectedInFlightDuration();
+
for (size_t j = 0; j < captureRequest->mOutputStreams.size(); j++) {
sp<Camera3OutputStreamInterface> outputStream = captureRequest->mOutputStreams.editItemAt(j);
@@ -4911,6 +4920,7 @@
}
res = outputStream->getBuffer(&outputBuffers->editItemAt(j),
+ waitDuration,
captureRequest->mOutputSurfaces[j]);
if (res != OK) {
// Can't get output buffer from gralloc queue - this could be due to
@@ -4937,13 +4947,6 @@
totalNumBuffers += halRequest->num_output_buffers;
// Log request in the in-flight queue
- sp<Camera3Device> parent = mParent.promote();
- if (parent == NULL) {
- // Should not happen, and nowhere to send errors to, so just log it
- CLOGE("RequestThread: Parent is gone");
- return INVALID_OPERATION;
- }
-
// If this request list is for constrained high speed recording (not
// preview), and the current request is not the last one in the batch,
// do not send callback to the app.
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index 159f2ca..5e749b6 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -223,6 +223,7 @@
static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
static const nsecs_t kDefaultExpectedDuration = 100000000; // 100 ms
static const nsecs_t kMinInflightDuration = 5000000000; // 5 s
+ static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec.
// SCHED_FIFO priority for request submission thread in HFR mode
static const int kRequestThreadPriority = 1;
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.cpp b/services/camera/libcameraservice/device3/Camera3Stream.cpp
index 9238590..35ed930 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Stream.cpp
@@ -577,6 +577,7 @@
}
status_t Camera3Stream::getBuffer(camera3_stream_buffer *buffer,
+ nsecs_t waitBufferTimeout,
const std::vector<size_t>& surface_ids) {
ATRACE_CALL();
Mutex::Autolock l(mLock);
@@ -594,13 +595,16 @@
ALOGV("%s: Already dequeued max output buffers (%d), wait for next returned one.",
__FUNCTION__, camera3_stream::max_buffers);
nsecs_t waitStart = systemTime(SYSTEM_TIME_MONOTONIC);
- res = mOutputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration);
+ if (waitBufferTimeout < kWaitForBufferDuration) {
+ waitBufferTimeout = kWaitForBufferDuration;
+ }
+ res = mOutputBufferReturnedSignal.waitRelative(mLock, waitBufferTimeout);
nsecs_t waitEnd = systemTime(SYSTEM_TIME_MONOTONIC);
mBufferLimitLatency.add(waitStart, waitEnd);
if (res != OK) {
if (res == TIMED_OUT) {
ALOGE("%s: wait for output buffer return timed out after %lldms (max_buffers %d)",
- __FUNCTION__, kWaitForBufferDuration / 1000000LL,
+ __FUNCTION__, waitBufferTimeout / 1000000LL,
camera3_stream::max_buffers);
}
return res;
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.h b/services/camera/libcameraservice/device3/Camera3Stream.h
index e30fc59..ef732b8 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.h
+++ b/services/camera/libcameraservice/device3/Camera3Stream.h
@@ -311,6 +311,7 @@
*
*/
status_t getBuffer(camera3_stream_buffer *buffer,
+ nsecs_t waitBufferTimeout,
const std::vector<size_t>& surface_ids = std::vector<size_t>());
/**
diff --git a/services/camera/libcameraservice/device3/Camera3StreamInterface.h b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
index bddd2e7..b4350ff 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamInterface.h
+++ b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
@@ -237,6 +237,7 @@
*
*/
virtual status_t getBuffer(camera3_stream_buffer *buffer,
+ nsecs_t waitBufferTimeout,
const std::vector<size_t>& surface_ids = std::vector<size_t>()) = 0;
/**