Merge "Add support for HDCP 2.3"
diff --git a/apex/Android.bp b/apex/Android.bp
index 604b268..51e4c23 100644
--- a/apex/Android.bp
+++ b/apex/Android.bp
@@ -27,6 +27,8 @@
"libmpeg2extractor",
"liboggextractor",
"libwavextractor",
+ // MediaPlayer2
+ "libmediaplayer2_jni",
],
key: "com.android.media.key",
}
diff --git a/camera/ndk/Android.bp b/camera/ndk/Android.bp
index 60c9f85..d96f403 100644
--- a/camera/ndk/Android.bp
+++ b/camera/ndk/Android.bp
@@ -137,6 +137,7 @@
shared_libs: [
"libhwbinder",
"libcamera2ndk_vendor",
+ "libcamera_metadata",
"libmediandk",
"libnativewindow",
"libutils",
@@ -144,6 +145,9 @@
"libcutils",
"liblog",
],
+ static_libs: [
+ "android.hardware.camera.common@1.0-helper",
+ ],
cflags: [
"-D__ANDROID_VNDK__",
],
diff --git a/camera/ndk/NdkCameraCaptureSession.cpp b/camera/ndk/NdkCameraCaptureSession.cpp
index 540d84e..ab796fb 100644
--- a/camera/ndk/NdkCameraCaptureSession.cpp
+++ b/camera/ndk/NdkCameraCaptureSession.cpp
@@ -80,7 +80,9 @@
if (session->isClosed()) {
ALOGE("%s: session %p is already closed", __FUNCTION__, session);
- *captureSequenceId = CAPTURE_SEQUENCE_ID_NONE;
+ if (captureSequenceId != nullptr) {
+ *captureSequenceId = CAPTURE_SEQUENCE_ID_NONE;
+ }
return ACAMERA_ERROR_SESSION_CLOSED;
}
diff --git a/camera/ndk/ndk_vendor/impl/ACameraManager.cpp b/camera/ndk/ndk_vendor/impl/ACameraManager.cpp
index f395b44..575ee9d 100644
--- a/camera/ndk/ndk_vendor/impl/ACameraManager.cpp
+++ b/camera/ndk/ndk_vendor/impl/ACameraManager.cpp
@@ -34,7 +34,10 @@
namespace android {
namespace acam {
-using CameraStatusAndId = frameworks::cameraservice::service::V2_0::CameraStatusAndId;
+using frameworks::cameraservice::service::V2_0::CameraStatusAndId;
+using frameworks::cameraservice::common::V2_0::ProviderIdAndVendorTagSections;
+using android::hardware::camera::common::V1_0::helper::VendorTagDescriptor;
+using android::hardware::camera::common::V1_0::helper::VendorTagDescriptorCache;
// Static member definitions
const char* CameraManagerGlobal::kCameraIdKey = "CameraId";
@@ -43,6 +46,104 @@
Mutex CameraManagerGlobal::sLock;
CameraManagerGlobal* CameraManagerGlobal::sInstance = nullptr;
+/**
+ * The vendor tag descriptor class that takes HIDL vendor tag information as
+ * input. Not part of vendor available VendorTagDescriptor class because that class is used by
+ * default HAL implementation code as well.
+ */
+class HidlVendorTagDescriptor : public VendorTagDescriptor {
+public:
+ /**
+ * Create a VendorTagDescriptor object from the HIDL VendorTagSection
+ * vector.
+ *
+ * Returns OK on success, or a negative error code.
+ */
+ static status_t createDescriptorFromHidl(const hidl_vec<VendorTagSection>& vts,
+ /*out*/ sp<VendorTagDescriptor> *descriptor);
+};
+
+status_t HidlVendorTagDescriptor::createDescriptorFromHidl(const hidl_vec<VendorTagSection> &vts,
+ sp<VendorTagDescriptor> *descriptor) {
+ int tagCount = 0;
+
+ for (size_t s = 0; s < vts.size(); s++) {
+ tagCount += vts[s].tags.size();
+ }
+
+ if (tagCount < 0 || tagCount > INT32_MAX) {
+ ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
+ return BAD_VALUE;
+ }
+
+ Vector<uint32_t> tagArray;
+ LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
+ "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
+
+ sp<HidlVendorTagDescriptor> desc = new HidlVendorTagDescriptor();
+ desc->mTagCount = tagCount;
+
+ KeyedVector<uint32_t, String8> tagToSectionMap;
+
+ int idx = 0;
+ for (size_t s = 0; s < vts.size(); s++) {
+ const VendorTagSection& section = vts[s];
+ const char *sectionName = section.sectionName.c_str();
+ if (sectionName == NULL) {
+ ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
+ return BAD_VALUE;
+ }
+ String8 sectionString(sectionName);
+ desc->mSections.add(sectionString);
+
+ for (size_t j = 0; j < section.tags.size(); j++) {
+ uint32_t tag = section.tags[j].tagId;
+ if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
+ ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
+ return BAD_VALUE;
+ }
+
+ tagArray.editItemAt(idx++) = section.tags[j].tagId;
+
+ const char *tagName = section.tags[j].tagName.c_str();
+ if (tagName == NULL) {
+ ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
+ return BAD_VALUE;
+ }
+ desc->mTagToNameMap.add(tag, String8(tagName));
+ tagToSectionMap.add(tag, sectionString);
+
+ int tagType = (int) section.tags[j].tagType;
+ if (tagType < 0 || tagType >= NUM_TYPES) {
+ ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
+ return BAD_VALUE;
+ }
+ desc->mTagToTypeMap.emplace(tag, tagType);
+ }
+ }
+
+ for (size_t i = 0; i < tagArray.size(); ++i) {
+ uint32_t tag = tagArray[i];
+ String8 sectionString = tagToSectionMap.valueFor(tag);
+
+ // Set up tag to section index map
+ ssize_t index = desc->mSections.indexOf(sectionString);
+ LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
+ desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
+
+ // Set up reverse mapping
+ ssize_t reverseIndex = -1;
+ if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
+ KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
+ reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
+ }
+ desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
+ }
+
+ *descriptor = std::move(desc);
+ return OK;
+}
+
CameraManagerGlobal&
CameraManagerGlobal::getInstance() {
Mutex::Autolock _l(sLock);
@@ -80,8 +181,34 @@
return (strncmp(value, "0", 2) != 0 && strncasecmp(value, "false", 6) != 0);
}
-// TODO: Add back when vendor tags are supported for libcamera2ndk_vendor when
-// the HIDL interface supports querying by vendor id.
+bool CameraManagerGlobal::setupVendorTags() {
+ sp<VendorTagDescriptorCache> tagCache = new VendorTagDescriptorCache();
+ Status status = Status::NO_ERROR;
+ std::vector<ProviderIdAndVendorTagSections> providerIdsAndVts;
+ auto remoteRet = mCameraService->getCameraVendorTagSections([&status, &providerIdsAndVts]
+ (Status s,
+ auto &IdsAndVts) {
+ status = s;
+ providerIdsAndVts = IdsAndVts; });
+
+ if (!remoteRet.isOk() || status != Status::NO_ERROR) {
+ ALOGE("Failed to retrieve VendorTagSections %s", remoteRet.description().c_str());
+ return false;
+ }
+ // Convert each providers VendorTagSections into a VendorTagDescriptor and
+ // add it to the cache
+ for (auto &providerIdAndVts : providerIdsAndVts) {
+ sp<VendorTagDescriptor> vendorTagDescriptor;
+ if (HidlVendorTagDescriptor::createDescriptorFromHidl(providerIdAndVts.vendorTagSections,
+ &vendorTagDescriptor) != OK) {
+ ALOGE("Failed to convert from Hidl: VendorTagDescriptor");
+ return false;
+ }
+ tagCache->addVendorDescriptor(providerIdAndVts.providerId, vendorTagDescriptor);
+ }
+ VendorTagDescriptorCache::setAsGlobalVendorTagCache(tagCache);
+ return true;
+}
sp<ICameraService> CameraManagerGlobal::getCameraService() {
Mutex::Autolock _l(mLock);
@@ -140,6 +267,13 @@
if (!remoteRet.isOk() || status != Status::NO_ERROR) {
ALOGE("Failed to add listener to camera service %s", remoteRet.description().c_str());
}
+
+ // Setup vendor tags
+ if (!setupVendorTags()) {
+ ALOGE("Unable to set up vendor tags");
+ return nullptr;
+ }
+
for (auto& c : cameraStatuses) {
onStatusChangedLocked(c);
}
diff --git a/camera/ndk/ndk_vendor/impl/ACameraManager.h b/camera/ndk/ndk_vendor/impl/ACameraManager.h
index c8d640f..6b1365a 100644
--- a/camera/ndk/ndk_vendor/impl/ACameraManager.h
+++ b/camera/ndk/ndk_vendor/impl/ACameraManager.h
@@ -142,6 +142,8 @@
void onStatusChanged(const CameraStatusAndId &statusAndId);
void onStatusChangedLocked(const CameraStatusAndId &statusAndId);
+ bool setupVendorTags();
+
// Utils for status
static bool validStatus(CameraDeviceStatus status);
static bool isStatusAvailable(CameraDeviceStatus status);
diff --git a/camera/ndk/ndk_vendor/tests/AImageReaderVendorTest.cpp b/camera/ndk/ndk_vendor/tests/AImageReaderVendorTest.cpp
index f9bb3ac..93108b0 100644
--- a/camera/ndk/ndk_vendor/tests/AImageReaderVendorTest.cpp
+++ b/camera/ndk/ndk_vendor/tests/AImageReaderVendorTest.cpp
@@ -37,12 +37,7 @@
#include <media/NdkImage.h>
#include <media/NdkImageReader.h>
#include <cutils/native_handle.h>
-
-//#define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
-//#define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
-#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
-#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#include <VendorTagDescriptor.h>
namespace {
@@ -53,6 +48,8 @@
static constexpr int kTestImageHeight = 480;
static constexpr int kTestImageFormat = AIMAGE_FORMAT_YUV_420_888;
+using android::hardware::camera::common::V1_0::helper::VendorTagDescriptorCache;
+
class CameraHelper {
public:
CameraHelper(const char* id, ACameraManager *manager) :
@@ -527,6 +524,8 @@
ALOGE("Failed to get cameraIdList: ret=%d", ret);
return;
}
+ // TODO: Add more rigorous tests for vendor tags
+ ASSERT_NE(VendorTagDescriptorCache::getGlobalVendorTagCache(), nullptr);
if (mCameraIdList->numCameras < 1) {
ALOGW("Device has no camera on board.");
return;
diff --git a/cmds/stagefright/Android.mk b/cmds/stagefright/Android.mk
index 7a10302..6eb2e9f 100644
--- a/cmds/stagefright/Android.mk
+++ b/cmds/stagefright/Android.mk
@@ -8,7 +8,7 @@
SineSource.cpp
LOCAL_SHARED_LIBRARIES := \
- libstagefright libmedia libmedia_omx libmediaextractor libutils libbinder \
+ libstagefright libmedia libmedia_omx libutils libbinder \
libstagefright_foundation libjpeg libui libgui libcutils liblog \
libhidlbase \
android.hardware.media.omx@1.0 \
@@ -36,7 +36,7 @@
record.cpp
LOCAL_SHARED_LIBRARIES := \
- libstagefright libmedia libmediaextractor liblog libutils libbinder \
+ libstagefright libmedia liblog libutils libbinder \
libstagefright_foundation
LOCAL_C_INCLUDES:= \
@@ -61,7 +61,7 @@
recordvideo.cpp
LOCAL_SHARED_LIBRARIES := \
- libstagefright libmedia libmediaextractor liblog libutils libbinder \
+ libstagefright libmedia liblog libutils libbinder \
libstagefright_foundation
LOCAL_C_INCLUDES:= \
@@ -87,7 +87,7 @@
audioloop.cpp
LOCAL_SHARED_LIBRARIES := \
- libstagefright libmedia libmediaextractor liblog libutils libbinder \
+ libstagefright libmedia liblog libutils libbinder \
libstagefright_foundation
LOCAL_C_INCLUDES:= \
@@ -111,7 +111,7 @@
LOCAL_SHARED_LIBRARIES := \
libstagefright liblog libutils libbinder libui libgui \
- libstagefright_foundation libmedia libcutils libmediaextractor
+ libstagefright_foundation libmedia libcutils
LOCAL_C_INCLUDES:= \
frameworks/av/media/libstagefright \
@@ -203,7 +203,7 @@
LOCAL_SHARED_LIBRARIES := \
libstagefright liblog libutils libbinder libstagefright_foundation \
- libcutils libc libmediaextractor
+ libcutils libc
LOCAL_C_INCLUDES:= \
frameworks/av/media/libstagefright \
diff --git a/drm/drmserver/DrmManagerService.cpp b/drm/drmserver/DrmManagerService.cpp
index 2532275..2600a2c 100644
--- a/drm/drmserver/DrmManagerService.cpp
+++ b/drm/drmserver/DrmManagerService.cpp
@@ -58,22 +58,26 @@
return drm_perm_labels[index];
}
-bool DrmManagerService::selinuxIsProtectedCallAllowed(pid_t spid, drm_perm_t perm) {
+bool DrmManagerService::selinuxIsProtectedCallAllowed(pid_t spid, const char* ssid, drm_perm_t perm) {
if (selinux_enabled <= 0) {
return true;
}
- char *sctx;
+ char *sctx = NULL;
const char *selinux_class = "drmservice";
const char *str_perm = get_perm_label(perm);
- if (getpidcon(spid, &sctx) != 0) {
- ALOGE("SELinux: getpidcon(pid=%d) failed.\n", spid);
- return false;
+ if (ssid == NULL) {
+ android_errorWriteLog(0x534e4554, "121035042");
+
+ if (getpidcon(spid, &sctx) != 0) {
+ ALOGE("SELinux: getpidcon(pid=%d) failed.\n", spid);
+ return false;
+ }
}
- bool allowed = (selinux_check_access(sctx, drmserver_context, selinux_class,
- str_perm, NULL) == 0);
+ bool allowed = (selinux_check_access(ssid ? ssid : sctx, drmserver_context,
+ selinux_class, str_perm, NULL) == 0);
freecon(sctx);
return allowed;
@@ -86,10 +90,11 @@
IPCThreadState* ipcState = IPCThreadState::self();
uid_t uid = ipcState->getCallingUid();
pid_t spid = ipcState->getCallingPid();
+ const char* ssid = ipcState->getCallingSid();
for (unsigned int i = 0; i < trustedUids.size(); ++i) {
if (trustedUids[i] == uid) {
- return selinuxIsProtectedCallAllowed(spid, perm);
+ return selinuxIsProtectedCallAllowed(spid, ssid, perm);
}
}
return false;
@@ -97,7 +102,9 @@
void DrmManagerService::instantiate() {
ALOGV("instantiate");
- defaultServiceManager()->addService(String16("drm.drmManager"), new DrmManagerService());
+ sp<DrmManagerService> service = new DrmManagerService();
+ service->setRequestingSid(true);
+ defaultServiceManager()->addService(String16("drm.drmManager"), service);
if (0 >= trustedUids.size()) {
// TODO
diff --git a/drm/drmserver/DrmManagerService.h b/drm/drmserver/DrmManagerService.h
index 7aaeab5..2e27a3c 100644
--- a/drm/drmserver/DrmManagerService.h
+++ b/drm/drmserver/DrmManagerService.h
@@ -60,7 +60,7 @@
static const char *get_perm_label(drm_perm_t perm);
- static bool selinuxIsProtectedCallAllowed(pid_t spid, drm_perm_t perm);
+ static bool selinuxIsProtectedCallAllowed(pid_t spid, const char* ssid, drm_perm_t perm);
static bool isProtectedCallAllowed(drm_perm_t perm);
diff --git a/drm/libmediadrm/DrmHal.cpp b/drm/libmediadrm/DrmHal.cpp
index 2d4b3d8..b72348f 100644
--- a/drm/libmediadrm/DrmHal.cpp
+++ b/drm/libmediadrm/DrmHal.cpp
@@ -24,7 +24,7 @@
#include <binder/IServiceManager.h>
#include <android/hardware/drm/1.2/types.h>
-#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <android/hidl/manager/1.2/IServiceManager.h>
#include <hidl/ServiceManagement.h>
#include <media/EventMetric.h>
@@ -354,10 +354,10 @@
Vector<sp<IDrmFactory>> DrmHal::makeDrmFactories() {
Vector<sp<IDrmFactory>> factories;
- auto manager = hardware::defaultServiceManager();
+ auto manager = hardware::defaultServiceManager1_2();
if (manager != NULL) {
- manager->listByInterface(drm::V1_0::IDrmFactory::descriptor,
+ manager->listManifestByInterface(drm::V1_0::IDrmFactory::descriptor,
[&factories](const hidl_vec<hidl_string> ®istered) {
for (const auto &instance : registered) {
auto factory = drm::V1_0::IDrmFactory::getService(instance);
@@ -367,7 +367,7 @@
}
}
);
- manager->listByInterface(drm::V1_1::IDrmFactory::descriptor,
+ manager->listManifestByInterface(drm::V1_1::IDrmFactory::descriptor,
[&factories](const hidl_vec<hidl_string> ®istered) {
for (const auto &instance : registered) {
auto factory = drm::V1_1::IDrmFactory::getService(instance);
diff --git a/include/media/DataSource.h b/include/media/DataSource.h
index 905bec1..198b27e 120000
--- a/include/media/DataSource.h
+++ b/include/media/DataSource.h
@@ -1 +1 @@
-../../media/libmediaextractor/include/media/DataSource.h
\ No newline at end of file
+stagefright/DataSource.h
\ No newline at end of file
diff --git a/include/media/DataSourceBase.h b/include/media/DataSourceBase.h
index 54c8047..d2ab2f1 120000
--- a/include/media/DataSourceBase.h
+++ b/include/media/DataSourceBase.h
@@ -1 +1 @@
-../../media/libmediaextractor/include/media/DataSourceBase.h
\ No newline at end of file
+stagefright/DataSourceBase.h
\ No newline at end of file
diff --git a/include/media/ExtractorUtils.h b/include/media/ExtractorUtils.h
deleted file mode 120000
index e2dd082..0000000
--- a/include/media/ExtractorUtils.h
+++ /dev/null
@@ -1 +0,0 @@
-../../media/libmediaextractor/include/media/ExtractorUtils.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/ExtractorUtils.h b/include/media/ExtractorUtils.h
similarity index 100%
rename from media/libmediaextractor/include/media/ExtractorUtils.h
rename to include/media/ExtractorUtils.h
diff --git a/include/media/MediaSource.h b/include/media/MediaSource.h
index 2e147c4..34bf65d 120000
--- a/include/media/MediaSource.h
+++ b/include/media/MediaSource.h
@@ -1 +1 @@
-../../media/libmediaextractor/include/media/MediaSource.h
\ No newline at end of file
+../../media/libstagefright/include/media/stagefright/MediaSource.h
\ No newline at end of file
diff --git a/media/codec2/components/cmds/Android.bp b/media/codec2/components/cmds/Android.bp
index 6b0977b..35f689e 100644
--- a/media/codec2/components/cmds/Android.bp
+++ b/media/codec2/components/cmds/Android.bp
@@ -15,7 +15,6 @@
"libcutils",
"libgui",
"liblog",
- "libmediaextractor",
"libstagefright",
"libstagefright_foundation",
"libui",
diff --git a/media/codec2/core/include/C2Component.h b/media/codec2/core/include/C2Component.h
index 8810725..ecf8d2e 100644
--- a/media/codec2/core/include/C2Component.h
+++ b/media/codec2/core/include/C2Component.h
@@ -409,12 +409,13 @@
kind_t kind; ///< component kind
rank_t rank; ///< component rank
C2String mediaType; ///< media type supported by the component
+ C2String owner; ///< name of the component store owning this component
/**
* name alias(es) for backward compatibility.
* \note Multiple components can have the same alias as long as their media-type differs.
*/
- std::vector<C2StringLiteral> aliases; ///< name aliases for backward compatibility
+ std::vector<C2String> aliases; ///< name aliases for backward compatibility
};
// METHODS AVAILABLE WHEN RUNNING
diff --git a/media/codec2/hidl/client/client.cpp b/media/codec2/hidl/client/client.cpp
index ff3e534..f5cc9ff 100644
--- a/media/codec2/hidl/client/client.cpp
+++ b/media/codec2/hidl/client/client.cpp
@@ -557,6 +557,7 @@
for (size_t i = 0; i < t.size(); ++i) {
c2_status_t status = objcpy(
&mTraitsList[i], &mAliasesBuffer[i], t[i]);
+ mTraitsList[i].owner = mInstanceName;
if (status != C2_OK) {
ALOGE("listComponents -- corrupted output.");
return;
diff --git a/media/codec2/sfplugin/Codec2InfoBuilder.cpp b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
index 5d0ccd2..a8cc62d 100644
--- a/media/codec2/sfplugin/Codec2InfoBuilder.cpp
+++ b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
@@ -73,10 +73,10 @@
constexpr OMX_U32 kMaxIndicesToCheck = 32;
status_t queryOmxCapabilities(
- const char* name, const char* mime, bool isEncoder,
+ const char* name, const char* mediaType, bool isEncoder,
MediaCodecInfo::CapabilitiesWriter* caps) {
- const char *role = GetComponentRole(isEncoder, mime);
+ const char *role = GetComponentRole(isEncoder, mediaType);
if (role == nullptr) {
return BAD_VALUE;
}
@@ -128,8 +128,8 @@
return err;
}
- bool isVideo = hasPrefix(mime, "video/") == 0;
- bool isImage = hasPrefix(mime, "image/") == 0;
+ bool isVideo = hasPrefix(mediaType, "video/") == 0;
+ bool isImage = hasPrefix(mediaType, "image/") == 0;
if (isVideo || isImage) {
OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
@@ -149,7 +149,7 @@
// AVC components may not list the constrained profiles explicitly, but
// decoders that support a profile also support its constrained version.
// Encoders must explicitly support constrained profiles.
- if (!isEncoder && strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC) == 0) {
+ if (!isEncoder && strcasecmp(mediaType, MEDIA_MIMETYPE_VIDEO_AVC) == 0) {
if (param.eProfile == OMX_VIDEO_AVCProfileHigh) {
caps->addProfileLevel(OMX_VIDEO_AVCProfileConstrainedHigh, param.eLevel);
} else if (param.eProfile == OMX_VIDEO_AVCProfileBaseline) {
@@ -193,7 +193,7 @@
asString(portFormat.eColorFormat), portFormat.eColorFormat);
}
}
- } else if (strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC) == 0) {
+ } else if (strcasecmp(mediaType, MEDIA_MIMETYPE_AUDIO_AAC) == 0) {
// More audio codecs if they have profiles.
OMX_AUDIO_PARAM_ANDROID_PROFILETYPE param;
InitOMXParams(¶m);
@@ -228,14 +228,17 @@
if (omxNode->configureVideoTunnelMode(
kPortIndexOutput, OMX_TRUE, 0, &sidebandHandle) == OK) {
// tunneled playback includes adaptive playback
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback
- | MediaCodecInfo::Capabilities::kFlagSupportsTunneledPlayback);
- } else if (omxNode->setPortMode(
- kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) == OK ||
- omxNode->prepareForAdaptivePlayback(
- kPortIndexOutput, OMX_TRUE,
- 1280 /* width */, 720 /* height */) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback);
+ } else {
+ // tunneled playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_TUNNELED_PLAYBACK);
+ if (omxNode->setPortMode(
+ kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) == OK ||
+ omxNode->prepareForAdaptivePlayback(
+ kPortIndexOutput, OMX_TRUE,
+ 1280 /* width */, 720 /* height */) != OK) {
+ // adaptive playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_ADAPTIVE_PLAYBACK);
+ }
}
}
@@ -243,11 +246,20 @@
OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE params;
InitOMXParams(¶ms);
params.nPortIndex = kPortIndexOutput;
- // TODO: should we verify if fallback is supported?
+
+ OMX_VIDEO_PARAM_INTRAREFRESHTYPE fallbackParams;
+ InitOMXParams(&fallbackParams);
+ fallbackParams.nPortIndex = kPortIndexOutput;
+ fallbackParams.eRefreshMode = OMX_VIDEO_IntraRefreshCyclic;
+
if (omxNode->getConfig(
(OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh,
- ¶ms, sizeof(params)) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsIntraRefresh);
+ ¶ms, sizeof(params)) != OK &&
+ omxNode->getParameter(
+ OMX_IndexParamVideoIntraRefresh, &fallbackParams,
+ sizeof(fallbackParams)) != OK) {
+ // intra refresh is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_INTRA_REFRESH);
}
}
@@ -270,12 +282,26 @@
writer->addMediaCodecInfo();
info->setName(name.c_str());
info->setOwner("default");
- info->setEncoder(encoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs = 0;
+ if (encoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ // NOTE: we don't support software-only codecs in OMX
+ if (!hasPrefix(name, "OMX.google.")) {
+ attrs |= MediaCodecInfo::kFlagIsVendor;
+ if (properties.quirkSet.find("attribute::software-codec")
+ == properties.quirkSet.end()) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
+ }
+ info->setAttributes(attrs);
info->setRank(omxRank);
- for (const MediaCodecsXmlParser::Type& type : properties.typeMap) {
- const std::string &mime = type.first;
+ // OMX components don't have aliases
+ for (const MediaCodecsXmlParser::Type &type : properties.typeMap) {
+ const std::string &mediaType = type.first;
+
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- info->addMime(mime.c_str());
+ info->addMediaType(mediaType.c_str());
const MediaCodecsXmlParser::AttributeMap &attrMap = type.second;
for (const MediaCodecsXmlParser::Attribute& attr : attrMap) {
const std::string &key = attr.first;
@@ -289,13 +315,13 @@
}
status_t err = queryOmxCapabilities(
name.c_str(),
- mime.c_str(),
+ mediaType.c_str(),
encoder,
caps.get());
if (err != OK) {
- ALOGE("Failed to query capabilities for %s (mime: %s). Error: %d",
+ ALOGI("Failed to query capabilities for %s (media type: %s). Error: %d",
name.c_str(),
- mime.c_str(),
+ mediaType.c_str(),
static_cast<int>(err));
}
}
@@ -407,20 +433,40 @@
break;
}
+ ALOGV("canonName = %s", canonName.c_str());
std::unique_ptr<MediaCodecInfoWriter> codecInfo = writer->addMediaCodecInfo();
codecInfo->setName(trait.name.c_str());
- codecInfo->setOwner("codec2");
+ codecInfo->setOwner(("codec2::" + trait.owner).c_str());
+ const MediaCodecsXmlParser::CodecProperties &codec = parser.getCodecMap().at(canonName);
+
bool encoder = trait.kind == C2Component::KIND_ENCODER;
- codecInfo->setEncoder(encoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs = 0;
+
+ if (encoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ if (trait.owner == "software") {
+ attrs |= MediaCodecInfo::kFlagIsSoftwareOnly;
+ } else {
+ attrs |= MediaCodecInfo::kFlagIsVendor;
+ if (trait.owner == "vendor-software") {
+ attrs |= MediaCodecInfo::kFlagIsSoftwareOnly;
+ } else if (codec.quirkSet.find("attribute::software-codec") == codec.quirkSet.end()) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
+ }
+ codecInfo->setAttributes(attrs);
codecInfo->setRank(rank);
- const MediaCodecsXmlParser::CodecProperties &codec =
- parser.getCodecMap().at(canonName);
+
+ for (const std::string &alias : codec.aliases) {
+ codecInfo->addAlias(alias.c_str());
+ }
for (auto typeIt = codec.typeMap.begin(); typeIt != codec.typeMap.end(); ++typeIt) {
const std::string &mediaType = typeIt->first;
const MediaCodecsXmlParser::AttributeMap &attrMap = typeIt->second;
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- codecInfo->addMime(mediaType.c_str());
+ codecInfo->addMediaType(mediaType.c_str());
for (auto attrIt = attrMap.begin(); attrIt != attrMap.end(); ++attrIt) {
std::string key, value;
std::tie(key, value) = *attrIt;
@@ -450,6 +496,23 @@
asString(err), asString(profileQuery[0].status));
if (err == C2_OK && profileQuery[0].status == C2_OK) {
if (profileQuery[0].values.type == C2FieldSupportedValues::VALUES) {
+ std::vector<std::shared_ptr<C2ParamDescriptor>> paramDescs;
+ c2_status_t err1 = intf->querySupportedParams(¶mDescs);
+ bool isHdr = false, isHdr10Plus = false;
+ if (err1 == C2_OK) {
+ for (const std::shared_ptr<C2ParamDescriptor> &desc : paramDescs) {
+ if ((uint32_t)desc->index() ==
+ C2StreamHdr10PlusInfo::output::PARAM_TYPE) {
+ isHdr10Plus = true;
+ } else if ((uint32_t)desc->index() ==
+ C2StreamHdrStaticInfo::output::PARAM_TYPE) {
+ isHdr = true;
+ }
+ }
+ }
+ // For VP9, the static info is always propagated by framework.
+ isHdr |= (mediaType == MIMETYPE_VIDEO_VP9);
+
for (C2Value::Primitive profile : profileQuery[0].values.values) {
pl.profile = (C2Config::profile_t)profile.ref<uint32_t>();
std::vector<std::unique_ptr<C2SettingResult>> failures;
@@ -473,6 +536,26 @@
caps->addProfileLevel(
(uint32_t)sdkProfile, (uint32_t)sdkLevel);
gotProfileLevels = true;
+ if (isHdr) {
+ auto hdrMapper = C2Mapper::GetHdrProfileLevelMapper(
+ trait.mediaType);
+ if (hdrMapper && hdrMapper->mapProfile(
+ pl.profile, &sdkProfile)) {
+ caps->addProfileLevel(
+ (uint32_t)sdkProfile,
+ (uint32_t)sdkLevel);
+ }
+ if (isHdr10Plus) {
+ hdrMapper = C2Mapper::GetHdrProfileLevelMapper(
+ trait.mediaType, true /*isHdr10Plus*/);
+ if (hdrMapper && hdrMapper->mapProfile(
+ pl.profile, &sdkProfile)) {
+ caps->addProfileLevel(
+ (uint32_t)sdkProfile,
+ (uint32_t)sdkLevel);
+ }
+ }
+ }
} else if (!mapper) {
caps->addProfileLevel(pl.profile, pl.level);
gotProfileLevels = true;
diff --git a/media/codec2/sfplugin/utils/Codec2Mapper.cpp b/media/codec2/sfplugin/utils/Codec2Mapper.cpp
index b1b33e1..c369e16 100644
--- a/media/codec2/sfplugin/utils/Codec2Mapper.cpp
+++ b/media/codec2/sfplugin/utils/Codec2Mapper.cpp
@@ -253,6 +253,14 @@
{ C2Config::PROFILE_HEVC_MAIN_10_INTRA, HEVCProfileMain10 },
};
+ALookup<C2Config::profile_t, int32_t> sHevcHdrProfiles = {
+ { C2Config::PROFILE_HEVC_MAIN_10, HEVCProfileMain10HDR10 },
+};
+
+ALookup<C2Config::profile_t, int32_t> sHevcHdr10PlusProfiles = {
+ { C2Config::PROFILE_HEVC_MAIN_10, HEVCProfileMain10HDR10Plus },
+};
+
ALookup<C2Config::level_t, int32_t> sMpeg2Levels = {
{ C2Config::LEVEL_MP2V_LOW, MPEG2LevelLL },
{ C2Config::LEVEL_MP2V_MAIN, MPEG2LevelML },
@@ -324,6 +332,20 @@
{ C2Config::PROFILE_VP9_1, VP9Profile1 },
{ C2Config::PROFILE_VP9_2, VP9Profile2 },
{ C2Config::PROFILE_VP9_3, VP9Profile3 },
+ { C2Config::PROFILE_VP9_2, VP9Profile2HDR },
+ { C2Config::PROFILE_VP9_3, VP9Profile3HDR },
+ { C2Config::PROFILE_VP9_2, VP9Profile2HDR10Plus },
+ { C2Config::PROFILE_VP9_3, VP9Profile3HDR10Plus },
+};
+
+ALookup<C2Config::profile_t, int32_t> sVp9HdrProfiles = {
+ { C2Config::PROFILE_VP9_2, VP9Profile2HDR },
+ { C2Config::PROFILE_VP9_3, VP9Profile3HDR },
+};
+
+ALookup<C2Config::profile_t, int32_t> sVp9Hdr10PlusProfiles = {
+ { C2Config::PROFILE_VP9_2, VP9Profile2HDR10Plus },
+ { C2Config::PROFILE_VP9_3, VP9Profile3HDR10Plus },
};
ALookup<C2Config::level_t, int32_t> sAv1Levels = {
@@ -461,6 +483,10 @@
};
struct HevcProfileLevelMapper : ProfileLevelMapperHelper {
+ HevcProfileLevelMapper(bool isHdr = false, bool isHdr10Plus = false) :
+ ProfileLevelMapperHelper(),
+ mIsHdr(isHdr), mIsHdr10Plus(isHdr10Plus) {}
+
virtual bool simpleMap(C2Config::level_t from, int32_t *to) {
return sHevcLevels.map(from, to);
}
@@ -468,11 +494,19 @@
return sHevcLevels.map(from, to);
}
virtual bool simpleMap(C2Config::profile_t from, int32_t *to) {
- return sHevcProfiles.map(from, to);
+ return mIsHdr10Plus ? sHevcHdr10PlusProfiles.map(from, to) :
+ mIsHdr ? sHevcHdrProfiles.map(from, to) :
+ sHevcProfiles.map(from, to);
}
virtual bool simpleMap(int32_t from, C2Config::profile_t *to) {
- return sHevcProfiles.map(from, to);
+ return mIsHdr10Plus ? sHevcHdr10PlusProfiles.map(from, to) :
+ mIsHdr ? sHevcHdrProfiles.map(from, to) :
+ sHevcProfiles.map(from, to);
}
+
+private:
+ bool mIsHdr;
+ bool mIsHdr10Plus;
};
struct Mpeg2ProfileLevelMapper : ProfileLevelMapperHelper {
@@ -527,6 +561,10 @@
};
struct Vp9ProfileLevelMapper : ProfileLevelMapperHelper {
+ Vp9ProfileLevelMapper(bool isHdr = false, bool isHdr10Plus = false) :
+ ProfileLevelMapperHelper(),
+ mIsHdr(isHdr), mIsHdr10Plus(isHdr10Plus) {}
+
virtual bool simpleMap(C2Config::level_t from, int32_t *to) {
return sVp9Levels.map(from, to);
}
@@ -534,11 +572,19 @@
return sVp9Levels.map(from, to);
}
virtual bool simpleMap(C2Config::profile_t from, int32_t *to) {
- return sVp9Profiles.map(from, to);
+ return mIsHdr10Plus ? sVp9Hdr10PlusProfiles.map(from, to) :
+ mIsHdr ? sVp9HdrProfiles.map(from, to) :
+ sVp9Profiles.map(from, to);
}
virtual bool simpleMap(int32_t from, C2Config::profile_t *to) {
- return sVp9Profiles.map(from, to);
+ return mIsHdr10Plus ? sVp9Hdr10PlusProfiles.map(from, to) :
+ mIsHdr ? sVp9HdrProfiles.map(from, to) :
+ sVp9Profiles.map(from, to);
}
+
+private:
+ bool mIsHdr;
+ bool mIsHdr10Plus;
};
} // namespace
@@ -570,6 +616,18 @@
}
// static
+std::shared_ptr<C2Mapper::ProfileLevelMapper>
+C2Mapper::GetHdrProfileLevelMapper(std::string mediaType, bool isHdr10Plus) {
+ std::transform(mediaType.begin(), mediaType.begin(), mediaType.end(), ::tolower);
+ if (mediaType == MIMETYPE_VIDEO_HEVC) {
+ return std::make_shared<HevcProfileLevelMapper>(true, isHdr10Plus);
+ } else if (mediaType == MIMETYPE_VIDEO_VP9) {
+ return std::make_shared<Vp9ProfileLevelMapper>(true, isHdr10Plus);
+ }
+ return nullptr;
+}
+
+// static
bool C2Mapper::map(C2Config::bitrate_mode_t from, int32_t *to) {
return sBitrateModes.map(from, to);
}
diff --git a/media/codec2/sfplugin/utils/Codec2Mapper.h b/media/codec2/sfplugin/utils/Codec2Mapper.h
index 1eeb92e..cec6f07 100644
--- a/media/codec2/sfplugin/utils/Codec2Mapper.h
+++ b/media/codec2/sfplugin/utils/Codec2Mapper.h
@@ -40,6 +40,9 @@
static std::shared_ptr<ProfileLevelMapper>
GetProfileLevelMapper(std::string mediaType);
+ static std::shared_ptr<ProfileLevelMapper>
+ GetHdrProfileLevelMapper(std::string mediaType, bool isHdr10Plus = false);
+
// convert between bitrates
static bool map(C2Config::bitrate_mode_t, int32_t*);
static bool map(int32_t, C2Config::bitrate_mode_t*);
diff --git a/media/extractors/flac/FLACExtractor.cpp b/media/extractors/flac/FLACExtractor.cpp
index e4bbc07..84fbcee 100644
--- a/media/extractors/flac/FLACExtractor.cpp
+++ b/media/extractors/flac/FLACExtractor.cpp
@@ -806,14 +806,42 @@
bool SniffFLAC(DataSourceHelper *source, float *confidence)
{
- // first 4 is the signature word
- // second 4 is the sizeof STREAMINFO
- // 042 is the mandatory STREAMINFO
- // no need to read rest of the header, as a premature EOF will be caught later
- uint8_t header[4+4];
- if (source->readAt(0, header, sizeof(header)) != sizeof(header)
- || memcmp("fLaC\0\0\0\042", header, 4+4))
- {
+ // Skip ID3 tags
+ off64_t pos = 0;
+ uint8_t header[10];
+ for (;;) {
+ if (source->readAt(pos, header, sizeof(header)) != sizeof(header)) {
+ return false; // no more file to read.
+ }
+
+ // check for ID3 tag
+ if (memcmp("ID3", header, 3) != 0) {
+ break; // not an ID3 tag.
+ }
+
+ // skip the ID3v2 data and check again
+ const unsigned id3Len = 10 +
+ (((header[6] & 0x7f) << 21)
+ | ((header[7] & 0x7f) << 14)
+ | ((header[8] & 0x7f) << 7)
+ | (header[9] & 0x7f));
+ pos += id3Len;
+
+ ALOGV("skipped ID3 tag of len %u new starting offset is %#016llx",
+ id3Len, (long long)pos);
+ }
+
+ // Check FLAC header.
+ // https://xiph.org/flac/format.html#stream
+ //
+ // Note: content stored big endian.
+ // byte offset bit size content
+ // 0 32 fLaC
+ // 4 8 metadata type STREAMINFO (0) (note: OR with 0x80 if last metadata)
+ // 5 24 size of metadata, for STREAMINFO (0x22).
+
+ if (memcmp("fLaC\x00\x00\x00\x22", header, 8) != 0 &&
+ memcmp("fLaC\x80\x00\x00\x22", header, 8) != 0) {
return false;
}
diff --git a/media/extractors/mp4/MPEG4Extractor.cpp b/media/extractors/mp4/MPEG4Extractor.cpp
index 0441359..cc1534a 100644
--- a/media/extractors/mp4/MPEG4Extractor.cpp
+++ b/media/extractors/mp4/MPEG4Extractor.cpp
@@ -985,6 +985,22 @@
off64_t stop_offset = *offset + chunk_size;
*offset = data_offset;
while (*offset < stop_offset) {
+
+ // pass udata terminate
+ if (mIsQT && stop_offset - *offset == 4 && chunk_type == FOURCC("udta")) {
+ // handle the case that udta terminates with terminate code x00000000
+ // note that 0 terminator is optional and we just handle this case.
+ uint32_t terminate_code = 1;
+ mDataSource->readAt(*offset, &terminate_code, 4);
+ if (0 == terminate_code) {
+ *offset += 4;
+ ALOGD("Terminal code for udta");
+ continue;
+ } else {
+ ALOGW("invalid udta Terminal code");
+ }
+ }
+
status_t err = parseChunk(offset, depth + 1);
if (err != OK) {
if (isTrack) {
@@ -5142,7 +5158,7 @@
sampleCtsOffset = 0;
}
- if (size < (off64_t)(sampleCount * bytesPerSample)) {
+ if (size < (off64_t)sampleCount * bytesPerSample) {
return -EINVAL;
}
diff --git a/media/extractors/mpeg2/Android.bp b/media/extractors/mpeg2/Android.bp
index b816093..2a94671 100644
--- a/media/extractors/mpeg2/Android.bp
+++ b/media/extractors/mpeg2/Android.bp
@@ -28,9 +28,8 @@
static_libs: [
"libcrypto",
- "libstagefright_foundation",
+ "libstagefright_foundation_without_imemory",
"libstagefright_mpeg2support",
- "libmediaextractor",
"libutils",
"libstagefright",
"libstagefright_esds",
diff --git a/media/extractors/ogg/OggExtractor.cpp b/media/extractors/ogg/OggExtractor.cpp
index 6efbfee..596c1c8 100644
--- a/media/extractors/ogg/OggExtractor.cpp
+++ b/media/extractors/ogg/OggExtractor.cpp
@@ -515,10 +515,10 @@
ALOGV("failed to read %zu bytes at offset %#016llx, got %zd bytes",
sizeof(header), (long long)offset, n);
- if (n < 0) {
- return n;
- } else if (n == 0) {
+ if (n == 0 || n == ERROR_END_OF_STREAM) {
return AMEDIA_ERROR_END_OF_STREAM;
+ } else if (n < 0) {
+ return AMEDIA_ERROR_UNKNOWN;
} else {
return AMEDIA_ERROR_IO;
}
@@ -872,7 +872,7 @@
ALOGV("readPage returned %zd", n);
- return n == ERROR_END_OF_STREAM ? AMEDIA_ERROR_END_OF_STREAM : AMEDIA_ERROR_UNKNOWN;
+ return (media_status_t) n;
}
// Prevent a harmless unsigned integer overflow by clamping to 0
diff --git a/media/libaaudio/include/aaudio/AAudio.h b/media/libaaudio/include/aaudio/AAudio.h
index 1493b26..8e36c77 100644
--- a/media/libaaudio/include/aaudio/AAudio.h
+++ b/media/libaaudio/include/aaudio/AAudio.h
@@ -373,6 +373,13 @@
* so the recorded volume may be very low.
*/
AAUDIO_INPUT_PRESET_UNPROCESSED = 9,
+
+ /**
+ * Use this preset for capturing audio meant to be processed in real time
+ * and played back for live performance (e.g karaoke).
+ * The capture path will minimize latency and coupling with playback path.
+ */
+ AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE = 10,
};
typedef int32_t aaudio_input_preset_t;
diff --git a/media/libaaudio/src/client/AudioStreamInternal.cpp b/media/libaaudio/src/client/AudioStreamInternal.cpp
index fffcda0..9c682b7 100644
--- a/media/libaaudio/src/client/AudioStreamInternal.cpp
+++ b/media/libaaudio/src/client/AudioStreamInternal.cpp
@@ -349,8 +349,7 @@
}
}
-aaudio_result_t AudioStreamInternal::requestStop()
-{
+aaudio_result_t AudioStreamInternal::requestStop() {
aaudio_result_t result = stopCallback();
if (result != AAUDIO_OK) {
return result;
diff --git a/media/libaaudio/src/client/AudioStreamInternalCapture.cpp b/media/libaaudio/src/client/AudioStreamInternalCapture.cpp
index 58ef7b1..7dcb620 100644
--- a/media/libaaudio/src/client/AudioStreamInternalCapture.cpp
+++ b/media/libaaudio/src/client/AudioStreamInternalCapture.cpp
@@ -259,6 +259,7 @@
if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
ALOGD("%s(): callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
+ result = systemStopFromCallback();
break;
}
}
diff --git a/media/libaaudio/src/client/AudioStreamInternalPlay.cpp b/media/libaaudio/src/client/AudioStreamInternalPlay.cpp
index 9af47b2..0884fca 100644
--- a/media/libaaudio/src/client/AudioStreamInternalPlay.cpp
+++ b/media/libaaudio/src/client/AudioStreamInternalPlay.cpp
@@ -294,6 +294,7 @@
}
} else if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
ALOGD("%s(): callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
+ result = systemStopFromCallback();
break;
}
}
diff --git a/media/libaaudio/src/core/AAudioAudio.cpp b/media/libaaudio/src/core/AAudioAudio.cpp
index 2fb3986..0d71efc 100644
--- a/media/libaaudio/src/core/AAudioAudio.cpp
+++ b/media/libaaudio/src/core/AAudioAudio.cpp
@@ -316,7 +316,7 @@
{
AudioStream *audioStream = convertAAudioStreamToAudioStream(stream);
ALOGD("%s(%p) called", __func__, stream);
- return audioStream->systemStop();
+ return audioStream->systemStopFromApp();
}
AAUDIO_API aaudio_result_t AAudioStream_waitForStateChange(AAudioStream* stream,
diff --git a/media/libaaudio/src/core/AAudioStreamParameters.cpp b/media/libaaudio/src/core/AAudioStreamParameters.cpp
index bd42697..88da53a 100644
--- a/media/libaaudio/src/core/AAudioStreamParameters.cpp
+++ b/media/libaaudio/src/core/AAudioStreamParameters.cpp
@@ -158,6 +158,7 @@
case AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION:
case AAUDIO_INPUT_PRESET_VOICE_RECOGNITION:
case AAUDIO_INPUT_PRESET_UNPROCESSED:
+ case AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE:
break; // valid
default:
ALOGE("input preset not valid = %d", mInputPreset);
diff --git a/media/libaaudio/src/core/AudioStream.cpp b/media/libaaudio/src/core/AudioStream.cpp
index 391af29..e39a075 100644
--- a/media/libaaudio/src/core/AudioStream.cpp
+++ b/media/libaaudio/src/core/AudioStream.cpp
@@ -119,21 +119,29 @@
return AAUDIO_OK;
}
-aaudio_result_t AudioStream::safeStart() {
+aaudio_result_t AudioStream::systemStart() {
std::lock_guard<std::mutex> lock(mStreamLock);
+
if (collidesWithCallback()) {
ALOGE("%s cannot be called from a callback!", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
- return requestStart();
+
+ aaudio_result_t result = requestStart();
+ if (result == AAUDIO_OK) {
+ // We only call this for logging in "dumpsys audio". So ignore return code.
+ (void) mPlayerBase->start();
+ }
+ return result;
}
-aaudio_result_t AudioStream::safePause() {
+aaudio_result_t AudioStream::systemPause() {
+ std::lock_guard<std::mutex> lock(mStreamLock);
+
if (!isPauseSupported()) {
return AAUDIO_ERROR_UNIMPLEMENTED;
}
- std::lock_guard<std::mutex> lock(mStreamLock);
if (collidesWithCallback()) {
ALOGE("%s cannot be called from a callback!", __func__);
return AAUDIO_ERROR_INVALID_STATE;
@@ -169,7 +177,12 @@
return AAUDIO_ERROR_INVALID_STATE;
}
- return requestPause();
+ aaudio_result_t result = requestPause();
+ if (result == AAUDIO_OK) {
+ // We only call this for logging in "dumpsys audio". So ignore return code.
+ (void) mPlayerBase->pause();
+ }
+ return result;
}
aaudio_result_t AudioStream::safeFlush() {
@@ -192,12 +205,31 @@
return requestFlush();
}
-aaudio_result_t AudioStream::safeStop() {
+aaudio_result_t AudioStream::systemStopFromCallback() {
+ std::lock_guard<std::mutex> lock(mStreamLock);
+ aaudio_result_t result = safeStop();
+ if (result == AAUDIO_OK) {
+ // We only call this for logging in "dumpsys audio". So ignore return code.
+ (void) mPlayerBase->stop();
+ }
+ return result;
+}
+
+aaudio_result_t AudioStream::systemStopFromApp() {
std::lock_guard<std::mutex> lock(mStreamLock);
if (collidesWithCallback()) {
- ALOGE("stream cannot be stopped from a callback!");
+ ALOGE("stream cannot be stopped by calling from a callback!");
return AAUDIO_ERROR_INVALID_STATE;
}
+ aaudio_result_t result = safeStop();
+ if (result == AAUDIO_OK) {
+ // We only call this for logging in "dumpsys audio". So ignore return code.
+ (void) mPlayerBase->stop();
+ }
+ return result;
+}
+
+aaudio_result_t AudioStream::safeStop() {
switch (getState()) {
// Proceed with stopping.
@@ -224,7 +256,7 @@
case AAUDIO_STREAM_STATE_CLOSING:
case AAUDIO_STREAM_STATE_CLOSED:
default:
- ALOGW("requestStop() stream not running, state = %s",
+ ALOGW("%s() stream not running, state = %s", __func__,
AAudio_convertStreamStateToText(getState()));
return AAUDIO_ERROR_INVALID_STATE;
}
@@ -349,21 +381,33 @@
}
}
-aaudio_result_t AudioStream::joinThread(void** returnArg, int64_t timeoutNanoseconds)
+aaudio_result_t AudioStream::joinThread(void** returnArg, int64_t timeoutNanoseconds __unused)
{
if (!mHasThread) {
ALOGE("joinThread() - but has no thread");
return AAUDIO_ERROR_INVALID_STATE;
}
+ aaudio_result_t result = AAUDIO_OK;
+ // If the callback is stopping the stream because the app passed back STOP
+ // then we don't need to join(). The thread is already about to exit.
+ if (pthread_self() != mThread) {
+ // Called from an app thread. Not the callback.
#if 0
- // TODO implement equivalent of pthread_timedjoin_np()
- struct timespec abstime;
- int err = pthread_timedjoin_np(mThread, returnArg, &abstime);
+ // TODO implement equivalent of pthread_timedjoin_np()
+ struct timespec abstime;
+ int err = pthread_timedjoin_np(mThread, returnArg, &abstime);
#else
- int err = pthread_join(mThread, returnArg);
+ int err = pthread_join(mThread, returnArg);
#endif
+ if (err) {
+ ALOGE("%s() pthread_join() returns err = %d", __func__, err);
+ result = AAudioConvert_androidToAAudioResult(-err);
+ }
+ }
+ // This must be set false so that the callback thread can be created
+ // when the stream is restarted.
mHasThread = false;
- return err ? AAudioConvert_androidToAAudioResult(-errno) : mThreadRegistrationResult;
+ return (result != AAUDIO_OK) ? result : mThreadRegistrationResult;
}
aaudio_data_callback_result_t AudioStream::maybeCallDataCallback(void *audioData,
diff --git a/media/libaaudio/src/core/AudioStream.h b/media/libaaudio/src/core/AudioStream.h
index 60200b2..46951f5 100644
--- a/media/libaaudio/src/core/AudioStream.h
+++ b/media/libaaudio/src/core/AudioStream.h
@@ -51,21 +51,6 @@
virtual ~AudioStream();
- /**
- * Lock a mutex and make sure we are not calling from a callback function.
- * @return result of requestStart();
- */
- aaudio_result_t safeStart();
-
- aaudio_result_t safePause();
-
- aaudio_result_t safeFlush();
-
- aaudio_result_t safeStop();
-
- aaudio_result_t safeClose();
-
- // =========== Begin ABSTRACT methods ===========================
protected:
/* Asynchronous requests.
@@ -74,7 +59,7 @@
virtual aaudio_result_t requestStart() = 0;
/**
- * Check the state to see if Pause if currently legal.
+ * Check the state to see if Pause is currently legal.
*
* @param result pointer to return code
* @return true if OK to continue, if false then return result
@@ -356,33 +341,28 @@
mPlayerBase->unregisterWithAudioManager();
}
- // Pass start request through PlayerBase for tracking.
- aaudio_result_t systemStart() {
- mPlayerBase->start();
- // Pass aaudio_result_t around the PlayerBase interface, which uses status__t.
- return mPlayerBase->getResult();
- }
+ aaudio_result_t systemStart();
- // Pass pause request through PlayerBase for tracking.
- aaudio_result_t systemPause() {
- mPlayerBase->pause();
- return mPlayerBase->getResult();
- }
+ aaudio_result_t systemPause();
- // Pass stop request through PlayerBase for tracking.
- aaudio_result_t systemStop() {
- mPlayerBase->stop();
- return mPlayerBase->getResult();
- }
+ aaudio_result_t safeFlush();
+
+ /**
+ * This is called when an app calls AAudioStream_requestStop();
+ * It prevents calls from a callback.
+ */
+ aaudio_result_t systemStopFromApp();
+
+ /**
+ * This is called internally when an app callback returns AAUDIO_CALLBACK_RESULT_STOP.
+ */
+ aaudio_result_t systemStopFromCallback();
+
+ aaudio_result_t safeClose();
protected:
- // PlayerBase allows the system to control the stream.
- // Calling through PlayerBase->start() notifies the AudioManager of the player state.
- // The AudioManager also can start/stop a stream by calling mPlayerBase->playerStart().
- // systemStart() ==> mPlayerBase->start() mPlayerBase->playerStart() ==> requestStart()
- // \ /
- // ------ AudioManager -------
+ // PlayerBase allows the system to control the stream volume.
class MyPlayerBase : public android::PlayerBase {
public:
explicit MyPlayerBase(AudioStream *parent);
@@ -406,20 +386,19 @@
void clearParentReference() { mParent = nullptr; }
+ // Just a stub. The ability to start audio through PlayerBase is being deprecated.
android::status_t playerStart() override {
- // mParent should NOT be null. So go ahead and crash if it is.
- mResult = mParent->safeStart();
- return AAudioConvert_aaudioToAndroidStatus(mResult);
+ return android::NO_ERROR;
}
+ // Just a stub. The ability to pause audio through PlayerBase is being deprecated.
android::status_t playerPause() override {
- mResult = mParent->safePause();
- return AAudioConvert_aaudioToAndroidStatus(mResult);
+ return android::NO_ERROR;
}
+ // Just a stub. The ability to stop audio through PlayerBase is being deprecated.
android::status_t playerStop() override {
- mResult = mParent->safeStop();
- return AAudioConvert_aaudioToAndroidStatus(mResult);
+ return android::NO_ERROR;
}
android::status_t playerSetVolume() override {
@@ -548,6 +527,8 @@
private:
+ aaudio_result_t safeStop();
+
std::mutex mStreamLock;
const android::sp<MyPlayerBase> mPlayerBase;
diff --git a/media/libaaudio/src/legacy/AudioStreamLegacy.cpp b/media/libaaudio/src/legacy/AudioStreamLegacy.cpp
index a6b9f5d..2edab58 100644
--- a/media/libaaudio/src/legacy/AudioStreamLegacy.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamLegacy.cpp
@@ -78,8 +78,9 @@
void AudioStreamLegacy::processCallbackCommon(aaudio_callback_operation_t opcode, void *info) {
aaudio_data_callback_result_t callbackResult;
- // This illegal size can be used to tell AudioFlinger to stop calling us.
- // This takes advantage of AudioFlinger killing the stream.
+ // This illegal size can be used to tell AudioRecord or AudioTrack to stop calling us.
+ // This takes advantage of them killing the stream when they see a size out of range.
+ // That is an undocumented behavior.
// TODO add to API in AudioRecord and AudioTrack
const size_t SIZE_STOP_CALLBACKS = SIZE_MAX;
@@ -95,7 +96,7 @@
ALOGW("processCallbackCommon() data, stream disconnected");
audioBuffer->size = SIZE_STOP_CALLBACKS;
} else if (!mCallbackEnabled.load()) {
- ALOGW("processCallbackCommon() stopping because callback disabled");
+ ALOGW("processCallbackCommon() no data because callback disabled");
audioBuffer->size = SIZE_STOP_CALLBACKS;
} else {
if (audioBuffer->frameCount == 0) {
@@ -115,10 +116,16 @@
}
if (callbackResult == AAUDIO_CALLBACK_RESULT_CONTINUE) {
audioBuffer->size = audioBuffer->frameCount * getBytesPerDeviceFrame();
- } else { // STOP or invalid result
- ALOGW("%s() callback requested stop, fake an error", __func__);
- audioBuffer->size = SIZE_STOP_CALLBACKS;
- // Disable the callback just in case AudioFlinger keeps trying to call us.
+ } else {
+ if (callbackResult == AAUDIO_CALLBACK_RESULT_STOP) {
+ ALOGD("%s() callback returned AAUDIO_CALLBACK_RESULT_STOP", __func__);
+ } else {
+ ALOGW("%s() callback returned invalid result = %d",
+ __func__, callbackResult);
+ }
+ audioBuffer->size = 0;
+ systemStopFromCallback();
+ // Disable the callback just in case the system keeps trying to call us.
mCallbackEnabled.store(false);
}
diff --git a/media/libaaudio/src/legacy/AudioStreamRecord.cpp b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
index 40e22ac..f550089 100644
--- a/media/libaaudio/src/legacy/AudioStreamRecord.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamRecord.cpp
@@ -486,6 +486,9 @@
int64_t *framePosition,
int64_t *timeNanoseconds) {
ExtendedTimestamp extendedTimestamp;
+ if (getState() != AAUDIO_STREAM_STATE_STARTED) {
+ return AAUDIO_ERROR_INVALID_STATE;
+ }
status_t status = mAudioRecord->getTimestamp(&extendedTimestamp);
if (status == WOULD_BLOCK) {
return AAUDIO_ERROR_INVALID_STATE;
diff --git a/media/libaaudio/src/legacy/AudioStreamTrack.cpp b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
index 1ac2558..c995e99 100644
--- a/media/libaaudio/src/legacy/AudioStreamTrack.cpp
+++ b/media/libaaudio/src/legacy/AudioStreamTrack.cpp
@@ -288,7 +288,7 @@
aaudio_result_t AudioStreamTrack::requestPause() {
if (mAudioTrack.get() == nullptr) {
- ALOGE("requestPause() no AudioTrack");
+ ALOGE("%s() no AudioTrack", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
@@ -304,7 +304,7 @@
aaudio_result_t AudioStreamTrack::requestFlush() {
if (mAudioTrack.get() == nullptr) {
- ALOGE("requestFlush() no AudioTrack");
+ ALOGE("%s() no AudioTrack", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
@@ -318,7 +318,7 @@
aaudio_result_t AudioStreamTrack::requestStop() {
if (mAudioTrack.get() == nullptr) {
- ALOGE("requestStop() no AudioTrack");
+ ALOGE("%s() no AudioTrack", __func__);
return AAUDIO_ERROR_INVALID_STATE;
}
diff --git a/media/libaaudio/src/utility/AAudioUtilities.cpp b/media/libaaudio/src/utility/AAudioUtilities.cpp
index f5b3ad4..723cbf1 100644
--- a/media/libaaudio/src/utility/AAudioUtilities.cpp
+++ b/media/libaaudio/src/utility/AAudioUtilities.cpp
@@ -210,6 +210,7 @@
STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_RECOGNITION == AUDIO_SOURCE_VOICE_RECOGNITION);
STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION == AUDIO_SOURCE_VOICE_COMMUNICATION);
STATIC_ASSERT(AAUDIO_INPUT_PRESET_UNPROCESSED == AUDIO_SOURCE_UNPROCESSED);
+ STATIC_ASSERT(AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE == AUDIO_SOURCE_VOICE_PERFORMANCE);
if (preset == AAUDIO_UNSPECIFIED) {
preset = AAUDIO_INPUT_PRESET_VOICE_RECOGNITION;
}
diff --git a/media/libaaudio/tests/test_attributes.cpp b/media/libaaudio/tests/test_attributes.cpp
index b01af25..dbf8712 100644
--- a/media/libaaudio/tests/test_attributes.cpp
+++ b/media/libaaudio/tests/test_attributes.cpp
@@ -130,6 +130,7 @@
AAUDIO_INPUT_PRESET_VOICE_RECOGNITION,
AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION,
AAUDIO_INPUT_PRESET_UNPROCESSED,
+ AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE,
};
static void checkAttributesUsage(aaudio_performance_mode_t perfMode) {
diff --git a/media/libaaudio/tests/test_timestamps.cpp b/media/libaaudio/tests/test_timestamps.cpp
index dfa7815..7b1dfd3 100644
--- a/media/libaaudio/tests/test_timestamps.cpp
+++ b/media/libaaudio/tests/test_timestamps.cpp
@@ -35,6 +35,7 @@
#define NUM_SECONDS 1
#define NUM_LOOPS 4
+#define MAX_TESTS 20
typedef struct TimestampInfo {
int64_t framesTotal;
@@ -53,6 +54,49 @@
bool forceUnderruns = false;
} TimestampCallbackData_t;
+struct TimeStampTestLog {
+ aaudio_policy_t isMmap;
+ aaudio_sharing_mode_t sharingMode;
+ aaudio_performance_mode_t performanceMode;
+ aaudio_direction_t direction;
+ aaudio_result_t result;
+};
+
+static int s_numTests = 0;
+// Use a plain old array because we reference this from the callback and do not want any
+// automatic memory allocation.
+static TimeStampTestLog s_testLogs[MAX_TESTS]{};
+
+static void logTestResult(bool isMmap,
+ aaudio_sharing_mode_t sharingMode,
+ aaudio_performance_mode_t performanceMode,
+ aaudio_direction_t direction,
+ aaudio_result_t result) {
+ if(s_numTests >= MAX_TESTS) {
+ printf("ERROR - MAX_TESTS too small = %d\n", MAX_TESTS);
+ return;
+ }
+ s_testLogs[s_numTests].isMmap = isMmap;
+ s_testLogs[s_numTests].sharingMode = sharingMode;
+ s_testLogs[s_numTests].performanceMode = performanceMode;
+ s_testLogs[s_numTests].direction = direction;
+ s_testLogs[s_numTests].result = result;
+ s_numTests++;
+}
+
+static void printTestResults() {
+ for (int i = 0; i < s_numTests; i++) {
+ TimeStampTestLog *log = &s_testLogs[i];
+ printf("%2d: mmap = %3s, sharing = %9s, perf = %11s, dir = %6s ---- %4s\n",
+ i,
+ log->isMmap ? "yes" : "no",
+ getSharingModeText(log->sharingMode),
+ getPerformanceModeText(log->performanceMode),
+ getDirectionText(log->direction),
+ log->result ? "FAIL" : "pass");
+ }
+}
+
// Callback function that fills the audio output buffer.
aaudio_data_callback_result_t timestampDataCallbackProc(
AAudioStream *stream,
@@ -115,6 +159,7 @@
int32_t originalBufferSize = 0;
int32_t requestedBufferSize = 0;
int32_t finalBufferSize = 0;
+ bool isMmap = false;
aaudio_format_t actualDataFormat = AAUDIO_FORMAT_PCM_FLOAT;
aaudio_sharing_mode_t actualSharingMode = AAUDIO_SHARING_MODE_SHARED;
aaudio_sharing_mode_t actualPerformanceMode = AAUDIO_PERFORMANCE_MODE_NONE;
@@ -124,7 +169,8 @@
memset(&sTimestampData, 0, sizeof(sTimestampData));
- printf("------------ testTimeStamps(policy = %d, sharing = %s, perf = %s, dir = %s) -----------\n",
+ printf("\n=================================================================================\n");
+ printf("--------- testTimeStamps(policy = %d, sharing = %s, perf = %s, dir = %s) --------\n",
mmapPolicy,
getSharingModeText(sharingMode),
getPerformanceModeText(performanceMode),
@@ -177,8 +223,8 @@
printf(" chans = %3d, rate = %6d format = %d\n",
actualChannelCount, actualSampleRate, actualDataFormat);
- printf(" Is MMAP used? %s\n", AAudioStream_isMMapUsed(aaudioStream)
- ? "yes" : "no");
+ isMmap = AAudioStream_isMMapUsed(aaudioStream);
+ printf(" Is MMAP used? %s\n", isMmap ? "yes" : "no");
// This is the number of frames that are read in one chunk by a DMA controller
// or a DSP or a mixer.
@@ -218,7 +264,7 @@
for (int second = 0; second < NUM_SECONDS; second++) {
// Give AAudio callback time to run in the background.
- sleep(1);
+ usleep(200 * 1000);
// Periodically print the progress so we know it hasn't died.
printf("framesWritten = %d, XRuns = %d\n",
@@ -234,18 +280,25 @@
}
printf("timestampCount = %d\n", sTimestampData.timestampCount);
- int printed = 0;
- for (int i = 0; i < sTimestampData.timestampCount; i++) {
+ int printedGood = 0;
+ int printedBad = 0;
+ for (int i = 1; i < sTimestampData.timestampCount; i++) {
TimestampInfo *timestamp = &sTimestampData.timestamps[i];
- bool posChanged = (timestamp->timestampPosition != (timestamp - 1)->timestampPosition);
- bool timeChanged = (timestamp->timestampNanos != (timestamp - 1)->timestampNanos);
- if ((printed < 20) && ((i < 10) || posChanged || timeChanged)) {
- printf(" %3d : frames %8lld, xferd %8lld", i,
- (long long) timestamp->framesTotal,
- (long long) timestamp->appPosition);
- if (timestamp->result != AAUDIO_OK) {
- printf(", result = %s\n", AAudio_convertResultToText(timestamp->result));
- } else {
+ if (timestamp->result != AAUDIO_OK) {
+ if (printedBad < 5) {
+ printf(" %3d : frames %8lld, xferd %8lld, result = %s\n",
+ i,
+ (long long) timestamp->framesTotal,
+ (long long) timestamp->appPosition,
+ AAudio_convertResultToText(timestamp->result));
+ printedBad++;
+ }
+ } else {
+ const bool posChanged = (timestamp->timestampPosition !=
+ (timestamp - 1)->timestampPosition);
+ const bool timeChanged = (timestamp->timestampNanos
+ != (timestamp - 1)->timestampNanos);
+ if ((printedGood < 20) && (posChanged || timeChanged)) {
bool negative = timestamp->timestampPosition < 0;
bool retro = (i > 0 && (timestamp->timestampPosition <
(timestamp - 1)->timestampPosition));
@@ -253,17 +306,39 @@
: (retro ? " <= RETROGRADE!" : "");
double latency = calculateLatencyMillis(timestamp->timestampPosition,
- timestamp->timestampNanos,
- timestamp->appPosition,
- timestamp->appNanoseconds,
- actualSampleRate);
- printf(", STAMP: pos = %8lld, nanos = %8lld, lat = %7.1f msec %s\n",
+ timestamp->timestampNanos,
+ timestamp->appPosition,
+ timestamp->appNanoseconds,
+ actualSampleRate);
+ printf(" %3d : frames %8lld, xferd %8lld",
+ i,
+ (long long) timestamp->framesTotal,
+ (long long) timestamp->appPosition);
+ printf(" STAMP: pos = %8lld, nanos = %8lld, lat = %7.1f msec %s\n",
(long long) timestamp->timestampPosition,
(long long) timestamp->timestampNanos,
latency,
message);
+ printedGood++;
}
- printed++;
+ }
+ }
+
+ if (printedGood == 0) {
+ printf("ERROR - AAudioStream_getTimestamp() never gave us a valid timestamp\n");
+ result = AAUDIO_ERROR_INTERNAL;
+ } else {
+ // Make sure we do not get timestamps when stopped.
+ int64_t position;
+ int64_t time;
+ aaudio_result_t tempResult = AAudioStream_getTimestamp(aaudioStream,
+ CLOCK_MONOTONIC,
+ &position, &time);
+ if (tempResult != AAUDIO_ERROR_INVALID_STATE) {
+ printf("ERROR - AAudioStream_getTimestamp() should return"
+ " INVALID_STATE when stopped! %s\n",
+ AAudio_convertResultToText(tempResult));
+ result = AAUDIO_ERROR_INTERNAL;
}
}
@@ -273,12 +348,14 @@
}
finish:
+
+ logTestResult(isMmap, sharingMode, performanceMode, direction, result);
+
if (aaudioStream != nullptr) {
AAudioStream_close(aaudioStream);
}
AAudioStreamBuilder_delete(aaudioBuilder);
printf("result = %d = %s\n", result, AAudio_convertResultToText(result));
-
return result;
}
@@ -292,7 +369,7 @@
// in a buffer if we hang or crash.
setvbuf(stdout, nullptr, _IONBF, (size_t) 0);
- printf("Test Timestamps V0.1.3\n");
+ printf("Test Timestamps V0.1.4\n");
// Legacy
aaudio_policy_t policy = AAUDIO_POLICY_NEVER;
@@ -332,5 +409,7 @@
AAUDIO_PERFORMANCE_MODE_LOW_LATENCY,
AAUDIO_DIRECTION_OUTPUT);
+ printTestResults();
+
return (result == AAUDIO_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
}
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index 827df6a..1417aaf 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -50,6 +50,7 @@
"libmediametrics",
"libmediautils",
"libnblog",
+ "libprocessgroup",
"libutils",
],
export_shared_lib_headers: ["libbinder"],
diff --git a/media/libaudioclient/AudioPolicy.cpp b/media/libaudioclient/AudioPolicy.cpp
index 9601d6d..3ab38cd 100644
--- a/media/libaudioclient/AudioPolicy.cpp
+++ b/media/libaudioclient/AudioPolicy.cpp
@@ -143,11 +143,18 @@
return NO_ERROR;
}
-void AudioMix::excludeUid(uid_t uid) const {
+void AudioMix::setExcludeUid(uid_t uid) const {
AudioMixMatchCriterion crit;
crit.mRule = RULE_EXCLUDE_UID;
crit.mValue.mUid = uid;
mCriteria.add(crit);
}
+void AudioMix::setMatchUid(uid_t uid) const {
+ AudioMixMatchCriterion crit;
+ crit.mRule = RULE_MATCH_UID;
+ crit.mValue.mUid = uid;
+ mCriteria.add(crit);
+}
+
} // namespace android
diff --git a/media/libaudioclient/AudioRecord.cpp b/media/libaudioclient/AudioRecord.cpp
index 3223647..72a23e3 100644
--- a/media/libaudioclient/AudioRecord.cpp
+++ b/media/libaudioclient/AudioRecord.cpp
@@ -26,6 +26,7 @@
#include <media/AudioRecord.h>
#include <utils/Log.h>
#include <private/media/AudioTrackShared.h>
+#include <processgroup/sched_policy.h>
#include <media/IAudioFlinger.h>
#include <media/MediaAnalyticsItem.h>
#include <media/TypeConverter.h>
@@ -1398,6 +1399,17 @@
return mAudioRecord->getActiveMicrophones(activeMicrophones).transactionError();
}
+status_t AudioRecord::setMicrophoneDirection(audio_microphone_direction_t direction)
+{
+ AutoMutex lock(mLock);
+ return mAudioRecord->setMicrophoneDirection(direction).transactionError();
+}
+
+status_t AudioRecord::setMicrophoneFieldDimension(float zoom) {
+ AutoMutex lock(mLock);
+ return mAudioRecord->setMicrophoneFieldDimension(zoom).transactionError();
+}
+
// =========================================================================
void AudioRecord::DeathNotifier::binderDied(const wp<IBinder>& who __unused)
diff --git a/media/libaudioclient/AudioTrack.cpp b/media/libaudioclient/AudioTrack.cpp
index b444d2d..e9a0e22 100644
--- a/media/libaudioclient/AudioTrack.cpp
+++ b/media/libaudioclient/AudioTrack.cpp
@@ -29,6 +29,7 @@
#include <media/AudioTrack.h>
#include <utils/Log.h>
#include <private/media/AudioTrackShared.h>
+#include <processgroup/sched_policy.h>
#include <media/IAudioFlinger.h>
#include <media/IAudioPolicyService.h>
#include <media/AudioParameter.h>
diff --git a/media/libaudioclient/aidl/android/media/IAudioRecord.aidl b/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
index 01e0a71..cf9c7f4 100644
--- a/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
+++ b/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
@@ -36,4 +36,12 @@
/* Get a list of current active microphones.
*/
void getActiveMicrophones(out MicrophoneInfo[] activeMicrophones);
+
+ /* Set the microphone direction (for processing).
+ */
+ void setMicrophoneDirection(int /*audio_microphone_direction_t*/ direction);
+
+ /* Set the microphone zoom (for processing).
+ */
+ void setMicrophoneFieldDimension(float zoom);
}
diff --git a/media/libaudioclient/include/media/AudioPolicy.h b/media/libaudioclient/include/media/AudioPolicy.h
index 96e1235..786fb9a 100644
--- a/media/libaudioclient/include/media/AudioPolicy.h
+++ b/media/libaudioclient/include/media/AudioPolicy.h
@@ -100,7 +100,8 @@
status_t readFromParcel(Parcel *parcel);
status_t writeToParcel(Parcel *parcel) const;
- void excludeUid(uid_t uid) const;
+ void setExcludeUid(uid_t uid) const;
+ void setMatchUid(uid_t uid) const;
mutable Vector<AudioMixMatchCriterion> mCriteria;
uint32_t mMixType;
diff --git a/media/libaudioclient/include/media/AudioRecord.h b/media/libaudioclient/include/media/AudioRecord.h
index 35a7e05..ebee124 100644
--- a/media/libaudioclient/include/media/AudioRecord.h
+++ b/media/libaudioclient/include/media/AudioRecord.h
@@ -534,6 +534,14 @@
*/
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ /* Set the Microphone direction (for processing purposes).
+ */
+ status_t setMicrophoneDirection(audio_microphone_direction_t direction);
+
+ /* Set the Microphone zoom factor (for processing purposes).
+ */
+ status_t setMicrophoneFieldDimension(float zoom);
+
/* Get the unique port ID assigned to this AudioRecord instance by audio policy manager.
* The ID is unique across all audioserver clients and can change during the life cycle
* of a given AudioRecord instance if the connection to audioserver is restored.
diff --git a/media/libaudiohal/impl/DeviceHalHidl.cpp b/media/libaudiohal/impl/DeviceHalHidl.cpp
index 7a9e843..a1e869f 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.cpp
+++ b/media/libaudiohal/impl/DeviceHalHidl.cpp
@@ -268,6 +268,8 @@
audio_input_flags_t flags,
const char *address,
audio_source_t source,
+ audio_devices_t outputDevice,
+ const char *outputDeviceAddress,
sp<StreamInHalInterface> *inStream) {
if (mDevice == 0) return NO_INIT;
DeviceAddress hidlDevice;
@@ -283,6 +285,17 @@
// for now, only send the main source at 1dbfs
SinkMetadata sinkMetadata = {{{ .source = AudioSource(source), .gain = 1 }}};
#endif
+#if MAJOR_VERSION < 5
+ (void)outputDevice;
+ (void)outputDeviceAddress;
+#else
+ if (outputDevice != AUDIO_DEVICE_NONE) {
+ DeviceAddress hidlOutputDevice;
+ status = deviceAddressFromHal(outputDevice, outputDeviceAddress, &hidlOutputDevice);
+ if (status != OK) return status;
+ sinkMetadata.tracks[0].destination.device(std::move(hidlOutputDevice));
+ }
+#endif
Return<void> ret = mDevice->openInputStream(
handle,
hidlDevice,
diff --git a/media/libaudiohal/impl/DeviceHalHidl.h b/media/libaudiohal/impl/DeviceHalHidl.h
index 291c88f..f7d465f 100644
--- a/media/libaudiohal/impl/DeviceHalHidl.h
+++ b/media/libaudiohal/impl/DeviceHalHidl.h
@@ -86,6 +86,8 @@
audio_input_flags_t flags,
const char *address,
audio_source_t source,
+ audio_devices_t outputDevice,
+ const char *outputDeviceAddress,
sp<StreamInHalInterface> *inStream);
// Returns whether createAudioPatch and releaseAudioPatch operations are supported.
diff --git a/media/libaudiohal/impl/DeviceHalLocal.cpp b/media/libaudiohal/impl/DeviceHalLocal.cpp
index dffe9da..ee68252 100644
--- a/media/libaudiohal/impl/DeviceHalLocal.cpp
+++ b/media/libaudiohal/impl/DeviceHalLocal.cpp
@@ -131,6 +131,8 @@
audio_input_flags_t flags,
const char *address,
audio_source_t source,
+ audio_devices_t /*outputDevice*/,
+ const char */*outputDeviceAddress*/,
sp<StreamInHalInterface> *inStream) {
audio_stream_in_t *halStream;
ALOGV("open_input_stream handle: %d devices: %x flags: %#x "
diff --git a/media/libaudiohal/impl/DeviceHalLocal.h b/media/libaudiohal/impl/DeviceHalLocal.h
index 18bd879..36db72e 100644
--- a/media/libaudiohal/impl/DeviceHalLocal.h
+++ b/media/libaudiohal/impl/DeviceHalLocal.h
@@ -79,6 +79,8 @@
audio_input_flags_t flags,
const char *address,
audio_source_t source,
+ audio_devices_t outputDevice,
+ const char *outputDeviceAddress,
sp<StreamInHalInterface> *inStream);
// Returns whether createAudioPatch and releaseAudioPatch operations are supported.
diff --git a/media/libaudiohal/impl/StreamHalHidl.cpp b/media/libaudiohal/impl/StreamHalHidl.cpp
index c12b362..2e35be6 100644
--- a/media/libaudiohal/impl/StreamHalHidl.cpp
+++ b/media/libaudiohal/impl/StreamHalHidl.cpp
@@ -854,5 +854,29 @@
}
#endif
+#if MAJOR_VERSION < 5
+status_t StreamInHalHidl::setMicrophoneDirection(audio_microphone_direction_t direction __unused) {
+ if (mStream == 0) return NO_INIT;
+ return INVALID_OPERATION;
+}
+
+status_t StreamInHalHidl::setMicrophoneFieldDimension(float zoom __unused) {
+ if (mStream == 0) return NO_INIT;
+ return INVALID_OPERATION;
+}
+#else
+status_t StreamInHalHidl::setMicrophoneDirection(audio_microphone_direction_t direction) {
+ if (!mStream) return NO_INIT;
+ return processReturn("setMicrophoneDirection",
+ mStream->setMicrophoneDirection(static_cast<MicrophoneDirection>(direction)));
+}
+
+status_t StreamInHalHidl::setMicrophoneFieldDimension(float zoom) {
+ if (!mStream) return NO_INIT;
+ return processReturn("setMicrophoneFieldDimension",
+ mStream->setMicrophoneFieldDimension(zoom));
+}
+#endif
+
} // namespace CPP_VERSION
} // namespace android
diff --git a/media/libaudiohal/impl/StreamHalHidl.h b/media/libaudiohal/impl/StreamHalHidl.h
index f7b507e..9ac1067 100644
--- a/media/libaudiohal/impl/StreamHalHidl.h
+++ b/media/libaudiohal/impl/StreamHalHidl.h
@@ -220,6 +220,12 @@
// Get active microphones
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
+ // Set microphone direction (for processing)
+ virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction) override;
+
+ // Set microphone zoom (for processing)
+ virtual status_t setMicrophoneFieldDimension(float zoom) override;
+
// Called when the metadata of the stream's sink has been changed.
status_t updateSinkMetadata(const SinkMetadata& sinkMetadata) override;
diff --git a/media/libaudiohal/impl/StreamHalLocal.cpp b/media/libaudiohal/impl/StreamHalLocal.cpp
index 26d30d4..fcb809b 100644
--- a/media/libaudiohal/impl/StreamHalLocal.cpp
+++ b/media/libaudiohal/impl/StreamHalLocal.cpp
@@ -368,5 +368,26 @@
}
#endif
+#if MAJOR_VERSION < 5
+status_t StreamInHalLocal::setMicrophoneDirection(audio_microphone_direction_t direction __unused) {
+ return INVALID_OPERATION;
+}
+
+status_t StreamInHalLocal::setMicrophoneFieldDimension(float zoom __unused) {
+ return INVALID_OPERATION;
+}
+#else
+status_t StreamInHalLocal::setMicrophoneDirection(audio_microphone_direction_t direction) {
+ if (mStream->set_microphone_direction == NULL) return INVALID_OPERATION;
+ return mStream->set_microphone_direction(mStream, direction);
+}
+
+status_t StreamInHalLocal::setMicrophoneFieldDimension(float zoom) {
+ if (mStream->set_microphone_field_dimension == NULL) return INVALID_OPERATION;
+ return mStream->set_microphone_field_dimension(mStream, zoom);
+
+}
+#endif
+
} // namespace CPP_VERSION
} // namespace android
diff --git a/media/libaudiohal/impl/StreamHalLocal.h b/media/libaudiohal/impl/StreamHalLocal.h
index 4fd1960..3d6c50e 100644
--- a/media/libaudiohal/impl/StreamHalLocal.h
+++ b/media/libaudiohal/impl/StreamHalLocal.h
@@ -204,6 +204,12 @@
// Get active microphones
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
+ // Sets microphone direction (for processing)
+ virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction);
+
+ // Sets microphone zoom (for processing)
+ virtual status_t setMicrophoneFieldDimension(float zoom);
+
// Called when the metadata of the stream's sink has been changed.
status_t updateSinkMetadata(const SinkMetadata& sinkMetadata) override;
diff --git a/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h b/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
index 7de8eb3..e565237 100644
--- a/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/DeviceHalInterface.h
@@ -84,6 +84,8 @@
audio_input_flags_t flags,
const char *address,
audio_source_t source,
+ audio_devices_t outputDevice,
+ const char *outputDeviceAddress,
sp<StreamInHalInterface> *inStream) = 0;
// Returns whether createAudioPatch and releaseAudioPatch operations are supported.
diff --git a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
index bd71dc0..ed8282f 100644
--- a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
@@ -179,6 +179,12 @@
// Get active microphones
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones) = 0;
+ // Set direction for capture processing
+ virtual status_t setMicrophoneDirection(audio_microphone_direction_t) = 0;
+
+ // Set zoom factor for capture stream
+ virtual status_t setMicrophoneFieldDimension(float zoom) = 0;
+
struct SinkMetadata {
std::vector<record_track_metadata_t> tracks;
};
diff --git a/media/libeffects/config/src/EffectsConfig.cpp b/media/libeffects/config/src/EffectsConfig.cpp
index 76b4adc..f39eb0c 100644
--- a/media/libeffects/config/src/EffectsConfig.cpp
+++ b/media/libeffects/config/src/EffectsConfig.cpp
@@ -115,6 +115,7 @@
{AUDIO_SOURCE_VOICE_RECOGNITION, "voice_recognition"},
{AUDIO_SOURCE_VOICE_COMMUNICATION, "voice_communication"},
{AUDIO_SOURCE_UNPROCESSED, "unprocessed"},
+ {AUDIO_SOURCE_VOICE_PERFORMANCE, "voice_performance"},
};
/** Find the stream type enum corresponding to the stream type name or return false */
diff --git a/media/libmedia/Android.bp b/media/libmedia/Android.bp
index 7d759e0..68dae56 100644
--- a/media/libmedia/Android.bp
+++ b/media/libmedia/Android.bp
@@ -213,6 +213,7 @@
"android.hidl.token@1.0-utils",
"liblog",
"libcutils",
+ "libprocessgroup",
"libutils",
"libbinder",
"libsonivox",
@@ -220,7 +221,6 @@
"libexpat",
"libcamera_client",
"libstagefright_foundation",
- "libmediaextractor",
"libgui",
"libdl",
"libaudioutils",
@@ -277,7 +277,6 @@
"libbinder",
"libcutils",
"liblog",
- "libmediaextractor",
"libmediandk",
"libnativewindow",
"libmediandk_utils",
diff --git a/media/libmedia/IMediaExtractor.cpp b/media/libmedia/IMediaExtractor.cpp
index e9a6230..fb6d3a2 100644
--- a/media/libmedia/IMediaExtractor.cpp
+++ b/media/libmedia/IMediaExtractor.cpp
@@ -19,6 +19,7 @@
#include <utils/Log.h>
#include <stdint.h>
+#include <time.h>
#include <sys/types.h>
#include <binder/IPCThreadState.h>
@@ -219,10 +220,16 @@
Vector<wp<IMediaSource>> tracks;
Vector<String8> trackDescriptions;
String8 toString() const;
+ time_t when;
} ExtractorInstance;
String8 ExtractorInstance::toString() const {
- String8 str = name;
+ String8 str;
+ char timeString[32];
+ strftime(timeString, sizeof(timeString), "%m-%d %T", localtime(&when));
+ str.append(timeString);
+ str.append(": ");
+ str.append(name);
str.append(" for mime ");
str.append(mime);
str.append(", source ");
@@ -287,6 +294,7 @@
ex.sourceDescription = source->toString();
ex.owner = IPCThreadState::self()->getCallingPid();
ex.extractor = extractor;
+ ex.when = time(NULL);
{
Mutex::Autolock lock(sExtractorsLock);
diff --git a/media/libmedia/IMediaMetadataRetriever.cpp b/media/libmedia/IMediaMetadataRetriever.cpp
index 590ba1a..f9fa86e 100644
--- a/media/libmedia/IMediaMetadataRetriever.cpp
+++ b/media/libmedia/IMediaMetadataRetriever.cpp
@@ -23,6 +23,7 @@
#include <media/IDataSource.h>
#include <media/IMediaHTTPService.h>
#include <media/IMediaMetadataRetriever.h>
+#include <processgroup/sched_policy.h>
#include <utils/String8.h>
#include <utils/KeyedVector.h>
diff --git a/media/libmedia/MediaCodecInfo.cpp b/media/libmedia/MediaCodecInfo.cpp
index 5308e1c..86ad997 100644
--- a/media/libmedia/MediaCodecInfo.cpp
+++ b/media/libmedia/MediaCodecInfo.cpp
@@ -28,6 +28,15 @@
namespace android {
+/** This redundant redeclaration is needed for C++ pre 14 */
+constexpr char MediaCodecInfo::Capabilities::FEATURE_ADAPTIVE_PLAYBACK[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_DYNAMIC_TIMESTAMP[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_FRAME_PARSING[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_INTRA_REFRESH[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_MULTIPLE_FRAMES[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_SECURE_PLAYBACK[];
+constexpr char MediaCodecInfo::Capabilities::FEATURE_TUNNELED_PLAYBACK[];
+
void MediaCodecInfo::Capabilities::getSupportedProfileLevels(
Vector<ProfileLevel> *profileLevels) const {
profileLevels->clear();
@@ -40,16 +49,11 @@
colorFormats->appendVector(mColorFormats);
}
-uint32_t MediaCodecInfo::Capabilities::getFlags() const {
- return mFlags;
-}
-
const sp<AMessage> MediaCodecInfo::Capabilities::getDetails() const {
return mDetails;
}
-MediaCodecInfo::Capabilities::Capabilities()
- : mFlags(0) {
+MediaCodecInfo::Capabilities::Capabilities() {
mDetails = new AMessage;
}
@@ -73,12 +77,10 @@
caps->mColorFormats.push_back(color);
}
}
- uint32_t flags = static_cast<uint32_t>(parcel.readInt32());
sp<AMessage> details = AMessage::FromParcel(parcel);
if (details == NULL)
return NULL;
if (caps != NULL) {
- caps->mFlags = flags;
caps->mDetails = details;
}
return caps;
@@ -96,7 +98,6 @@
for (size_t i = 0; i < mColorFormats.size(); i++) {
parcel->writeInt32(mColorFormats.itemAt(i));
}
- parcel->writeInt32(mFlags);
mDetails->writeToParcel(parcel);
return OK;
}
@@ -111,6 +112,14 @@
mCap->mDetails->setInt32(key, value);
}
+void MediaCodecInfo::CapabilitiesWriter::removeDetail(const char* key) {
+ if (mCap->mDetails->removeEntryAt(mCap->mDetails->findEntryByName(key)) == OK) {
+ ALOGD("successfully removed detail %s", key);
+ } else {
+ ALOGD("detail %s wasn't present to remove", key);
+ }
+}
+
void MediaCodecInfo::CapabilitiesWriter::addProfileLevel(
uint32_t profile, uint32_t level) {
ProfileLevel profileLevel;
@@ -129,32 +138,32 @@
}
}
-void MediaCodecInfo::CapabilitiesWriter::addFlags(uint32_t flags) {
- mCap->mFlags |= flags;
-}
-
MediaCodecInfo::CapabilitiesWriter::CapabilitiesWriter(
MediaCodecInfo::Capabilities* cap) : mCap(cap) {
}
-bool MediaCodecInfo::isEncoder() const {
- return mIsEncoder;
+MediaCodecInfo::Attributes MediaCodecInfo::getAttributes() const {
+ return mAttributes;
}
-uint32_t MediaCodecInfo::rank() const {
+uint32_t MediaCodecInfo::getRank() const {
return mRank;
}
-void MediaCodecInfo::getSupportedMimes(Vector<AString> *mimes) const {
- mimes->clear();
+void MediaCodecInfo::getAliases(Vector<AString> *aliases) const {
+ *aliases = mAliases;
+}
+
+void MediaCodecInfo::getSupportedMediaTypes(Vector<AString> *mediaTypes) const {
+ mediaTypes->clear();
for (size_t ix = 0; ix < mCaps.size(); ix++) {
- mimes->push_back(mCaps.keyAt(ix));
+ mediaTypes->push_back(mCaps.keyAt(ix));
}
}
const sp<MediaCodecInfo::Capabilities>
-MediaCodecInfo::getCapabilitiesFor(const char *mime) const {
- ssize_t ix = getCapabilityIndex(mime);
+MediaCodecInfo::getCapabilitiesFor(const char *mediaType) const {
+ ssize_t ix = getCapabilityIndex(mediaType);
if (ix >= 0) {
return mCaps.valueAt(ix);
}
@@ -173,21 +182,26 @@
sp<MediaCodecInfo> MediaCodecInfo::FromParcel(const Parcel &parcel) {
AString name = AString::FromParcel(parcel);
AString owner = AString::FromParcel(parcel);
- bool isEncoder = static_cast<bool>(parcel.readInt32());
+ Attributes attributes = static_cast<Attributes>(parcel.readInt32());
uint32_t rank = parcel.readUint32();
sp<MediaCodecInfo> info = new MediaCodecInfo;
info->mName = name;
info->mOwner = owner;
- info->mIsEncoder = isEncoder;
+ info->mAttributes = attributes;
info->mRank = rank;
+ size_t numAliases = static_cast<size_t>(parcel.readInt32());
+ for (size_t i = 0; i < numAliases; i++) {
+ AString alias = AString::FromParcel(parcel);
+ info->mAliases.add(alias);
+ }
size_t size = static_cast<size_t>(parcel.readInt32());
for (size_t i = 0; i < size; i++) {
- AString mime = AString::FromParcel(parcel);
+ AString mediaType = AString::FromParcel(parcel);
sp<Capabilities> caps = Capabilities::FromParcel(parcel);
if (caps == NULL)
return NULL;
if (info != NULL) {
- info->mCaps.add(mime, caps);
+ info->mCaps.add(mediaType, caps);
}
}
return info;
@@ -196,8 +210,12 @@
status_t MediaCodecInfo::writeToParcel(Parcel *parcel) const {
mName.writeToParcel(parcel);
mOwner.writeToParcel(parcel);
- parcel->writeInt32(mIsEncoder);
+ parcel->writeInt32(mAttributes);
parcel->writeUint32(mRank);
+ parcel->writeInt32(mAliases.size());
+ for (const AString &alias : mAliases) {
+ alias.writeToParcel(parcel);
+ }
parcel->writeInt32(mCaps.size());
for (size_t i = 0; i < mCaps.size(); i++) {
mCaps.keyAt(i).writeToParcel(parcel);
@@ -206,10 +224,10 @@
return OK;
}
-ssize_t MediaCodecInfo::getCapabilityIndex(const char *mime) const {
- if (mime) {
+ssize_t MediaCodecInfo::getCapabilityIndex(const char *mediaType) const {
+ if (mediaType) {
for (size_t ix = 0; ix < mCaps.size(); ix++) {
- if (mCaps.keyAt(ix).equalsIgnoreCase(mime)) {
+ if (mCaps.keyAt(ix).equalsIgnoreCase(mediaType)) {
return ix;
}
}
@@ -217,19 +235,26 @@
return -1;
}
-MediaCodecInfo::MediaCodecInfo() : mRank(0x100) {
+MediaCodecInfo::MediaCodecInfo()
+ : mAttributes((MediaCodecInfo::Attributes)0),
+ mRank(0x100) {
}
void MediaCodecInfoWriter::setName(const char* name) {
mInfo->mName = name;
}
+void MediaCodecInfoWriter::addAlias(const char* name) {
+ mInfo->mAliases.add(name);
+}
+
void MediaCodecInfoWriter::setOwner(const char* owner) {
mInfo->mOwner = owner;
}
-void MediaCodecInfoWriter::setEncoder(bool isEncoder) {
- mInfo->mIsEncoder = isEncoder;
+void MediaCodecInfoWriter::setAttributes(
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attributes) {
+ mInfo->mAttributes = (MediaCodecInfo::Attributes)attributes;
}
void MediaCodecInfoWriter::setRank(uint32_t rank) {
@@ -237,21 +262,21 @@
}
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter>
- MediaCodecInfoWriter::addMime(const char *mime) {
- ssize_t ix = mInfo->getCapabilityIndex(mime);
+ MediaCodecInfoWriter::addMediaType(const char *mediaType) {
+ ssize_t ix = mInfo->getCapabilityIndex(mediaType);
if (ix >= 0) {
return std::unique_ptr<MediaCodecInfo::CapabilitiesWriter>(
new MediaCodecInfo::CapabilitiesWriter(
mInfo->mCaps.valueAt(ix).get()));
}
sp<MediaCodecInfo::Capabilities> caps = new MediaCodecInfo::Capabilities();
- mInfo->mCaps.add(AString(mime), caps);
+ mInfo->mCaps.add(AString(mediaType), caps);
return std::unique_ptr<MediaCodecInfo::CapabilitiesWriter>(
new MediaCodecInfo::CapabilitiesWriter(caps.get()));
}
-bool MediaCodecInfoWriter::removeMime(const char *mime) {
- ssize_t ix = mInfo->getCapabilityIndex(mime);
+bool MediaCodecInfoWriter::removeMediaType(const char *mediaType) {
+ ssize_t ix = mInfo->getCapabilityIndex(mediaType);
if (ix >= 0) {
mInfo->mCaps.removeItemsAt(ix);
return true;
diff --git a/media/libmedia/TypeConverter.cpp b/media/libmedia/TypeConverter.cpp
index b5a7172..c24e046 100644
--- a/media/libmedia/TypeConverter.cpp
+++ b/media/libmedia/TypeConverter.cpp
@@ -74,6 +74,7 @@
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_WIRED_HEADSET),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_AUX_DIGITAL),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_HDMI),
+ MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_HDMI_ARC),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_TELEPHONY_RX),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_VOICE_CALL),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BACK_MIC),
@@ -93,6 +94,8 @@
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BUS),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_PROXY),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_USB_HEADSET),
+ MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BLUETOOTH_BLE),
+ MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_ECHO_REFERENCE),
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_DEFAULT),
// STUB must be after DEFAULT, so the latter is picked up by toString first.
MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_STUB),
@@ -357,6 +360,8 @@
MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_VOICE_COMMUNICATION),
MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_REMOTE_SUBMIX),
MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_UNPROCESSED),
+ MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_VOICE_PERFORMANCE),
+ MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_ECHO_REFERENCE),
MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_FM_TUNER),
MAKE_STRING_FROM_ENUM(AUDIO_SOURCE_HOTWORD),
TERMINATOR
diff --git a/media/libmedia/include/media/MediaCodecInfo.h b/media/libmedia/include/media/MediaCodecInfo.h
index b3777d3..54f565a 100644
--- a/media/libmedia/include/media/MediaCodecInfo.h
+++ b/media/libmedia/include/media/MediaCodecInfo.h
@@ -30,6 +30,8 @@
#include <utils/Vector.h>
#include <utils/StrongPointer.h>
+#include <type_traits>
+
namespace android {
struct AMessage;
@@ -51,21 +53,47 @@
struct CapabilitiesWriter;
+ enum Attributes : int32_t {
+ // attribute flags
+ kFlagIsEncoder = 1 << 0,
+ kFlagIsVendor = 1 << 1,
+ kFlagIsSoftwareOnly = 1 << 2,
+ kFlagIsHardwareAccelerated = 1 << 3,
+ };
+
struct Capabilities : public RefBase {
- enum {
- // decoder flags
- kFlagSupportsAdaptivePlayback = 1 << 0,
- kFlagSupportsSecurePlayback = 1 << 1,
- kFlagSupportsTunneledPlayback = 1 << 2,
+ constexpr static char FEATURE_ADAPTIVE_PLAYBACK[] = "feature-adaptive-playback";
+ constexpr static char FEATURE_DYNAMIC_TIMESTAMP[] = "feature-dynamic-timestamp";
+ constexpr static char FEATURE_FRAME_PARSING[] = "feature-frame-parsing";
+ constexpr static char FEATURE_INTRA_REFRESH[] = "feature-frame-parsing";
+ constexpr static char FEATURE_MULTIPLE_FRAMES[] = "feature-multiple-frames";
+ constexpr static char FEATURE_SECURE_PLAYBACK[] = "feature-secure-playback";
+ constexpr static char FEATURE_TUNNELED_PLAYBACK[] = "feature-tunneled-playback";
- // encoder flags
- kFlagSupportsIntraRefresh = 1 << 0,
-
- };
-
+ /**
+ * Returns the supported levels for each supported profile in a target array.
+ *
+ * @param profileLevels target array for the profile levels.
+ */
void getSupportedProfileLevels(Vector<ProfileLevel> *profileLevels) const;
+
+ /**
+ * Returns the supported color formats in a target array. Only used for video/image
+ * components.
+ *
+ * @param colorFormats target array for the color formats.
+ */
void getSupportedColorFormats(Vector<uint32_t> *colorFormats) const;
- uint32_t getFlags() const;
+
+ /**
+ * Returns metadata associated with this codec capability.
+ *
+ * This contains:
+ * - features,
+ * - performance data.
+ *
+ * TODO: expose this as separate API-s and wrap here.
+ */
const sp<AMessage> getDetails() const;
protected:
@@ -73,7 +101,6 @@
SortedVector<ProfileLevel> mProfileLevelsSorted;
Vector<uint32_t> mColorFormats;
SortedVector<uint32_t> mColorFormatsSorted;
- uint32_t mFlags;
sp<AMessage> mDetails;
Capabilities();
@@ -93,8 +120,7 @@
/**
* This class is used for modifying information inside a `Capabilities`
* object. An object of type `CapabilitiesWriter` can be obtained by calling
- * `MediaCodecInfoWriter::addMime()` or
- * `MediaCodecInfoWriter::updateMime()`.
+ * `MediaCodecInfoWriter::addMediaType()`.
*/
struct CapabilitiesWriter {
/**
@@ -122,6 +148,13 @@
*/
void addDetail(const char* key, int32_t value);
/**
+ * Removes a key-value pair from the list of details. If the key is not
+ * present, this call does nothing.
+ *
+ * @param key The key.
+ */
+ void removeDetail(const char* key);
+ /**
* Add a profile-level pair. If this profile-level pair already exists,
* it will be ignored.
*
@@ -136,13 +169,7 @@
* @param format The color format.
*/
void addColorFormat(uint32_t format);
- /**
- * Add flags. The underlying operation is bitwise-or. In other words,
- * bits that have already been set will be ignored.
- *
- * @param flags The additional flags.
- */
- void addFlags(uint32_t flags);
+
private:
/**
* The associated `Capabilities` object.
@@ -158,19 +185,42 @@
friend MediaCodecInfoWriter;
};
- bool isEncoder() const;
- void getSupportedMimes(Vector<AString> *mimes) const;
- const sp<Capabilities> getCapabilitiesFor(const char *mime) const;
+ inline bool isEncoder() const {
+ return getAttributes() & kFlagIsEncoder;
+ }
+
+ Attributes getAttributes() const;
+ void getSupportedMediaTypes(Vector<AString> *mediaTypes) const;
+ const sp<Capabilities> getCapabilitiesFor(const char *mediaType) const;
const char *getCodecName() const;
/**
+ * Returns a vector containing alternate names for the codec.
+ *
+ * \param aliases the destination array for the aliases. This is cleared.
+ *
+ * Multiple codecs may share alternate names as long as their supported media types are
+ * distinct; however, these will result in different aliases for the MediaCodec user as
+ * the canonical codec has to be resolved without knowing the media type in
+ * MediaCodec::CreateByComponentName.
+ */
+ void getAliases(Vector<AString> *aliases) const;
+
+ /**
* Return the name of the service that hosts the codec. This value is not
* visible at the Java level.
*
* Currently, this is the "instance name" of the IOmx service.
*/
const char *getOwnerName() const;
- uint32_t rank() const;
+
+ /**
+ * Returns the rank of the component.
+ *
+ * Technically this is defined to be per media type, but that makes ordering the MediaCodecList
+ * impossible as MediaCodecList is ordered by codec name.
+ */
+ uint32_t getRank() const;
/**
* Serialization over Binder
@@ -181,11 +231,12 @@
private:
AString mName;
AString mOwner;
- bool mIsEncoder;
+ Attributes mAttributes;
KeyedVector<AString, sp<Capabilities> > mCaps;
+ Vector<AString> mAliases;
uint32_t mRank;
- ssize_t getCapabilityIndex(const char *mime) const;
+ ssize_t getCapabilityIndex(const char *mediaType) const;
/**
* Construct an `MediaCodecInfo` object. After the construction, its
@@ -219,6 +270,13 @@
*/
void setName(const char* name);
/**
+ * Adds an alias (alternate name) for the codec. Multiple codecs can share an alternate name
+ * as long as their supported media types are distinct.
+ *
+ * @param name an alternate name.
+ */
+ void addAlias(const char* name);
+ /**
* Set the owner name of the codec.
*
* This "owner name" is the name of the `IOmx` instance that supports this
@@ -228,32 +286,32 @@
*/
void setOwner(const char* owner);
/**
- * Set whether this codec is an encoder or a decoder.
+ * Sets codec attributes.
*
- * @param isEncoder Whether this codec is an encoder or a decoder.
+ * @param attributes Codec attributes.
*/
- void setEncoder(bool isEncoder = true);
+ void setAttributes(typename std::underlying_type<MediaCodecInfo::Attributes>::type attributes);
/**
- * Add a mime to an indexed list and return a `CapabilitiesWriter` object
+ * Add a media type to an indexed list and return a `CapabilitiesWriter` object
* that can be used for modifying the associated `Capabilities`.
*
- * If the mime already exists, this function will return the
- * `CapabilitiesWriter` associated with the mime.
+ * If the media type already exists, this function will return the
+ * `CapabilitiesWriter` associated with the media type.
*
- * @param[in] mime The name of a new mime to add.
+ * @param[in] mediaType The name of a new media type to add.
* @return writer The `CapabilitiesWriter` object for modifying the
- * `Capabilities` associated with the mime. `writer` will be valid
- * regardless of whether `mime` already exists or not.
+ * `Capabilities` associated with the media type. `writer` will be valid
+ * regardless of whether `mediaType` already exists or not.
*/
- std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> addMime(
- const char* mime);
+ std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> addMediaType(
+ const char* mediaType);
/**
- * Remove a mime.
+ * Remove a media type.
*
- * @param mime The name of the mime to remove.
- * @return `true` if `mime` is removed; `false` if `mime` is not found.
+ * @param mediaType The name of the media type to remove.
+ * @return `true` if `mediaType` is removed; `false` if `mediaType` is not found.
*/
- bool removeMime(const char* mime);
+ bool removeMediaType(const char* mediaType);
/**
* Set rank of the codec. MediaCodecList will stable-sort the list according
* to rank in non-descending order.
diff --git a/media/libmediaextractor/Android.bp b/media/libmediaextractor/Android.bp
deleted file mode 100644
index 4758cd6..0000000
--- a/media/libmediaextractor/Android.bp
+++ /dev/null
@@ -1,60 +0,0 @@
-cc_library {
- name: "libmediaextractor",
-
- include_dirs: [
- "frameworks/av/include",
- "frameworks/av/media/libmediaextractor/include",
- ],
-
- export_include_dirs: ["include"],
-
- cflags: [
- "-Wno-multichar",
- "-Werror",
- "-Wall",
- ],
-
- static: {
- cflags: [
- "-Wno-multichar",
- "-Werror",
- "-Wall",
- "-DNO_IMEMORY",
- ],
- },
-
- shared_libs: [
- "libbinder",
- "libstagefright_foundation",
- "libutils",
- "liblog",
- ],
-
- header_libs: [
- "media_ndk_headers",
- ],
-
- export_header_lib_headers: [
- "media_ndk_headers",
- ],
-
- srcs: [
- "DataSourceBase.cpp",
- "MediaBuffer.cpp",
- "MediaBufferBase.cpp",
- "MediaBufferGroup.cpp",
- "MediaSource.cpp",
- "MetaData.cpp",
- "MetaDataBase.cpp",
- ],
-
- clang: true,
-
- sanitize: {
- misc_undefined: [
- "unsigned-integer-overflow",
- "signed-integer-overflow",
- ],
- cfi: true,
- },
-}
diff --git a/media/libmediaplayer2/Android.bp b/media/libmediaplayer2/Android.bp
index 38f42dc..b3f7404 100644
--- a/media/libmediaplayer2/Android.bp
+++ b/media/libmediaplayer2/Android.bp
@@ -21,7 +21,6 @@
"libgui",
"liblog",
"libmedia_omx",
- "libmediaextractor",
"libstagefright_foundation",
"libui",
"libutils",
diff --git a/media/libmediaplayer2/JavaVMHelper.cpp b/media/libmediaplayer2/JavaVMHelper.cpp
index 90aaa7f..8d03ed0 100644
--- a/media/libmediaplayer2/JavaVMHelper.cpp
+++ b/media/libmediaplayer2/JavaVMHelper.cpp
@@ -19,6 +19,7 @@
#include "mediaplayer2/JavaVMHelper.h"
#include <media/stagefright/foundation/ADebug.h>
+#include <utils/threads.h>
#include <stdlib.h>
@@ -27,6 +28,109 @@
// static
std::atomic<JavaVM *> JavaVMHelper::sJavaVM(NULL);
+/*
+ * Makes the current thread visible to the VM.
+ *
+ * The JNIEnv pointer returned is only valid for the current thread, and
+ * thus must be tucked into thread-local storage.
+ */
+static int javaAttachThread(const char* threadName, JNIEnv** pEnv) {
+ JavaVMAttachArgs args;
+ JavaVM* vm;
+ jint result;
+
+ vm = JavaVMHelper::getJavaVM();
+ if (vm == NULL) {
+ return JNI_ERR;
+ }
+
+ args.version = JNI_VERSION_1_4;
+ args.name = (char*) threadName;
+ args.group = NULL;
+
+ result = vm->AttachCurrentThread(pEnv, (void*) &args);
+ if (result != JNI_OK) {
+ ALOGI("NOTE: attach of thread '%s' failed\n", threadName);
+ }
+
+ return result;
+}
+
+/*
+ * Detach the current thread from the set visible to the VM.
+ */
+static int javaDetachThread(void) {
+ JavaVM* vm;
+ jint result;
+
+ vm = JavaVMHelper::getJavaVM();
+ if (vm == NULL) {
+ return JNI_ERR;
+ }
+
+ result = vm->DetachCurrentThread();
+ if (result != JNI_OK) {
+ ALOGE("ERROR: thread detach failed\n");
+ }
+ return result;
+}
+
+/*
+ * When starting a native thread that will be visible from the VM, we
+ * bounce through this to get the right attach/detach action.
+ * Note that this function calls free(args)
+ */
+static int javaThreadShell(void* args) {
+ void* start = ((void**)args)[0];
+ void* userData = ((void **)args)[1];
+ char* name = (char*) ((void **)args)[2]; // we own this storage
+ free(args);
+ JNIEnv* env;
+ int result;
+
+ /* hook us into the VM */
+ if (javaAttachThread(name, &env) != JNI_OK) {
+ return -1;
+ }
+
+ /* start the thread running */
+ result = (*(android_thread_func_t)start)(userData);
+
+ /* unhook us */
+ javaDetachThread();
+ free(name);
+
+ return result;
+}
+
+/*
+ * This is invoked from androidCreateThreadEtc() via the callback
+ * set with androidSetCreateThreadFunc().
+ *
+ * We need to create the new thread in such a way that it gets hooked
+ * into the VM before it really starts executing.
+ */
+static int javaCreateThreadEtc(
+ android_thread_func_t entryFunction,
+ void* userData,
+ const char* threadName,
+ int32_t threadPriority,
+ size_t threadStackSize,
+ android_thread_id_t* threadId) {
+ void** args = (void**) malloc(3 * sizeof(void*)); // javaThreadShell must free
+ int result;
+
+ LOG_ALWAYS_FATAL_IF(threadName == nullptr, "threadName not provided to javaCreateThreadEtc");
+
+ args[0] = (void*) entryFunction;
+ args[1] = userData;
+ args[2] = (void*) strdup(threadName); // javaThreadShell must free
+
+ result = androidCreateRawThreadEtc(javaThreadShell, args,
+ threadName, threadPriority, threadStackSize, threadId);
+ return result;
+}
+
// static
JNIEnv *JavaVMHelper::getJNIEnv() {
JNIEnv *env;
@@ -40,9 +144,19 @@
return env;
}
+//static
+JavaVM *JavaVMHelper::getJavaVM() {
+ return sJavaVM.load();
+}
+
// static
void JavaVMHelper::setJavaVM(JavaVM *vm) {
sJavaVM.store(vm);
+
+ // Ensure that Thread(/*canCallJava*/ true) in libutils is attached to the VM.
+ // This is supposed to be done by runtime, but when libutils is used with linker
+ // namespace, CreateThreadFunc should be initialized separately within the namespace.
+ androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
}
} // namespace android
diff --git a/media/libmediaplayer2/include/mediaplayer2/JavaVMHelper.h b/media/libmediaplayer2/include/mediaplayer2/JavaVMHelper.h
index 35091b7..4b56aca 100644
--- a/media/libmediaplayer2/include/mediaplayer2/JavaVMHelper.h
+++ b/media/libmediaplayer2/include/mediaplayer2/JavaVMHelper.h
@@ -26,6 +26,7 @@
struct JavaVMHelper {
static JNIEnv *getJNIEnv();
+ static JavaVM *getJavaVM();
static void setJavaVM(JavaVM *vm);
private:
diff --git a/media/libmediaplayerservice/Android.bp b/media/libmediaplayerservice/Android.bp
index 51879fd..55867a5 100644
--- a/media/libmediaplayerservice/Android.bp
+++ b/media/libmediaplayerservice/Android.bp
@@ -24,7 +24,6 @@
"liblog",
"libmedia",
"libmedia_omx",
- "libmediaextractor",
"libmediadrm",
"libmediametrics",
"libmediautils",
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index dadfe28..a1a2660 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -8682,14 +8682,17 @@
if (omxNode->configureVideoTunnelMode(
kPortIndexOutput, OMX_TRUE, 0, &sidebandHandle) == OK) {
// tunneled playback includes adaptive playback
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback
- | MediaCodecInfo::Capabilities::kFlagSupportsTunneledPlayback);
- } else if (omxNode->setPortMode(
- kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) == OK ||
- omxNode->prepareForAdaptivePlayback(
- kPortIndexOutput, OMX_TRUE,
- 1280 /* width */, 720 /* height */) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsAdaptivePlayback);
+ } else {
+ // tunneled playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_TUNNELED_PLAYBACK);
+ if (omxNode->setPortMode(
+ kPortIndexOutput, IOMX::kPortModeDynamicANWBuffer) != OK &&
+ omxNode->prepareForAdaptivePlayback(
+ kPortIndexOutput, OMX_TRUE,
+ 1280 /* width */, 720 /* height */) != OK) {
+ // adaptive playback is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_ADAPTIVE_PLAYBACK);
+ }
}
}
@@ -8697,11 +8700,20 @@
OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE params;
InitOMXParams(¶ms);
params.nPortIndex = kPortIndexOutput;
- // TODO: should we verify if fallback is supported?
+
+ OMX_VIDEO_PARAM_INTRAREFRESHTYPE fallbackParams;
+ InitOMXParams(&fallbackParams);
+ fallbackParams.nPortIndex = kPortIndexOutput;
+ fallbackParams.eRefreshMode = OMX_VIDEO_IntraRefreshCyclic;
+
if (omxNode->getConfig(
(OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh,
- ¶ms, sizeof(params)) == OK) {
- caps->addFlags(MediaCodecInfo::Capabilities::kFlagSupportsIntraRefresh);
+ ¶ms, sizeof(params)) != OK &&
+ omxNode->getParameter(
+ OMX_IndexParamVideoIntraRefresh, &fallbackParams,
+ sizeof(fallbackParams)) != OK) {
+ // intra refresh is not supported
+ caps->removeDetail(MediaCodecInfo::Capabilities::FEATURE_INTRA_REFRESH);
}
}
diff --git a/media/libstagefright/Android.bp b/media/libstagefright/Android.bp
index 249f2a4..f45cc58 100644
--- a/media/libstagefright/Android.bp
+++ b/media/libstagefright/Android.bp
@@ -94,6 +94,7 @@
"CameraSource.cpp",
"CameraSourceTimeLapse.cpp",
"DataConverter.cpp",
+ "DataSourceBase.cpp",
"DataSourceFactory.cpp",
"DataURISource.cpp",
"ClearFileSource.cpp",
@@ -113,6 +114,7 @@
"MediaCodecSource.cpp",
"MediaExtractor.cpp",
"MediaExtractorFactory.cpp",
+ "MediaSource.cpp",
"MediaSync.cpp",
"MediaTrack.cpp",
"http/ClearMediaHTTP.cpp",
@@ -150,7 +152,6 @@
"libmedia",
"libmedia_omx",
"libaudioclient",
- "libmediaextractor",
"libmediametrics",
"libmediautils",
"libui",
diff --git a/media/libmediaextractor/DataSourceBase.cpp b/media/libstagefright/DataSourceBase.cpp
similarity index 100%
rename from media/libmediaextractor/DataSourceBase.cpp
rename to media/libstagefright/DataSourceBase.cpp
diff --git a/media/libstagefright/MediaClock.cpp b/media/libstagefright/MediaClock.cpp
index 8bff9f7..4f9bc6d 100644
--- a/media/libstagefright/MediaClock.cpp
+++ b/media/libstagefright/MediaClock.cpp
@@ -110,7 +110,7 @@
if (mAnchorTimeRealUs != -1) {
int64_t oldNowMediaUs =
mAnchorTimeMediaUs + (nowUs - mAnchorTimeRealUs) * (double)mPlaybackRate;
- if (nowMediaUs < oldNowMediaUs
+ if (nowMediaUs < oldNowMediaUs + kAnchorFluctuationAllowedUs
&& nowMediaUs > oldNowMediaUs - kAnchorFluctuationAllowedUs) {
return;
}
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 7816fae..c7da7c7 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -862,9 +862,9 @@
//static
sp<CodecBase> MediaCodec::GetCodecBase(const AString &name, const char *owner) {
if (owner) {
- if (strncmp(owner, "default", 8) == 0) {
+ if (strcmp(owner, "default") == 0) {
return new ACodec;
- } else if (strncmp(owner, "codec2", 7) == 0) {
+ } else if (strncmp(owner, "codec2", 6) == 0) {
return CreateCCodec();
}
}
@@ -911,10 +911,10 @@
continue;
}
mCodecInfo = mcl->getCodecInfo(codecIdx);
- Vector<AString> mimes;
- mCodecInfo->getSupportedMimes(&mimes);
- for (size_t i = 0; i < mimes.size(); i++) {
- if (mimes[i].startsWith("video/")) {
+ Vector<AString> mediaTypes;
+ mCodecInfo->getSupportedMediaTypes(&mediaTypes);
+ for (size_t i = 0; i < mediaTypes.size(); i++) {
+ if (mediaTypes[i].startsWith("video/")) {
mIsVideo = true;
break;
}
diff --git a/media/libstagefright/MediaCodecList.cpp b/media/libstagefright/MediaCodecList.cpp
index eaff283..93478e9 100644
--- a/media/libstagefright/MediaCodecList.cpp
+++ b/media/libstagefright/MediaCodecList.cpp
@@ -215,13 +215,9 @@
mCodecInfos.begin(),
mCodecInfos.end(),
[](const sp<MediaCodecInfo> &info1, const sp<MediaCodecInfo> &info2) {
- if (info2 == nullptr) {
- return false;
- } else if (info1 == nullptr) {
- return true;
- } else {
- return info1->rank() < info2->rank();
- }
+ // null is lowest
+ return info1 == nullptr
+ || (info2 != nullptr && info1->getRank() < info2->getRank());
});
}
diff --git a/media/libstagefright/MediaCodecListOverrides.cpp b/media/libstagefright/MediaCodecListOverrides.cpp
index cac53f4..dd7c3e6 100644
--- a/media/libstagefright/MediaCodecListOverrides.cpp
+++ b/media/libstagefright/MediaCodecListOverrides.cpp
@@ -228,18 +228,18 @@
continue;
}
- Vector<AString> mimes;
- info->getSupportedMimes(&mimes);
- for (size_t i = 0; i < mimes.size(); ++i) {
+ Vector<AString> mediaTypes;
+ info->getSupportedMediaTypes(&mediaTypes);
+ for (size_t i = 0; i < mediaTypes.size(); ++i) {
const sp<MediaCodecInfo::Capabilities> &caps =
- info->getCapabilitiesFor(mimes[i].c_str());
+ info->getCapabilitiesFor(mediaTypes[i].c_str());
if (!forceToMeasure &&
(caps->getDetails()->contains("max-supported-instances") ||
caps->getDetails()->contains("max-concurrent-instances"))) {
continue;
}
- size_t max = doProfileCodecs(info->isEncoder(), name, mimes[i], caps);
+ size_t max = doProfileCodecs(info->isEncoder(), name, mediaTypes[i], caps);
if (max > 0) {
CodecSettings settings;
char maxStr[32];
@@ -248,7 +248,7 @@
AString key = name;
key.append(" ");
- key.append(mimes[i]);
+ key.append(mediaTypes[i]);
if (info->isEncoder()) {
encoder_results->add(key, settings);
diff --git a/media/libmediaextractor/MediaSource.cpp b/media/libstagefright/MediaSource.cpp
similarity index 100%
rename from media/libmediaextractor/MediaSource.cpp
rename to media/libstagefright/MediaSource.cpp
diff --git a/media/libstagefright/OmxInfoBuilder.cpp b/media/libstagefright/OmxInfoBuilder.cpp
index 96b896b..382c947 100644
--- a/media/libstagefright/OmxInfoBuilder.cpp
+++ b/media/libstagefright/OmxInfoBuilder.cpp
@@ -57,14 +57,9 @@
}
status_t queryCapabilities(
- const IOmxStore::NodeInfo& node, const char* mime, bool isEncoder,
+ const IOmxStore::NodeInfo& node, const char* mediaType, bool isEncoder,
MediaCodecInfo::CapabilitiesWriter* caps) {
sp<ACodec> codec = new ACodec();
- status_t err = codec->queryCapabilities(
- node.owner.c_str(), node.name.c_str(), mime, isEncoder, caps);
- if (err != OK) {
- return err;
- }
for (const auto& attribute : node.attributes) {
// All features have an int32 value except
// "feature-bitrate-modes", which has a string value.
@@ -81,6 +76,12 @@
attribute.key.c_str(), attribute.value.c_str());
}
}
+ // query capabilities may remove capabilities that are not actually supported by the codec
+ status_t err = codec->queryCapabilities(
+ node.owner.c_str(), node.name.c_str(), mediaType, isEncoder, caps);
+ if (err != OK) {
+ return err;
+ }
return OK;
}
@@ -163,7 +164,10 @@
info = c2i->second.get();
info->setName(nodeName.c_str());
info->setOwner(node.owner.c_str());
- info->setEncoder(isEncoder);
+ info->setAttributes(
+ // all OMX codecs are vendor codecs (in the vendor partition), but
+ // treat OMX.google codecs as non-hardware-accelerated and non-vendor
+ (isEncoder ? MediaCodecInfo::kFlagIsEncoder : 0));
info->setRank(defaultRank);
} else {
// The node has been seen before. Simply retrieve the
@@ -180,7 +184,19 @@
info = c2i->second.get();
info->setName(nodeName.c_str());
info->setOwner(node.owner.c_str());
- info->setEncoder(isEncoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs =
+ MediaCodecInfo::kFlagIsVendor;
+ if (isEncoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ if (std::count_if(
+ node.attributes.begin(), node.attributes.end(),
+ [](const IOmxStore::Attribute &i) -> bool {
+ return i.key == "attribute::software-codec";
+ })) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
+ info->setAttributes(attrs);
info->setRank(defaultRank);
} else {
// If preferPlatformNodes is true, this node must be
@@ -195,12 +211,12 @@
}
}
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- info->addMime(typeName.c_str());
+ info->addMediaType(typeName.c_str());
if (queryCapabilities(
node, typeName.c_str(), isEncoder, caps.get()) != OK) {
- ALOGW("Fail to add mime %s to codec %s",
+ ALOGW("Fail to add media type %s to codec %s",
typeName.c_str(), nodeName.c_str());
- info->removeMime(typeName.c_str());
+ info->removeMediaType(typeName.c_str());
}
}
@@ -219,7 +235,18 @@
info = c2i->second.get();
info->setName(nodeName.c_str());
info->setOwner(node->owner.c_str());
- info->setEncoder(isEncoder);
+ typename std::underlying_type<MediaCodecInfo::Attributes>::type attrs =
+ MediaCodecInfo::kFlagIsVendor;
+ if (isEncoder) {
+ attrs |= MediaCodecInfo::kFlagIsEncoder;
+ }
+ if (std::count_if(
+ node->attributes.begin(), node->attributes.end(),
+ [](const IOmxStore::Attribute &i) -> bool {
+ return i.key == "attribute::software-codec";
+ })) {
+ attrs |= MediaCodecInfo::kFlagIsHardwareAccelerated;
+ }
info->setRank(defaultRank);
} else {
// The node has been seen before. Simply retrieve the
@@ -227,13 +254,13 @@
info = c2i->second.get();
}
std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> caps =
- info->addMime(typeName.c_str());
+ info->addMediaType(typeName.c_str());
if (queryCapabilities(
*node, typeName.c_str(), isEncoder, caps.get()) != OK) {
- ALOGW("Fail to add mime %s to codec %s "
+ ALOGW("Fail to add media type %s to codec %s "
"after software codecs",
typeName.c_str(), nodeName.c_str());
- info->removeMime(typeName.c_str());
+ info->removeMediaType(typeName.c_str());
}
}
}
diff --git a/media/libstagefright/codecs/m4v_h263/dec/SoftMPEG4.cpp b/media/libstagefright/codecs/m4v_h263/dec/SoftMPEG4.cpp
index fda7028..a8fcdd1 100644
--- a/media/libstagefright/codecs/m4v_h263/dec/SoftMPEG4.cpp
+++ b/media/libstagefright/codecs/m4v_h263/dec/SoftMPEG4.cpp
@@ -382,6 +382,7 @@
if (portIndex == 0 && mInitialized) {
CHECK_EQ((int)PVResetVideoDecoder(mHandle), (int)PV_TRUE);
}
+ mFramesConfigured = false;
}
void SoftMPEG4::onReset() {
diff --git a/media/libstagefright/foundation/Android.bp b/media/libstagefright/foundation/Android.bp
index dcf1ab8..dd1d904 100644
--- a/media/libstagefright/foundation/Android.bp
+++ b/media/libstagefright/foundation/Android.bp
@@ -4,8 +4,8 @@
vendor_available: true,
}
-cc_library {
- name: "libstagefright_foundation",
+cc_defaults {
+ name: "libstagefright_foundation_defaults",
vendor_available: true,
vndk: {
enabled: true,
@@ -25,6 +25,7 @@
header_libs: [
"libhardware_headers",
"libstagefright_foundation_headers",
+ "media_ndk_headers",
"media_plugin_headers",
],
@@ -64,8 +65,13 @@
"AudioPresentationInfo.cpp",
"ByteUtils.cpp",
"ColorUtils.cpp",
+ "MediaBuffer.cpp",
+ "MediaBufferBase.cpp",
+ "MediaBufferGroup.cpp",
"MediaDefs.cpp",
"MediaKeys.cpp",
+ "MetaData.cpp",
+ "MetaDataBase.cpp",
"avc_utils.cpp",
"base64.cpp",
"hexdump.cpp",
@@ -81,3 +87,20 @@
cfi: true,
},
}
+
+cc_library {
+ name: "libstagefright_foundation",
+ defaults: ["libstagefright_foundation_defaults"],
+}
+
+cc_library_static {
+ name: "libstagefright_foundation_without_imemory",
+ defaults: ["libstagefright_foundation_defaults"],
+
+ cflags: [
+ "-Wno-multichar",
+ "-Werror",
+ "-Wall",
+ "-DNO_IMEMORY",
+ ],
+}
diff --git a/media/libmediaextractor/MediaBuffer.cpp b/media/libstagefright/foundation/MediaBuffer.cpp
similarity index 93%
rename from media/libmediaextractor/MediaBuffer.cpp
rename to media/libstagefright/foundation/MediaBuffer.cpp
index bab3a03..9beac05 100644
--- a/media/libmediaextractor/MediaBuffer.cpp
+++ b/media/libstagefright/foundation/MediaBuffer.cpp
@@ -59,9 +59,11 @@
#ifndef NO_IMEMORY
} else {
ALOGV("creating memoryDealer");
- sp<MemoryDealer> memoryDealer =
- new MemoryDealer(size + sizeof(SharedControl), "MediaBuffer");
- mMemory = memoryDealer->allocate(size + sizeof(SharedControl));
+ size_t newSize = 0;
+ if (!__builtin_add_overflow(size, sizeof(SharedControl), &newSize)) {
+ sp<MemoryDealer> memoryDealer = new MemoryDealer(newSize, "MediaBuffer");
+ mMemory = memoryDealer->allocate(newSize);
+ }
if (mMemory == NULL) {
ALOGW("Failed to allocate shared memory, trying regular allocation!");
mData = malloc(size);
diff --git a/media/libmediaextractor/MediaBufferBase.cpp b/media/libstagefright/foundation/MediaBufferBase.cpp
similarity index 100%
rename from media/libmediaextractor/MediaBufferBase.cpp
rename to media/libstagefright/foundation/MediaBufferBase.cpp
diff --git a/media/libmediaextractor/MediaBufferGroup.cpp b/media/libstagefright/foundation/MediaBufferGroup.cpp
similarity index 100%
rename from media/libmediaextractor/MediaBufferGroup.cpp
rename to media/libstagefright/foundation/MediaBufferGroup.cpp
diff --git a/media/libmediaextractor/MetaData.cpp b/media/libstagefright/foundation/MetaData.cpp
similarity index 100%
rename from media/libmediaextractor/MetaData.cpp
rename to media/libstagefright/foundation/MetaData.cpp
diff --git a/media/libmediaextractor/MetaDataBase.cpp b/media/libstagefright/foundation/MetaDataBase.cpp
similarity index 100%
rename from media/libmediaextractor/MetaDataBase.cpp
rename to media/libstagefright/foundation/MetaDataBase.cpp
diff --git a/media/libstagefright/httplive/Android.bp b/media/libstagefright/httplive/Android.bp
index c4a072b..c0ee14e 100644
--- a/media/libstagefright/httplive/Android.bp
+++ b/media/libstagefright/httplive/Android.bp
@@ -32,7 +32,6 @@
"libcrypto",
"libcutils",
"libmedia",
- "libmediaextractor",
"libmediandk",
"libstagefright",
"libstagefright_foundation",
diff --git a/media/libmediaextractor/include/media/DataSource.h b/media/libstagefright/include/media/stagefright/DataSource.h
similarity index 100%
rename from media/libmediaextractor/include/media/DataSource.h
rename to media/libstagefright/include/media/stagefright/DataSource.h
diff --git a/media/libmediaextractor/include/media/DataSourceBase.h b/media/libstagefright/include/media/stagefright/DataSourceBase.h
similarity index 100%
rename from media/libmediaextractor/include/media/DataSourceBase.h
rename to media/libstagefright/include/media/stagefright/DataSourceBase.h
diff --git a/media/libstagefright/include/media/stagefright/MediaBuffer.h b/media/libstagefright/include/media/stagefright/MediaBuffer.h
deleted file mode 120000
index 1d49c1a..0000000
--- a/media/libstagefright/include/media/stagefright/MediaBuffer.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../libmediaextractor/include/media/stagefright/MediaBuffer.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/stagefright/MediaBuffer.h b/media/libstagefright/include/media/stagefright/MediaBuffer.h
similarity index 100%
rename from media/libmediaextractor/include/media/stagefright/MediaBuffer.h
rename to media/libstagefright/include/media/stagefright/MediaBuffer.h
diff --git a/media/libstagefright/include/media/stagefright/MediaBufferBase.h b/media/libstagefright/include/media/stagefright/MediaBufferBase.h
deleted file mode 120000
index 80e49b0..0000000
--- a/media/libstagefright/include/media/stagefright/MediaBufferBase.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../libmediaextractor/include/media/stagefright/MediaBufferBase.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/stagefright/MediaBufferBase.h b/media/libstagefright/include/media/stagefright/MediaBufferBase.h
similarity index 100%
rename from media/libmediaextractor/include/media/stagefright/MediaBufferBase.h
rename to media/libstagefright/include/media/stagefright/MediaBufferBase.h
diff --git a/media/libstagefright/include/media/stagefright/MediaBufferGroup.h b/media/libstagefright/include/media/stagefright/MediaBufferGroup.h
deleted file mode 120000
index 009b3d9..0000000
--- a/media/libstagefright/include/media/stagefright/MediaBufferGroup.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../libmediaextractor/include/media/stagefright/MediaBufferGroup.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h b/media/libstagefright/include/media/stagefright/MediaBufferGroup.h
similarity index 100%
rename from media/libmediaextractor/include/media/stagefright/MediaBufferGroup.h
rename to media/libstagefright/include/media/stagefright/MediaBufferGroup.h
diff --git a/media/libstagefright/include/media/stagefright/MediaCodecConstants.h b/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
index 984c23d..c06c288 100644
--- a/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
+++ b/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
@@ -31,6 +31,21 @@
constexpr int32_t AVCProfileConstrainedBaseline = 0x10000;
constexpr int32_t AVCProfileConstrainedHigh = 0x80000;
+inline static const char *asString_AVCProfile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case AVCProfileBaseline: return "Baseline";
+ case AVCProfileMain: return "Main";
+ case AVCProfileExtended: return "Extended";
+ case AVCProfileHigh: return "High";
+ case AVCProfileHigh10: return "High10";
+ case AVCProfileHigh422: return "High422";
+ case AVCProfileHigh444: return "High444";
+ case AVCProfileConstrainedBaseline: return "ConstrainedBaseline";
+ case AVCProfileConstrainedHigh: return "ConstrainedHigh";
+ default: return def;
+ }
+}
+
constexpr int32_t AVCLevel1 = 0x01;
constexpr int32_t AVCLevel1b = 0x02;
constexpr int32_t AVCLevel11 = 0x04;
@@ -48,6 +63,35 @@
constexpr int32_t AVCLevel5 = 0x4000;
constexpr int32_t AVCLevel51 = 0x8000;
constexpr int32_t AVCLevel52 = 0x10000;
+constexpr int32_t AVCLevel6 = 0x20000;
+constexpr int32_t AVCLevel61 = 0x40000;
+constexpr int32_t AVCLevel62 = 0x80000;
+
+inline static const char *asString_AVCLevel(int32_t i, const char *def = "??") {
+ switch (i) {
+ case AVCLevel1: return "1";
+ case AVCLevel1b: return "1b";
+ case AVCLevel11: return "1.1";
+ case AVCLevel12: return "1.2";
+ case AVCLevel13: return "1.3";
+ case AVCLevel2: return "2";
+ case AVCLevel21: return "2.1";
+ case AVCLevel22: return "2.2";
+ case AVCLevel3: return "3";
+ case AVCLevel31: return "3.1";
+ case AVCLevel32: return "3.2";
+ case AVCLevel4: return "4";
+ case AVCLevel41: return "4.1";
+ case AVCLevel42: return "4.2";
+ case AVCLevel5: return "5";
+ case AVCLevel51: return "5.1";
+ case AVCLevel52: return "5.2";
+ case AVCLevel6: return "6";
+ case AVCLevel61: return "6.1";
+ case AVCLevel62: return "6.2";
+ default: return def;
+ }
+}
constexpr int32_t H263ProfileBaseline = 0x01;
constexpr int32_t H263ProfileH320Coding = 0x02;
@@ -59,6 +103,21 @@
constexpr int32_t H263ProfileInterlace = 0x80;
constexpr int32_t H263ProfileHighLatency = 0x100;
+inline static const char *asString_H263Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case H263ProfileBaseline: return "Baseline";
+ case H263ProfileH320Coding: return "H320Coding";
+ case H263ProfileBackwardCompatible: return "BackwardCompatible";
+ case H263ProfileISWV2: return "ISWV2";
+ case H263ProfileISWV3: return "ISWV3";
+ case H263ProfileHighCompression: return "HighCompression";
+ case H263ProfileInternet: return "Internet";
+ case H263ProfileInterlace: return "Interlace";
+ case H263ProfileHighLatency: return "HighLatency";
+ default: return def;
+ }
+}
+
constexpr int32_t H263Level10 = 0x01;
constexpr int32_t H263Level20 = 0x02;
constexpr int32_t H263Level30 = 0x04;
@@ -68,6 +127,20 @@
constexpr int32_t H263Level60 = 0x40;
constexpr int32_t H263Level70 = 0x80;
+inline static const char *asString_H263Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case H263Level10: return "10";
+ case H263Level20: return "20";
+ case H263Level30: return "30";
+ case H263Level40: return "40";
+ case H263Level45: return "45";
+ case H263Level50: return "50";
+ case H263Level60: return "60";
+ case H263Level70: return "70";
+ default: return def;
+ }
+}
+
constexpr int32_t MPEG4ProfileSimple = 0x01;
constexpr int32_t MPEG4ProfileSimpleScalable = 0x02;
constexpr int32_t MPEG4ProfileCore = 0x04;
@@ -85,6 +158,28 @@
constexpr int32_t MPEG4ProfileAdvancedScalable = 0x4000;
constexpr int32_t MPEG4ProfileAdvancedSimple = 0x8000;
+inline static const char *asString_MPEG4Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case MPEG4ProfileSimple: return "Simple";
+ case MPEG4ProfileSimpleScalable: return "SimpleScalable";
+ case MPEG4ProfileCore: return "Core";
+ case MPEG4ProfileMain: return "Main";
+ case MPEG4ProfileNbit: return "Nbit";
+ case MPEG4ProfileScalableTexture: return "ScalableTexture";
+ case MPEG4ProfileSimpleFace: return "SimpleFace";
+ case MPEG4ProfileSimpleFBA: return "SimpleFBA";
+ case MPEG4ProfileBasicAnimated: return "BasicAnimated";
+ case MPEG4ProfileHybrid: return "Hybrid";
+ case MPEG4ProfileAdvancedRealTime: return "AdvancedRealTime";
+ case MPEG4ProfileCoreScalable: return "CoreScalable";
+ case MPEG4ProfileAdvancedCoding: return "AdvancedCoding";
+ case MPEG4ProfileAdvancedCore: return "AdvancedCore";
+ case MPEG4ProfileAdvancedScalable: return "AdvancedScalable";
+ case MPEG4ProfileAdvancedSimple: return "AdvancedSimple";
+ default: return def;
+ }
+}
+
constexpr int32_t MPEG4Level0 = 0x01;
constexpr int32_t MPEG4Level0b = 0x02;
constexpr int32_t MPEG4Level1 = 0x04;
@@ -96,6 +191,22 @@
constexpr int32_t MPEG4Level5 = 0x80;
constexpr int32_t MPEG4Level6 = 0x100;
+inline static const char *asString_MPEG4Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case MPEG4Level0: return "0";
+ case MPEG4Level0b: return "0b";
+ case MPEG4Level1: return "1";
+ case MPEG4Level2: return "2";
+ case MPEG4Level3: return "3";
+ case MPEG4Level3b: return "3b";
+ case MPEG4Level4: return "4";
+ case MPEG4Level4a: return "4a";
+ case MPEG4Level5: return "5";
+ case MPEG4Level6: return "6";
+ default: return def;
+ }
+}
+
constexpr int32_t MPEG2ProfileSimple = 0x00;
constexpr int32_t MPEG2ProfileMain = 0x01;
constexpr int32_t MPEG2Profile422 = 0x02;
@@ -103,12 +214,35 @@
constexpr int32_t MPEG2ProfileSpatial = 0x04;
constexpr int32_t MPEG2ProfileHigh = 0x05;
+inline static const char *asString_MPEG2Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case MPEG2ProfileSimple: return "Simple";
+ case MPEG2ProfileMain: return "Main";
+ case MPEG2Profile422: return "422";
+ case MPEG2ProfileSNR: return "SNR";
+ case MPEG2ProfileSpatial: return "Spatial";
+ case MPEG2ProfileHigh: return "High";
+ default: return def;
+ }
+}
+
constexpr int32_t MPEG2LevelLL = 0x00;
constexpr int32_t MPEG2LevelML = 0x01;
constexpr int32_t MPEG2LevelH14 = 0x02;
constexpr int32_t MPEG2LevelHL = 0x03;
constexpr int32_t MPEG2LevelHP = 0x04;
+inline static const char *asString_MPEG2Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case MPEG2LevelLL: return "LL";
+ case MPEG2LevelML: return "ML";
+ case MPEG2LevelH14: return "H14";
+ case MPEG2LevelHL: return "HL";
+ case MPEG2LevelHP: return "HP";
+ default: return def;
+ }
+}
+
constexpr int32_t AACObjectMain = 1;
constexpr int32_t AACObjectLC = 2;
constexpr int32_t AACObjectSSR = 3;
@@ -122,13 +256,48 @@
constexpr int32_t AACObjectELD = 39;
constexpr int32_t AACObjectXHE = 42;
+inline static const char *asString_AACObject(int32_t i, const char *def = "??") {
+ switch (i) {
+ case AACObjectMain: return "Main";
+ case AACObjectLC: return "LC";
+ case AACObjectSSR: return "SSR";
+ case AACObjectLTP: return "LTP";
+ case AACObjectHE: return "HE";
+ case AACObjectScalable: return "Scalable";
+ case AACObjectERLC: return "ERLC";
+ case AACObjectERScalable: return "ERScalable";
+ case AACObjectLD: return "LD";
+ case AACObjectHE_PS: return "HE_PS";
+ case AACObjectELD: return "ELD";
+ case AACObjectXHE: return "XHE";
+ default: return def;
+ }
+}
+
constexpr int32_t VP8Level_Version0 = 0x01;
constexpr int32_t VP8Level_Version1 = 0x02;
constexpr int32_t VP8Level_Version2 = 0x04;
constexpr int32_t VP8Level_Version3 = 0x08;
+inline static const char *asString_VP8Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case VP8Level_Version0: return "V0";
+ case VP8Level_Version1: return "V1";
+ case VP8Level_Version2: return "V2";
+ case VP8Level_Version3: return "V3";
+ default: return def;
+ }
+}
+
constexpr int32_t VP8ProfileMain = 0x01;
+inline static const char *asString_VP8Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case VP8ProfileMain: return "Main";
+ default: return def;
+ }
+}
+
constexpr int32_t VP9Profile0 = 0x01;
constexpr int32_t VP9Profile1 = 0x02;
constexpr int32_t VP9Profile2 = 0x04;
@@ -138,6 +307,20 @@
constexpr int32_t VP9Profile2HDR10Plus = 0x4000;
constexpr int32_t VP9Profile3HDR10Plus = 0x8000;
+inline static const char *asString_VP9Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case VP9Profile0: return "0";
+ case VP9Profile1: return "1";
+ case VP9Profile2: return "2";
+ case VP9Profile3: return "3";
+ case VP9Profile2HDR: return "2HDR";
+ case VP9Profile3HDR: return "3HDR";
+ case VP9Profile2HDR10Plus: return "2HDRPlus";
+ case VP9Profile3HDR10Plus: return "3HDRPlus";
+ default: return def;
+ }
+}
+
constexpr int32_t VP9Level1 = 0x1;
constexpr int32_t VP9Level11 = 0x2;
constexpr int32_t VP9Level2 = 0x4;
@@ -153,10 +336,39 @@
constexpr int32_t VP9Level61 = 0x1000;
constexpr int32_t VP9Level62 = 0x2000;
+inline static const char *asString_VP9Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case VP9Level1: return "1";
+ case VP9Level11: return "1.1";
+ case VP9Level2: return "2";
+ case VP9Level21: return "2.1";
+ case VP9Level3: return "3";
+ case VP9Level31: return "3.1";
+ case VP9Level4: return "4";
+ case VP9Level41: return "4.1";
+ case VP9Level5: return "5";
+ case VP9Level51: return "5.1";
+ case VP9Level52: return "5.2";
+ case VP9Level6: return "6";
+ case VP9Level61: return "6.1";
+ case VP9Level62: return "6.2";
+ default: return def;
+ }
+}
+
constexpr int32_t AV1Profile0 = 0x01;
constexpr int32_t AV1Profile1 = 0x02;
constexpr int32_t AV1Profile2 = 0x04;
+inline static const char *asString_AV1Profile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case AV1Profile0: return "0";
+ case AV1Profile1: return "1";
+ case AV1Profile2: return "2";
+ default: return def;
+ }
+}
+
constexpr int32_t AV1Level2 = 0x1;
constexpr int32_t AV1Level21 = 0x2;
constexpr int32_t AV1Level22 = 0x4;
@@ -182,12 +394,53 @@
constexpr int32_t AV1Level72 = 0x400000;
constexpr int32_t AV1Level73 = 0x800000;
+inline static const char *asString_AV1Level(int32_t i, const char *def = "??") {
+ switch (i) {
+ case AV1Level2: return "2";
+ case AV1Level21: return "2.1";
+ case AV1Level22: return "2.2";
+ case AV1Level23: return "2.3";
+ case AV1Level3: return "3";
+ case AV1Level31: return "3.1";
+ case AV1Level32: return "3.2";
+ case AV1Level33: return "3.3";
+ case AV1Level4: return "4";
+ case AV1Level41: return "4.1";
+ case AV1Level42: return "4.2";
+ case AV1Level43: return "4.3";
+ case AV1Level5: return "5";
+ case AV1Level51: return "5.1";
+ case AV1Level52: return "5.2";
+ case AV1Level53: return "5.3";
+ case AV1Level6: return "6";
+ case AV1Level61: return "6.1";
+ case AV1Level62: return "6.2";
+ case AV1Level63: return "6.3";
+ case AV1Level7: return "7";
+ case AV1Level71: return "7.1";
+ case AV1Level72: return "7.2";
+ case AV1Level73: return "7.3";
+ default: return def;
+ }
+}
+
constexpr int32_t HEVCProfileMain = 0x01;
constexpr int32_t HEVCProfileMain10 = 0x02;
constexpr int32_t HEVCProfileMainStill = 0x04;
constexpr int32_t HEVCProfileMain10HDR10 = 0x1000;
constexpr int32_t HEVCProfileMain10HDR10Plus = 0x2000;
+inline static const char *asString_HEVCProfile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case HEVCProfileMain: return "Main";
+ case HEVCProfileMain10: return "Main10";
+ case HEVCProfileMainStill: return "MainStill";
+ case HEVCProfileMain10HDR10: return "Main10HDR10";
+ case HEVCProfileMain10HDR10Plus: return "Main10HDR10Plus";
+ default: return def;
+ }
+}
+
constexpr int32_t HEVCMainTierLevel1 = 0x1;
constexpr int32_t HEVCHighTierLevel1 = 0x2;
constexpr int32_t HEVCMainTierLevel2 = 0x4;
@@ -215,6 +468,38 @@
constexpr int32_t HEVCMainTierLevel62 = 0x1000000;
constexpr int32_t HEVCHighTierLevel62 = 0x2000000;
+inline static const char *asString_HEVCTierLevel(int32_t i, const char *def = "??") {
+ switch (i) {
+ case HEVCMainTierLevel1: return "Main 1";
+ case HEVCHighTierLevel1: return "High 1";
+ case HEVCMainTierLevel2: return "Main 2";
+ case HEVCHighTierLevel2: return "High 2";
+ case HEVCMainTierLevel21: return "Main 2.1";
+ case HEVCHighTierLevel21: return "High 2.1";
+ case HEVCMainTierLevel3: return "Main 3";
+ case HEVCHighTierLevel3: return "High 3";
+ case HEVCMainTierLevel31: return "Main 3.1";
+ case HEVCHighTierLevel31: return "High 3.1";
+ case HEVCMainTierLevel4: return "Main 4";
+ case HEVCHighTierLevel4: return "High 4";
+ case HEVCMainTierLevel41: return "Main 4.1";
+ case HEVCHighTierLevel41: return "High 4.1";
+ case HEVCMainTierLevel5: return "Main 5";
+ case HEVCHighTierLevel5: return "High 5";
+ case HEVCMainTierLevel51: return "Main 5.1";
+ case HEVCHighTierLevel51: return "High 5.1";
+ case HEVCMainTierLevel52: return "Main 5.2";
+ case HEVCHighTierLevel52: return "High 5.2";
+ case HEVCMainTierLevel6: return "Main 6";
+ case HEVCHighTierLevel6: return "High 6";
+ case HEVCMainTierLevel61: return "Main 6.1";
+ case HEVCHighTierLevel61: return "High 6.1";
+ case HEVCMainTierLevel62: return "Main 6.2";
+ case HEVCHighTierLevel62: return "High 6.2";
+ default: return def;
+ }
+}
+
constexpr int32_t DolbyVisionProfileDvavPer = 0x1;
constexpr int32_t DolbyVisionProfileDvavPen = 0x2;
constexpr int32_t DolbyVisionProfileDvheDer = 0x4;
@@ -226,6 +511,22 @@
constexpr int32_t DolbyVisionProfileDvheSt = 0x100;
constexpr int32_t DolbyVisionProfileDvavSe = 0x200;
+inline static const char *asString_DolbyVisionProfile(int32_t i, const char *def = "??") {
+ switch (i) {
+ case DolbyVisionProfileDvavPer: return "DvavPer";
+ case DolbyVisionProfileDvavPen: return "DvavPen";
+ case DolbyVisionProfileDvheDer: return "DvheDer";
+ case DolbyVisionProfileDvheDen: return "DvheDen";
+ case DolbyVisionProfileDvheDtr: return "DvheDtr";
+ case DolbyVisionProfileDvheStn: return "DvheStn";
+ case DolbyVisionProfileDvheDth: return "DvheDth";
+ case DolbyVisionProfileDvheDtb: return "DvheDtb";
+ case DolbyVisionProfileDvheSt: return "DvheSt";
+ case DolbyVisionProfileDvavSe: return "DvavSe";
+ default: return def;
+ }
+}
+
constexpr int32_t DolbyVisionLevelHd24 = 0x1;
constexpr int32_t DolbyVisionLevelHd30 = 0x2;
constexpr int32_t DolbyVisionLevelFhd24 = 0x4;
@@ -236,10 +537,34 @@
constexpr int32_t DolbyVisionLevelUhd48 = 0x80;
constexpr int32_t DolbyVisionLevelUhd60 = 0x100;
+inline static const char *asString_DolbyVisionLevel(int32_t i, const char *def = "??") {
+ switch (i) {
+ case DolbyVisionLevelHd24: return "Hd24";
+ case DolbyVisionLevelHd30: return "Hd30";
+ case DolbyVisionLevelFhd24: return "Fhd24";
+ case DolbyVisionLevelFhd30: return "Fhd30";
+ case DolbyVisionLevelFhd60: return "Fhd60";
+ case DolbyVisionLevelUhd24: return "Uhd24";
+ case DolbyVisionLevelUhd30: return "Uhd30";
+ case DolbyVisionLevelUhd48: return "Uhd48";
+ case DolbyVisionLevelUhd60: return "Uhd60";
+ default: return def;
+ }
+}
+
constexpr int32_t BITRATE_MODE_CBR = 2;
constexpr int32_t BITRATE_MODE_CQ = 0;
constexpr int32_t BITRATE_MODE_VBR = 1;
+inline static const char *asString_BitrateMode(int32_t i, const char *def = "??") {
+ switch (i) {
+ case BITRATE_MODE_CBR: return "CBR";
+ case BITRATE_MODE_CQ: return "CQ";
+ case BITRATE_MODE_VBR: return "VBR";
+ default: return def;
+ }
+}
+
constexpr int32_t COLOR_Format12bitRGB444 = 3;
constexpr int32_t COLOR_Format16bitARGB1555 = 5;
constexpr int32_t COLOR_Format16bitARGB4444 = 4;
@@ -293,6 +618,64 @@
constexpr int32_t COLOR_QCOM_FormatYUV420SemiPlanar = 0x7fa30c00;
constexpr int32_t COLOR_TI_FormatYUV420PackedSemiPlanar = 0x7f000100;
+inline static const char *asString_ColorFormat(int32_t i, const char *def = "??") {
+ switch (i) {
+ case COLOR_Format12bitRGB444: return "12bitRGB444";
+ case COLOR_Format16bitARGB1555: return "16bitARGB1555";
+ case COLOR_Format16bitARGB4444: return "16bitARGB4444";
+ case COLOR_Format16bitBGR565: return "16bitBGR565";
+ case COLOR_Format16bitRGB565: return "16bitRGB565";
+ case COLOR_Format18bitARGB1665: return "18bitARGB1665";
+ case COLOR_Format18BitBGR666: return "18BitBGR666";
+ case COLOR_Format18bitRGB666: return "18bitRGB666";
+ case COLOR_Format19bitARGB1666: return "19bitARGB1666";
+ case COLOR_Format24BitABGR6666: return "24BitABGR6666";
+ case COLOR_Format24bitARGB1887: return "24bitARGB1887";
+ case COLOR_Format24BitARGB6666: return "24BitARGB6666";
+ case COLOR_Format24bitBGR888: return "24bitBGR888";
+ case COLOR_Format24bitRGB888: return "24bitRGB888";
+ case COLOR_Format25bitARGB1888: return "25bitARGB1888";
+ case COLOR_Format32bitABGR8888: return "32bitABGR8888";
+ case COLOR_Format32bitARGB8888: return "32bitARGB8888";
+ case COLOR_Format32bitBGRA8888: return "32bitBGRA8888";
+ case COLOR_Format8bitRGB332: return "8bitRGB332";
+ case COLOR_FormatCbYCrY: return "CbYCrY";
+ case COLOR_FormatCrYCbY: return "CrYCbY";
+ case COLOR_FormatL16: return "L16";
+ case COLOR_FormatL2: return "L2";
+ case COLOR_FormatL24: return "L24";
+ case COLOR_FormatL32: return "L32";
+ case COLOR_FormatL4: return "L4";
+ case COLOR_FormatL8: return "L8";
+ case COLOR_FormatMonochrome: return "Monochrome";
+ case COLOR_FormatRawBayer10bit: return "RawBayer10bit";
+ case COLOR_FormatRawBayer8bit: return "RawBayer8bit";
+ case COLOR_FormatRawBayer8bitcompressed: return "RawBayer8bitcompressed";
+ case COLOR_FormatRGBAFlexible: return "RGBAFlexible";
+ case COLOR_FormatRGBFlexible: return "RGBFlexible";
+ case COLOR_FormatSurface: return "Surface";
+ case COLOR_FormatYCbYCr: return "YCbYCr";
+ case COLOR_FormatYCrYCb: return "YCrYCb";
+ case COLOR_FormatYUV411PackedPlanar: return "YUV411PackedPlanar";
+ case COLOR_FormatYUV411Planar: return "YUV411Planar";
+ case COLOR_FormatYUV420Flexible: return "YUV420Flexible";
+ case COLOR_FormatYUV420PackedPlanar: return "YUV420PackedPlanar";
+ case COLOR_FormatYUV420PackedSemiPlanar: return "YUV420PackedSemiPlanar";
+ case COLOR_FormatYUV420Planar: return "YUV420Planar";
+ case COLOR_FormatYUV420SemiPlanar: return "YUV420SemiPlanar";
+ case COLOR_FormatYUV422Flexible: return "YUV422Flexible";
+ case COLOR_FormatYUV422PackedPlanar: return "YUV422PackedPlanar";
+ case COLOR_FormatYUV422PackedSemiPlanar: return "YUV422PackedSemiPlanar";
+ case COLOR_FormatYUV422Planar: return "YUV422Planar";
+ case COLOR_FormatYUV422SemiPlanar: return "YUV422SemiPlanar";
+ case COLOR_FormatYUV444Flexible: return "YUV444Flexible";
+ case COLOR_FormatYUV444Interleaved: return "YUV444Interleaved";
+ case COLOR_QCOM_FormatYUV420SemiPlanar: return "QCOM_YUV420SemiPlanar";
+ case COLOR_TI_FormatYUV420PackedSemiPlanar: return "TI_YUV420PackedSemiPlanar";
+ default: return def;
+ }
+}
+
constexpr char FEATURE_AdaptivePlayback[] = "adaptive-playback";
constexpr char FEATURE_IntraRefresh[] = "intra-refresh";
constexpr char FEATURE_PartialFrame[] = "partial-frame";
diff --git a/media/libmediaextractor/include/media/MediaSource.h b/media/libstagefright/include/media/stagefright/MediaSource.h
similarity index 100%
rename from media/libmediaextractor/include/media/MediaSource.h
rename to media/libstagefright/include/media/stagefright/MediaSource.h
diff --git a/media/libstagefright/include/media/stagefright/MetaData.h b/media/libstagefright/include/media/stagefright/MetaData.h
deleted file mode 120000
index 160f8d3..0000000
--- a/media/libstagefright/include/media/stagefright/MetaData.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../libmediaextractor/include/media/stagefright/MetaData.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/stagefright/MetaData.h b/media/libstagefright/include/media/stagefright/MetaData.h
similarity index 100%
rename from media/libmediaextractor/include/media/stagefright/MetaData.h
rename to media/libstagefright/include/media/stagefright/MetaData.h
diff --git a/media/libstagefright/include/media/stagefright/MetaDataBase.h b/media/libstagefright/include/media/stagefright/MetaDataBase.h
deleted file mode 120000
index 1e12193..0000000
--- a/media/libstagefright/include/media/stagefright/MetaDataBase.h
+++ /dev/null
@@ -1 +0,0 @@
-../../../../libmediaextractor/include/media/stagefright/MetaDataBase.h
\ No newline at end of file
diff --git a/media/libmediaextractor/include/media/stagefright/MetaDataBase.h b/media/libstagefright/include/media/stagefright/MetaDataBase.h
similarity index 100%
rename from media/libmediaextractor/include/media/stagefright/MetaDataBase.h
rename to media/libstagefright/include/media/stagefright/MetaDataBase.h
diff --git a/media/libstagefright/omx/1.0/Omx.cpp b/media/libstagefright/omx/1.0/Omx.cpp
index 4e2d398..121bb1a 100644
--- a/media/libstagefright/omx/1.0/Omx.cpp
+++ b/media/libstagefright/omx/1.0/Omx.cpp
@@ -124,11 +124,11 @@
} else {
uint32_t quirks = 0;
for (const auto& quirk : codec->second.quirkSet) {
- if (quirk == "requires-allocate-on-input-ports") {
+ if (quirk == "quirk::requires-allocate-on-input-ports") {
quirks |= OMXNodeInstance::
kRequiresAllocateBufferOnInputPorts;
}
- if (quirk == "requires-allocate-on-output-ports") {
+ if (quirk == "quirk::requires-allocate-on-output-ports") {
quirks |= OMXNodeInstance::
kRequiresAllocateBufferOnOutputPorts;
}
diff --git a/media/libstagefright/omx/tests/Android.bp b/media/libstagefright/omx/tests/Android.bp
index 31bc837..fb03229 100644
--- a/media/libstagefright/omx/tests/Android.bp
+++ b/media/libstagefright/omx/tests/Android.bp
@@ -9,7 +9,6 @@
"libbinder",
"libmedia",
"libmedia_omx",
- "libmediaextractor",
"libutils",
"liblog",
"libstagefright_foundation",
diff --git a/media/libstagefright/xmlparser/MediaCodecsXmlParser.cpp b/media/libstagefright/xmlparser/MediaCodecsXmlParser.cpp
index 2dec9fa..6e541ba 100644
--- a/media/libstagefright/xmlparser/MediaCodecsXmlParser.cpp
+++ b/media/libstagefright/xmlparser/MediaCodecsXmlParser.cpp
@@ -26,8 +26,9 @@
#include <sys/stat.h>
#include <expat.h>
-#include <cctype>
#include <algorithm>
+#include <cctype>
+#include <string>
namespace android {
@@ -326,8 +327,8 @@
case SECTION_DECODER:
case SECTION_ENCODER:
{
- if (strEq(name, "Quirk")) {
- (void)addQuirk(attrs);
+ if (strEq(name, "Quirk") || strEq(name, "Attribute")) {
+ (void)addQuirk(attrs, name);
} else if (strEq(name, "Type")) {
(void)addTypeFromAttributes(attrs,
(mCurrentSection == SECTION_ENCODER));
@@ -348,6 +349,8 @@
if (outside &&
(strEq(name, "Limit") || strEq(name, "Feature"))) {
ALOGW("ignoring %s specified outside of a Type", name);
+ } else if (strEq(name, "Alias")) {
+ (void)addAlias(attrs);
} else if (strEq(name, "Limit")) {
(void)addLimit(attrs);
} else if (strEq(name, "Feature")) {
@@ -579,7 +582,7 @@
return OK;
}
-status_t MediaCodecsXmlParser::addQuirk(const char **attrs) {
+status_t MediaCodecsXmlParser::addQuirk(const char **attrs, const char *tag) {
if (mCurrentCodec == mCodecMap.end()) {
return BAD_VALUE;
}
@@ -606,7 +609,12 @@
return BAD_VALUE;
}
- mCurrentCodec->second.quirkSet.emplace(name);
+ std::string tagString = tag;
+ std::transform(tagString.begin(), tagString.end(), tagString.begin(), ::tolower);
+ tagString.append("::");
+ tagString.append(name);
+ mCurrentCodec->second.quirkSet.emplace(tagString.c_str());
+ ALOGI("adding %s to %s", tagString.c_str(), mCurrentCodec->first.c_str());
return OK;
}
@@ -760,6 +768,7 @@
strEq(a_name, "quality") ||
strEq(a_name, "size") ||
strEq(a_name, "measured-blocks-per-second") ||
+ strHasPrefix(a_name, "performance-point-") ||
strHasPrefix(a_name, "measured-frame-rate-")) {
// "range" is specified in exactly one of the following forms:
// 1) min-max
@@ -964,6 +973,34 @@
return OK;
}
+status_t MediaCodecsXmlParser::addAlias(const char **attrs) {
+ size_t i = 0;
+ const char *name = nullptr;
+
+ while (attrs[i] != nullptr) {
+ if (strEq(attrs[i], "name")) {
+ if (attrs[++i] == nullptr) {
+ ALOGE("addAlias: name is null");
+ return BAD_VALUE;
+ }
+ name = attrs[i];
+ } else {
+ ALOGE("addAlias: unrecognized attribute: %s", attrs[i]);
+ return BAD_VALUE;
+ }
+ ++i;
+ }
+
+ // Every feature must have a name.
+ if (name == nullptr) {
+ ALOGE("alias with no 'name' attribute");
+ return BAD_VALUE;
+ }
+
+ mCurrentCodec->second.aliases.emplace_back(name);
+ return OK;
+}
+
const MediaCodecsXmlParser::AttributeMap&
MediaCodecsXmlParser::getServiceAttributeMap() const {
return mServiceAttributeMap;
@@ -1041,11 +1078,18 @@
NodeInfo nodeInfo;
nodeInfo.name = codecName;
+ // NOTE: no aliases are exposed in role info
+ // attribute quirks are exposed as node attributes
nodeInfo.attributeList.reserve(typeAttributeMap.size());
for (const auto& attribute : typeAttributeMap) {
nodeInfo.attributeList.push_back(
Attribute{attribute.first, attribute.second});
}
+ for (const std::string &quirk : codec.second.quirkSet) {
+ if (strHasPrefix(quirk.c_str(), "attribute::")) {
+ nodeInfo.attributeList.push_back(Attribute{quirk, "present"});
+ }
+ }
nodeList->insert(std::make_pair(
std::move(order), std::move(nodeInfo)));
}
diff --git a/media/libstagefright/xmlparser/include/media/stagefright/xmlparser/MediaCodecsXmlParser.h b/media/libstagefright/xmlparser/include/media/stagefright/xmlparser/MediaCodecsXmlParser.h
index cc69e52..fd949da 100644
--- a/media/libstagefright/xmlparser/include/media/stagefright/xmlparser/MediaCodecsXmlParser.h
+++ b/media/libstagefright/xmlparser/include/media/stagefright/xmlparser/MediaCodecsXmlParser.h
@@ -65,6 +65,7 @@
size_t order; ///< Order of appearance in the file (starting from 0)
QuirkSet quirkSet; ///< Set of quirks requested by this codec
TypeMap typeMap; ///< Map of types supported by this codec
+ std::vector<std::string> aliases; ///< Name aliases for this codec
};
typedef std::pair<std::string, CodecProperties> Codec;
@@ -76,6 +77,7 @@
struct NodeInfo {
std::string name;
std::vector<Attribute> attributeList;
+ // note: aliases are not exposed here as they are not part of the role map
};
/**
@@ -171,8 +173,9 @@
void addMediaCodec(bool encoder, const char *name,
const char *type = nullptr);
- status_t addQuirk(const char **attrs);
+ status_t addQuirk(const char **attrs, const char *tag);
status_t addTypeFromAttributes(const char **attrs, bool encoder);
+ status_t addAlias(const char **attrs);
status_t addLimit(const char **attrs);
status_t addFeature(const char **attrs);
void addType(const char *name);
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 73bd2ca..74754ea 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -78,7 +78,6 @@
"libmedia_omx",
"libmedia_jni",
"libmediadrm",
- "libmediaextractor",
"libstagefright",
"libstagefright_foundation",
"libstagefright_bufferqueue_helper",
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 26f76c0..0d6ef46 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -2379,7 +2379,8 @@
return BAD_VALUE;
}
- sp<ThreadBase> thread = openInput_l(module, input, config, *devices, address, source, flags);
+ sp<ThreadBase> thread = openInput_l(
+ module, input, config, *devices, address, source, flags, AUDIO_DEVICE_NONE, String8{});
if (thread != 0) {
// notify client processes of the new input creation
@@ -2395,7 +2396,9 @@
audio_devices_t devices,
const String8& address,
audio_source_t source,
- audio_input_flags_t flags)
+ audio_input_flags_t flags,
+ audio_devices_t outputDevice,
+ const String8& outputDeviceAddress)
{
AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);
if (inHwDev == NULL) {
@@ -2424,7 +2427,8 @@
sp<DeviceHalInterface> inHwHal = inHwDev->hwDevice();
sp<StreamInHalInterface> inStream;
status_t status = inHwHal->openInputStream(
- *input, devices, &halconfig, flags, address.string(), source, &inStream);
+ *input, devices, &halconfig, flags, address.string(), source,
+ outputDevice, outputDeviceAddress, &inStream);
ALOGV("openInput_l() openInputStream returned input %p, devices %#x, SamplingRate %d"
", Format %#x, Channels %#x, flags %#x, status %d addr %s",
inStream.get(),
@@ -2447,7 +2451,8 @@
ALOGV("openInput_l() reopening with proposed sampling rate and channel mask");
inStream.clear();
status = inHwHal->openInputStream(
- *input, devices, &halconfig, flags, address.string(), source, &inStream);
+ *input, devices, &halconfig, flags, address.string(), source,
+ outputDevice, outputDeviceAddress, &inStream);
// FIXME log this new status; HAL should not propose any further changes
}
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index 6c698f6..c1169d2 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -579,6 +579,10 @@
virtual binder::Status stop();
virtual binder::Status getActiveMicrophones(
std::vector<media::MicrophoneInfo>* activeMicrophones);
+ virtual binder::Status setMicrophoneDirection(
+ int /*audio_microphone_direction_t*/ direction);
+ virtual binder::Status setMicrophoneFieldDimension(float zoom);
+
private:
const sp<RecordThread::RecordTrack> mRecordTrack;
@@ -620,7 +624,9 @@
audio_devices_t device,
const String8& address,
audio_source_t source,
- audio_input_flags_t flags);
+ audio_input_flags_t flags,
+ audio_devices_t outputDevice,
+ const String8& outputDeviceAddress);
sp<ThreadBase> openOutput_l(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t *config,
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index 538a0eb..3381e4d 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -211,6 +211,8 @@
((patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) &&
((patch->sinks[0].ext.device.hw_module != srcModule) ||
!audioHwDevice->supportsAudioPatches()))) {
+ audio_devices_t outputDevice = AUDIO_DEVICE_NONE;
+ String8 outputDeviceAddress;
if (patch->num_sources == 2) {
if (patch->sources[1].type != AUDIO_PORT_TYPE_MIX ||
(patch->num_sinks != 0 && patch->sinks[0].ext.device.hw_module !=
@@ -261,6 +263,8 @@
goto exit;
}
newPatch.mPlayback.setThread(reinterpret_cast<PlaybackThread*>(thread.get()));
+ outputDevice = device;
+ outputDeviceAddress = address;
}
audio_devices_t device = patch->sources[0].ext.device.type;
String8 address = String8(patch->sources[0].ext.device.address);
@@ -293,7 +297,9 @@
device,
address,
AUDIO_SOURCE_MIC,
- flags);
+ flags,
+ outputDevice,
+ outputDeviceAddress);
ALOGV("mAudioFlinger.openInput_l() returned %p inChannelMask %08x",
thread.get(), config.channel_mask);
if (thread == 0) {
@@ -322,6 +328,13 @@
}
}
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
+ // remove stale audio patch with same input as sink if any
+ for (auto& iter : mPatches) {
+ if (iter.second.mAudioPatch.sinks[0].ext.mix.handle == thread->id()) {
+ mPatches.erase(iter.first);
+ break;
+ }
+ }
} else {
sp<DeviceHalInterface> hwDevice = audioHwDevice->hwDevice();
status = hwDevice->createAudioPatch(patch->num_sources,
@@ -376,6 +389,14 @@
}
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
+
+ // remove stale audio patch with same output as source if any
+ for (auto& iter : mPatches) {
+ if (iter.second.mAudioPatch.sources[0].ext.mix.handle == thread->id()) {
+ mPatches.erase(iter.first);
+ break;
+ }
+ }
} break;
default:
status = BAD_VALUE;
diff --git a/services/audioflinger/RecordTracks.h b/services/audioflinger/RecordTracks.h
index 85f5456..32af7d5 100644
--- a/services/audioflinger/RecordTracks.h
+++ b/services/audioflinger/RecordTracks.h
@@ -71,6 +71,9 @@
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t setMicrophoneDirection(audio_microphone_direction_t direction);
+ status_t setMicrophoneFieldDimension(float zoom);
+
static bool checkServerLatencySupported(
audio_format_t format, audio_input_flags_t flags) {
return audio_is_linear_pcm(format)
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 989e6eb..31a8c7d 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -494,6 +494,8 @@
case AUDIO_SOURCE_VOICE_COMMUNICATION: return "voice communication";
case AUDIO_SOURCE_REMOTE_SUBMIX: return "remote submix";
case AUDIO_SOURCE_UNPROCESSED: return "unprocessed";
+ case AUDIO_SOURCE_VOICE_PERFORMANCE: return "voice performance";
+ case AUDIO_SOURCE_ECHO_REFERENCE: return "echo reference";
case AUDIO_SOURCE_FM_TUNER: return "FM tuner";
case AUDIO_SOURCE_HOTWORD: return "hotword";
default: return "unknown";
@@ -7580,6 +7582,20 @@
return status;
}
+status_t AudioFlinger::RecordThread::setMicrophoneDirection(audio_microphone_direction_t direction)
+{
+ ALOGV("RecordThread::setMicrophoneDirection");
+ AutoMutex _l(mLock);
+ return mInput->stream->setMicrophoneDirection(direction);
+}
+
+status_t AudioFlinger::RecordThread::setMicrophoneFieldDimension(float zoom)
+{
+ ALOGV("RecordThread::setMicrophoneFieldDimension");
+ AutoMutex _l(mLock);
+ return mInput->stream->setMicrophoneFieldDimension(zoom);
+}
+
void AudioFlinger::RecordThread::updateMetadata_l()
{
if (mInput == nullptr || mInput->stream == nullptr ||
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index 5d06773..aab7601 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -1545,6 +1545,9 @@
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t setMicrophoneDirection(audio_microphone_direction_t direction);
+ status_t setMicrophoneFieldDimension(float zoom);
+
void updateMetadata_l() override;
bool fastTrackAvailable() const { return mFastTrackAvail; }
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 9a7f1f1..d23d19d 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -1710,6 +1710,18 @@
mRecordTrack->getActiveMicrophones(activeMicrophones));
}
+binder::Status AudioFlinger::RecordHandle::setMicrophoneDirection(
+ int /*audio_microphone_direction_t*/ direction) {
+ ALOGV("%s()", __func__);
+ return binder::Status::fromStatusT(mRecordTrack->setMicrophoneDirection(
+ static_cast<audio_microphone_direction_t>(direction)));
+}
+
+binder::Status AudioFlinger::RecordHandle::setMicrophoneFieldDimension(float zoom) {
+ ALOGV("%s()", __func__);
+ return binder::Status::fromStatusT(mRecordTrack->setMicrophoneFieldDimension(zoom));
+}
+
// ----------------------------------------------------------------------------
#undef LOG_TAG
#define LOG_TAG "AF::RecordTrack"
@@ -2004,6 +2016,27 @@
}
}
+status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneDirection(
+ audio_microphone_direction_t direction) {
+ sp<ThreadBase> thread = mThread.promote();
+ if (thread != 0) {
+ RecordThread *recordThread = (RecordThread *)thread.get();
+ return recordThread->setMicrophoneDirection(direction);
+ } else {
+ return BAD_VALUE;
+ }
+}
+
+status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneFieldDimension(float zoom) {
+ sp<ThreadBase> thread = mThread.promote();
+ if (thread != 0) {
+ RecordThread *recordThread = (RecordThread *)thread.get();
+ return recordThread->setMicrophoneFieldDimension(zoom);
+ } else {
+ return BAD_VALUE;
+ }
+}
+
// ----------------------------------------------------------------------------
#undef LOG_TAG
#define LOG_TAG "AF::PatchRecord"
diff --git a/services/audiopolicy/TEST_MAPPING b/services/audiopolicy/TEST_MAPPING
new file mode 100644
index 0000000..a94fd87
--- /dev/null
+++ b/services/audiopolicy/TEST_MAPPING
@@ -0,0 +1,10 @@
+{
+ "presubmit": [
+ {
+ "name": "audiopolicy_tests"
+ },
+ {
+ "name": "systemaudio_tests"
+ }
+ ]
+}
diff --git a/services/audiopolicy/common/include/policy.h b/services/audiopolicy/common/include/policy.h
index 30b0044..46a2a40 100644
--- a/services/audiopolicy/common/include/policy.h
+++ b/services/audiopolicy/common/include/policy.h
@@ -83,7 +83,10 @@
* @param[in] inputSource to consider. Valid sources are:
* - AUDIO_SOURCE_VOICE_COMMUNICATION
* - AUDIO_SOURCE_CAMCORDER
+ * - AUDIO_SOURCE_VOICE_PERFORMANCE
+ * - AUDIO_SOURCE_UNPROCESSED
* - AUDIO_SOURCE_MIC
+ * - AUDIO_SOURCE_ECHO_REFERENCE
* - AUDIO_SOURCE_FM_TUNER
* - AUDIO_SOURCE_VOICE_RECOGNITION
* - AUDIO_SOURCE_HOTWORD
@@ -96,10 +99,16 @@
{
switch (inputSource) {
case AUDIO_SOURCE_VOICE_COMMUNICATION:
- return 6;
+ return 9;
case AUDIO_SOURCE_CAMCORDER:
- return 5;
+ return 8;
+ case AUDIO_SOURCE_VOICE_PERFORMANCE:
+ return 7;
+ case AUDIO_SOURCE_UNPROCESSED:
+ return 6;
case AUDIO_SOURCE_MIC:
+ return 5;
+ case AUDIO_SOURCE_ECHO_REFERENCE:
return 4;
case AUDIO_SOURCE_FM_TUNER:
return 3;
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h
index fa9ba0b..d4cfd1e 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h
@@ -23,11 +23,12 @@
#include "AudioIODescriptorInterface.h"
#include "AudioPort.h"
#include "ClientDescriptor.h"
+#include "DeviceDescriptor.h"
#include "EffectDescriptor.h"
+#include "IOProfile.h"
namespace android {
-class IOProfile;
class AudioMix;
class AudioPolicyClientInterface;
@@ -42,10 +43,16 @@
audio_port_handle_t getId() const;
audio_module_handle_t getModuleHandle() const;
+ audio_devices_t getDeviceType() const { return (mDevice != nullptr) ?
+ mDevice->type() : AUDIO_DEVICE_NONE; }
+ sp<DeviceDescriptor> getDevice() const { return mDevice; }
+ void setDevice(const sp<DeviceDescriptor> &device) { mDevice = device; }
+ DeviceVector supportedDevices() const {
+ return mProfile != nullptr ? mProfile->getSupportedDevices() : DeviceVector(); }
+
void dump(String8 *dst) const override;
audio_io_handle_t mIoHandle = AUDIO_IO_HANDLE_NONE; // input handle
- audio_devices_t mDevice = AUDIO_DEVICE_NONE; // current device this input is routed to
AudioMix *mPolicyMix = nullptr; // non NULL when used by a dynamic policy
const sp<IOProfile> mProfile; // I/O profile this output derives from
@@ -61,6 +68,7 @@
bool isSourceActive(audio_source_t source) const;
audio_source_t source() const;
bool isSoundTrigger() const;
+ audio_attributes_t getHighestPriorityAttributes() const;
void setClientActive(const sp<RecordClientDescriptor>& client, bool active);
int32_t activeCount() { return mGlobalActiveCount; }
void trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled);
@@ -71,8 +79,7 @@
void setPatchHandle(audio_patch_handle_t handle) override;
status_t open(const audio_config_t *config,
- audio_devices_t device,
- const String8& address,
+ const sp<DeviceDescriptor> &device,
audio_source_t source,
audio_input_flags_t flags,
audio_io_handle_t *input);
@@ -99,6 +106,8 @@
audio_patch_handle_t mPatchHandle = AUDIO_PATCH_HANDLE_NONE;
audio_port_handle_t mId = AUDIO_PORT_HANDLE_NONE;
+ sp<DeviceDescriptor> mDevice = nullptr; /**< current device this input is routed to */
+
// Because a preemptible capture session can preempt another one, we end up in an endless loop
// situation were each session is allowed to restart after being preempted,
// thus preempting the other one which restarts and so on.
@@ -120,8 +129,8 @@
sp<AudioInputDescriptor> getInputFromId(audio_port_handle_t id) const;
// count active capture sessions using one of the specified devices.
- // ignore devices if AUDIO_DEVICE_IN_DEFAULT is passed
- uint32_t activeInputsCountOnDevices(audio_devices_t devices = AUDIO_DEVICE_IN_DEFAULT) const;
+ // ignore devices if empty vector is passed
+ uint32_t activeInputsCountOnDevices(const DeviceVector &devices) const;
/**
* return io handle of active input or 0 if no input is active
@@ -130,8 +139,6 @@
*/
Vector<sp <AudioInputDescriptor> > getActiveInputs();
- audio_devices_t getSupportedDevices(audio_io_handle_t handle) const;
-
sp<AudioInputDescriptor> getInputForClient(audio_port_handle_t portId);
void trackEffectEnabled(const sp<EffectDescriptor> &effect, bool enabled);
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
index ed995e0..14b995b 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
@@ -26,13 +26,14 @@
#include "AudioIODescriptorInterface.h"
#include "AudioPort.h"
#include "ClientDescriptor.h"
+#include "DeviceDescriptor.h"
+#include <map>
namespace android {
class IOProfile;
class AudioMix;
class AudioPolicyClientInterface;
-class DeviceDescriptor;
// descriptor for audio outputs. Used to maintain current configuration of each opened audio output
// and keep track of the usage of this output by each audio stream type.
@@ -48,14 +49,12 @@
void log(const char* indent);
audio_port_handle_t getId() const;
- virtual audio_devices_t device() const;
- virtual bool sharesHwModuleWith(const sp<AudioOutputDescriptor>& outputDesc);
- virtual audio_devices_t supportedDevices();
+ virtual DeviceVector devices() const { return mDevices; }
+ bool sharesHwModuleWith(const sp<AudioOutputDescriptor>& outputDesc);
+ virtual DeviceVector supportedDevices() const { return mDevices; }
virtual bool isDuplicated() const { return false; }
virtual uint32_t latency() { return 0; }
virtual bool isFixedVolume(audio_devices_t device);
- virtual sp<AudioOutputDescriptor> subOutput1() { return 0; }
- virtual sp<AudioOutputDescriptor> subOutput2() { return 0; }
virtual bool setVolume(float volume,
audio_stream_type_t stream,
audio_devices_t device,
@@ -119,7 +118,7 @@
return mActiveClients;
}
- audio_devices_t mDevice = AUDIO_DEVICE_NONE; // current device this output is routed to
+ DeviceVector mDevices; /**< current devices this output is routed to */
nsecs_t mStopTime[AUDIO_STREAM_CNT];
int mMuteCount[AUDIO_STREAM_CNT]; // mute request counter
bool mStrategyMutedByDevice[NUM_STRATEGIES]; // strategies muted because of incompatible
@@ -151,14 +150,15 @@
virtual ~SwAudioOutputDescriptor() {}
void dump(String8 *dst) const override;
- virtual audio_devices_t device() const;
- virtual bool sharesHwModuleWith(const sp<AudioOutputDescriptor>& outputDesc);
- virtual audio_devices_t supportedDevices();
+ virtual DeviceVector devices() const;
+ void setDevices(const DeviceVector &devices) { mDevices = devices; }
+ bool sharesHwModuleWith(const sp<SwAudioOutputDescriptor>& outputDesc);
+ virtual DeviceVector supportedDevices() const;
virtual uint32_t latency();
virtual bool isDuplicated() const { return (mOutput1 != NULL && mOutput2 != NULL); }
virtual bool isFixedVolume(audio_devices_t device);
- virtual sp<AudioOutputDescriptor> subOutput1() { return mOutput1; }
- virtual sp<AudioOutputDescriptor> subOutput2() { return mOutput2; }
+ sp<SwAudioOutputDescriptor> subOutput1() { return mOutput1; }
+ sp<SwAudioOutputDescriptor> subOutput2() { return mOutput2; }
void changeStreamActiveCount(
const sp<TrackClientDescriptor>& client, int delta) override;
virtual bool setVolume(float volume,
@@ -171,22 +171,49 @@
const struct audio_port_config *srcConfig = NULL) const;
virtual void toAudioPort(struct audio_port *port) const;
- status_t open(const audio_config_t *config,
- audio_devices_t device,
- const String8& address,
- audio_stream_type_t stream,
- audio_output_flags_t flags,
- audio_io_handle_t *output);
- // Called when a stream is about to be started
- // Note: called before setClientActive(true);
- status_t start();
- // Called after a stream is stopped.
- // Note: called after setClientActive(false);
- void stop();
- void close();
- status_t openDuplicating(const sp<SwAudioOutputDescriptor>& output1,
- const sp<SwAudioOutputDescriptor>& output2,
- audio_io_handle_t *ioHandle);
+ status_t open(const audio_config_t *config,
+ const DeviceVector &devices,
+ audio_stream_type_t stream,
+ audio_output_flags_t flags,
+ audio_io_handle_t *output);
+
+ // Called when a stream is about to be started
+ // Note: called before setClientActive(true);
+ status_t start();
+ // Called after a stream is stopped.
+ // Note: called after setClientActive(false);
+ void stop();
+ void close();
+ status_t openDuplicating(const sp<SwAudioOutputDescriptor>& output1,
+ const sp<SwAudioOutputDescriptor>& output2,
+ audio_io_handle_t *ioHandle);
+
+ /**
+ * @brief supportsDevice
+ * @param device to be checked against
+ * @return true if the device is supported by type (for non bus / remote submix devices),
+ * true if the device is supported (both type and address) for bus / remote submix
+ * false otherwise
+ */
+ bool supportsDevice(const sp<DeviceDescriptor> &device) const;
+
+ /**
+ * @brief supportsAllDevices
+ * @param devices to be checked against
+ * @return true if the device is weakly supported by type (e.g. for non bus / rsubmix devices),
+ * true if the device is supported (both type and address) for bus / remote submix
+ * false otherwise
+ */
+ bool supportsAllDevices(const DeviceVector &devices) const;
+
+ /**
+ * @brief filterSupportedDevices takes a vector of devices and filters them according to the
+ * device supported by this output (the profile from which this output derives from)
+ * @param devices reference device vector to be filtered
+ * @return vector of devices filtered from the supported devices of this output (weakly or not
+ * depending on the device type)
+ */
+ DeviceVector filterSupportedDevices(const DeviceVector &devices) const;
const sp<IOProfile> mProfile; // I/O profile this output derives from
audio_io_handle_t mIoHandle; // output handle
@@ -208,7 +235,6 @@
void dump(String8 *dst) const override;
- virtual audio_devices_t supportedDevices();
virtual bool setVolume(float volume,
audio_stream_type_t stream,
audio_devices_t device,
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioPolicyMix.h b/services/audiopolicy/common/managerdefinitions/include/AudioPolicyMix.h
index 955e87b..e6a62d9 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioPolicyMix.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioPolicyMix.h
@@ -16,6 +16,7 @@
#pragma once
+#include "DeviceDescriptor.h"
#include <utils/RefBase.h>
#include <media/AudioPolicy.h>
#include <utils/KeyedVector.h>
@@ -74,9 +75,9 @@
status_t getOutputForAttr(audio_attributes_t attributes, uid_t uid,
sp<SwAudioOutputDescriptor> &desc);
- audio_devices_t getDeviceAndMixForInputSource(audio_source_t inputSource,
- audio_devices_t availableDeviceTypes,
- AudioMix **policyMix);
+ sp<DeviceDescriptor> getDeviceAndMixForInputSource(audio_source_t inputSource,
+ const DeviceVector &availableDeviceTypes,
+ AudioMix **policyMix);
status_t getInputMixForAttr(audio_attributes_t attr, AudioMix **policyMix);
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioPort.h b/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
index bb9cad8..1b5a2d6 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
@@ -65,6 +65,7 @@
uint32_t getFlags() const { return mFlags; }
virtual void attach(const sp<HwModule>& module);
+ virtual void detach();
bool isAttached() { return mModule != 0; }
// Audio port IDs are in a different namespace than AudioFlinger unique IDs
@@ -161,7 +162,7 @@
const struct audio_port_config *srcConfig = NULL) const = 0;
virtual sp<AudioPort> getAudioPort() const = 0;
virtual bool hasSameHwModuleAs(const sp<AudioPortConfig>& other) const {
- return (other != 0) &&
+ return (other != 0) && (other->getAudioPort() != 0) && (getAudioPort() != 0) &&
(other->getAudioPort()->getModuleHandle() == getAudioPort()->getModuleHandle());
}
unsigned int mSamplingRate = 0u;
diff --git a/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
index d02123c..b581665 100644
--- a/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/DeviceDescriptor.h
@@ -53,6 +53,8 @@
// AudioPort
virtual void attach(const sp<HwModule>& module);
+ virtual void detach();
+
virtual void toAudioPort(struct audio_port *port) const;
virtual void importAudioPort(const sp<AudioPort>& port, bool force = false);
@@ -164,6 +166,23 @@
return !operator==(right);
}
+ /**
+ * @brief getFirstValidAddress
+ * @return the first valid address of a list of device, "" if no device with valid address
+ * found.
+ * This helper function helps maintaining compatibility with legacy where we used to have a
+ * devices mask and an address.
+ */
+ String8 getFirstValidAddress() const
+ {
+ for (const auto &device : *this) {
+ if (device->address() != "") {
+ return device->address();
+ }
+ }
+ return String8("");
+ }
+
std::string toString() const;
void dump(String8 *dst, const String8 &tag, int spaces = 0, bool verbose = true) const;
diff --git a/services/audiopolicy/common/managerdefinitions/include/HwModule.h b/services/audiopolicy/common/managerdefinitions/include/HwModule.h
index 2b57fa9..d7dc4b0 100644
--- a/services/audiopolicy/common/managerdefinitions/include/HwModule.h
+++ b/services/audiopolicy/common/managerdefinitions/include/HwModule.h
@@ -46,6 +46,22 @@
const DeviceVector &getDeclaredDevices() const { return mDeclaredDevices; }
void setDeclaredDevices(const DeviceVector &devices);
+ DeviceVector getAllDevices() const
+ {
+ DeviceVector devices = mDeclaredDevices;
+ devices.merge(mDynamicDevices);
+ return devices;
+ }
+ void addDynamicDevice(const sp<DeviceDescriptor> &device)
+ {
+ mDynamicDevices.add(device);
+ }
+
+ bool removeDynamicDevice(const sp<DeviceDescriptor> &device)
+ {
+ return mDynamicDevices.remove(device) >= 0;
+ }
+ DeviceVector getDynamicDevices() const { return mDynamicDevices; }
const InputProfileCollection &getInputProfiles() const { return mInputProfiles; }
const OutputProfileCollection &getOutputProfiles() const { return mOutputProfiles; }
@@ -104,6 +120,7 @@
InputProfileCollection mInputProfiles; // input profiles exposed by this module
uint32_t mHalVersion; // audio HAL API version
DeviceVector mDeclaredDevices; // devices declared in audio_policy configuration file.
+ DeviceVector mDynamicDevices; /**< devices that can be added/removed at runtime (e.g. rsbumix)*/
AudioRouteVector mRoutes;
AudioPortVector mPorts;
};
@@ -113,13 +130,58 @@
public:
sp<HwModule> getModuleFromName(const char *name) const;
- sp<HwModule> getModuleForDevice(audio_devices_t device) const;
+ sp<HwModule> getModuleForDeviceTypes(audio_devices_t device) const;
- sp<DeviceDescriptor> getDeviceDescriptor(const audio_devices_t device,
- const char *device_address,
- const char *device_name,
+ sp<HwModule> getModuleForDevice(const sp<DeviceDescriptor> &device) const;
+
+ DeviceVector getAvailableDevicesFromModuleName(const char *name,
+ const DeviceVector &availableDevices) const;
+
+ /**
+ * @brief getDeviceDescriptor returns a device descriptor associated to the device type and
+ * device address (if matchAddress is true).
+ * It may loop twice on all modules to check if allowToCreate is true
+ * -first loop will check if the device is found on a module since declared in the list
+ * of device port in configuration file
+ * -(allowToCreate is true)second loop will check if the device is weakly supported by one
+ * or more profiles on a given module and will add as a supported device for this module.
+ * The device will also be added to the dynamic list of device of this module
+ * @param type of the device requested
+ * @param address of the device requested
+ * @param name of the device that requested
+ * @param matchAddress true if a strong match is required
+ * @param allowToCreate true if allowed to create dynamic device (e.g. hdmi, usb...)
+ * @return device descriptor associated to the type (and address if matchAddress is true)
+ */
+ sp<DeviceDescriptor> getDeviceDescriptor(const audio_devices_t type,
+ const char *address,
+ const char *name,
+ bool allowToCreate = false,
bool matchAddress = true) const;
+ /**
+ * @brief createDevice creates a new device from the type and address given. It checks that
+ * according to the device type, a module is supporting this device (weak check).
+ * This concerns only dynamic device, aka device with a specific address and not
+ * already supported by module/underlying profiles.
+ * @param type of the device to be created
+ * @param address of the device to be created
+ * @param name of the device to be created
+ * @return device descriptor if a module is supporting this type, nullptr otherwise.
+ */
+ sp<DeviceDescriptor> createDevice(const audio_devices_t type,
+ const char *address,
+ const char *name) const;
+
+ /**
+ * @brief cleanUpForDevice: loop on all profiles of all modules to remove device from
+ * the list of supported device. If this device is a dynamic device (aka a device not in the
+ * xml file with a runtime address), it is also removed from the module collection of dynamic
+ * devices.
+ * @param device that has been disconnected
+ */
+ void cleanUpForDevice(const sp<DeviceDescriptor> &device);
+
void dump(String8 *dst) const;
};
diff --git a/services/audiopolicy/common/managerdefinitions/include/IOProfile.h b/services/audiopolicy/common/managerdefinitions/include/IOProfile.h
index ca6ca56..d0c05a5 100644
--- a/services/audiopolicy/common/managerdefinitions/include/IOProfile.h
+++ b/services/audiopolicy/common/managerdefinitions/include/IOProfile.h
@@ -57,12 +57,25 @@
}
}
- // This method is used for input and direct output, and is not used for other output.
- // If parameter updatedSamplingRate is non-NULL, it is assigned the actual sample rate.
- // For input, flags is interpreted as audio_input_flags_t.
- // TODO: merge audio_output_flags_t and audio_input_flags_t.
- bool isCompatibleProfile(audio_devices_t device,
- const String8& address,
+ /**
+ * @brief isCompatibleProfile: This method is used for input and direct output,
+ * and is not used for other output.
+ * Checks if the IO profile is compatible with specified parameters.
+ * For input, flags is interpreted as audio_input_flags_t.
+ * TODO: merge audio_output_flags_t and audio_input_flags_t.
+ *
+ * @param devices vector of devices to be checked for compatibility
+ * @param samplingRate to be checked for compatibility. Must be specified
+ * @param updatedSamplingRate if non-NULL, it is assigned the actual sample rate.
+ * @param format to be checked for compatibility. Must be specified
+ * @param updatedFormat if non-NULL, it is assigned the actual format
+ * @param channelMask to be checked for compatibility. Must be specified
+ * @param updatedChannelMask if non-NULL, it is assigned the actual channel mask
+ * @param flags to be checked for compatibility
+ * @param exactMatchRequiredForInputFlags true if exact match is required on flags
+ * @return true if the profile is compatible, false otherwise.
+ */
+ bool isCompatibleProfile(const DeviceVector &devices,
uint32_t samplingRate,
uint32_t *updatedSamplingRate,
audio_format_t format,
@@ -78,7 +91,7 @@
bool hasSupportedDevices() const { return !mSupportedDevices.isEmpty(); }
- bool supportDevice(audio_devices_t device) const
+ bool supportsDeviceTypes(audio_devices_t device) const
{
if (audio_is_output_devices(device)) {
return mSupportedDevices.types() & device;
@@ -86,41 +99,37 @@
return mSupportedDevices.types() & (device & ~AUDIO_DEVICE_BIT_IN);
}
- bool supportDeviceAddress(const String8 &address) const
+ /**
+ * @brief supportsDevice
+ * @param device to be checked against
+ * forceCheckOnAddress if true, check on type and address whatever the type, otherwise
+ * the address enforcement is limited to "offical devices" that distinguishe on address
+ * @return true if the device is supported by type (for non bus / remote submix devices),
+ * true if the device is supported (both type and address) for bus / remote submix
+ * false otherwise
+ */
+ bool supportsDevice(const sp<DeviceDescriptor> &device, bool forceCheckOnAddress = false) const
{
- return mSupportedDevices[0]->address() == address;
- }
-
- // chose first device present in mSupportedDevices also part of deviceType
- audio_devices_t getSupportedDeviceForType(audio_devices_t deviceType) const
- {
- for (size_t k = 0; k < mSupportedDevices.size(); k++) {
- audio_devices_t profileType = mSupportedDevices[k]->type();
- if (profileType & deviceType) {
- return profileType;
- }
+ if (!device_distinguishes_on_address(device->type()) && !forceCheckOnAddress) {
+ return supportsDeviceTypes(device->type());
}
- return AUDIO_DEVICE_NONE;
+ return mSupportedDevices.contains(device);
}
- audio_devices_t getSupportedDevicesType() const { return mSupportedDevices.types(); }
-
void clearSupportedDevices() { mSupportedDevices.clear(); }
void addSupportedDevice(const sp<DeviceDescriptor> &device)
{
mSupportedDevices.add(device);
}
-
+ void removeSupportedDevice(const sp<DeviceDescriptor> &device)
+ {
+ mSupportedDevices.remove(device);
+ }
void setSupportedDevices(const DeviceVector &devices)
{
mSupportedDevices = devices;
}
- sp<DeviceDescriptor> getSupportedDeviceByAddress(audio_devices_t type, String8 address) const
- {
- return mSupportedDevices.getDevice(type, address);
- }
-
const DeviceVector &getSupportedDevices() const { return mSupportedDevices; }
bool canOpenNewIo() {
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
index 0bc88a5..55d4db4 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
@@ -21,7 +21,6 @@
#include <policy.h>
#include <AudioPolicyInterface.h>
#include "AudioInputDescriptor.h"
-#include "IOProfile.h"
#include "AudioGain.h"
#include "HwModule.h"
@@ -55,30 +54,7 @@
audio_source_t AudioInputDescriptor::source() const
{
- audio_source_t source = AUDIO_SOURCE_DEFAULT;
-
- for (bool activeOnly : { true, false }) {
- int32_t topPriority = -1;
- app_state_t topState = APP_STATE_IDLE;
- for (const auto &client : getClientIterable()) {
- if (activeOnly && !client->active()) {
- continue;
- }
- app_state_t curState = client->appState();
- if (curState >= topState) {
- int32_t curPriority = source_priority(client->source());
- if (curPriority > topPriority) {
- source = client->source();
- topPriority = curPriority;
- }
- topState = curState;
- }
- }
- if (source != AUDIO_SOURCE_DEFAULT) {
- break;
- }
- }
- return source;
+ return getHighestPriorityAttributes().source;
}
void AudioInputDescriptor::toAudioPortConfig(struct audio_port_config *dstConfig,
@@ -148,6 +124,34 @@
return false;
}
+audio_attributes_t AudioInputDescriptor::getHighestPriorityAttributes() const
+{
+ audio_attributes_t attributes = { .source = AUDIO_SOURCE_DEFAULT };
+
+ for (bool activeOnly : { true, false }) {
+ int32_t topPriority = -1;
+ app_state_t topState = APP_STATE_IDLE;
+ for (const auto &client : getClientIterable()) {
+ if (activeOnly && !client->active()) {
+ continue;
+ }
+ app_state_t curState = client->appState();
+ if (curState >= topState) {
+ int32_t curPriority = source_priority(client->source());
+ if (curPriority > topPriority) {
+ attributes = client->attributes();
+ topPriority = curPriority;
+ }
+ topState = curState;
+ }
+ }
+ if (attributes.source != AUDIO_SOURCE_DEFAULT) {
+ break;
+ }
+ }
+ return attributes;
+}
+
bool AudioInputDescriptor::isSoundTrigger() const {
// sound trigger and non sound trigger clients are not mixed on a given input
// so check only first client
@@ -180,8 +184,7 @@
}
status_t AudioInputDescriptor::open(const audio_config_t *config,
- audio_devices_t device,
- const String8& address,
+ const sp<DeviceDescriptor> &device,
audio_source_t source,
audio_input_flags_t flags,
audio_io_handle_t *input)
@@ -198,24 +201,26 @@
mDevice = device;
- ALOGV("opening input for device %08x address %s profile %p name %s",
- mDevice, address.string(), mProfile.get(), mProfile->getName().string());
+ ALOGV("opening input for device %s profile %p name %s",
+ mDevice->toString().c_str(), mProfile.get(), mProfile->getName().string());
+
+ audio_devices_t deviceType = mDevice->type();
status_t status = mClientInterface->openInput(mProfile->getModuleHandle(),
input,
&lConfig,
- &mDevice,
- address,
+ &deviceType,
+ mDevice->address(),
source,
flags);
- LOG_ALWAYS_FATAL_IF(mDevice != device,
+ LOG_ALWAYS_FATAL_IF(mDevice->type() != deviceType,
"%s openInput returned device %08x when given device %08x",
- __FUNCTION__, mDevice, device);
+ __FUNCTION__, mDevice->type(), deviceType);
if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(*input == AUDIO_IO_HANDLE_NONE,
- "%s openInput returned input handle %d for device %08x",
- __FUNCTION__, *input, device);
+ "%s openInput returned input handle %d for device %s",
+ __FUNCTION__, *input, mDevice->toString().c_str());
mSamplingRate = lConfig.sample_rate;
mChannelMask = lConfig.channel_mask;
mFormat = lConfig.format;
@@ -423,7 +428,7 @@
dst->appendFormat(" Sampling rate: %d\n", mSamplingRate);
dst->appendFormat(" Format: %d\n", mFormat);
dst->appendFormat(" Channels: %08x\n", mChannelMask);
- dst->appendFormat(" Devices %08x\n", mDevice);
+ dst->appendFormat(" Devices %s\n", mDevice->toString().c_str());
getEnabledEffects().dump(dst, 1 /*spaces*/, false /*verbose*/);
dst->append(" AudioRecord Clients:\n");
ClientMapHandler<RecordClientDescriptor>::dump(dst);
@@ -452,14 +457,13 @@
return NULL;
}
-uint32_t AudioInputCollection::activeInputsCountOnDevices(audio_devices_t devices) const
+uint32_t AudioInputCollection::activeInputsCountOnDevices(const DeviceVector &devices) const
{
uint32_t count = 0;
for (size_t i = 0; i < size(); i++) {
const sp<AudioInputDescriptor> inputDescriptor = valueAt(i);
if (inputDescriptor->isActive() &&
- ((devices == AUDIO_DEVICE_IN_DEFAULT) ||
- ((inputDescriptor->mDevice & devices & ~AUDIO_DEVICE_BIT_IN) != 0))) {
+ (devices.isEmpty() || devices.contains(inputDescriptor->getDevice()))) {
count++;
}
}
@@ -479,13 +483,6 @@
return activeInputs;
}
-audio_devices_t AudioInputCollection::getSupportedDevices(audio_io_handle_t handle) const
-{
- sp<AudioInputDescriptor> inputDesc = valueFor(handle);
- audio_devices_t devices = inputDesc->mProfile->getSupportedDevicesType();
- return devices;
-}
-
sp<AudioInputDescriptor> AudioInputCollection::getInputForClient(audio_port_handle_t portId)
{
for (size_t i = 0; i < size(); i++) {
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
index 97504ab..643cbd1 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
@@ -82,25 +82,10 @@
return mId;
}
-audio_devices_t AudioOutputDescriptor::device() const
-{
- return mDevice;
-}
-
-audio_devices_t AudioOutputDescriptor::supportedDevices()
-{
- return mDevice;
-}
-
bool AudioOutputDescriptor::sharesHwModuleWith(
const sp<AudioOutputDescriptor>& outputDesc)
{
- if (outputDesc->isDuplicated()) {
- return sharesHwModuleWith(outputDesc->subOutput1()) ||
- sharesHwModuleWith(outputDesc->subOutput2());
- } else {
- return hasSameHwModuleAs(outputDesc);
- }
+ return hasSameHwModuleAs(outputDesc);
}
void AudioOutputDescriptor::changeStreamActiveCount(const sp<TrackClientDescriptor>& client,
@@ -282,7 +267,7 @@
dst->appendFormat(" Sampling rate: %d\n", mSamplingRate);
dst->appendFormat(" Format: %08x\n", mFormat);
dst->appendFormat(" Channels: %08x\n", mChannelMask);
- dst->appendFormat(" Devices: %08x\n", device());
+ dst->appendFormat(" Devices: %s\n", devices().toString().c_str());
dst->appendFormat(" Global active count: %u\n", mGlobalActiveCount);
dst->append(" Stream volume activeCount muteCount\n");
for (int i = 0; i < (int)AUDIO_STREAM_CNT; i++) {
@@ -330,17 +315,18 @@
AudioOutputDescriptor::dump(dst);
}
-audio_devices_t SwAudioOutputDescriptor::device() const
+DeviceVector SwAudioOutputDescriptor::devices() const
{
if (isDuplicated()) {
- return (audio_devices_t)(mOutput1->mDevice | mOutput2->mDevice);
- } else {
- return mDevice;
+ DeviceVector devices = mOutput1->devices();
+ devices.merge(mOutput2->devices());
+ return devices;
}
+ return mDevices;
}
bool SwAudioOutputDescriptor::sharesHwModuleWith(
- const sp<AudioOutputDescriptor>& outputDesc)
+ const sp<SwAudioOutputDescriptor>& outputDesc)
{
if (isDuplicated()) {
return mOutput1->sharesHwModuleWith(outputDesc) || mOutput2->sharesHwModuleWith(outputDesc);
@@ -352,13 +338,30 @@
}
}
-audio_devices_t SwAudioOutputDescriptor::supportedDevices()
+DeviceVector SwAudioOutputDescriptor::supportedDevices() const
{
if (isDuplicated()) {
- return (audio_devices_t)(mOutput1->supportedDevices() | mOutput2->supportedDevices());
- } else {
- return mProfile->getSupportedDevicesType();
+ DeviceVector supportedDevices = mOutput1->supportedDevices();
+ supportedDevices.merge(mOutput2->supportedDevices());
+ return supportedDevices;
}
+ return mProfile->getSupportedDevices();
+}
+
+bool SwAudioOutputDescriptor::supportsDevice(const sp<DeviceDescriptor> &device) const
+{
+ return supportedDevices().contains(device);
+}
+
+bool SwAudioOutputDescriptor::supportsAllDevices(const DeviceVector &devices) const
+{
+ return supportedDevices().containsAllDevices(devices);
+}
+
+DeviceVector SwAudioOutputDescriptor::filterSupportedDevices(const DeviceVector &devices) const
+{
+ DeviceVector filteredDevices = supportedDevices();
+ return filteredDevices.filter(devices);
}
uint32_t SwAudioOutputDescriptor::latency()
@@ -443,12 +446,15 @@
}
status_t SwAudioOutputDescriptor::open(const audio_config_t *config,
- audio_devices_t device,
- const String8& address,
+ const DeviceVector &devices,
audio_stream_type_t stream,
audio_output_flags_t flags,
audio_io_handle_t *output)
{
+ mDevices = devices;
+ const String8& address = devices.getFirstValidAddress();
+ audio_devices_t device = devices.types();
+
audio_config_t lConfig;
if (config == nullptr) {
lConfig = AUDIO_CONFIG_INITIALIZER;
@@ -459,7 +465,6 @@
lConfig = *config;
}
- mDevice = device;
// if the selected profile is offloaded and no offload info was specified,
// create a default one
if ((mProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) &&
@@ -477,19 +482,19 @@
mFlags = (audio_output_flags_t)(mFlags | flags);
- ALOGV("opening output for device %08x address %s profile %p name %s",
- mDevice, address.string(), mProfile.get(), mProfile->getName().string());
+ ALOGV("opening output for device %s profile %p name %s",
+ mDevices.toString().c_str(), mProfile.get(), mProfile->getName().string());
status_t status = mClientInterface->openOutput(mProfile->getModuleHandle(),
output,
&lConfig,
- &mDevice,
+ &device,
address,
&mLatency,
mFlags);
- LOG_ALWAYS_FATAL_IF(mDevice != device,
+ LOG_ALWAYS_FATAL_IF(mDevices.types() != device,
"%s openOutput returned device %08x when given device %08x",
- __FUNCTION__, mDevice, device);
+ __FUNCTION__, mDevices.types(), device);
if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(*output == AUDIO_IO_HANDLE_NONE,
@@ -605,11 +610,6 @@
mSource->dump(dst, 0, 0);
}
-audio_devices_t HwAudioOutputDescriptor::supportedDevices()
-{
- return mDevice;
-}
-
void HwAudioOutputDescriptor::toAudioPortConfig(
struct audio_port_config *dstConfig,
const struct audio_port_config *srcConfig) const
@@ -657,7 +657,7 @@
for (size_t i = 0; i < this->size(); i++) {
const sp<SwAudioOutputDescriptor> outputDesc = this->valueAt(i);
if (outputDesc->isStreamActive(stream, inPastMs, sysTime)
- && ((outputDesc->device() & APM_AUDIO_OUT_DEVICE_REMOTE_ALL) == 0)) {
+ && ((outputDesc->devices().types() & APM_AUDIO_OUT_DEVICE_REMOTE_ALL) == 0)) {
return true;
}
}
@@ -670,7 +670,7 @@
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < size(); i++) {
const sp<SwAudioOutputDescriptor> outputDesc = valueAt(i);
- if (((outputDesc->device() & APM_AUDIO_OUT_DEVICE_REMOTE_ALL) != 0) &&
+ if (((outputDesc->devices().types() & APM_AUDIO_OUT_DEVICE_REMOTE_ALL) != 0) &&
outputDesc->isStreamActive(stream, inPastMs, sysTime)) {
// do not consider re routing (when the output is going to a dynamic policy)
// as "remote playback"
@@ -686,7 +686,8 @@
{
for (size_t i = 0; i < size(); i++) {
sp<SwAudioOutputDescriptor> outputDesc = valueAt(i);
- if (!outputDesc->isDuplicated() && outputDesc->device() & AUDIO_DEVICE_OUT_ALL_A2DP) {
+ if (!outputDesc->isDuplicated() &&
+ outputDesc->devices().types() & AUDIO_DEVICE_OUT_ALL_A2DP) {
return this->keyAt(i);
}
}
@@ -700,10 +701,9 @@
if ((primaryOutput != NULL) && (primaryOutput->mProfile != NULL)
&& (primaryOutput->mProfile->getModule() != NULL)) {
sp<HwModule> primaryHwModule = primaryOutput->mProfile->getModule();
- Vector <sp<IOProfile>> primaryHwModuleOutputProfiles =
- primaryHwModule->getOutputProfiles();
- for (size_t i = 0; i < primaryHwModuleOutputProfiles.size(); i++) {
- if (primaryHwModuleOutputProfiles[i]->supportDevice(AUDIO_DEVICE_OUT_ALL_A2DP)) {
+
+ for (const auto &outputProfile : primaryHwModule->getOutputProfiles()) {
+ if (outputProfile->supportsDeviceTypes(AUDIO_DEVICE_OUT_ALL_A2DP)) {
return true;
}
}
@@ -754,13 +754,6 @@
return false;
}
-audio_devices_t SwAudioOutputCollection::getSupportedDevices(audio_io_handle_t handle) const
-{
- sp<SwAudioOutputDescriptor> outputDesc = valueFor(handle);
- audio_devices_t devices = outputDesc->mProfile->getSupportedDevicesType();
- return devices;
-}
-
sp<SwAudioOutputDescriptor> SwAudioOutputCollection::getOutputForClient(audio_port_handle_t portId)
{
for (size_t i = 0; i < size(); i++) {
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPolicyMix.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPolicyMix.cpp
index 776d98f..d18091c 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPolicyMix.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPolicyMix.cpp
@@ -280,13 +280,11 @@
return BAD_VALUE;
}
-audio_devices_t AudioPolicyMixCollection::getDeviceAndMixForInputSource(audio_source_t inputSource,
- audio_devices_t availDevices,
- AudioMix **policyMix)
+sp<DeviceDescriptor> AudioPolicyMixCollection::getDeviceAndMixForInputSource(
+ audio_source_t inputSource, const DeviceVector &availDevices, AudioMix **policyMix)
{
for (size_t i = 0; i < size(); i++) {
AudioMix *mix = valueAt(i)->getMix();
-
if (mix->mMixType != MIX_TYPE_RECORDERS) {
continue;
}
@@ -295,17 +293,21 @@
mix->mCriteria[j].mValue.mSource == inputSource) ||
(RULE_EXCLUDE_ATTRIBUTE_CAPTURE_PRESET == mix->mCriteria[j].mRule &&
mix->mCriteria[j].mValue.mSource != inputSource)) {
- if (availDevices & AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
+ // assuming PolicyMix only for remote submix for input
+ // so mix->mDeviceType can only be AUDIO_DEVICE_OUT_REMOTE_SUBMIX
+ audio_devices_t device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
+ auto mixDevice = availDevices.getDevice(device, mix->mDeviceAddress);
+ if (mixDevice != nullptr) {
if (policyMix != NULL) {
*policyMix = mix;
}
- return AUDIO_DEVICE_IN_REMOTE_SUBMIX;
+ return mixDevice;
}
break;
}
}
}
- return AUDIO_DEVICE_NONE;
+ return nullptr;
}
status_t AudioPolicyMixCollection::getInputMixForAttr(audio_attributes_t attr, AudioMix **policyMix)
@@ -360,10 +362,12 @@
break;
}
}
- if (!deviceMatch) {
+ if (deviceMatch) {
+ mix->setMatchUid(uid);
+ } else {
// this mix doesn't go to one of the listed devices for the given uid,
// modify its rules to exclude the uid
- mix->excludeUid(uid);
+ mix->setExcludeUid(uid);
}
}
@@ -382,7 +386,7 @@
for (size_t j = 0; j < mix->mCriteria.size(); j++) {
const uint32_t rule = mix->mCriteria[j].mRule;
// is this rule affecting the uid?
- if (rule == RULE_EXCLUDE_UID
+ if ((rule == RULE_EXCLUDE_UID || rule == RULE_MATCH_UID)
&& uid == mix->mCriteria[j].mValue.mUid) {
foundUidRule = true;
criteriaToRemove.push_back(j);
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
index 19dde6a..9fcf5e7 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
@@ -31,9 +31,15 @@
// --- AudioPort class implementation
void AudioPort::attach(const sp<HwModule>& module)
{
+ ALOGV("%s: attaching module %s to port %s", __FUNCTION__, getModuleName(), mName.string());
mModule = module;
}
+void AudioPort::detach()
+{
+ mModule = nullptr;
+}
+
// Note that is a different namespace than AudioFlinger unique IDs
audio_port_handle_t AudioPort::getNextUniqueId()
{
diff --git a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
index 04cbcd1..01111c5 100644
--- a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
@@ -58,6 +58,12 @@
mId = getNextUniqueId();
}
+void DeviceDescriptor::detach()
+{
+ mId = AUDIO_PORT_HANDLE_NONE;
+ AudioPort::detach();
+}
+
bool DeviceDescriptor::equals(const sp<DeviceDescriptor>& other) const
{
// Devices are considered equal if they:
diff --git a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
index 80af88d..7d2d094 100644
--- a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
@@ -52,6 +52,9 @@
sp<DeviceDescriptor> devDesc = new DeviceDescriptor(device);
devDesc->setAddress(address);
+ addDynamicDevice(devDesc);
+ // Reciprocally attach the device to the module
+ devDesc->attach(this);
profile->addSupportedDevice(devDesc);
return addOutputProfile(profile);
@@ -97,6 +100,9 @@
{
for (size_t i = 0; i < mOutputProfiles.size(); i++) {
if (mOutputProfiles[i]->getName() == name) {
+ for (const auto &device : mOutputProfiles[i]->getSupportedDevices()) {
+ removeDynamicDevice(device);
+ }
mOutputProfiles.removeAt(i);
break;
}
@@ -114,6 +120,9 @@
sp<DeviceDescriptor> devDesc = new DeviceDescriptor(device);
devDesc->setAddress(address);
+ addDynamicDevice(devDesc);
+ // Reciprocally attach the device to the module
+ devDesc->attach(this);
profile->addSupportedDevice(devDesc);
ALOGV("addInputProfile() name %s rate %d mask 0x%08x",
@@ -126,6 +135,9 @@
{
for (size_t i = 0; i < mInputProfiles.size(); i++) {
if (mInputProfiles[i]->getName() == name) {
+ for (const auto &device : mInputProfiles[i]->getSupportedDevices()) {
+ removeDynamicDevice(device);
+ }
mInputProfiles.removeAt(i);
break;
}
@@ -247,6 +259,7 @@
}
}
mDeclaredDevices.dump(dst, String8("Declared"), 2, true);
+ mDynamicDevices.dump(dst, String8("Dynamic"), 2, true);
mRoutes.dump(dst, 2);
}
@@ -260,13 +273,13 @@
return nullptr;
}
-sp <HwModule> HwModuleCollection::getModuleForDevice(audio_devices_t device) const
+sp <HwModule> HwModuleCollection::getModuleForDeviceTypes(audio_devices_t device) const
{
for (const auto& module : *this) {
const auto& profiles = audio_is_output_device(device) ?
module->getOutputProfiles() : module->getInputProfiles();
for (const auto& profile : profiles) {
- if (profile->supportDevice(device)) {
+ if (profile->supportsDeviceTypes(device)) {
return module;
}
}
@@ -274,30 +287,127 @@
return nullptr;
}
-sp<DeviceDescriptor> HwModuleCollection::getDeviceDescriptor(const audio_devices_t device,
- const char *device_address,
- const char *device_name,
+sp <HwModule> HwModuleCollection::getModuleForDevice(const sp<DeviceDescriptor> &device) const
+{
+ for (const auto& module : *this) {
+ const auto& profiles = audio_is_output_device(device->type()) ?
+ module->getOutputProfiles() : module->getInputProfiles();
+ for (const auto& profile : profiles) {
+ if (profile->supportsDevice(device)) {
+ return module;
+ }
+ }
+ }
+ return nullptr;
+}
+
+DeviceVector HwModuleCollection::getAvailableDevicesFromModuleName(
+ const char *name, const DeviceVector &availableDevices) const
+{
+ sp<HwModule> module = getModuleFromName(name);
+ if (module == nullptr) {
+ return DeviceVector();
+ }
+ return availableDevices.getDevicesFromHwModule(module->getHandle());
+}
+
+sp<DeviceDescriptor> HwModuleCollection::getDeviceDescriptor(const audio_devices_t deviceType,
+ const char *address,
+ const char *name,
+ bool allowToCreate,
bool matchAddress) const
{
- String8 address = (device_address == nullptr || !matchAddress) ?
- String8("") : String8(device_address);
+ String8 devAddress = (address == nullptr || !matchAddress) ? String8("") : String8(address);
// handle legacy remote submix case where the address was not always specified
- if (device_distinguishes_on_address(device) && (address.length() == 0)) {
- address = String8("0");
+ if (device_distinguishes_on_address(deviceType) && (devAddress.length() == 0)) {
+ devAddress = String8("0");
}
for (const auto& hwModule : *this) {
- DeviceVector declaredDevices = hwModule->getDeclaredDevices();
- sp<DeviceDescriptor> deviceDesc = declaredDevices.getDevice(device, address);
- if (deviceDesc) {
- return deviceDesc;
+ DeviceVector moduleDevices = hwModule->getAllDevices();
+ auto moduleDevice = moduleDevices.getDevice(deviceType, devAddress);
+ if (moduleDevice) {
+ if (allowToCreate) {
+ moduleDevice->attach(hwModule);
+ }
+ return moduleDevice;
}
}
+ if (!allowToCreate) {
+ ALOGE("%s: could not find HW module for device %s %04x address %s", __FUNCTION__,
+ name, deviceType, address);
+ return nullptr;
+ }
+ return createDevice(deviceType, address, name);
+}
- sp<DeviceDescriptor> devDesc = new DeviceDescriptor(device);
- devDesc->setName(String8(device_name));
- devDesc->setAddress(address);
- return devDesc;
+sp<DeviceDescriptor> HwModuleCollection::createDevice(const audio_devices_t type,
+ const char *address,
+ const char *name) const
+{
+ sp<HwModule> hwModule = getModuleForDeviceTypes(type);
+ if (hwModule == 0) {
+ ALOGE("%s: could not find HW module for device %04x address %s", __FUNCTION__, type,
+ address);
+ return nullptr;
+ }
+ sp<DeviceDescriptor> device = new DeviceDescriptor(type, String8(name));
+ device->setName(String8(name));
+ device->setAddress(String8(address));
+
+ // Add the device to the list of dynamic devices
+ hwModule->addDynamicDevice(device);
+ // Reciprocally attach the device to the module
+ device->attach(hwModule);
+ ALOGD("%s: adding dynamic device %s to module %s", __FUNCTION__,
+ device->toString().c_str(), hwModule->getName());
+
+ const auto &profiles = (audio_is_output_device(type) ? hwModule->getOutputProfiles() :
+ hwModule->getInputProfiles());
+ for (const auto &profile : profiles) {
+ // Add the device as supported to all profile supporting "weakly" or not the device
+ // according to its type
+ if (profile->supportsDevice(device, false /*matchAdress*/)) {
+
+ // @todo quid of audio profile? import the profile from device of the same type?
+ const auto &isoTypeDeviceForProfile = profile->getSupportedDevices().getDevice(type);
+ device->importAudioPort(isoTypeDeviceForProfile, true /* force */);
+
+ ALOGV("%s: adding device %s to profile %s", __FUNCTION__,
+ device->toString().c_str(), profile->getTagName().c_str());
+ profile->addSupportedDevice(device);
+ }
+ }
+ return device;
+}
+
+void HwModuleCollection::cleanUpForDevice(const sp<DeviceDescriptor> &device)
+{
+ for (const auto& hwModule : *this) {
+ DeviceVector moduleDevices = hwModule->getAllDevices();
+ if (!moduleDevices.contains(device)) {
+ continue;
+ }
+ device->detach();
+ // Only remove from dynamic list, not from declared list!!!
+ if (!hwModule->getDynamicDevices().contains(device)) {
+ return;
+ }
+ hwModule->removeDynamicDevice(device);
+ ALOGV("%s: removed dynamic device %s from module %s", __FUNCTION__,
+ device->toString().c_str(), hwModule->getName());
+
+ const IOProfileCollection &profiles = audio_is_output_device(device->type()) ?
+ hwModule->getOutputProfiles() : hwModule->getInputProfiles();
+ for (const auto &profile : profiles) {
+ // For cleanup, strong match is required
+ if (profile->supportsDevice(device, true /*matchAdress*/)) {
+ ALOGV("%s: removing device %s from profile %s", __FUNCTION__,
+ device->toString().c_str(), profile->getTagName().c_str());
+ profile->removeSupportedDevice(device);
+ }
+ }
+ }
}
void HwModuleCollection::dump(String8 *dst) const
diff --git a/services/audiopolicy/common/managerdefinitions/src/IOProfile.cpp b/services/audiopolicy/common/managerdefinitions/src/IOProfile.cpp
index 3788244..fe2eaee 100644
--- a/services/audiopolicy/common/managerdefinitions/src/IOProfile.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/IOProfile.cpp
@@ -25,11 +25,7 @@
namespace android {
-// checks if the IO profile is compatible with specified parameters.
-// Sampling rate, format and channel mask must be specified in order to
-// get a valid a match
-bool IOProfile::isCompatibleProfile(audio_devices_t device,
- const String8& address,
+bool IOProfile::isCompatibleProfile(const DeviceVector &devices,
uint32_t samplingRate,
uint32_t *updatedSamplingRate,
audio_format_t format,
@@ -46,14 +42,8 @@
getType() == AUDIO_PORT_TYPE_MIX && getRole() == AUDIO_PORT_ROLE_SINK;
ALOG_ASSERT(isPlaybackThread != isRecordThread);
-
- if (device != AUDIO_DEVICE_NONE) {
- // just check types if multiple devices are selected
- if (popcount(device & ~AUDIO_DEVICE_BIT_IN) > 1) {
- if ((mSupportedDevices.types() & device) != device) {
- return false;
- }
- } else if (mSupportedDevices.getDevice(device, address) == 0) {
+ if (!devices.isEmpty()) {
+ if (!mSupportedDevices.containsAllDevices(devices)) {
return false;
}
}
diff --git a/services/audiopolicy/engineconfigurable/src/InputSource.cpp b/services/audiopolicy/engineconfigurable/src/InputSource.cpp
index b9a38d4..d252d3f 100644
--- a/services/audiopolicy/engineconfigurable/src/InputSource.cpp
+++ b/services/audiopolicy/engineconfigurable/src/InputSource.cpp
@@ -25,7 +25,8 @@
status_t Element<audio_source_t>::setIdentifier(audio_source_t identifier)
{
- if (identifier > AUDIO_SOURCE_MAX && identifier != AUDIO_SOURCE_HOTWORD) {
+ if (identifier > AUDIO_SOURCE_MAX && identifier != AUDIO_SOURCE_HOTWORD
+ && identifier != AUDIO_SOURCE_FM_TUNER && identifier != AUDIO_SOURCE_ECHO_REFERENCE) {
return BAD_VALUE;
}
mIdentifier = identifier;
diff --git a/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp b/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
index fc6c1e4..1934fa4 100644
--- a/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
+++ b/services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp
@@ -295,8 +295,8 @@
auto criterionType = criterion->getCriterionType();
int deviceAddressId;
- if (not criterionType->getNumericalValue(devDesc->mAddress.string(), deviceAddressId)) {
- ALOGE("%s: unknown device address reported (%s)", __FUNCTION__, devDesc->mAddress.c_str());
+ if (not criterionType->getNumericalValue(devDesc->address().string(), deviceAddressId)) {
+ ALOGW("%s: unknown device address reported (%s)", __FUNCTION__, devDesc->address().c_str());
return BAD_TYPE;
}
int currentValueMask = criterion->getCriterionState();
diff --git a/services/audiopolicy/enginedefault/src/Engine.cpp b/services/audiopolicy/enginedefault/src/Engine.cpp
index 69395f3..3d68cd8 100644
--- a/services/audiopolicy/enginedefault/src/Engine.cpp
+++ b/services/audiopolicy/enginedefault/src/Engine.cpp
@@ -322,7 +322,7 @@
// a primary device
// FIXME: this is not the right way of solving this problem
audio_devices_t availPrimaryOutputDevices =
- (primaryOutput->supportedDevices() | AUDIO_DEVICE_OUT_HEARING_AID) &
+ (primaryOutput->supportedDevices().types() | AUDIO_DEVICE_OUT_HEARING_AID) &
availableOutputDevices.types();
if (((availableInputDevices.types() &
@@ -475,7 +475,7 @@
// compressed format as they would likely not be mixed and dropped.
for (size_t i = 0; i < outputs.size(); i++) {
sp<AudioOutputDescriptor> desc = outputs.valueAt(i);
- audio_devices_t devices = desc->device() &
+ audio_devices_t devices = desc->devices().types() &
(AUDIO_DEVICE_OUT_HDMI | AUDIO_DEVICE_OUT_SPDIF | AUDIO_DEVICE_OUT_HDMI_ARC);
if (desc->isActive() && !audio_is_linear_pcm(desc->mFormat) &&
devices != AUDIO_DEVICE_NONE) {
@@ -631,6 +631,7 @@
case AUDIO_SOURCE_UNPROCESSED:
case AUDIO_SOURCE_HOTWORD:
case AUDIO_SOURCE_CAMCORDER:
+ case AUDIO_SOURCE_VOICE_PERFORMANCE:
inputSource = AUDIO_SOURCE_VOICE_COMMUNICATION;
break;
default:
@@ -737,16 +738,32 @@
device = AUDIO_DEVICE_IN_VOICE_CALL;
}
break;
+ case AUDIO_SOURCE_VOICE_PERFORMANCE:
+ if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
+ device = AUDIO_DEVICE_IN_WIRED_HEADSET;
+ } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_HEADSET) {
+ device = AUDIO_DEVICE_IN_USB_HEADSET;
+ } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
+ device = AUDIO_DEVICE_IN_USB_DEVICE;
+ } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
+ device = AUDIO_DEVICE_IN_BUILTIN_MIC;
+ }
+ break;
case AUDIO_SOURCE_REMOTE_SUBMIX:
if (availableDeviceTypes & AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
}
break;
- case AUDIO_SOURCE_FM_TUNER:
+ case AUDIO_SOURCE_FM_TUNER:
if (availableDeviceTypes & AUDIO_DEVICE_IN_FM_TUNER) {
device = AUDIO_DEVICE_IN_FM_TUNER;
}
break;
+ case AUDIO_SOURCE_ECHO_REFERENCE:
+ if (availableDeviceTypes & AUDIO_DEVICE_IN_ECHO_REFERENCE) {
+ device = AUDIO_DEVICE_IN_ECHO_REFERENCE;
+ }
+ break;
default:
ALOGW("getDeviceForInputSource() invalid input source %d", inputSource);
break;
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 5544821..5c8a799 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -88,36 +88,39 @@
return status;
}
-void AudioPolicyManager::broadcastDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const String8 &device_address)
+void AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
+ audio_policy_dev_state_t state)
{
- AudioParameter param(device_address);
+ AudioParameter param(device->address());
const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ?
AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect);
- param.addInt(key, device);
+ param.addInt(key, device->type());
mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
}
-status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t device,
+status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t deviceType,
audio_policy_dev_state_t state,
const char *device_address,
const char *device_name)
{
ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s",
- device, state, device_address, device_name);
+ deviceType, state, device_address, device_name);
// connect/disconnect only 1 device at a time
- if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
+ if (!audio_is_output_device(deviceType) && !audio_is_input_device(deviceType)) return BAD_VALUE;
- sp<DeviceDescriptor> devDesc =
- mHwModules.getDeviceDescriptor(device, device_address, device_name);
+ sp<DeviceDescriptor> device =
+ mHwModules.getDeviceDescriptor(deviceType, device_address, device_name,
+ state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
+ if (device == 0) {
+ return INVALID_OPERATION;
+ }
// handle output devices
- if (audio_is_output_device(device)) {
+ if (audio_is_output_device(deviceType)) {
SortedVector <audio_io_handle_t> outputs;
- ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
+ ssize_t index = mAvailableOutputDevices.indexOf(device);
// save a copy of the opened output descriptors before any output is opened or closed
// by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
@@ -127,70 +130,60 @@
// handle output device connection
case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
if (index >= 0) {
- ALOGW("setDeviceConnectionState() device already connected: %x", device);
+ ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
return INVALID_OPERATION;
}
- ALOGV("setDeviceConnectionState() connecting device %x", device);
+ ALOGV("%s() connecting device %s", __func__, device->toString().c_str());
// register new device as available
- index = mAvailableOutputDevices.add(devDesc);
- if (index >= 0) {
- sp<HwModule> module = mHwModules.getModuleForDevice(device);
- if (module == 0) {
- ALOGD("setDeviceConnectionState() could not find HW module for device %08x",
- device);
- mAvailableOutputDevices.remove(devDesc);
- return INVALID_OPERATION;
- }
- mAvailableOutputDevices[index]->attach(module);
- } else {
+ if (mAvailableOutputDevices.add(device) < 0) {
return NO_MEMORY;
}
// Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
// parameters on newly connected devices (instead of opening the outputs...)
- broadcastDeviceConnectionState(device, state, devDesc->address());
+ broadcastDeviceConnectionState(device, state);
- if (checkOutputsForDevice(devDesc, state, outputs, devDesc->address()) != NO_ERROR) {
- mAvailableOutputDevices.remove(devDesc);
+ if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
+ mAvailableOutputDevices.remove(device);
- broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
- devDesc->address());
+ mHwModules.cleanUpForDevice(device);
+
+ broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
return INVALID_OPERATION;
}
// Propagate device availability to Engine
- mEngine->setDeviceConnectionState(devDesc, state);
+ mEngine->setDeviceConnectionState(device, state);
// outputs should never be empty here
ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
"checkOutputsForDevice() returned no outputs but status OK");
- ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %zu outputs",
- outputs.size());
+ ALOGV("%s() checkOutputsForDevice() returned %zu outputs", __func__, outputs.size());
} break;
// handle output device disconnection
case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
if (index < 0) {
- ALOGW("setDeviceConnectionState() device not connected: %x", device);
+ ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
return INVALID_OPERATION;
}
- ALOGV("setDeviceConnectionState() disconnecting output device %x", device);
+ ALOGV("%s() disconnecting output device %s", __func__, device->toString().c_str());
// Send Disconnect to HALs
- broadcastDeviceConnectionState(device, state, devDesc->address());
+ broadcastDeviceConnectionState(device, state);
// remove device from available output devices
- mAvailableOutputDevices.remove(devDesc);
+ mAvailableOutputDevices.remove(device);
- checkOutputsForDevice(devDesc, state, outputs, devDesc->address());
+ checkOutputsForDevice(device, state, outputs);
// Propagate device availability to Engine
- mEngine->setDeviceConnectionState(devDesc, state);
+ mEngine->setDeviceConnectionState(device, state);
} break;
default:
- ALOGE("setDeviceConnectionState() invalid state: %x", state);
+ ALOGE("%s() invalid state: %x", __func__, state);
return BAD_VALUE;
}
@@ -199,8 +192,8 @@
if (!outputs.isEmpty()) {
for (audio_io_handle_t output : outputs) {
sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(output);
- // close unused outputs after device disconnection or direct outputs that have been
- // opened by checkOutputsForDevice() to query dynamic parameters
+ // close unused outputs after device disconnection or direct outputs that have
+ // been opened by checkOutputsForDevice() to query dynamic parameters
if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
(((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
(desc->mDirectOpenCount == 0))) {
@@ -214,29 +207,28 @@
});
if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
- audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
- updateCallRouting(newDevice);
+ DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
+ updateCallRouting(newDevices);
}
- const audio_devices_t msdOutDevice = getModuleDeviceTypes(
- mAvailableOutputDevices, AUDIO_HARDWARE_MODULE_ID_MSD);
+ const DeviceVector msdOutDevices = getMsdAudioOutDevices();
for (size_t i = 0; i < mOutputs.size(); i++) {
sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) {
- audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/);
+ DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
// do not force device change on duplicated output because if device is 0, it will
// also force a device 0 for the two outputs it is duplicated to which may override
// a valid device selection on those outputs.
- bool force = (msdOutDevice == AUDIO_DEVICE_NONE || msdOutDevice != desc->device())
+ bool force = (msdOutDevices.isEmpty() || msdOutDevices != desc->devices())
&& !desc->isDuplicated()
- && (!device_distinguishes_on_address(device)
+ && (!device_distinguishes_on_address(deviceType)
// always force when disconnecting (a non-duplicated device)
|| (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
- setOutputDevice(desc, newDevice, force, 0);
+ setOutputDevices(desc, newDevices, force, 0);
}
}
if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
- cleanUpForDevice(devDesc);
+ cleanUpForDevice(device);
}
mpClientInterface->onAudioPortListUpdate();
@@ -244,67 +236,59 @@
} // end if is output device
// handle input devices
- if (audio_is_input_device(device)) {
+ if (audio_is_input_device(deviceType)) {
SortedVector <audio_io_handle_t> inputs;
- ssize_t index = mAvailableInputDevices.indexOf(devDesc);
+ ssize_t index = mAvailableInputDevices.indexOf(device);
switch (state)
{
// handle input device connection
case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
if (index >= 0) {
- ALOGW("setDeviceConnectionState() device already connected: %d", device);
+ ALOGW("%s() device already connected: %s", __func__, device->toString().c_str());
return INVALID_OPERATION;
}
- sp<HwModule> module = mHwModules.getModuleForDevice(device);
- if (module == NULL) {
- ALOGW("setDeviceConnectionState(): could not find HW module for device %08x",
- device);
- return INVALID_OPERATION;
- }
-
// Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
// parameters on newly connected devices (instead of opening the inputs...)
- broadcastDeviceConnectionState(device, state, devDesc->address());
+ broadcastDeviceConnectionState(device, state);
- if (checkInputsForDevice(devDesc, state, inputs, devDesc->address()) != NO_ERROR) {
- broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
- devDesc->address());
+ if (checkInputsForDevice(device, state, inputs) != NO_ERROR) {
+ broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
+
+ mHwModules.cleanUpForDevice(device);
+
return INVALID_OPERATION;
}
- index = mAvailableInputDevices.add(devDesc);
- if (index >= 0) {
- mAvailableInputDevices[index]->attach(module);
- } else {
+ if (mAvailableInputDevices.add(device) < 0) {
return NO_MEMORY;
}
// Propagate device availability to Engine
- mEngine->setDeviceConnectionState(devDesc, state);
+ mEngine->setDeviceConnectionState(device, state);
} break;
// handle input device disconnection
case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
if (index < 0) {
- ALOGW("setDeviceConnectionState() device not connected: %d", device);
+ ALOGW("%s() device not connected: %s", __func__, device->toString().c_str());
return INVALID_OPERATION;
}
- ALOGV("setDeviceConnectionState() disconnecting input device %x", device);
+ ALOGV("%s() disconnecting input device %s", __func__, device->toString().c_str());
// Set Disconnect to HALs
- broadcastDeviceConnectionState(device, state, devDesc->address());
+ broadcastDeviceConnectionState(device, state);
- checkInputsForDevice(devDesc, state, inputs, devDesc->address());
- mAvailableInputDevices.remove(devDesc);
+ checkInputsForDevice(device, state, inputs);
+ mAvailableInputDevices.remove(device);
// Propagate device availability to Engine
- mEngine->setDeviceConnectionState(devDesc, state);
+ mEngine->setDeviceConnectionState(device, state);
} break;
default:
- ALOGE("setDeviceConnectionState() invalid state: %x", state);
+ ALOGE("%s() invalid state: %x", __func__, state);
return BAD_VALUE;
}
@@ -314,19 +298,19 @@
updateDevicesAndOutputs();
if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
- audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
- updateCallRouting(newDevice);
+ DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
+ updateCallRouting(newDevices);
}
if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
- cleanUpForDevice(devDesc);
+ cleanUpForDevice(device);
}
mpClientInterface->onAudioPortListUpdate();
return NO_ERROR;
} // end if is input device
- ALOGW("setDeviceConnectionState() invalid device: %x", device);
+ ALOGW("%s() invalid device: %s", __func__, device->toString().c_str());
return BAD_VALUE;
}
@@ -334,7 +318,7 @@
const char *device_address)
{
sp<DeviceDescriptor> devDesc =
- mHwModules.getDeviceDescriptor(device, device_address, "",
+ mHwModules.getDeviceDescriptor(device, device_address, "", false /* allowToCreate */,
(strlen(device_address) != 0)/*matchAddress*/);
if (devDesc == 0) {
@@ -350,7 +334,7 @@
} else if (audio_is_input_device(device)) {
deviceVector = &mAvailableInputDevices;
} else {
- ALOGW("getDeviceConnectionState() invalid device type %08x", device);
+ ALOGW("%s() invalid device type %08x", __func__, device);
return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
}
@@ -376,8 +360,7 @@
// Check if the device is currently connected
sp<DeviceDescriptor> devDesc =
mHwModules.getDeviceDescriptor(device, device_address, device_name);
- ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
- if (index < 0) {
+ if (devDesc == 0 || mAvailableOutputDevices.indexOf(devDesc) < 0) {
// Nothing to do: device is not connected
return NO_ERROR;
}
@@ -425,16 +408,20 @@
return NO_ERROR;
}
-uint32_t AudioPolicyManager::updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs)
+uint32_t AudioPolicyManager::updateCallRouting(const DeviceVector &rxDevices, uint32_t delayMs)
{
bool createTxPatch = false;
uint32_t muteWaitMs = 0;
- if(!hasPrimaryOutput() || mPrimaryOutput->device() == AUDIO_DEVICE_OUT_STUB) {
+ if(!hasPrimaryOutput() || mPrimaryOutput->devices().types() == AUDIO_DEVICE_OUT_STUB) {
return muteWaitMs;
}
- audio_devices_t txDevice = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
- ALOGV("updateCallRouting device rxDevice %08x txDevice %08x", rxDevice, txDevice);
+ ALOG_ASSERT(!rxDevices.isEmpty(), "updateCallRouting() no selected output device");
+
+ audio_attributes_t attr = { .source = AUDIO_SOURCE_VOICE_COMMUNICATION };
+ auto txDevice = getDeviceAndMixForAttributes(attr);
+ ALOGV("updateCallRouting device rxDevice %s txDevice %s",
+ rxDevices.toString().c_str(), txDevice->toString().c_str());
// release existing RX patch if any
if (mCallRxPatch != 0) {
@@ -450,16 +437,15 @@
// If the RX device is on the primary HW module, then use legacy routing method for voice calls
// via setOutputDevice() on primary output.
// Otherwise, create two audio patches for TX and RX path.
- if (availablePrimaryOutputDevices() & rxDevice) {
- muteWaitMs = setOutputDevice(mPrimaryOutput, rxDevice, true, delayMs);
+ if (availablePrimaryOutputDevices().contains(rxDevices.itemAt(0))) {
+ muteWaitMs = setOutputDevices(mPrimaryOutput, rxDevices, true, delayMs);
// If the TX device is also on the primary HW module, setOutputDevice() will take care
// of it due to legacy implementation. If not, create a patch.
- if ((availablePrimaryInputDevices() & txDevice & ~AUDIO_DEVICE_BIT_IN)
- == AUDIO_DEVICE_NONE) {
+ if (!availablePrimaryModuleInputDevices().contains(txDevice)) {
createTxPatch = true;
}
} else { // create RX path audio patch
- mCallRxPatch = createTelephonyPatch(true /*isRx*/, rxDevice, delayMs);
+ mCallRxPatch = createTelephonyPatch(true /*isRx*/, rxDevices.itemAt(0), delayMs);
createTxPatch = true;
}
if (createTxPatch) { // create TX path audio patch
@@ -470,26 +456,31 @@
}
sp<AudioPatch> AudioPolicyManager::createTelephonyPatch(
- bool isRx, audio_devices_t device, uint32_t delayMs) {
+ bool isRx, const sp<DeviceDescriptor> &device, uint32_t delayMs) {
PatchBuilder patchBuilder;
- sp<DeviceDescriptor> txSourceDeviceDesc;
+ if (device == nullptr) {
+ return nullptr;
+ }
if (isRx) {
- patchBuilder.addSink(findDevice(mAvailableOutputDevices, device)).
- addSource(findDevice(mAvailableInputDevices, AUDIO_DEVICE_IN_TELEPHONY_RX));
+ patchBuilder.addSink(device).
+ addSource(mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX));
} else {
- patchBuilder.addSource(txSourceDeviceDesc = findDevice(mAvailableInputDevices, device)).
- addSink(findDevice(mAvailableOutputDevices, AUDIO_DEVICE_OUT_TELEPHONY_TX));
+ patchBuilder.addSource(device).
+ addSink(mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX));
}
- audio_devices_t outputDevice = isRx ? device : AUDIO_DEVICE_OUT_TELEPHONY_TX;
- SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(outputDevice, mOutputs);
- audio_io_handle_t output = selectOutput(outputs);
+ // @TODO: still ignoring the address, or not dealing platform with mutliple telephonydevices
+ const sp<DeviceDescriptor> outputDevice = isRx ?
+ device : mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX);
+ SortedVector<audio_io_handle_t> outputs =
+ getOutputsForDevices(DeviceVector(outputDevice), mOutputs);
+ audio_io_handle_t output = selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
// request to reuse existing output stream if one is already opened to reach the target device
if (output != AUDIO_IO_HANDLE_NONE) {
sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
- ALOG_ASSERT(!outputDesc->isDuplicated(),
- "%s() %#x device output %d is duplicated", __func__, outputDevice, output);
+ ALOG_ASSERT(!outputDesc->isDuplicated(), "%s() %s device output %d is duplicated", __func__,
+ outputDevice->toString().c_str(), output);
patchBuilder.addSource(outputDesc, { .stream = AUDIO_STREAM_PATCH });
}
@@ -499,7 +490,7 @@
// call TX device but this information is not in the audio patch and logic here must be
// symmetric to the one in startInput()
for (const auto& activeDesc : mInputs.getActiveInputs()) {
- if (activeDesc->hasSameHwModuleAs(txSourceDeviceDesc)) {
+ if (activeDesc->hasSameHwModuleAs(device)) {
closeActiveClients(activeDesc);
}
}
@@ -599,17 +590,17 @@
}
if (hasPrimaryOutput()) {
- // Note that despite the fact that getNewOutputDevice() is called on the primary output,
+ // Note that despite the fact that getNewOutputDevices() is called on the primary output,
// the device returned is not necessarily reachable via this output
- audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
+ DeviceVector rxDevices = getNewOutputDevices(mPrimaryOutput, false /*fromCache*/);
// force routing command to audio hardware when ending call
// even if no device change is needed
- if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) {
- rxDevice = mPrimaryOutput->device();
+ if (isStateInCall(oldState) && rxDevices.isEmpty()) {
+ rxDevices = mPrimaryOutput->devices();
}
if (state == AUDIO_MODE_IN_CALL) {
- updateCallRouting(rxDevice, delayMs);
+ updateCallRouting(rxDevices, delayMs);
} else if (oldState == AUDIO_MODE_IN_CALL) {
if (mCallRxPatch != 0) {
mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
@@ -619,18 +610,18 @@
mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
mCallTxPatch.clear();
}
- setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
+ setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
} else {
- setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
+ setOutputDevices(mPrimaryOutput, rxDevices, force, 0);
}
}
// reevaluate routing on all outputs in case tracks have been started during the call
for (size_t i = 0; i < mOutputs.size(); i++) {
sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
- audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/);
+ DeviceVector newDevices = getNewOutputDevices(desc, true /*fromCache*/);
if (state != AUDIO_MODE_IN_CALL || desc != mPrimaryOutput) {
- setOutputDevice(desc, newDevice, (newDevice != AUDIO_DEVICE_NONE), 0 /*delayMs*/);
+ setOutputDevices(desc, newDevices, !newDevices.isEmpty(), 0 /*delayMs*/);
}
}
@@ -654,7 +645,7 @@
}
void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
- audio_policy_forced_cfg_t config)
+ audio_policy_forced_cfg_t config)
{
ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
if (config == mEngine->getForceUse(usage)) {
@@ -680,26 +671,24 @@
delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
}
if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
- audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, true /*fromCache*/);
- waitMs = updateCallRouting(newDevice, delayMs);
+ DeviceVector newDevices = getNewOutputDevices(mPrimaryOutput, true /*fromCache*/);
+ waitMs = updateCallRouting(newDevices, delayMs);
}
for (size_t i = 0; i < mOutputs.size(); i++) {
sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
- audio_devices_t newDevice = getNewOutputDevice(outputDesc, true /*fromCache*/);
+ DeviceVector newDevices = getNewOutputDevices(outputDesc, true /*fromCache*/);
if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
- waitMs = setOutputDevice(outputDesc, newDevice, (newDevice != AUDIO_DEVICE_NONE),
- delayMs);
+ waitMs = setOutputDevices(outputDesc, newDevices, !newDevices.isEmpty(), delayMs);
}
- if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) {
- applyStreamVolumes(outputDesc, newDevice, waitMs, true);
+ if (forceVolumeReeval && !newDevices.isEmpty()) {
+ applyStreamVolumes(outputDesc, newDevices.types(), waitMs, true);
}
}
for (const auto& activeDesc : mInputs.getActiveInputs()) {
- audio_devices_t newDevice = getNewInputDevice(activeDesc);
+ auto newDevice = getNewInputDevice(activeDesc);
// Force new input selection if the new device can not be reached via current input
- if (activeDesc->mProfile->getSupportedDevices().types() &
- (newDevice & ~AUDIO_DEVICE_BIT_IN)) {
+ if (activeDesc->mProfile->getSupportedDevices().contains(newDevice)) {
setInputDevice(activeDesc->mIoHandle, newDevice);
} else {
closeInput(activeDesc->mIoHandle);
@@ -715,7 +704,7 @@
// Find an output profile compatible with the parameters passed. When "directOnly" is set, restrict
// search to profiles for direct outputs.
sp<IOProfile> AudioPolicyManager::getProfileForOutput(
- audio_devices_t device,
+ const DeviceVector& devices,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
@@ -736,7 +725,7 @@
for (const auto& hwModule : mHwModules) {
for (const auto& curProfile : hwModule->getOutputProfiles()) {
- if (!curProfile->isCompatibleProfile(device, String8(""),
+ if (!curProfile->isCompatibleProfile(devices,
samplingRate, NULL /*updatedSamplingRate*/,
format, NULL /*updatedFormat*/,
channelMask, NULL /*updatedChannelMask*/,
@@ -744,7 +733,7 @@
continue;
}
// reject profiles not corresponding to a device currently available
- if ((mAvailableOutputDevices.types() & curProfile->getSupportedDevicesType()) == 0) {
+ if (!mAvailableOutputDevices.containsAtLeastOne(curProfile->getSupportedDevices())) {
continue;
}
if (!directOnly) return curProfile;
@@ -765,7 +754,7 @@
audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream)
{
routing_strategy strategy = getStrategy(stream);
- audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
+ DeviceVector devices = getDevicesForStrategy(strategy, false /*fromCache*/);
// Note that related method getOutputForAttr() uses getOutputForDevice() not selectOutput().
// We use selectOutput() here since we don't have the desired AudioTrack sample rate,
@@ -773,10 +762,11 @@
// getOutput() solely on audio_stream_type such as AudioSystem::getOutputFrameCount()
// and AudioSystem::getOutputSamplingRate().
- SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
- audio_io_handle_t output = selectOutput(outputs);
+ SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
+ audio_io_handle_t output = selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
- ALOGV("getOutput() stream %d selected device %08x, output %d", stream, device, output);
+ ALOGV("getOutput() stream %d selected devices %s, output %d", stream,
+ devices.toString().c_str(), output);
return output;
}
@@ -813,12 +803,11 @@
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId)
{
- DeviceVector outputDevices;
+ DeviceVector devices;
routing_strategy strategy;
- audio_devices_t device;
- const audio_port_handle_t requestedDeviceId = *selectedDeviceId;
- audio_devices_t msdDevice =
- getModuleDeviceTypes(mAvailableOutputDevices, AUDIO_HARDWARE_MODULE_ID_MSD);
+ audio_devices_t deviceType = AUDIO_DEVICE_NONE;
+ const audio_port_handle_t requestedPortId = *selectedDeviceId;
+ DeviceVector msdDevices = getMsdAudioOutDevices();
status_t status = getAudioAttributes(resultAttr, attr, *stream);
if (status != NO_ERROR) {
@@ -829,17 +818,16 @@
" session %d selectedDeviceId %d",
__func__,
resultAttr->usage, resultAttr->content_type, resultAttr->tags, resultAttr->flags,
- session, requestedDeviceId);
+ session, requestedPortId);
*stream = streamTypefromAttributesInt(resultAttr);
strategy = getStrategyForAttr(resultAttr);
// First check for explicit routing (eg. setPreferredDevice)
- if (requestedDeviceId != AUDIO_PORT_HANDLE_NONE) {
- sp<DeviceDescriptor> deviceDesc =
- mAvailableOutputDevices.getDeviceFromId(requestedDeviceId);
- device = deviceDesc->type();
+ sp<DeviceDescriptor> requestedDevice = mAvailableOutputDevices.getDeviceFromId(requestedPortId);
+ if (requestedDevice != nullptr) {
+ deviceType = requestedDevice->type();
} else {
// If no explict route, is there a matching dynamic policy that applies?
sp<SwAudioOutputDescriptor> desc;
@@ -863,7 +851,7 @@
ALOGW("%s no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE", __func__);
return BAD_VALUE;
}
- device = getDeviceForStrategy(strategy, false /*fromCache*/);
+ deviceType = getDeviceForStrategy(strategy, false /*fromCache*/);
}
if ((resultAttr->flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
@@ -875,42 +863,44 @@
// FIXME: provide a more generic approach which is not device specific and move this back
// to getOutputForDevice.
// TODO: Remove check of AUDIO_STREAM_MUSIC once migration is completed on the app side.
- if (device == AUDIO_DEVICE_OUT_TELEPHONY_TX &&
+ if (deviceType == AUDIO_DEVICE_OUT_TELEPHONY_TX &&
(*stream == AUDIO_STREAM_MUSIC || resultAttr->usage == AUDIO_USAGE_VOICE_COMMUNICATION) &&
audio_is_linear_pcm(config->format) &&
isInCall()) {
- if (requestedDeviceId != AUDIO_PORT_HANDLE_NONE) {
+ if (requestedPortId != AUDIO_PORT_HANDLE_NONE) {
*flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INCALL_MUSIC;
} else {
// Get the devce type directly from the engine to bypass preferred route logic
- device = mEngine->getDeviceForStrategy(strategy);
+ deviceType = mEngine->getDeviceForStrategy(strategy);
}
}
ALOGV("%s device 0x%x, sampling rate %d, format %#x, channel mask %#x, "
"flags %#x",
- __func__, device, config->sample_rate, config->format, config->channel_mask, *flags);
+ __func__,
+ deviceType, config->sample_rate, config->format, config->channel_mask, *flags);
*output = AUDIO_IO_HANDLE_NONE;
- if (msdDevice != AUDIO_DEVICE_NONE) {
- *output = getOutputForDevice(msdDevice, session, *stream, config, flags);
- if (*output != AUDIO_IO_HANDLE_NONE && setMsdPatch(device) == NO_ERROR) {
- ALOGV("%s() Using MSD device 0x%x instead of device 0x%x",
- __func__, msdDevice, device);
- device = msdDevice;
+ if (!msdDevices.isEmpty()) {
+ *output = getOutputForDevices(msdDevices, session, *stream, config, flags);
+ sp<DeviceDescriptor> deviceDesc = mAvailableOutputDevices.getDevice(deviceType);
+ if (*output != AUDIO_IO_HANDLE_NONE && setMsdPatch(deviceDesc) == NO_ERROR) {
+ ALOGV("%s() Using MSD devices %s instead of device %s",
+ __func__, msdDevices.toString().c_str(), deviceDesc->toString().c_str());
+ deviceType = msdDevices.types();
} else {
*output = AUDIO_IO_HANDLE_NONE;
}
}
+ devices = mAvailableOutputDevices.getDevicesFromTypeMask(deviceType);
if (*output == AUDIO_IO_HANDLE_NONE) {
- *output = getOutputForDevice(device, session, *stream, config, flags);
+ *output = getOutputForDevices(devices, session, *stream, config, flags);
}
if (*output == AUDIO_IO_HANDLE_NONE) {
return INVALID_OPERATION;
}
- outputDevices = mAvailableOutputDevices.getDevicesFromTypeMask(device);
- *selectedDeviceId = getFirstDeviceId(outputDevices);
+ *selectedDeviceId = getFirstDeviceId(devices);
ALOGV("%s returns output %d selectedDeviceId %d", __func__, *output, *selectedDeviceId);
@@ -931,7 +921,7 @@
if (*portId != AUDIO_PORT_HANDLE_NONE) {
return INVALID_OPERATION;
}
- const audio_port_handle_t requestedDeviceId = *selectedDeviceId;
+ const audio_port_handle_t requestedPortId = *selectedDeviceId;
audio_attributes_t resultAttr;
status_t status = getOutputForAttrInt(&resultAttr, output, session, attr, stream, uid,
config, flags, selectedDeviceId);
@@ -946,20 +936,20 @@
sp<TrackClientDescriptor> clientDesc =
new TrackClientDescriptor(*portId, uid, session, resultAttr, clientConfig,
- requestedDeviceId, *stream,
+ requestedPortId, *stream,
getStrategyForAttr(&resultAttr),
*flags);
sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(*output);
outputDesc->addClient(clientDesc);
ALOGV("%s returns output %d selectedDeviceId %d for port ID %d",
- __func__, *output, requestedDeviceId, *portId);
+ __func__, *output, requestedPortId, *portId);
return NO_ERROR;
}
-audio_io_handle_t AudioPolicyManager::getOutputForDevice(
- audio_devices_t device,
+audio_io_handle_t AudioPolicyManager::getOutputForDevices(
+ const DeviceVector &devices,
audio_session_t session,
audio_stream_type_t stream,
const audio_config_t *config,
@@ -1017,7 +1007,7 @@
if (((*flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
!(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
- profile = getProfileForOutput(device,
+ profile = getProfileForOutput(devices,
config->sample_rate,
config->format,
config->channel_mask,
@@ -1037,7 +1027,7 @@
(config->channel_mask == desc->mChannelMask) &&
(session == desc->mDirectClientSession)) {
desc->mDirectOpenCount++;
- ALOGI("getOutputForDevice() reusing direct output %d for session %d",
+ ALOGI("%s reusing direct output %d for session %d", __func__,
mOutputs.keyAt(i), session);
return mOutputs.keyAt(i);
}
@@ -1051,8 +1041,7 @@
sp<SwAudioOutputDescriptor> outputDesc =
new SwAudioOutputDescriptor(profile, mpClientInterface);
- DeviceVector outputDevices = mAvailableOutputDevices.getDevicesFromTypeMask(device);
- String8 address = getFirstDeviceAddress(outputDevices);
+ String8 address = getFirstDeviceAddress(devices);
// MSD patch may be using the only output stream that can service this request. Release
// MSD patch to prioritize this request over any active output on MSD.
@@ -1062,7 +1051,7 @@
for (size_t j = 0; j < patch->mPatch.num_sinks; ++j) {
const struct audio_port_config *sink = &patch->mPatch.sinks[j];
if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
- (sink->ext.device.type & device) != AUDIO_DEVICE_NONE &&
+ (sink->ext.device.type & devices.types()) != AUDIO_DEVICE_NONE &&
(address.isEmpty() || strncmp(sink->ext.device.address, address.string(),
AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
releaseAudioPatch(patch->mHandle, mUidCached);
@@ -1071,15 +1060,15 @@
}
}
- status = outputDesc->open(config, device, address, stream, *flags, &output);
+ status = outputDesc->open(config, devices, stream, *flags, &output);
// only accept an output with the requested parameters
if (status != NO_ERROR ||
(config->sample_rate != 0 && config->sample_rate != outputDesc->mSamplingRate) ||
(config->format != AUDIO_FORMAT_DEFAULT && config->format != outputDesc->mFormat) ||
(config->channel_mask != 0 && config->channel_mask != outputDesc->mChannelMask)) {
- ALOGV("getOutputForDevice() failed opening direct output: output %d sample rate %d %d,"
- "format %d %d, channel mask %04x %04x", output, config->sample_rate,
+ ALOGV("%s failed opening direct output: output %d sample rate %d %d,"
+ "format %d %d, channel mask %04x %04x", __func__, output, config->sample_rate,
outputDesc->mSamplingRate, config->format, outputDesc->mFormat,
config->channel_mask, outputDesc->mChannelMask);
if (output != AUDIO_IO_HANDLE_NONE) {
@@ -1097,7 +1086,7 @@
addOutput(output, outputDesc);
mPreviousOutputs = mOutputs;
- ALOGV("getOutputForDevice() returns new direct output %d", output);
+ ALOGV("%s returns new direct output %d", __func__, output);
mpClientInterface->onAudioPortListUpdate();
return output;
}
@@ -1118,14 +1107,14 @@
if (audio_is_linear_pcm(config->format)) {
// get which output is suitable for the specified stream. The actual
// routing change will happen when startOutput() will be called
- SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
+ SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
// at this stage we should ignore the DIRECT flag as no direct output could be found earlier
*flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
output = selectOutput(outputs, *flags, config->format,
config->channel_mask, config->sample_rate);
}
- ALOGW_IF((output == 0), "getOutputForDevice() could not find output for stream %d, "
+ ALOGW_IF((output == 0), "getOutputForDevices() could not find output for stream %d, "
"sampling rate %d, format %#x, channels %#x, flags %#x",
stream, config->sample_rate, config->format, config->channel_mask, *flags);
@@ -1133,13 +1122,14 @@
}
sp<DeviceDescriptor> AudioPolicyManager::getMsdAudioInDevice() const {
- sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
- if (msdModule != 0) {
- DeviceVector msdInputDevices = mAvailableInputDevices.getDevicesFromHwModule(
- msdModule->getHandle());
- if (!msdInputDevices.isEmpty()) return msdInputDevices.itemAt(0);
- }
- return 0;
+ auto msdInDevices = mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
+ mAvailableInputDevices);
+ return msdInDevices.isEmpty()? nullptr : msdInDevices.itemAt(0);
+}
+
+DeviceVector AudioPolicyManager::getMsdAudioOutDevices() const {
+ return mHwModules.getAvailableDevicesFromModuleName(AUDIO_HARDWARE_MODULE_ID_MSD,
+ mAvailableOutputDevices);
}
const AudioPatchCollection AudioPolicyManager::getMsdPatches() const {
@@ -1160,7 +1150,7 @@
return msdPatches;
}
-status_t AudioPolicyManager::getBestMsdAudioProfileFor(audio_devices_t outputDevice,
+status_t AudioPolicyManager::getBestMsdAudioProfileFor(const sp<DeviceDescriptor> &outputDevice,
bool hwAvSync, audio_port_config *sourceConfig, audio_port_config *sinkConfig) const
{
sp<HwModule> msdModule = mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
@@ -1170,7 +1160,7 @@
}
sp<HwModule> deviceModule = mHwModules.getModuleForDevice(outputDevice);
if (deviceModule == nullptr) {
- ALOGE("%s() unable to get module for %#x", __func__, outputDevice);
+ ALOGE("%s() unable to get module for %s", __func__, outputDevice->toString().c_str());
return NO_INIT;
}
const InputProfileCollection &inputProfiles = msdModule->getInputProfiles();
@@ -1180,7 +1170,7 @@
}
const OutputProfileCollection &outputProfiles = deviceModule->getOutputProfiles();
if (outputProfiles.isEmpty()) {
- ALOGE("%s() no output profiles for device %#x", __func__, outputDevice);
+ ALOGE("%s() no output profiles for device %s", __func__, outputDevice->toString().c_str());
return NO_INIT;
}
AudioProfileVector msdProfiles;
@@ -1201,8 +1191,8 @@
compressedFormatsOrder, surroundChannelMasksOrder, true /*preferHigherSamplingRates*/,
&bestSinkConfig);
if (result != NO_ERROR) {
- ALOGD("%s() no matching profiles found for device: %#x, hwAvSync: %d",
- __func__, outputDevice, hwAvSync);
+ ALOGD("%s() no matching profiles found for device: %s, hwAvSync: %d",
+ __func__, outputDevice->toString().c_str(), hwAvSync);
return result;
}
sinkConfig->sample_rate = bestSinkConfig.sample_rate;
@@ -1231,11 +1221,10 @@
return NO_ERROR;
}
-PatchBuilder AudioPolicyManager::buildMsdPatch(audio_devices_t outputDevice) const
+PatchBuilder AudioPolicyManager::buildMsdPatch(const sp<DeviceDescriptor> &outputDevice) const
{
PatchBuilder patchBuilder;
- patchBuilder.addSource(getMsdAudioInDevice()).
- addSink(findDevice(mAvailableOutputDevices, outputDevice));
+ patchBuilder.addSource(getMsdAudioInDevice()).addSink(outputDevice);
audio_port_config sourceConfig = patchBuilder.patch()->sources[0];
audio_port_config sinkConfig = patchBuilder.patch()->sinks[0];
// TODO: Figure out whether MSD module has HW_AV_SYNC flag set in the AP config file.
@@ -1253,15 +1242,18 @@
return patchBuilder;
}
-status_t AudioPolicyManager::setMsdPatch(audio_devices_t outputDevice) {
- ALOGV("%s() for outputDevice %#x", __func__, outputDevice);
- if (outputDevice == AUDIO_DEVICE_NONE) {
+status_t AudioPolicyManager::setMsdPatch(const sp<DeviceDescriptor> &outputDevice) {
+ sp<DeviceDescriptor> device = outputDevice;
+ if (device == nullptr) {
// Use media strategy for unspecified output device. This should only
// occur on checkForDeviceAndOutputChanges(). Device connection events may
// therefore invalidate explicit routing requests.
- outputDevice = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
+ DeviceVector devices = getDevicesForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
+ LOG_ALWAYS_FATAL_IF(devices.isEmpty(), "no outpudevice to set Msd Patch");
+ device = devices.itemAt(0);
}
- PatchBuilder patchBuilder = buildMsdPatch(outputDevice);
+ ALOGV("%s() for device %s", __func__, device->toString().c_str());
+ PatchBuilder patchBuilder = buildMsdPatch(device);
const struct audio_patch* patch = patchBuilder.patch();
const AudioPatchCollection msdPatches = getMsdPatches();
if (!msdPatches.isEmpty()) {
@@ -1277,8 +1269,9 @@
patch, 0 /*delayMs*/, mUidCached, nullptr /*patchDescPtr*/);
ALOGE_IF(status != NO_ERROR, "%s() error %d creating MSD audio patch", __func__, status);
ALOGI_IF(status == NO_ERROR, "%s() Patch created from MSD_IN to "
- "device:%#x (format:%#x channels:%#x samplerate:%d)", __func__, outputDevice,
- patch->sources[0].format, patch->sources[0].channel_mask, patch->sources[0].sample_rate);
+ "device:%s (format:%#x channels:%#x samplerate:%d)", __func__,
+ device->toString().c_str(), patch->sources[0].format,
+ patch->sources[0].channel_mask, patch->sources[0].sample_rate);
return status;
}
@@ -1289,7 +1282,7 @@
uint32_t samplingRate)
{
// select one output among several that provide a path to a particular device or set of
- // devices (the list was previously build by getOutputsForDevice()).
+ // devices (the list was previously build by getOutputsForDevices()).
// The priority is as follows:
// 1: the output supporting haptic playback when requesting haptic playback
// 2: the output with the highest number of requested policy flags
@@ -1451,17 +1444,19 @@
bool force = !outputDesc->isActive() &&
(outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
- audio_devices_t device = AUDIO_DEVICE_NONE;
+ DeviceVector devices;
AudioMix *policyMix = NULL;
const char *address = NULL;
if (outputDesc->mPolicyMix != NULL) {
policyMix = outputDesc->mPolicyMix;
+ audio_devices_t newDeviceType;
address = policyMix->mDeviceAddress.string();
if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
- device = policyMix->mDeviceType;
+ newDeviceType = policyMix->mDeviceType;
} else {
- device = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
+ newDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
}
+ devices.add(mAvailableOutputDevices.getDevice(newDeviceType, String8(address)));
}
// requiresMuteCheck is false when we can bypass mute strategy.
@@ -1476,8 +1471,8 @@
outputDesc->setClientActive(client, true);
if (client->hasPreferredDevice(true)) {
- device = getNewOutputDevice(outputDesc, false /*fromCache*/);
- if (device != outputDesc->device()) {
+ devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
+ if (devices != outputDesc->devices()) {
checkStrategyRoute(getStrategy(stream), outputDesc->mIoHandle);
}
}
@@ -1486,10 +1481,10 @@
selectOutputForMusicEffects();
}
- if (outputDesc->streamActiveCount(stream) == 1 || device != AUDIO_DEVICE_NONE) {
+ if (outputDesc->streamActiveCount(stream) == 1 || !devices.isEmpty()) {
// starting an output being rerouted?
- if (device == AUDIO_DEVICE_NONE) {
- device = getNewOutputDevice(outputDesc, false /*fromCache*/);
+ if (devices.isEmpty()) {
+ devices = getNewOutputDevices(outputDesc, false /*fromCache*/);
}
routing_strategy strategy = getStrategy(stream);
@@ -1498,13 +1493,13 @@
(beaconMuteLatency > 0);
uint32_t waitMs = beaconMuteLatency;
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
if (desc != outputDesc) {
// An output has a shared device if
// - managed by the same hw module
// - supports the currently selected device
const bool sharedDevice = outputDesc->sharesHwModuleWith(desc)
- && (desc->supportedDevices() & device) != AUDIO_DEVICE_NONE;
+ && (!desc->filterSupportedDevices(devices).isEmpty());
// force a device change if any other output is:
// - managed by the same hw module
@@ -1514,7 +1509,7 @@
// In this case, the audio HAL must receive the new device selection so that it can
// change the device currently selected by the other output.
if (sharedDevice &&
- desc->device() != device &&
+ desc->devices() != devices &&
desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
force = true;
}
@@ -1537,13 +1532,13 @@
}
const uint32_t muteWaitMs =
- setOutputDevice(outputDesc, device, force, 0, NULL, address, requiresMuteCheck);
+ setOutputDevices(outputDesc, devices, force, 0, NULL, requiresMuteCheck);
// apply volume rules for current stream and device if necessary
checkAndSetVolume(stream,
- mVolumeCurves->getVolumeIndex(stream, outputDesc->device()),
+ mVolumeCurves->getVolumeIndex(stream, outputDesc->devices().types()),
outputDesc,
- outputDesc->device());
+ outputDesc->devices().types());
// update the outputs if starting an output with a stream that can affect notification
// routing
@@ -1574,7 +1569,7 @@
// Automatically enable the remote submix input when output is started on a re routing mix
// of type MIX_TYPE_RECORDERS
- if (audio_is_remote_submix_device(device) && policyMix != NULL &&
+ if (audio_is_remote_submix_device(devices.types()) && policyMix != NULL &&
policyMix->mMixType == MIX_TYPE_RECORDERS) {
setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
@@ -1619,7 +1614,7 @@
if (outputDesc->streamActiveCount(stream) == 1) {
// Automatically disable the remote submix input when output is stopped on a
// re routing mix of type MIX_TYPE_RECORDERS
- if (audio_is_remote_submix_device(outputDesc->mDevice) &&
+ if (audio_is_remote_submix_device(outputDesc->devices().types()) &&
outputDesc->mPolicyMix != NULL &&
outputDesc->mPolicyMix->mMixType == MIX_TYPE_RECORDERS) {
setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
@@ -1640,33 +1635,31 @@
// store time at which the stream was stopped - see isStreamActive()
if (outputDesc->streamActiveCount(stream) == 0 || forceDeviceUpdate) {
outputDesc->mStopTime[stream] = systemTime();
- audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
+ DeviceVector newDevices = getNewOutputDevices(outputDesc, false /*fromCache*/);
// delay the device switch by twice the latency because stopOutput() is executed when
// the track stop() command is received and at that time the audio track buffer can
// still contain data that needs to be drained. The latency only covers the audio HAL
// and kernel buffers. Also the latency does not always include additional delay in the
// audio path (audio DSP, CODEC ...)
- setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2);
+ setOutputDevices(outputDesc, newDevices, false, outputDesc->latency()*2);
// force restoring the device selection on other active outputs if it differs from the
// one being selected for this output
uint32_t delayMs = outputDesc->latency()*2;
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
if (desc != outputDesc &&
desc->isActive() &&
outputDesc->sharesHwModuleWith(desc) &&
- (newDevice != desc->device())) {
- audio_devices_t newDevice2 = getNewOutputDevice(desc, false /*fromCache*/);
- bool force = desc->device() != newDevice2;
+ (newDevices != desc->devices())) {
+ DeviceVector newDevices2 = getNewOutputDevices(desc, false /*fromCache*/);
+ bool force = desc->devices() != newDevices2;
- setOutputDevice(desc,
- newDevice2,
- force,
- delayMs);
+ setOutputDevices(desc, newDevices2, force, delayMs);
+
// re-apply device specific volume if not done by setOutputDevice()
if (!force) {
- applyStreamVolumes(desc, newDevice2, delayMs);
+ applyStreamVolumes(desc, newDevices2.types(), delayMs);
}
}
}
@@ -1739,29 +1732,27 @@
attr->source, config->sample_rate, config->format, config->channel_mask, session, flags);
status_t status = NO_ERROR;
- // handle legacy remote submix case where the address was not always specified
- String8 address = String8("");
audio_source_t halInputSource;
- audio_source_t inputSource = attr->source;
+ audio_attributes_t attributes = *attr;
AudioMix *policyMix = NULL;
- DeviceVector inputDevices;
+ sp<DeviceDescriptor> device;
sp<AudioInputDescriptor> inputDesc;
sp<RecordClientDescriptor> clientDesc;
audio_port_handle_t requestedDeviceId = *selectedDeviceId;
bool isSoundTrigger;
- audio_devices_t device;
// The supplied portId must be AUDIO_PORT_HANDLE_NONE
if (*portId != AUDIO_PORT_HANDLE_NONE) {
return INVALID_OPERATION;
}
- if (inputSource == AUDIO_SOURCE_DEFAULT) {
- inputSource = AUDIO_SOURCE_MIC;
+ if (attr->source == AUDIO_SOURCE_DEFAULT) {
+ attributes.source = AUDIO_SOURCE_MIC;
}
// Explicit routing?
- sp<DeviceDescriptor> deviceDesc = mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
+ sp<DeviceDescriptor> explicitRoutingDevice =
+ mAvailableInputDevices.getDeviceFromId(*selectedDeviceId);
// special case for mmap capture: if an input IO handle is specified, we reuse this input if
// possible
@@ -1802,7 +1793,7 @@
}
}
*inputType = API_INPUT_LEGACY;
- device = inputDesc->mDevice;
+ device = inputDesc->getDevice();
ALOGI("%s reusing MMAP input %d for session %d", __FUNCTION__, *input, session);
goto exit;
@@ -1811,44 +1802,38 @@
*input = AUDIO_IO_HANDLE_NONE;
*inputType = API_INPUT_INVALID;
- halInputSource = inputSource;
+ halInputSource = attributes.source;
- if (inputSource == AUDIO_SOURCE_REMOTE_SUBMIX &&
- strncmp(attr->tags, "addr=", strlen("addr=")) == 0) {
- status = mPolicyMixes.getInputMixForAttr(*attr, &policyMix);
+ if (attributes.source == AUDIO_SOURCE_REMOTE_SUBMIX &&
+ strncmp(attributes.tags, "addr=", strlen("addr=")) == 0) {
+ status = mPolicyMixes.getInputMixForAttr(attributes, &policyMix);
if (status != NO_ERROR) {
goto error;
}
*inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
- device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
- address = String8(attr->tags + strlen("addr="));
+ device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
+ String8(attr->tags + strlen("addr=")));
} else {
- if (deviceDesc != 0) {
- device = deviceDesc->type();
+ if (explicitRoutingDevice != nullptr) {
+ device = explicitRoutingDevice;
} else {
- device = getDeviceAndMixForInputSource(inputSource, &policyMix);
+ device = getDeviceAndMixForAttributes(attributes, &policyMix);
}
- if (device == AUDIO_DEVICE_NONE) {
- ALOGW("getInputForAttr() could not find device for source %d", inputSource);
+ if (device == nullptr) {
+ ALOGW("getInputForAttr() could not find device for source %d", attributes.source);
status = BAD_VALUE;
goto error;
}
- if (policyMix != NULL) {
- address = policyMix->mDeviceAddress;
- if (policyMix->mMixType == MIX_TYPE_RECORDERS) {
- // there is an external policy, but this input is attached to a mix of recorders,
- // meaning it receives audio injected into the framework, so the recorder doesn't
- // know about it and is therefore considered "legacy"
- *inputType = API_INPUT_LEGACY;
- } else {
- // recording a mix of players defined by an external policy, we're rerouting for
- // an external policy
- *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
- }
- } else if (audio_is_remote_submix_device(device)) {
- address = String8("0");
+ if (policyMix != nullptr) {
+ ALOG_ASSERT(policyMix->mMixType == MIX_TYPE_RECORDERS, "Invalid Mix Type");
+ // there is an external policy, but this input is attached to a mix of recorders,
+ // meaning it receives audio injected into the framework, so the recorder doesn't
+ // know about it and is therefore considered "legacy"
+ *inputType = API_INPUT_LEGACY;
+ } else if (audio_is_remote_submix_device(device->type())) {
+ device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX, String8("0"));
*inputType = API_INPUT_MIX_CAPTURE;
- } else if (device == AUDIO_DEVICE_IN_TELEPHONY_RX) {
+ } else if (device->type() == AUDIO_DEVICE_IN_TELEPHONY_RX) {
*inputType = API_INPUT_TELEPHONY_RX;
} else {
*inputType = API_INPUT_LEGACY;
@@ -1856,7 +1841,7 @@
}
- *input = getInputForDevice(device, address, session, inputSource,
+ *input = getInputForDevice(device, session, attributes.source,
config, flags,
policyMix);
if (*input == AUDIO_IO_HANDLE_NONE) {
@@ -1866,16 +1851,16 @@
exit:
- inputDevices = mAvailableInputDevices.getDevicesFromTypeMask(device);
- *selectedDeviceId = getFirstDeviceId(inputDevices);
+ *selectedDeviceId = mAvailableInputDevices.contains(device) ?
+ device->getId() : AUDIO_PORT_HANDLE_NONE;
- isSoundTrigger = inputSource == AUDIO_SOURCE_HOTWORD &&
+ isSoundTrigger = attributes.source == AUDIO_SOURCE_HOTWORD &&
mSoundTriggerSessions.indexOfKey(session) > 0;
*portId = AudioPort::getNextUniqueId();
- clientDesc = new RecordClientDescriptor(*portId, uid, session,
- *attr, *config, requestedDeviceId,
- inputSource,flags, isSoundTrigger);
+ clientDesc = new RecordClientDescriptor(*portId, uid, session, *attr, *config,
+ requestedDeviceId, attributes.source, flags,
+ isSoundTrigger);
inputDesc = mInputs.valueFor(*input);
inputDesc->addClient(clientDesc);
@@ -1889,8 +1874,7 @@
}
-audio_io_handle_t AudioPolicyManager::getInputForDevice(audio_devices_t device,
- String8 address,
+audio_io_handle_t AudioPolicyManager::getInputForDevice(const sp<DeviceDescriptor> &device,
audio_session_t session,
audio_source_t inputSource,
const audio_config_base_t *config,
@@ -1926,8 +1910,7 @@
audio_input_flags_t profileFlags = flags;
for (;;) {
profileFormat = config->format; // reset each time through loop, in case it is updated
- profile = getInputProfile(device, address,
- profileSamplingRate, profileFormat, profileChannelMask,
+ profile = getInputProfile(device, profileSamplingRate, profileFormat, profileChannelMask,
profileFlags);
if (profile != 0) {
break; // success
@@ -1936,9 +1919,9 @@
} else if (profileFlags != AUDIO_INPUT_FLAG_NONE) {
profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
} else { // fail
- ALOGW("getInputForDevice() could not find profile for device 0x%X, "
- "sampling rate %u, format %#x, channel mask 0x%X, flags %#x",
- device, config->sample_rate, config->format, config->channel_mask, flags);
+ ALOGW("%s could not find profile for device %s, sampling rate %u, format %#x, "
+ "channel mask 0x%X, flags %#x", __func__, device->toString().c_str(),
+ config->sample_rate, config->format, config->channel_mask, flags);
return input;
}
}
@@ -1995,14 +1978,7 @@
lConfig.channel_mask = profileChannelMask;
lConfig.format = profileFormat;
- if (address == "") {
- DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromTypeMask(device);
- // the inputs vector must be of size >= 1, but we don't want to crash here
- address = getFirstDeviceAddress(inputDevices);
- }
-
- status_t status = inputDesc->open(&lConfig, device, address,
- halInputSource, profileFlags, &input);
+ status_t status = inputDesc->open(&lConfig, device, halInputSource, profileFlags, &input);
// only accept input with the exact requested set of parameters
if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
@@ -2059,7 +2035,7 @@
// indicate active capture to sound trigger service if starting capture from a mic on
// primary HW module
- audio_devices_t device = getNewInputDevice(inputDesc);
+ sp<DeviceDescriptor> device = getNewInputDevice(inputDesc);
setInputDevice(input, device, true /* force */);
if (inputDesc->activeCount() == 1) {
@@ -2070,8 +2046,8 @@
MIX_STATE_MIXING);
}
- audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
- if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
+ DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
+ if (primaryInputDevices.contains(device) &&
mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
SoundTrigger::setCaptureState(true);
}
@@ -2079,7 +2055,7 @@
// automatically enable the remote submix output when input is started if not
// used by a policy mix of type MIX_TYPE_RECORDERS
// For remote submix (a virtual device), we open only one input per capture request.
- if (audio_is_remote_submix_device(inputDesc->mDevice)) {
+ if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
String8 address = String8("");
if (inputDesc->mPolicyMix == NULL) {
address = String8("0");
@@ -2130,7 +2106,7 @@
// automatically disable the remote submix output when input is stopped if not
// used by a policy mix of type MIX_TYPE_RECORDERS
- if (audio_is_remote_submix_device(inputDesc->mDevice)) {
+ if (audio_is_remote_submix_device(inputDesc->getDeviceType())) {
String8 address = String8("");
if (inputDesc->mPolicyMix == NULL) {
address = String8("0");
@@ -2143,14 +2119,12 @@
address, "remote-submix");
}
}
-
- audio_devices_t device = inputDesc->mDevice;
resetInputDevice(input);
// indicate inactive capture to sound trigger service if stopping capture from a mic on
// primary HW module
- audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
- if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
+ DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
+ if (primaryInputDevices.contains(inputDesc->getDevice()) &&
mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
SoundTrigger::setCaptureState(false);
}
@@ -2280,7 +2254,7 @@
status_t status = NO_ERROR;
for (size_t i = 0; i < mOutputs.size(); i++) {
sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
- audio_devices_t curDevice = desc->device();
+ audio_devices_t curDevice = desc->devices().types();
for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
if (!(streamsMatchForvolume(stream, (audio_stream_type_t)curStream))) {
continue;
@@ -2356,8 +2330,8 @@
// 4: the first output in the list
routing_strategy strategy = getStrategy(AUDIO_STREAM_MUSIC);
- audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
- SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
+ DeviceVector devices = getDevicesForStrategy(strategy, false /*fromCache*/);
+ SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
if (outputs.size() == 0) {
return AUDIO_IO_HANDLE_NONE;
@@ -2693,8 +2667,7 @@
devices[i].mType, devices[i].mAddress, String8());
SortedVector<audio_io_handle_t> outputs;
if (checkOutputsForDevice(devDesc, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
- outputs,
- devDesc->address()) != NO_ERROR) {
+ outputs) != NO_ERROR) {
ALOGE("setUidDeviceAffinities() error in checkOutputsForDevice for device=%08x"
" addr=%s", devices[i].mType, devices[i].mAddress.string());
return INVALID_OPERATION;
@@ -2715,8 +2688,7 @@
devices[i].mType, devices[i].mAddress, String8());
SortedVector<audio_io_handle_t> outputs;
if (checkOutputsForDevice(devDesc, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
- outputs,
- devDesc->address()) != NO_ERROR) {
+ outputs) != NO_ERROR) {
ALOGE("%s() error in checkOutputsForDevice for device=%08x addr=%s",
__FUNCTION__, devices[i].mType, devices[i].mAddress.string());
return INVALID_OPERATION;
@@ -2836,7 +2808,7 @@
// See if there is a profile to support this.
// AUDIO_DEVICE_NONE
- sp<IOProfile> profile = getProfileForOutput(AUDIO_DEVICE_NONE /*ignore device */,
+ sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
offloadInfo.sample_rate,
offloadInfo.format,
offloadInfo.channel_mask,
@@ -2850,7 +2822,7 @@
const audio_attributes_t& attributes) {
audio_output_flags_t output_flags = AUDIO_OUTPUT_FLAG_NONE;
audio_attributes_flags_to_audio_output_flags(attributes.flags, output_flags);
- sp<IOProfile> profile = getProfileForOutput(AUDIO_DEVICE_NONE /*ignore device */,
+ sp<IOProfile> profile = getProfileForOutput(DeviceVector() /*ignore device */,
config.sample_rate,
config.format,
config.channel_mask,
@@ -3044,8 +3016,7 @@
return BAD_VALUE;
}
- if (!outputDesc->mProfile->isCompatibleProfile(devDesc->type(),
- devDesc->address(),
+ if (!outputDesc->mProfile->isCompatibleProfile(DeviceVector(devDesc),
patch->sources[0].sample_rate,
NULL, // updatedSamplingRate
patch->sources[0].format,
@@ -3066,7 +3037,7 @@
// TODO: reconfigure output format and channels here
ALOGV("createAudioPatch() setting device %08x on output %d",
devices.types(), outputDesc->mIoHandle);
- setOutputDevice(outputDesc, devices.types(), true, 0, handle);
+ setOutputDevices(outputDesc, devices, true, 0, handle);
index = mAudioPatches.indexOfKey(*handle);
if (index >= 0) {
if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
@@ -3095,14 +3066,13 @@
return BAD_VALUE;
}
}
- sp<DeviceDescriptor> devDesc =
+ sp<DeviceDescriptor> device =
mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
- if (devDesc == 0) {
+ if (device == 0) {
return BAD_VALUE;
}
- if (!inputDesc->mProfile->isCompatibleProfile(devDesc->type(),
- devDesc->address(),
+ if (!inputDesc->mProfile->isCompatibleProfile(DeviceVector(device),
patch->sinks[0].sample_rate,
NULL, /*updatedSampleRate*/
patch->sinks[0].format,
@@ -3116,9 +3086,9 @@
return INVALID_OPERATION;
}
// TODO: reconfigure output format and channels here
- ALOGV("createAudioPatch() setting device %08x on output %d",
- devDesc->type(), inputDesc->mIoHandle);
- setInputDevice(inputDesc->mIoHandle, devDesc->type(), true, handle);
+ ALOGV("%s() setting device %s on output %d", __func__,
+ device->toString().c_str(), inputDesc->mIoHandle);
+ setInputDevice(inputDesc->mIoHandle, device, true, handle);
index = mAudioPatches.indexOfKey(*handle);
if (index >= 0) {
if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
@@ -3138,16 +3108,16 @@
return BAD_VALUE;
}
}
- sp<DeviceDescriptor> srcDeviceDesc =
+ sp<DeviceDescriptor> srcDevice =
mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
- if (srcDeviceDesc == 0) {
+ if (srcDevice == 0) {
return BAD_VALUE;
}
//update source and sink with our own data as the data passed in the patch may
// be incomplete.
struct audio_patch newPatch = *patch;
- srcDeviceDesc->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]);
+ srcDevice->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]);
for (size_t i = 0; i < patch->num_sinks; i++) {
if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
@@ -3155,26 +3125,26 @@
return INVALID_OPERATION;
}
- sp<DeviceDescriptor> sinkDeviceDesc =
+ sp<DeviceDescriptor> sinkDevice =
mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
- if (sinkDeviceDesc == 0) {
+ if (sinkDevice == 0) {
return BAD_VALUE;
}
- sinkDeviceDesc->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]);
+ sinkDevice->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]);
// create a software bridge in PatchPanel if:
// - source and sink devices are on different HW modules OR
// - audio HAL version is < 3.0
// - audio HAL version is >= 3.0 but no route has been declared between devices
- if (!srcDeviceDesc->hasSameHwModuleAs(sinkDeviceDesc) ||
- (srcDeviceDesc->getModuleVersionMajor() < 3) ||
- !srcDeviceDesc->getModule()->supportsPatch(srcDeviceDesc, sinkDeviceDesc)) {
+ if (!srcDevice->hasSameHwModuleAs(sinkDevice) ||
+ (srcDevice->getModuleVersionMajor() < 3) ||
+ !srcDevice->getModule()->supportsPatch(srcDevice, sinkDevice)) {
// support only one sink device for now to simplify output selection logic
if (patch->num_sinks > 1) {
return INVALID_OPERATION;
}
SortedVector<audio_io_handle_t> outputs =
- getOutputsForDevice(sinkDeviceDesc->type(), mOutputs);
+ getOutputsForDevices(DeviceVector(sinkDevice), mOutputs);
// if the sink device is reachable via an opened output stream, request to go via
// this output stream by adding a second source to the patch description
audio_io_handle_t output = selectOutput(outputs);
@@ -3232,11 +3202,11 @@
return BAD_VALUE;
}
- setOutputDevice(outputDesc,
- getNewOutputDevice(outputDesc, true /*fromCache*/),
- true,
- 0,
- NULL);
+ setOutputDevices(outputDesc,
+ getNewOutputDevices(outputDesc, true /*fromCache*/),
+ true,
+ 0,
+ NULL);
} else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
@@ -3359,8 +3329,8 @@
void AudioPolicyManager::checkStrategyRoute(routing_strategy strategy,
audio_io_handle_t ouptutToSkip)
{
- audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
- SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
+ DeviceVector devices = getDevicesForStrategy(strategy, false /*fromCache*/);
+ SortedVector<audio_io_handle_t> outputs = getOutputsForDevices(devices, mOutputs);
for (size_t j = 0; j < mOutputs.size(); j++) {
if (mOutputs.keyAt(j) == ouptutToSkip) {
continue;
@@ -3379,8 +3349,8 @@
}
}
} else {
- audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
- setOutputDevice(outputDesc, newDevice, false);
+ setOutputDevices(
+ outputDesc, getNewOutputDevices(outputDesc, false /*fromCache*/), false);
}
}
}
@@ -3443,7 +3413,8 @@
{
*session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
*ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
- *device = getDeviceAndMixForInputSource(AUDIO_SOURCE_HOTWORD);
+ audio_attributes_t attr = { .source = AUDIO_SOURCE_HOTWORD };
+ *device = getDeviceAndMixForAttributes(attr)->type();
return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
}
@@ -3469,10 +3440,10 @@
return INVALID_OPERATION;
}
- sp<DeviceDescriptor> srcDeviceDesc =
+ sp<DeviceDescriptor> srcDevice =
mAvailableInputDevices.getDevice(source->ext.device.type,
- String8(source->ext.device.address));
- if (srcDeviceDesc == 0) {
+ String8(source->ext.device.address));
+ if (srcDevice == 0) {
ALOGW("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
return BAD_VALUE;
}
@@ -3483,7 +3454,7 @@
sp<AudioPatch> patchDesc = new AudioPatch(&dummyPatch, uid);
sp<SourceClientDescriptor> sourceDesc =
- new SourceClientDescriptor(*portId, uid, *attributes, patchDesc, srcDeviceDesc,
+ new SourceClientDescriptor(*portId, uid, *attributes, patchDesc, srcDevice,
streamTypefromAttributesInt(attributes),
getStrategyForAttr(attributes));
@@ -3504,18 +3475,20 @@
audio_attributes_t attributes = sourceDesc->attributes();
routing_strategy strategy = getStrategyForAttr(&attributes);
audio_stream_type_t stream = sourceDesc->stream();
- sp<DeviceDescriptor> srcDeviceDesc = sourceDesc->srcDevice();
+ sp<DeviceDescriptor> srcDevice = sourceDesc->srcDevice();
- audio_devices_t sinkDevice = getDeviceForStrategy(strategy, true);
- sp<DeviceDescriptor> sinkDeviceDesc =
- mAvailableOutputDevices.getDevice(sinkDevice, String8(""));
+ DeviceVector sinkDevices = getDevicesForStrategy(strategy, true);
+ ALOG_ASSERT(!sinkDevices.isEmpty(), "connectAudioSource(): no device found for strategy");
+ sp<DeviceDescriptor> sinkDevice = sinkDevices.itemAt(0);
+ ALOG_ASSERT(mAvailableOutputDevices.contains(sinkDevice), "%s: Device %s not available",
+ __FUNCTION__, sinkDevice->toString().c_str());
audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
- if (srcDeviceDesc->hasSameHwModuleAs(sinkDeviceDesc) &&
- srcDeviceDesc->getModuleVersionMajor() >= 3 &&
- sinkDeviceDesc->getModule()->supportsPatch(srcDeviceDesc, sinkDeviceDesc) &&
- srcDeviceDesc->getAudioPort()->mGains.size() > 0) {
+ if (srcDevice->hasSameHwModuleAs(sinkDevice) &&
+ srcDevice->getModuleVersionMajor() >= 3 &&
+ sinkDevice->getModule()->supportsPatch(srcDevice, sinkDevice) &&
+ srcDevice->getAudioPort()->mGains.size() > 0) {
ALOGV("%s Device to Device route supported by >=3.0 HAL", __FUNCTION__);
// TODO: may explicitly specify whether we should use HW or SW patch
// create patch between src device and output device
@@ -3532,12 +3505,12 @@
getOutputForAttrInt(&resultAttr, &output, AUDIO_SESSION_NONE,
&attributes, &stream, sourceDesc->uid(), &config, &flags, &selectedDeviceId);
if (output == AUDIO_IO_HANDLE_NONE) {
- ALOGV("%s no output for device %08x", __FUNCTION__, sinkDevice);
+ ALOGV("%s no output for device %08x", __FUNCTION__, sinkDevices.types());
return INVALID_OPERATION;
}
sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
if (outputDesc->isDuplicated()) {
- ALOGV("%s output for device %08x is duplicated", __FUNCTION__, sinkDevice);
+ ALOGV("%s output for device %08x is duplicated", __FUNCTION__, sinkDevices.types());
return INVALID_OPERATION;
}
status_t status = outputDesc->start();
@@ -3551,7 +3524,7 @@
// - the sink is defined by whatever output device is currently selected for the output
// though which this patch is routed.
PatchBuilder patchBuilder;
- patchBuilder.addSource(srcDeviceDesc).addSource(outputDesc, { .stream = stream });
+ patchBuilder.addSource(srcDevice).addSource(outputDesc, { .stream = stream });
status = mpClientInterface->createAudioPatch(patchBuilder.patch(),
&afPatchHandle,
0);
@@ -3978,8 +3951,6 @@
// mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
// open all output streams needed to access attached devices
- audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types();
- audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
for (const auto& hwModule : mHwModulesAll) {
hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
@@ -4008,51 +3979,49 @@
if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
continue;
}
- audio_devices_t profileType = outProfile->getSupportedDevicesType();
- if ((profileType & mDefaultOutputDevice->type()) != AUDIO_DEVICE_NONE) {
- profileType = mDefaultOutputDevice->type();
+ const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
+ DeviceVector availProfileDevices = supportedDevices.filter(mAvailableOutputDevices);
+ sp<DeviceDescriptor> supportedDevice = 0;
+ if (supportedDevices.contains(mDefaultOutputDevice)) {
+ supportedDevice = mDefaultOutputDevice;
} else {
- // chose first device present in profile's SupportedDevices also part of
- // outputDeviceTypes
- profileType = outProfile->getSupportedDeviceForType(outputDeviceTypes);
+ // choose first device present in profile's SupportedDevices also part of
+ // mAvailableOutputDevices.
+ if (availProfileDevices.isEmpty()) {
+ continue;
+ }
+ supportedDevice = availProfileDevices.itemAt(0);
}
- if ((profileType & outputDeviceTypes) == 0) {
+ if (!mAvailableOutputDevices.contains(supportedDevice)) {
continue;
}
sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
mpClientInterface);
- const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
- const DeviceVector &devicesForType = supportedDevices.getDevicesFromTypeMask(
- profileType);
- String8 address = getFirstDeviceAddress(devicesForType);
audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
- status_t status = outputDesc->open(nullptr, profileType, address,
- AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
-
+ status_t status = outputDesc->open(nullptr, DeviceVector(supportedDevice),
+ AUDIO_STREAM_DEFAULT,
+ AUDIO_OUTPUT_FLAG_NONE, &output);
if (status != NO_ERROR) {
- ALOGW("Cannot open output stream for device %08x on hw module %s",
- outputDesc->mDevice,
- hwModule->getName());
- } else {
- for (const auto& dev : supportedDevices) {
- ssize_t index = mAvailableOutputDevices.indexOf(dev);
- // give a valid ID to an attached device once confirmed it is reachable
- if (index >= 0 && !mAvailableOutputDevices[index]->isAttached()) {
- mAvailableOutputDevices[index]->attach(hwModule);
- }
- }
- if (mPrimaryOutput == 0 &&
- outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
- mPrimaryOutput = outputDesc;
- }
- addOutput(output, outputDesc);
- setOutputDevice(outputDesc,
- profileType,
- true,
- 0,
- NULL,
- address);
+ ALOGW("Cannot open output stream for devices %s on hw module %s",
+ supportedDevice->toString().c_str(), hwModule->getName());
+ continue;
}
+ for (const auto &device : availProfileDevices) {
+ // give a valid ID to an attached device once confirmed it is reachable
+ if (!device->isAttached()) {
+ device->attach(hwModule);
+ }
+ }
+ if (mPrimaryOutput == 0 &&
+ outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
+ mPrimaryOutput = outputDesc;
+ }
+ addOutput(output, outputDesc);
+ setOutputDevices(outputDesc,
+ DeviceVector(supportedDevice),
+ true,
+ 0,
+ NULL);
}
// open input streams needed to access attached devices to validate
// mAvailableInputDevices list
@@ -4067,75 +4036,59 @@
continue;
}
// chose first device present in profile's SupportedDevices also part of
- // inputDeviceTypes
- audio_devices_t profileType = inProfile->getSupportedDeviceForType(inputDeviceTypes);
-
- if ((profileType & inputDeviceTypes) == 0) {
+ // available input devices
+ const DeviceVector &supportedDevices = inProfile->getSupportedDevices();
+ DeviceVector availProfileDevices = supportedDevices.filter(mAvailableInputDevices);
+ if (availProfileDevices.isEmpty()) {
+ ALOGE("%s: Input device list is empty!", __FUNCTION__);
continue;
}
sp<AudioInputDescriptor> inputDesc =
new AudioInputDescriptor(inProfile, mpClientInterface);
- DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromTypeMask(profileType);
- // the inputs vector must be of size >= 1, but we don't want to crash here
- String8 address = getFirstDeviceAddress(inputDevices);
- ALOGV(" for input device 0x%x using address %s", profileType, address.string());
- ALOGE_IF(inputDevices.size() == 0, "Input device list is empty!");
-
audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
status_t status = inputDesc->open(nullptr,
- profileType,
- address,
+ availProfileDevices.itemAt(0),
AUDIO_SOURCE_MIC,
AUDIO_INPUT_FLAG_NONE,
&input);
-
- if (status == NO_ERROR) {
- for (const auto& dev : inProfile->getSupportedDevices()) {
- ssize_t index = mAvailableInputDevices.indexOf(dev);
- // give a valid ID to an attached device once confirmed it is reachable
- if (index >= 0) {
- sp<DeviceDescriptor> devDesc = mAvailableInputDevices[index];
- if (!devDesc->isAttached()) {
- devDesc->attach(hwModule);
- devDesc->importAudioPort(inProfile, true);
- }
- }
- }
- inputDesc->close();
- } else {
- ALOGW("Cannot open input stream for device %08x on hw module %s",
- profileType,
+ if (status != NO_ERROR) {
+ ALOGW("Cannot open input stream for device %s on hw module %s",
+ availProfileDevices.toString().c_str(),
hwModule->getName());
+ continue;
}
+ for (const auto &device : availProfileDevices) {
+ // give a valid ID to an attached device once confirmed it is reachable
+ if (!device->isAttached()) {
+ device->attach(hwModule);
+ device->importAudioPort(inProfile, true);
+ }
+ }
+ inputDesc->close();
}
}
// make sure all attached devices have been allocated a unique ID
- for (size_t i = 0; i < mAvailableOutputDevices.size();) {
- if (!mAvailableOutputDevices[i]->isAttached()) {
- ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type());
- mAvailableOutputDevices.remove(mAvailableOutputDevices[i]);
- continue;
+ auto checkAndSetAvailable = [this](auto& devices) {
+ for (size_t i = 0; i < devices.size();) {
+ const auto &device = devices[i];
+ if (!device->isAttached()) {
+ ALOGW("device %s is unreachable", device->toString().c_str());
+ devices.remove(device);
+ continue;
+ }
+ // Device is now validated and can be appended to the available devices of the engine
+ mEngine->setDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
+ i++;
}
- // The device is now validated and can be appended to the available devices of the engine
- mEngine->setDeviceConnectionState(mAvailableOutputDevices[i],
- AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
- i++;
- }
- for (size_t i = 0; i < mAvailableInputDevices.size();) {
- if (!mAvailableInputDevices[i]->isAttached()) {
- ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type());
- mAvailableInputDevices.remove(mAvailableInputDevices[i]);
- continue;
- }
- // The device is now validated and can be appended to the available devices of the engine
- mEngine->setDeviceConnectionState(mAvailableInputDevices[i],
- AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
- i++;
- }
+ };
+ checkAndSetAvailable(mAvailableOutputDevices);
+ checkAndSetAvailable(mAvailableInputDevices);
+
// make sure default device is reachable
- if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) {
- ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type());
+ if (mDefaultOutputDevice == 0 || !mAvailableOutputDevices.contains(mDefaultOutputDevice)) {
+ ALOGE_IF(mDefaultOutputDevice != 0, "Default device %s is unreachable",
+ mDefaultOutputDevice->toString().c_str());
status = NO_INIT;
}
// If microphones address is empty, set it according to device type
@@ -4208,44 +4161,27 @@
nextAudioPortGeneration();
}
-void AudioPolicyManager::findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/,
- const audio_devices_t device /*in*/,
- const String8& address /*in*/,
- SortedVector<audio_io_handle_t>& outputs /*out*/) {
- sp<DeviceDescriptor> devDesc =
- desc->mProfile->getSupportedDeviceByAddress(device, address);
- if (devDesc != 0) {
- ALOGV("findIoHandlesByAddress(): adding opened output %d on same address %s",
- desc->mIoHandle, address.string());
- outputs.add(desc->mIoHandle);
- }
-}
-
-status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc,
+status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& device,
audio_policy_dev_state_t state,
- SortedVector<audio_io_handle_t>& outputs,
- const String8& address)
+ SortedVector<audio_io_handle_t>& outputs)
{
- audio_devices_t device = devDesc->type();
+ audio_devices_t deviceType = device->type();
+ const String8 &address = device->address();
sp<SwAudioOutputDescriptor> desc;
- if (audio_device_is_digital(device)) {
+ if (audio_device_is_digital(deviceType)) {
// erase all current sample rates, formats and channel masks
- devDesc->clearAudioProfiles();
+ device->clearAudioProfiles();
}
if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
// first list already open outputs that can be routed to this device
for (size_t i = 0; i < mOutputs.size(); i++) {
desc = mOutputs.valueAt(i);
- if (!desc->isDuplicated() && (desc->supportedDevices() & device)) {
- if (!device_distinguishes_on_address(device)) {
- ALOGV("checkOutputsForDevice(): adding opened output %d", mOutputs.keyAt(i));
- outputs.add(mOutputs.keyAt(i));
- } else {
- ALOGV(" checking address match due to device 0x%x", device);
- findIoHandlesByAddress(desc, device, address, outputs);
- }
+ if (!desc->isDuplicated() && desc->supportsDevice(device)) {
+ ALOGV("checkOutputsForDevice(): adding opened output %d on device %s",
+ mOutputs.keyAt(i), device->toString().c_str());
+ outputs.add(mOutputs.keyAt(i));
}
}
// then look for output profiles that can be routed to this device
@@ -4253,13 +4189,10 @@
for (const auto& hwModule : mHwModules) {
for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
- if (profile->supportDevice(device)) {
- if (!device_distinguishes_on_address(device) ||
- profile->supportDeviceAddress(address)) {
- profiles.add(profile);
- ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
- j, hwModule->getName());
- }
+ if (profile->supportsDevice(device)) {
+ profiles.add(profile);
+ ALOGV("checkOutputsForDevice(): adding profile %zu from module %s",
+ j, hwModule->getName());
}
}
}
@@ -4267,7 +4200,7 @@
ALOGV(" found %zu profiles, %zu outputs", profiles.size(), outputs.size());
if (profiles.isEmpty() && outputs.isEmpty()) {
- ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
+ ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
return BAD_VALUE;
}
@@ -4283,8 +4216,8 @@
if (!desc->isDuplicated() && desc->mProfile == profile) {
// matching profile: save the sample rates, format and channel masks supported
// by the profile in our device descriptor
- if (audio_device_is_digital(device)) {
- devDesc->importAudioPort(profile);
+ if (audio_device_is_digital(deviceType)) {
+ device->importAudioPort(profile);
}
break;
}
@@ -4300,20 +4233,20 @@
}
ALOGV("opening output for device %08x with params %s profile %p name %s",
- device, address.string(), profile.get(), profile->getName().string());
+ deviceType, address.string(), profile.get(), profile->getName().string());
desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
- status_t status = desc->open(nullptr, device, address,
+ status_t status = desc->open(nullptr, DeviceVector(device),
AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
if (status == NO_ERROR) {
// Here is where the out_set_parameters() for card & device gets called
if (!address.isEmpty()) {
- char *param = audio_device_address_to_parameter(device, address);
+ char *param = audio_device_address_to_parameter(deviceType, address);
mpClientInterface->setParameters(output, String8(param));
free(param);
}
- updateAudioProfiles(devDesc, output, profile->getAudioProfiles());
+ updateAudioProfiles(device, output, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkOutputsForDevice() missing param");
desc->close();
@@ -4328,7 +4261,8 @@
config.offload_info.channel_mask = config.channel_mask;
config.offload_info.format = config.format;
- status_t status = desc->open(&config, device, address, AUDIO_STREAM_DEFAULT,
+ status_t status = desc->open(&config, DeviceVector(device),
+ AUDIO_STREAM_DEFAULT,
AUDIO_OUTPUT_FLAG_NONE, &output);
if (status != NO_ERROR) {
output = AUDIO_IO_HANDLE_NONE;
@@ -4337,14 +4271,15 @@
if (output != AUDIO_IO_HANDLE_NONE) {
addOutput(output, desc);
- if (device_distinguishes_on_address(device) && address != "0") {
+ if (device_distinguishes_on_address(deviceType) && address != "0") {
sp<AudioPolicyMix> policyMix;
- if (mPolicyMixes.getAudioPolicyMix(address, policyMix) != NO_ERROR) {
- ALOGE("checkOutputsForDevice() cannot find policy for address %s",
+ if (mPolicyMixes.getAudioPolicyMix(address, policyMix) == NO_ERROR) {
+ policyMix->setOutput(desc);
+ desc->mPolicyMix = policyMix->getMix();
+ } else {
+ ALOGW("checkOutputsForDevice() cannot find policy for address %s",
address.string());
}
- policyMix->setOutput(desc);
- desc->mPolicyMix = policyMix->getMix();
} else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
hasPrimaryOutput()) {
@@ -4376,28 +4311,28 @@
output = AUDIO_IO_HANDLE_NONE;
}
if (output == AUDIO_IO_HANDLE_NONE) {
- ALOGW("checkOutputsForDevice() could not open output for device %x", device);
+ ALOGW("checkOutputsForDevice() could not open output for device %x", deviceType);
profiles.removeAt(profile_index);
profile_index--;
} else {
outputs.add(output);
// Load digital format info only for digital devices
- if (audio_device_is_digital(device)) {
- devDesc->importAudioPort(profile);
+ if (audio_device_is_digital(deviceType)) {
+ device->importAudioPort(profile);
}
- if (device_distinguishes_on_address(device)) {
- ALOGV("checkOutputsForDevice(): setOutputDevice(dev=0x%x, addr=%s)",
- device, address.string());
- setOutputDevice(desc, device, true/*force*/, 0/*delay*/,
- NULL/*patch handle*/, address.string());
+ if (device_distinguishes_on_address(deviceType)) {
+ ALOGV("checkOutputsForDevice(): setOutputDevices %s",
+ device->toString().c_str());
+ setOutputDevices(desc, DeviceVector(device), true/*force*/, 0/*delay*/,
+ NULL/*patch handle*/);
}
ALOGV("checkOutputsForDevice(): adding output %d", output);
}
}
if (profiles.isEmpty()) {
- ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
+ ALOGW("checkOutputsForDevice(): No output available for device %04x", deviceType);
return BAD_VALUE;
}
} else { // Disconnect
@@ -4406,10 +4341,9 @@
desc = mOutputs.valueAt(i);
if (!desc->isDuplicated()) {
// exact match on device
- if (device_distinguishes_on_address(device) &&
- (desc->supportedDevices() == device)) {
- findIoHandlesByAddress(desc, device, address, outputs);
- } else if (!(desc->supportedDevices() & mAvailableOutputDevices.types())) {
+ if (device_distinguishes_on_address(deviceType) && desc->supportsDevice(device)) {
+ outputs.add(mOutputs.keyAt(i));
+ } else if (!mAvailableOutputDevices.containsAtLeastOne(desc->supportedDevices())) {
ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
mOutputs.keyAt(i));
outputs.add(mOutputs.keyAt(i));
@@ -4420,7 +4354,7 @@
for (const auto& hwModule : mHwModules) {
for (size_t j = 0; j < hwModule->getOutputProfiles().size(); j++) {
sp<IOProfile> profile = hwModule->getOutputProfiles()[j];
- if (profile->supportDevice(device)) {
+ if (profile->supportsDevice(device)) {
ALOGV("checkOutputsForDevice(): "
"clearing direct output profile %zu on module %s",
j, hwModule->getName());
@@ -4432,24 +4366,22 @@
return NO_ERROR;
}
-status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& devDesc,
+status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& device,
audio_policy_dev_state_t state,
- SortedVector<audio_io_handle_t>& inputs,
- const String8& address)
+ SortedVector<audio_io_handle_t>& inputs)
{
- audio_devices_t device = devDesc->type();
sp<AudioInputDescriptor> desc;
- if (audio_device_is_digital(device)) {
+ if (audio_device_is_digital(device->type())) {
// erase all current sample rates, formats and channel masks
- devDesc->clearAudioProfiles();
+ device->clearAudioProfiles();
}
if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
// first list already open inputs that can be routed to this device
for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
desc = mInputs.valueAt(input_index);
- if (desc->mProfile->supportDevice(device)) {
+ if (desc->mProfile->supportsDeviceTypes(device->type())) {
ALOGV("checkInputsForDevice(): adding opened input %d", mInputs.keyAt(input_index));
inputs.add(mInputs.keyAt(input_index));
}
@@ -4463,19 +4395,16 @@
profile_index++) {
sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
- if (profile->supportDevice(device)) {
- if (!device_distinguishes_on_address(device) ||
- profile->supportDeviceAddress(address)) {
- profiles.add(profile);
- ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
- profile_index, hwModule->getName());
- }
+ if (profile->supportsDevice(device)) {
+ profiles.add(profile);
+ ALOGV("checkInputsForDevice(): adding profile %zu from module %s",
+ profile_index, hwModule->getName());
}
}
}
if (profiles.isEmpty() && inputs.isEmpty()) {
- ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
+ ALOGW("%s: No input available for device %s", __func__, device->toString().c_str());
return BAD_VALUE;
}
@@ -4490,8 +4419,8 @@
for (input_index = 0; input_index < mInputs.size(); input_index++) {
desc = mInputs.valueAt(input_index);
if (desc->mProfile == profile) {
- if (audio_device_is_digital(device)) {
- devDesc->importAudioPort(profile);
+ if (audio_device_is_digital(device->type())) {
+ device->importAudioPort(profile);
}
break;
}
@@ -4510,18 +4439,18 @@
audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
status_t status = desc->open(nullptr,
device,
- address,
AUDIO_SOURCE_MIC,
AUDIO_INPUT_FLAG_NONE,
&input);
if (status == NO_ERROR) {
+ const String8& address = device->address();
if (!address.isEmpty()) {
- char *param = audio_device_address_to_parameter(device, address);
+ char *param = audio_device_address_to_parameter(device->type(), address);
mpClientInterface->setParameters(input, String8(param));
free(param);
}
- updateAudioProfiles(devDesc, input, profile->getAudioProfiles());
+ updateAudioProfiles(device, input, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkInputsForDevice() direct input missing param");
desc->close();
@@ -4534,20 +4463,21 @@
} // endif input != 0
if (input == AUDIO_IO_HANDLE_NONE) {
- ALOGW("checkInputsForDevice() could not open input for device 0x%X", device);
+ ALOGW("%s could not open input for device %s", __func__,
+ device->toString().c_str());
profiles.removeAt(profile_index);
profile_index--;
} else {
inputs.add(input);
- if (audio_device_is_digital(device)) {
- devDesc->importAudioPort(profile);
+ if (audio_device_is_digital(device->type())) {
+ device->importAudioPort(profile);
}
ALOGV("checkInputsForDevice(): adding input %d", input);
}
} // end scan profiles
if (profiles.isEmpty()) {
- ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
+ ALOGW("%s: No input available for device %s", __func__, device->toString().c_str());
return BAD_VALUE;
}
} else {
@@ -4555,7 +4485,7 @@
// check if one opened input is not needed any more after disconnecting one device
for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
desc = mInputs.valueAt(input_index);
- if (!(desc->mProfile->supportDevice(mAvailableInputDevices.types()))) {
+ if (!mAvailableInputDevices.containsAtLeastOne(desc->supportedDevices())) {
ALOGV("checkInputsForDevice(): disconnecting adding input %d",
mInputs.keyAt(input_index));
inputs.add(mInputs.keyAt(input_index));
@@ -4567,7 +4497,7 @@
profile_index < hwModule->getInputProfiles().size();
profile_index++) {
sp<IOProfile> profile = hwModule->getInputProfiles()[profile_index];
- if (profile->supportDevice(device)) {
+ if (profile->supportsDevice(device)) {
ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %s",
profile_index, hwModule->getName());
profile->clearAudioProfiles();
@@ -4641,7 +4571,7 @@
// MSD patches may have been released to support a non-MSD direct output. Reset MSD patch if
// no direct outputs are open.
- if (mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD) != 0) {
+ if (!getMsdAudioOutDevices().isEmpty()) {
bool directOutputOpen = false;
for (size_t i = 0; i < mOutputs.size(); i++) {
if (mOutputs[i]->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
@@ -4668,7 +4598,7 @@
nextAudioPortGeneration();
- audio_devices_t device = inputDesc->mDevice;
+ sp<DeviceDescriptor> device = inputDesc->getDevice();
ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
if (index >= 0) {
sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
@@ -4680,26 +4610,26 @@
inputDesc->close();
mInputs.removeItem(input);
- audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
- if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
+ DeviceVector primaryInputDevices = availablePrimaryModuleInputDevices();
+ if (primaryInputDevices.contains(device) &&
mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
SoundTrigger::setCaptureState(false);
}
}
-SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevice(
- audio_devices_t device,
- const SwAudioOutputCollection& openOutputs)
+SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevices(
+ const DeviceVector &devices,
+ const SwAudioOutputCollection& openOutputs)
{
SortedVector<audio_io_handle_t> outputs;
- ALOGVV("getOutputsForDevice() device %04x", device);
+ ALOGVV("%s() devices %s", __func__, devices.toString().c_str());
for (size_t i = 0; i < openOutputs.size(); i++) {
- ALOGVV("output %zu isDuplicated=%d device=%04x",
+ ALOGVV("output %zu isDuplicated=%d device=%s",
i, openOutputs.valueAt(i)->isDuplicated(),
- openOutputs.valueAt(i)->supportedDevices());
- if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) {
- ALOGVV("getOutputsForDevice() found output %d", openOutputs.keyAt(i));
+ openOutputs.valueAt(i)->supportedDevices().toString().c_str());
+ if (openOutputs.valueAt(i)->supportsAllDevices(devices)) {
+ ALOGVV("%s() found output %d", __func__, openOutputs.keyAt(i));
outputs.add(openOutputs.keyAt(i));
}
}
@@ -4721,10 +4651,10 @@
void AudioPolicyManager::checkOutputForStrategy(routing_strategy strategy)
{
- audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/);
- audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/);
- SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs);
- SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs);
+ DeviceVector oldDevices = getDevicesForStrategy(strategy, true /*fromCache*/);
+ DeviceVector newDevices = getDevicesForStrategy(strategy, false /*fromCache*/);
+ SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevices(oldDevices, mPreviousOutputs);
+ SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevices(newDevices, mOutputs);
// also take into account external policy-related changes: add all outputs which are
// associated with policies in the "before" and "after" output vectors
@@ -4744,7 +4674,7 @@
}
}
- if (srcOutputs != dstOutputs) {
+ if (!dstOutputs.isEmpty() && srcOutputs != dstOutputs) {
// get maximum latency of all source outputs to determine the minimum mute time guaranteeing
// audio from invalidated tracks will be rendered when unmuting
uint32_t maxLatency = 0;
@@ -4754,14 +4684,16 @@
maxLatency = desc->latency();
}
}
- ALOGV("checkOutputForStrategy() strategy %d, moving from output %d to output %d",
- strategy, srcOutputs[0], dstOutputs[0]);
+ ALOGV("%s: strategy %d, moving from output %s to output %s", __func__, strategy,
+ (srcOutputs.isEmpty()? "none" : std::to_string(srcOutputs[0]).c_str()),
+ (dstOutputs.isEmpty()? "none" : std::to_string(dstOutputs[0]).c_str()));
// mute strategy while moving tracks from one output to another
for (audio_io_handle_t srcOut : srcOutputs) {
sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueFor(srcOut);
if (desc != 0 && isStrategyActive(desc, strategy)) {
setStrategyMute(strategy, true, desc);
- setStrategyMute(strategy, false, desc, maxLatency * LATENCY_MUTE_FACTOR, newDevice);
+ setStrategyMute(strategy, false, desc, maxLatency * LATENCY_MUTE_FACTOR,
+ newDevices.types());
}
sp<SourceClientDescriptor> source =
getSourceForStrategyOnOutput(srcOut, strategy);
@@ -4880,26 +4812,28 @@
return device;
}
-audio_devices_t AudioPolicyManager::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
- bool fromCache)
+DeviceVector AudioPolicyManager::getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
+ bool fromCache)
{
+ DeviceVector devices;
+
ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
if (index >= 0) {
sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
if (patchDesc->mUid != mUidCached) {
- ALOGV("getNewOutputDevice() device %08x forced by patch %d",
- outputDesc->device(), outputDesc->getPatchHandle());
- return outputDesc->device();
+ ALOGV("%s device %s forced by patch %d", __func__,
+ outputDesc->devices().toString().c_str(), outputDesc->getPatchHandle());
+ return outputDesc->devices();
}
}
// Honor explicit routing requests only if no client using default routing is active on this
// input: a specific app can not force routing for other apps by setting a preferred device.
bool active; // unused
- sp<DeviceDescriptor> deviceDesc =
+ sp<DeviceDescriptor> device =
findPreferredDevice(outputDesc, STRATEGY_NONE, active, mAvailableOutputDevices);
- if (deviceDesc != nullptr) {
- return deviceDesc->type();
+ if (device != nullptr) {
+ return DeviceVector(device);
}
// check the following by order of priority to request a routing change if necessary:
@@ -4925,66 +4859,65 @@
// FIXME: extend use of isStrategyActiveOnSameModule() to all strategies
// with a refined rule considering mutually exclusive devices (using same backend)
// as opposed to all streams on the same audio HAL module.
- audio_devices_t device = AUDIO_DEVICE_NONE;
if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) &&
mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
- device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
} else if (isInCall() ||
isStrategyActiveOnSameModule(outputDesc, STRATEGY_PHONE)) {
- device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_PHONE, fromCache);
} else if (isStrategyActiveOnSameModule(outputDesc, STRATEGY_SONIFICATION)) {
- device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_SONIFICATION, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) {
- device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) {
- device = getDeviceForStrategy(STRATEGY_ACCESSIBILITY, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_ACCESSIBILITY, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)) {
- device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) {
- device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_MEDIA, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) {
- device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_DTMF, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) {
- device = getDeviceForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache);
} else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) {
- device = getDeviceForStrategy(STRATEGY_REROUTING, fromCache);
+ devices = getDevicesForStrategy(STRATEGY_REROUTING, fromCache);
}
- ALOGV("getNewOutputDevice() selected device %x", device);
- return device;
+ ALOGV("getNewOutputDevice() selected devices %s", devices.toString().c_str());
+ return devices;
}
-audio_devices_t AudioPolicyManager::getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc)
+sp<DeviceDescriptor> AudioPolicyManager::getNewInputDevice(
+ const sp<AudioInputDescriptor>& inputDesc)
{
- audio_devices_t device = AUDIO_DEVICE_NONE;
+ sp<DeviceDescriptor> device;
ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
if (index >= 0) {
sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
if (patchDesc->mUid != mUidCached) {
- ALOGV("getNewInputDevice() device %08x forced by patch %d",
- inputDesc->mDevice, inputDesc->getPatchHandle());
- return inputDesc->mDevice;
+ ALOGV("getNewInputDevice() device %s forced by patch %d",
+ inputDesc->getDevice()->toString().c_str(), inputDesc->getPatchHandle());
+ return inputDesc->getDevice();
}
}
// Honor explicit routing requests only if no client using default routing is active on this
// input: a specific app can not force routing for other apps by setting a preferred device.
bool active;
- sp<DeviceDescriptor> deviceDesc =
- findPreferredDevice(inputDesc, AUDIO_SOURCE_DEFAULT, active, mAvailableInputDevices);
- if (deviceDesc != nullptr) {
- return deviceDesc->type();
+ device = findPreferredDevice(inputDesc, AUDIO_SOURCE_DEFAULT, active, mAvailableInputDevices);
+ if (device != nullptr) {
+ return device;
}
// If we are not in call and no client is active on this input, this methods returns
// AUDIO_DEVICE_NONE, causing the patch on the input stream to be released.
- audio_source_t source = inputDesc->source();
- if (source == AUDIO_SOURCE_DEFAULT && isInCall()) {
- source = AUDIO_SOURCE_VOICE_COMMUNICATION;
+ audio_attributes_t attributes = inputDesc->getHighestPriorityAttributes();
+ if (attributes.source == AUDIO_SOURCE_DEFAULT && isInCall()) {
+ attributes.source = AUDIO_SOURCE_VOICE_COMMUNICATION;
}
- if (source != AUDIO_SOURCE_DEFAULT) {
- device = getDeviceAndMixForInputSource(source);
+ if (attributes.source != AUDIO_SOURCE_DEFAULT) {
+ device = getDeviceAndMixForAttributes(attributes);
}
return device;
@@ -5006,36 +4939,37 @@
if (stream < (audio_stream_type_t) 0 || stream >= AUDIO_STREAM_PUBLIC_CNT) {
return AUDIO_DEVICE_NONE;
}
- audio_devices_t activeDevices = AUDIO_DEVICE_NONE;
- audio_devices_t devices = AUDIO_DEVICE_NONE;
+ DeviceVector activeDevices;
+ DeviceVector devices;
for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
continue;
}
routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream);
- audio_devices_t curDevices =
- getDeviceForStrategy((routing_strategy)curStrategy, false /*fromCache*/);
- devices |= curDevices;
- for (audio_io_handle_t output : getOutputsForDevice(curDevices, mOutputs)) {
+ DeviceVector curDevices =
+ getDevicesForStrategy((routing_strategy)curStrategy, false /*fromCache*/);
+ devices.merge(curDevices);
+ for (audio_io_handle_t output : getOutputsForDevices(curDevices, mOutputs)) {
sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
if (outputDesc->isStreamActive((audio_stream_type_t)curStream)) {
- activeDevices |= outputDesc->device();
+ activeDevices.merge(outputDesc->devices());
}
}
}
// Favor devices selected on active streams if any to report correct device in case of
// explicit device selection
- if (activeDevices != AUDIO_DEVICE_NONE) {
+ if (!activeDevices.isEmpty()) {
devices = activeDevices;
}
/*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it
and doesn't really need to.*/
- if (devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
- devices |= AUDIO_DEVICE_OUT_SPEAKER;
- devices &= ~AUDIO_DEVICE_OUT_SPEAKER_SAFE;
+ DeviceVector speakerSafeDevices = devices.getDevicesFromTypeMask(AUDIO_DEVICE_OUT_SPEAKER_SAFE);
+ if (!speakerSafeDevices.isEmpty()) {
+ devices.merge(mAvailableOutputDevices.getDevicesFromTypeMask(AUDIO_DEVICE_OUT_SPEAKER));
+ devices.remove(speakerSafeDevices);
}
- return devices;
+ return devices.types();
}
routing_strategy AudioPolicyManager::getStrategy(audio_stream_type_t stream) const
@@ -5126,34 +5060,33 @@
return 0;
}
-audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
- bool fromCache)
+DeviceVector AudioPolicyManager::getDevicesForStrategy(routing_strategy strategy, bool fromCache)
{
// Honor explicit routing requests only if all active clients have a preferred route in which
// case the last active client route is used
- sp<DeviceDescriptor> deviceDesc = findPreferredDevice(mOutputs, strategy, mAvailableOutputDevices);
- if (deviceDesc != nullptr) {
- return deviceDesc->type();
+ sp<DeviceDescriptor> device = findPreferredDevice(mOutputs, strategy, mAvailableOutputDevices);
+ if (device != nullptr) {
+ return DeviceVector(device);
}
if (fromCache) {
- ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
- strategy, mDeviceForStrategy[strategy]);
- return mDeviceForStrategy[strategy];
+ ALOGVV("%s from cache strategy %d, device %s", __func__, strategy,
+ mDevicesForStrategy[strategy].toString().c_str());
+ return mDevicesForStrategy[strategy];
}
- return mEngine->getDeviceForStrategy(strategy);
+ return mAvailableOutputDevices.getDevicesFromTypeMask(mEngine->getDeviceForStrategy(strategy));
}
void AudioPolicyManager::updateDevicesAndOutputs()
{
for (int i = 0; i < NUM_STRATEGIES; i++) {
- mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
+ mDevicesForStrategy[i] = getDevicesForStrategy((routing_strategy)i, false /*fromCache*/);
}
mPreviousOutputs = mOutputs;
}
uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
- audio_devices_t prevDevice,
+ audio_devices_t prevDeviceType,
uint32_t delayMs)
{
// mute/unmute strategies using an incompatible device combination
@@ -5164,13 +5097,14 @@
}
uint32_t muteWaitMs = 0;
- audio_devices_t device = outputDesc->device();
- bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2);
+ audio_devices_t deviceType = outputDesc->devices().types();
+ bool shouldMute = outputDesc->isActive() && (popcount(deviceType) >= 2);
for (size_t i = 0; i < NUM_STRATEGIES; i++) {
- audio_devices_t curDevice = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
- curDevice = curDevice & outputDesc->supportedDevices();
- bool mute = shouldMute && (curDevice & device) && (curDevice != device);
+ audio_devices_t curDeviceType =
+ getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
+ curDeviceType = curDeviceType & outputDesc->supportedDevices().types();
+ bool mute = shouldMute && (curDeviceType & deviceType) && (curDeviceType != deviceType);
bool doMute = false;
if (mute && !outputDesc->mStrategyMutedByDevice[i]) {
@@ -5184,12 +5118,11 @@
for (size_t j = 0; j < mOutputs.size(); j++) {
sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
// skip output if it does not share any device with current output
- if ((desc->supportedDevices() & outputDesc->supportedDevices())
- == AUDIO_DEVICE_NONE) {
+ if (!desc->supportedDevices().containsAtLeastOne(outputDesc->supportedDevices())) {
continue;
}
ALOGVV("checkDeviceMuteStrategies() %s strategy %zu (curDevice %04x)",
- mute ? "muting" : "unmuting", i, curDevice);
+ mute ? "muting" : "unmuting", i, curDeviceType);
setStrategyMute((routing_strategy)i, mute, desc, mute ? 0 : delayMs);
if (isStrategyActive(desc, (routing_strategy)i)) {
if (mute) {
@@ -5209,7 +5142,7 @@
// temporary mute output if device selection changes to avoid volume bursts due to
// different per device volumes
- if (outputDesc->isActive() && (device != prevDevice)) {
+ if (outputDesc->isActive() && (deviceType != prevDeviceType)) {
uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
// temporary mute duration is conservatively set to 4 times the reported latency
uint32_t tempMuteDurationMs = outputDesc->latency() * 4;
@@ -5223,7 +5156,7 @@
// delayed device change
setStrategyMute((routing_strategy)i, true, outputDesc, delayMs);
setStrategyMute((routing_strategy)i, false, outputDesc,
- delayMs + tempMuteDurationMs, device);
+ delayMs + tempMuteDurationMs, deviceType);
}
}
}
@@ -5237,46 +5170,45 @@
return 0;
}
-uint32_t AudioPolicyManager::setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
- audio_devices_t device,
- bool force,
- int delayMs,
- audio_patch_handle_t *patchHandle,
- const char *address,
- bool requiresMuteCheck)
+uint32_t AudioPolicyManager::setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
+ const DeviceVector &devices,
+ bool force,
+ int delayMs,
+ audio_patch_handle_t *patchHandle,
+ bool requiresMuteCheck)
{
- ALOGV("setOutputDevice() device %04x delayMs %d", device, delayMs);
- AudioParameter param;
+ ALOGV("%s device %s delayMs %d", __func__, devices.toString().c_str(), delayMs);
uint32_t muteWaitMs;
if (outputDesc->isDuplicated()) {
- muteWaitMs = setOutputDevice(outputDesc->subOutput1(), device, force, delayMs,
- nullptr /* patchHandle */, nullptr /* address */, requiresMuteCheck);
- muteWaitMs += setOutputDevice(outputDesc->subOutput2(), device, force, delayMs,
- nullptr /* patchHandle */, nullptr /* address */, requiresMuteCheck);
+ muteWaitMs = setOutputDevices(outputDesc->subOutput1(), devices, force, delayMs,
+ nullptr /* patchHandle */, requiresMuteCheck);
+ muteWaitMs += setOutputDevices(outputDesc->subOutput2(), devices, force, delayMs,
+ nullptr /* patchHandle */, requiresMuteCheck);
return muteWaitMs;
}
- // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
- // output profile
- if ((device != AUDIO_DEVICE_NONE) &&
- ((device & outputDesc->supportedDevices()) == AUDIO_DEVICE_NONE)) {
- return 0;
- }
// filter devices according to output selected
- device = (audio_devices_t)(device & outputDesc->supportedDevices());
+ DeviceVector filteredDevices = outputDesc->filterSupportedDevices(devices);
- audio_devices_t prevDevice = outputDesc->mDevice;
+ // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
+ // output profile
+ if (!devices.isEmpty() && filteredDevices.isEmpty()) {
+ ALOGV("%s: unsupported device %s for output", __func__, devices.toString().c_str());
+ return 0;
+ }
- ALOGV("setOutputDevice() prevDevice 0x%04x", prevDevice);
+ DeviceVector prevDevices = outputDesc->devices();
- if (device != AUDIO_DEVICE_NONE) {
- outputDesc->mDevice = device;
+ ALOGV("setOutputDevices() prevDevice %s", prevDevices.toString().c_str());
+
+ if (!filteredDevices.isEmpty()) {
+ outputDesc->setDevices(filteredDevices);
}
// if the outputs are not materially active, there is no need to mute.
if (requiresMuteCheck) {
- muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs);
+ muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevices.types(), delayMs);
} else {
ALOGV("%s: suppressing checkDeviceMuteStrategies", __func__);
muteWaitMs = 0;
@@ -5287,42 +5219,32 @@
// OR the requested device is the same as current device
// AND force is not specified
// AND the output is connected by a valid audio patch.
- // Doing this check here allows the caller to call setOutputDevice() without conditions
- if ((device == AUDIO_DEVICE_NONE || device == prevDevice) &&
- !force &&
- outputDesc->getPatchHandle() != 0) {
- ALOGV("setOutputDevice() setting same device 0x%04x or null device", device);
+ // Doing this check here allows the caller to call setOutputDevices() without conditions
+ if ((!filteredDevices.isEmpty() || filteredDevices == prevDevices) &&
+ !force && outputDesc->getPatchHandle() != 0) {
+ ALOGV("%s setting same device %s or null device, force=%d, patch handle=%d", __func__,
+ filteredDevices.toString().c_str(), force, outputDesc->getPatchHandle());
return muteWaitMs;
}
- ALOGV("setOutputDevice() changing device");
+ ALOGV("%s changing device to %s", __func__, filteredDevices.toString().c_str());
// do the routing
- if (device == AUDIO_DEVICE_NONE) {
+ if (filteredDevices.isEmpty()) {
resetOutputDevice(outputDesc, delayMs, NULL);
} else {
- DeviceVector deviceList;
- if ((address == NULL) || (strlen(address) == 0)) {
- deviceList = mAvailableOutputDevices.getDevicesFromTypeMask(device);
- } else {
- sp<DeviceDescriptor> deviceDesc = mAvailableOutputDevices.getDevice(
- device, String8(address));
- if (deviceDesc) deviceList.add(deviceDesc);
+ PatchBuilder patchBuilder;
+ patchBuilder.addSource(outputDesc);
+ ALOG_ASSERT(filteredDevices.size() <= AUDIO_PATCH_PORTS_MAX, "Too many sink ports");
+ for (const auto &filteredDevice : filteredDevices) {
+ patchBuilder.addSink(filteredDevice);
}
- if (!deviceList.isEmpty()) {
- PatchBuilder patchBuilder;
- patchBuilder.addSource(outputDesc);
- ALOG_ASSERT(deviceList.size() <= AUDIO_PATCH_PORTS_MAX, "Too many sink ports");
- for (const auto &device : deviceList) {
- patchBuilder.addSink(device);
- }
- installPatch(__func__, patchHandle, outputDesc.get(), patchBuilder.patch(), delayMs);
- }
+ installPatch(__func__, patchHandle, outputDesc.get(), patchBuilder.patch(), delayMs);
}
// update stream volumes according to new device
- applyStreamVolumes(outputDesc, device, delayMs);
+ applyStreamVolumes(outputDesc, filteredDevices.types(), delayMs);
return muteWaitMs;
}
@@ -5351,18 +5273,17 @@
}
status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
- audio_devices_t device,
+ const sp<DeviceDescriptor> &device,
bool force,
audio_patch_handle_t *patchHandle)
{
status_t status = NO_ERROR;
sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
- if ((device != AUDIO_DEVICE_NONE) && ((device != inputDesc->mDevice) || force)) {
- inputDesc->mDevice = device;
+ if ((device != nullptr) && ((device != inputDesc->getDevice()) || force)) {
+ inputDesc->setDevice(device);
- DeviceVector deviceList = mAvailableInputDevices.getDevicesFromTypeMask(device);
- if (!deviceList.isEmpty()) {
+ if (mAvailableInputDevices.contains(device)) {
PatchBuilder patchBuilder;
patchBuilder.addSink(inputDesc,
// AUDIO_SOURCE_HOTWORD is for internal use only:
@@ -5374,7 +5295,7 @@
}
return result; }).
//only one input device for now
- addSource(deviceList.itemAt(0));
+ addSource(device);
status = installPatch(__func__, patchHandle, inputDesc.get(), patchBuilder.patch(), 0);
}
}
@@ -5404,8 +5325,7 @@
return status;
}
-sp<IOProfile> AudioPolicyManager::getInputProfile(audio_devices_t device,
- const String8& address,
+sp<IOProfile> AudioPolicyManager::getInputProfile(const sp<DeviceDescriptor> &device,
uint32_t& samplingRate,
audio_format_t& format,
audio_channel_mask_t& channelMask,
@@ -5425,7 +5345,7 @@
for (const auto& profile : hwModule->getInputProfiles()) {
// profile->log();
//updatedFormat = format;
- if (profile->isCompatibleProfile(device, address, samplingRate,
+ if (profile->isCompatibleProfile(DeviceVector(device), samplingRate,
&samplingRate /*updatedSamplingRate*/,
format,
&format, /*updatedFormat*/
@@ -5436,7 +5356,7 @@
true /*exactMatchRequiredForInputFlags*/)) {
return profile;
}
- if (firstInexact == nullptr && profile->isCompatibleProfile(device, address,
+ if (firstInexact == nullptr && profile->isCompatibleProfile(DeviceVector(device),
samplingRate,
&updatedSamplingRate,
format,
@@ -5460,32 +5380,33 @@
return NULL;
}
-
-audio_devices_t AudioPolicyManager::getDeviceAndMixForInputSource(audio_source_t inputSource,
- AudioMix **policyMix)
+sp<DeviceDescriptor> AudioPolicyManager::getDeviceAndMixForAttributes(
+ const audio_attributes_t &attributes, AudioMix **policyMix)
{
// Honor explicit routing requests only if all active clients have a preferred route in which
// case the last active client route is used
- sp<DeviceDescriptor> deviceDesc =
- findPreferredDevice(mInputs, inputSource, mAvailableInputDevices);
- if (deviceDesc != nullptr) {
- return deviceDesc->type();
+ sp<DeviceDescriptor> device =
+ findPreferredDevice(mInputs, attributes.source, mAvailableInputDevices);
+ if (device != nullptr) {
+ return device;
}
-
- audio_devices_t availableDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
- audio_devices_t selectedDeviceFromMix =
- mPolicyMixes.getDeviceAndMixForInputSource(inputSource, availableDeviceTypes, policyMix);
-
- if (selectedDeviceFromMix != AUDIO_DEVICE_NONE) {
- return selectedDeviceFromMix;
- }
- return getDeviceForInputSource(inputSource);
+ sp<DeviceDescriptor> selectedDeviceFromMix =
+ mPolicyMixes.getDeviceAndMixForInputSource(attributes.source, mAvailableInputDevices,
+ policyMix);
+ return (selectedDeviceFromMix != nullptr) ?
+ selectedDeviceFromMix : getDeviceForAttributes(attributes);
}
-audio_devices_t AudioPolicyManager::getDeviceForInputSource(audio_source_t inputSource)
+sp<DeviceDescriptor> AudioPolicyManager::getDeviceForAttributes(const audio_attributes_t &attributes)
{
- return mEngine->getDeviceForInputSource(inputSource);
+ audio_devices_t device = mEngine->getDeviceForInputSource(attributes.source);
+ if (attributes.source == AUDIO_SOURCE_REMOTE_SUBMIX &&
+ strncmp(attributes.tags, "addr=", strlen("addr=")) == 0) {
+ return mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
+ String8(attributes.tags + strlen("addr=")));
+ }
+ return mAvailableInputDevices.getDevice(device);
}
float AudioPolicyManager::computeVolume(audio_stream_type_t stream,
@@ -5630,7 +5551,7 @@
}
if (device == AUDIO_DEVICE_NONE) {
- device = outputDesc->device();
+ device = outputDesc->devices().types();
}
float volumeDb = computeVolume(stream, index, device);
@@ -5701,7 +5622,7 @@
audio_devices_t device)
{
if (device == AUDIO_DEVICE_NONE) {
- device = outputDesc->device();
+ device = outputDesc->devices().types();
}
ALOGVV("setStreamMute() stream %d, mute %d, mMuteCount %d device %04x",
@@ -5798,9 +5719,9 @@
return false;
}
-bool AudioPolicyManager::isStrategyActiveOnSameModule(const sp<AudioOutputDescriptor>& outputDesc,
- routing_strategy strategy, uint32_t inPastMs,
- nsecs_t sysTime) const
+bool AudioPolicyManager::isStrategyActiveOnSameModule(const sp<SwAudioOutputDescriptor>& outputDesc,
+ routing_strategy strategy, uint32_t inPastMs,
+ nsecs_t sysTime) const
{
for (size_t i = 0; i < mOutputs.size(); i++) {
sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
@@ -5859,6 +5780,8 @@
releaseAudioPatch(patchDesc->mHandle, patchDesc->mUid);
}
}
+
+ mHwModules.cleanUpForDevice(deviceDesc);
}
void AudioPolicyManager::modifySurroundFormats(
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index 9eb1dcf..e99de16 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -313,36 +313,40 @@
// where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND
// before updateDevicesAndOutputs() is called.
virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy,
- bool fromCache);
+ bool fromCache)
+ {
+ return getDevicesForStrategy(strategy, fromCache).types();
+ }
+
+ DeviceVector getDevicesForStrategy(routing_strategy strategy, bool fromCache);
bool isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc, routing_strategy strategy,
uint32_t inPastMs = 0, nsecs_t sysTime = 0) const;
- bool isStrategyActiveOnSameModule(const sp<AudioOutputDescriptor>& outputDesc,
- routing_strategy strategy, uint32_t inPastMs = 0,
- nsecs_t sysTime = 0) const;
+ bool isStrategyActiveOnSameModule(const sp<SwAudioOutputDescriptor>& outputDesc,
+ routing_strategy strategy, uint32_t inPastMs = 0,
+ nsecs_t sysTime = 0) const;
// change the route of the specified output. Returns the number of ms we have slept to
// allow new routing to take effect in certain cases.
- virtual uint32_t setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
- audio_devices_t device,
- bool force = false,
- int delayMs = 0,
- audio_patch_handle_t *patchHandle = NULL,
- const char *address = nullptr,
- bool requiresMuteCheck = true);
+ uint32_t setOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
+ const DeviceVector &device,
+ bool force = false,
+ int delayMs = 0,
+ audio_patch_handle_t *patchHandle = NULL,
+ bool requiresMuteCheck = true);
status_t resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
int delayMs = 0,
audio_patch_handle_t *patchHandle = NULL);
status_t setInputDevice(audio_io_handle_t input,
- audio_devices_t device,
+ const sp<DeviceDescriptor> &device,
bool force = false,
audio_patch_handle_t *patchHandle = NULL);
status_t resetInputDevice(audio_io_handle_t input,
audio_patch_handle_t *patchHandle = NULL);
// select input device corresponding to requested audio source
- virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource);
+ sp<DeviceDescriptor> getDeviceForAttributes(const audio_attributes_t &attributes);
// compute the actual volume for a given stream according to the requested index and a particular
// device
@@ -391,15 +395,13 @@
// when a device is disconnected, checks if an output is not used any more and
// returns its handle if any.
// transfers the audio tracks and effects from one output thread to another accordingly.
- status_t checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc,
+ status_t checkOutputsForDevice(const sp<DeviceDescriptor>& device,
audio_policy_dev_state_t state,
- SortedVector<audio_io_handle_t>& outputs,
- const String8& address);
+ SortedVector<audio_io_handle_t>& outputs);
- status_t checkInputsForDevice(const sp<DeviceDescriptor>& devDesc,
+ status_t checkInputsForDevice(const sp<DeviceDescriptor>& device,
audio_policy_dev_state_t state,
- SortedVector<audio_io_handle_t>& inputs,
- const String8& address);
+ SortedVector<audio_io_handle_t>& inputs);
// close an output and its companion duplicating output.
void closeOutput(audio_io_handle_t output);
@@ -437,8 +439,8 @@
// must be called every time a condition that affects the device choice for a given output is
// changed: connected device, phone state, force use, output start, output stop..
// see getDeviceForStrategy() for the use of fromCache parameter
- audio_devices_t getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
- bool fromCache);
+ DeviceVector getNewOutputDevices(const sp<SwAudioOutputDescriptor>& outputDesc,
+ bool fromCache);
// updates cache of device used by all strategies (mDeviceForStrategy[])
// must be called every time a condition that affects the device choice for a given strategy is
@@ -448,7 +450,7 @@
void updateDevicesAndOutputs();
// selects the most appropriate device on input for current state
- audio_devices_t getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc);
+ sp<DeviceDescriptor> getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc);
virtual uint32_t getMaxEffectsCpuLoad()
{
@@ -460,16 +462,16 @@
return mEffects.getMaxEffectsMemory();
}
- SortedVector<audio_io_handle_t> getOutputsForDevice(audio_devices_t device,
- const SwAudioOutputCollection& openOutputs);
+ SortedVector<audio_io_handle_t> getOutputsForDevices(
+ const DeviceVector &devices, const SwAudioOutputCollection& openOutputs);
// mute/unmute strategies using an incompatible device combination
// if muting, wait for the audio in pcm buffer to be drained before proceeding
// if unmuting, unmute only after the specified delay
// Returns the number of ms waited
virtual uint32_t checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
- audio_devices_t prevDevice,
- uint32_t delayMs);
+ audio_devices_t prevDeviceType,
+ uint32_t delayMs);
audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs,
audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
@@ -477,13 +479,22 @@
audio_channel_mask_t channelMask = AUDIO_CHANNEL_NONE,
uint32_t samplingRate = 0);
// samplingRate, format, channelMask are in/out and so may be modified
- sp<IOProfile> getInputProfile(audio_devices_t device,
- const String8& address,
+ sp<IOProfile> getInputProfile(const sp<DeviceDescriptor> & device,
uint32_t& samplingRate,
audio_format_t& format,
audio_channel_mask_t& channelMask,
audio_input_flags_t flags);
- sp<IOProfile> getProfileForOutput(audio_devices_t device,
+ /**
+ * @brief getProfileForOutput
+ * @param devices vector of descriptors, may be empty if ignoring the device is required
+ * @param samplingRate
+ * @param format
+ * @param channelMask
+ * @param flags
+ * @param directOnly
+ * @return IOProfile to be used if found, nullptr otherwise
+ */
+ sp<IOProfile> getProfileForOutput(const DeviceVector &devices,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
@@ -501,19 +512,19 @@
return mAudioPatches.removeAudioPatch(handle);
}
- audio_devices_t availablePrimaryOutputDevices() const
+ DeviceVector availablePrimaryOutputDevices() const
{
if (!hasPrimaryOutput()) {
- return AUDIO_DEVICE_NONE;
+ return DeviceVector();
}
- return mPrimaryOutput->supportedDevices() & mAvailableOutputDevices.types();
+ return mAvailableOutputDevices.filter(mPrimaryOutput->supportedDevices());
}
- audio_devices_t availablePrimaryInputDevices() const
+ DeviceVector availablePrimaryModuleInputDevices() const
{
if (!hasPrimaryOutput()) {
- return AUDIO_DEVICE_NONE;
+ return DeviceVector();
}
- return mAvailableInputDevices.getDeviceTypesFromHwModule(
+ return mAvailableInputDevices.getDevicesFromHwModule(
mPrimaryOutput->getModuleHandle());
}
/**
@@ -530,8 +541,9 @@
return (devices.size() > 0) ? devices.itemAt(0)->address() : String8("");
}
- uint32_t updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs = 0);
- sp<AudioPatch> createTelephonyPatch(bool isRx, audio_devices_t device, uint32_t delayMs);
+ uint32_t updateCallRouting(const DeviceVector &rxDevices, uint32_t delayMs = 0);
+ sp<AudioPatch> createTelephonyPatch(bool isRx, const sp<DeviceDescriptor> &device,
+ uint32_t delayMs);
sp<DeviceDescriptor> findDevice(
const DeviceVector& devices, audio_devices_t device) const;
audio_devices_t getModuleDeviceTypes(
@@ -581,7 +593,16 @@
DeviceVector mAvailableInputDevices; // all available input devices
bool mLimitRingtoneVolume; // limit ringtone volume to music volume if headset connected
- audio_devices_t mDeviceForStrategy[NUM_STRATEGIES];
+
+ /**
+ * @brief mDevicesForStrategy vector of devices that are assigned for a given strategy.
+ * Note: in case of removal of device (@see setDeviceConnectionState), the device descriptor
+ * will be removed from the @see mAvailableOutputDevices or @see mAvailableInputDevices
+ * but the devices for strategies will be reevaluated within the
+ * @see setDeviceConnectionState function.
+ */
+ DeviceVector mDevicesForStrategy[NUM_STRATEGIES];
+
float mLastVoiceVolume; // last voice volume value sent to audio HAL
bool mA2dpSuspended; // true if A2DP output is suspended
@@ -637,13 +658,14 @@
// Support for Multi-Stream Decoder (MSD) module
sp<DeviceDescriptor> getMsdAudioInDevice() const;
+ DeviceVector getMsdAudioOutDevices() const;
const AudioPatchCollection getMsdPatches() const;
- status_t getBestMsdAudioProfileFor(audio_devices_t outputDevice,
+ status_t getBestMsdAudioProfileFor(const sp<DeviceDescriptor> &outputDevice,
bool hwAvSync,
audio_port_config *sourceConfig,
audio_port_config *sinkConfig) const;
- PatchBuilder buildMsdPatch(audio_devices_t outputDevice) const;
- status_t setMsdPatch(audio_devices_t outputDevice = AUDIO_DEVICE_NONE);
+ PatchBuilder buildMsdPatch(const sp<DeviceDescriptor> &outputDevice) const;
+ status_t setMsdPatch(const sp<DeviceDescriptor> &outputDevice = nullptr);
// If any, resolve any "dynamic" fields of an Audio Profiles collection
void updateAudioProfiles(const sp<DeviceDescriptor>& devDesc, audio_io_handle_t ioHandle,
@@ -654,22 +676,12 @@
// It can give a chance to HAL implementer to retrieve dynamic capabilities associated
// to this device for example.
// TODO avoid opening stream to retrieve capabilities of a profile.
- void broadcastDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const String8 &device_address);
+ void broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
+ audio_policy_dev_state_t state);
// updates device caching and output for streams that can influence the
// routing of notifications
void handleNotificationRoutingForStream(audio_stream_type_t stream);
- // find the outputs on a given output descriptor that have the given address.
- // to be called on an AudioOutputDescriptor whose supported devices (as defined
- // in mProfile->mSupportedDevices) matches the device whose address is to be matched.
- // see deviceDistinguishesOnAddress(audio_devices_t) for whether the device type is one
- // where addresses are used to distinguish between one connected device and another.
- void findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/,
- const audio_devices_t device /*in*/,
- const String8& address /*in*/,
- SortedVector<audio_io_handle_t>& outputs /*out*/);
uint32_t curAudioPortGeneration() const { return mAudioPortGeneration; }
// internal method, get audio_attributes_t from either a source audio_attributes_t
// or audio_stream_type_t, respectively.
@@ -687,15 +699,14 @@
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId);
// internal method to return the output handle for the given device and format
- audio_io_handle_t getOutputForDevice(
- audio_devices_t device,
+ audio_io_handle_t getOutputForDevices(
+ const DeviceVector &devices,
audio_session_t session,
audio_stream_type_t stream,
const audio_config_t *config,
audio_output_flags_t *flags);
// internal method to return the input handle for the given device and format
- audio_io_handle_t getInputForDevice(audio_devices_t device,
- String8 address,
+ audio_io_handle_t getInputForDevice(const sp<DeviceDescriptor> &device,
audio_session_t session,
audio_source_t inputSource,
const audio_config_base_t *config,
@@ -713,14 +724,14 @@
// select input device corresponding to requested audio source and return associated policy
// mix if any. Calls getDeviceForInputSource().
- audio_devices_t getDeviceAndMixForInputSource(audio_source_t inputSource,
- AudioMix **policyMix = NULL);
+ sp<DeviceDescriptor> getDeviceAndMixForAttributes(const audio_attributes_t &attributes,
+ AudioMix **policyMix = NULL);
// Called by setDeviceConnectionState().
- status_t setDeviceConnectionStateInt(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name);
+ status_t setDeviceConnectionStateInt(audio_devices_t deviceType,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name);
void updateMono(audio_io_handle_t output) {
AudioParameter param;
param.addInt(String8(AudioParameter::keyMonoOutput), (int)mMasterMono);
diff --git a/services/audiopolicy/service/AudioPolicyEffects.cpp b/services/audiopolicy/service/AudioPolicyEffects.cpp
index 29b0561..919a90d 100644
--- a/services/audiopolicy/service/AudioPolicyEffects.cpp
+++ b/services/audiopolicy/service/AudioPolicyEffects.cpp
@@ -330,11 +330,12 @@
return BAD_VALUE;
}
- // HOTWORD and FM_TUNER are two special case sources > MAX.
+ // HOTWORD, FM_TUNER and ECHO_REFERENCE are special case sources > MAX.
if (source < AUDIO_SOURCE_DEFAULT ||
(source > AUDIO_SOURCE_MAX &&
source != AUDIO_SOURCE_HOTWORD &&
- source != AUDIO_SOURCE_FM_TUNER)) {
+ source != AUDIO_SOURCE_FM_TUNER &&
+ source != AUDIO_SOURCE_ECHO_REFERENCE)) {
ALOGE("addSourceDefaultEffect(): Unsupported source type %d", source);
return BAD_VALUE;
}
@@ -534,7 +535,8 @@
CAMCORDER_SRC_TAG,
VOICE_REC_SRC_TAG,
VOICE_COMM_SRC_TAG,
- UNPROCESSED_SRC_TAG
+ UNPROCESSED_SRC_TAG,
+ VOICE_PERFORMANCE_SRC_TAG
};
// returns the audio_source_t enum corresponding to the input source name or
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index 80503fd..2c904d9 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -336,8 +336,11 @@
}
// already checked by client, but double-check in case the client wrapper is bypassed
- if (attr->source < AUDIO_SOURCE_DEFAULT && attr->source >= AUDIO_SOURCE_CNT &&
- attr->source != AUDIO_SOURCE_HOTWORD && attr->source != AUDIO_SOURCE_FM_TUNER) {
+ if ((attr->source < AUDIO_SOURCE_DEFAULT)
+ || (attr->source >= AUDIO_SOURCE_CNT
+ && attr->source != AUDIO_SOURCE_HOTWORD
+ && attr->source != AUDIO_SOURCE_FM_TUNER
+ && attr->source != AUDIO_SOURCE_ECHO_REFERENCE)) {
return BAD_VALUE;
}
@@ -367,7 +370,8 @@
if ((attr->source == AUDIO_SOURCE_VOICE_UPLINK ||
attr->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
- attr->source == AUDIO_SOURCE_VOICE_CALL) &&
+ attr->source == AUDIO_SOURCE_VOICE_CALL ||
+ attr->source == AUDIO_SOURCE_ECHO_REFERENCE) &&
!captureAudioOutputAllowed(pid, uid)) {
return PERMISSION_DENIED;
}
diff --git a/services/mediacodec/MediaCodecUpdateService.cpp b/services/mediacodec/MediaCodecUpdateService.cpp
index aee890d..0e6892d 100644
--- a/services/mediacodec/MediaCodecUpdateService.cpp
+++ b/services/mediacodec/MediaCodecUpdateService.cpp
@@ -18,14 +18,10 @@
//#define LOG_NDEBUG 0
#include <android/dlext.h>
-#include <android-base/logging.h>
-#include <android-base/strings.h>
-#include <dirent.h>
#include <dlfcn.h>
#include <media/CodecServiceRegistrant.h>
#include <utils/Log.h>
-#include <ziparchive/zip_archive.h>
-#include <cutils/properties.h>
+#include <utils/String8.h>
#include "MediaCodecUpdateService.h"
@@ -47,90 +43,53 @@
}
namespace android {
-namespace media {
-binder::Status MediaCodecUpdateService::loadPlugins(const ::std::string& apkPath) {
- ALOGV("loadPlugins %s", apkPath.c_str());
+void loadFromApex(const char *libDirPath) {
+ ALOGV("loadFromApex: path=%s", libDirPath);
- ZipArchiveHandle zipHandle;
- void *registrantLib = NULL;
- int32_t ret = OpenArchive(apkPath.c_str(), &zipHandle);
+ String8 libPath = String8(libDirPath) + "/libmedia_codecserviceregistrant.so";
- if (ret == 0) {
- char abilist32[PROPERTY_VALUE_MAX];
- property_get("ro.product.cpu.abilist32", abilist32, "armeabi-v7a");
+ android_namespace_t *codecNs = android_create_namespace("codecs",
+ nullptr, // ld_library_path
+ libDirPath,
+ ANDROID_NAMESPACE_TYPE_ISOLATED,
+ nullptr, // permitted_when_isolated_path
+ nullptr); // parent
- auto abis = base::Split(abilist32, ",");
- if (abis.empty()) {
- ALOGW("abilist is empty, trying armeabi-v7a ...");
- abis.push_back("armeabi-v7a");
- }
-
- // TODO: Only try the first entry in abilist32 for now.
- // We probably should try the next if it fails.
- String8 libPathInApk = String8("lib/") + String8(abis[0].c_str());
- String8 defaultLibPath = String8(apkPath.c_str()) + "!/" + libPathInApk;
- String8 libPath = defaultLibPath + "/libmedia_codecserviceregistrant.so";
- String8 zipEntryPath = libPathInApk + "/libmedia_codecserviceregistrant.so";
-
- ZipEntry entry;
- ret = FindEntry(zipHandle, ZipString(zipEntryPath), &entry);
-
- if (ret == 0) {
- android_namespace_t *codecNs = android_create_namespace("codecs",
- nullptr, // ld_library_path
- defaultLibPath.c_str(),
- ANDROID_NAMESPACE_TYPE_ISOLATED,
- nullptr, // permitted_when_isolated_path
- nullptr); // parent
-
- if (codecNs != nullptr) {
- String8 linked_libraries(LINKED_LIBRARIES);
- if (android_link_namespaces(
- codecNs, nullptr, linked_libraries.c_str())) {
- const android_dlextinfo dlextinfo = {
- .flags = ANDROID_DLEXT_USE_NAMESPACE,
- .library_namespace = codecNs,
- };
-
- registrantLib = android_dlopen_ext(
- libPath.string(),
- RTLD_NOW | RTLD_LOCAL, &dlextinfo);
-
- if (registrantLib == NULL) {
- ALOGE("Failed to load lib from archive: %s", dlerror());
- }
- } else {
- ALOGE("Failed to link namespace");
- }
- } else {
- ALOGE("Failed to create codec namespace");
- }
- } else {
- ALOGE("Failed to find entry (ret=%d)", ret);
- }
-
- CloseArchive(zipHandle);
- } else {
- ALOGE("Failed to open archive (ret=%d)", ret);
+ if (codecNs == nullptr) {
+ ALOGE("Failed to create codec namespace");
+ return;
}
- if (registrantLib) {
- RegisterCodecServicesFunc registerCodecServices =
- reinterpret_cast<RegisterCodecServicesFunc>(
- dlsym(registrantLib, "RegisterCodecServices"));
- if (registerCodecServices) {
- registerCodecServices();
- } else {
- LOG(WARNING) << "Cannot register codec services "
- "-- corrupted library.";
- }
- } else {
- LOG(ERROR) << "Cannot find codec service registrant.";
+ String8 linked_libraries(LINKED_LIBRARIES);
+ if (!android_link_namespaces(codecNs, nullptr, linked_libraries.c_str())) {
+ ALOGE("Failed to link namespace");
+ return;
}
- return binder::Status::ok();
+ const android_dlextinfo dlextinfo = {
+ .flags = ANDROID_DLEXT_USE_NAMESPACE,
+ .library_namespace = codecNs,
+ };
+
+ void *registrantLib = android_dlopen_ext(
+ libPath.string(),
+ RTLD_NOW | RTLD_LOCAL, &dlextinfo);
+
+ if (registrantLib == nullptr) {
+ ALOGE("Failed to load lib from archive: %s", dlerror());
+ }
+
+ RegisterCodecServicesFunc registerCodecServices =
+ reinterpret_cast<RegisterCodecServicesFunc>(
+ dlsym(registrantLib, "RegisterCodecServices"));
+
+ if (registerCodecServices == nullptr) {
+ ALOGE("Cannot register codec services -- corrupted library.");
+ return;
+ }
+
+ registerCodecServices();
}
-} // namespace media
} // namespace android
diff --git a/services/mediacodec/MediaCodecUpdateService.h b/services/mediacodec/MediaCodecUpdateService.h
index 7b7cee9..09d6dbe 100644
--- a/services/mediacodec/MediaCodecUpdateService.h
+++ b/services/mediacodec/MediaCodecUpdateService.h
@@ -17,24 +17,10 @@
#ifndef ANDROID_MEDIA_CODEC_UPDATE_SERVICE_H
#define ANDROID_MEDIA_CODEC_UPDATE_SERVICE_H
-#include <binder/BinderService.h>
-#include <android/media/BnMediaUpdateService.h>
-
namespace android {
-namespace media {
-class MediaCodecUpdateService
- : public BinderService<MediaCodecUpdateService>, public BnMediaUpdateService
-{
- friend class BinderService<MediaCodecUpdateService>;
-public:
- MediaCodecUpdateService() : BnMediaUpdateService() { }
- virtual ~MediaCodecUpdateService() { }
- static const char* getServiceName() { return "media.codec.update"; }
- binder::Status loadPlugins(const ::std::string& apkPath);
-};
+void loadFromApex(const char *libDirPath);
-} // namespace media
} // namespace android
#endif // ANDROID_MEDIA_CODEC_UPDATE_SERVICE_H
diff --git a/services/mediacodec/main_swcodecservice.cpp b/services/mediacodec/main_swcodecservice.cpp
index 79fea25..1168825 100644
--- a/services/mediacodec/main_swcodecservice.cpp
+++ b/services/mediacodec/main_swcodecservice.cpp
@@ -20,11 +20,7 @@
// from LOCAL_C_INCLUDES
#include "minijail.h"
-#include <android-base/properties.h>
-#include <binder/ProcessState.h>
-#include <dlfcn.h>
#include <hidl/HidlTransportSupport.h>
-#include <media/CodecServiceRegistrant.h>
#include "MediaCodecUpdateService.h"
@@ -49,32 +45,10 @@
signal(SIGPIPE, SIG_IGN);
SetUpMinijail(kSystemSeccompPolicyPath, kVendorSeccompPolicyPath);
- std::string value = base::GetProperty("ro.build.type", "unknown");
- if (value == "userdebug" || value == "eng") {
- media::MediaCodecUpdateService::instantiate();
- }
-
- android::ProcessState::self()->startThreadPool();
-
::android::hardware::configureRpcThreadpool(64, false);
- // Registration of customized codec services
- void *registrantLib = dlopen(
- "libmedia_codecserviceregistrant.so",
- RTLD_NOW | RTLD_LOCAL);
- if (registrantLib) {
- RegisterCodecServicesFunc registerCodecServices =
- reinterpret_cast<RegisterCodecServicesFunc>(
- dlsym(registrantLib, "RegisterCodecServices"));
- if (registerCodecServices) {
- registerCodecServices();
- } else {
- LOG(WARNING) << "Cannot register codec services "
- "-- corrupted library.";
- }
- } else {
- LOG(ERROR) << "Cannot find codec service registrant.";
- }
+ // codec libs are currently 32-bit only
+ loadFromApex("/apex/com.android.media.swcodec/lib");
::android::hardware::joinRpcThreadpool();
}
diff --git a/services/mediaextractor/Android.mk b/services/mediaextractor/Android.mk
index 6101c8a..dd64881 100644
--- a/services/mediaextractor/Android.mk
+++ b/services/mediaextractor/Android.mk
@@ -46,6 +46,7 @@
LOCAL_INIT_RC := mediaextractor.rc
LOCAL_C_INCLUDES := frameworks/av/media/libmedia
LOCAL_CFLAGS := -Wall -Werror
+LOCAL_SANITIZE := scudo
include $(BUILD_EXECUTABLE)
# service seccomp filter
diff --git a/services/mediaextractor/main_extractorservice.cpp b/services/mediaextractor/main_extractorservice.cpp
index 8d3359a..5f42711 100644
--- a/services/mediaextractor/main_extractorservice.cpp
+++ b/services/mediaextractor/main_extractorservice.cpp
@@ -42,6 +42,12 @@
static const char kVendorSeccompPolicyPath[] =
"/vendor/etc/seccomp_policy/mediaextractor.policy";
+// Disable Scudo's mismatch allocation check, as it is being triggered
+// by some third party code.
+extern "C" const char *__scudo_default_options() {
+ return "DeallocationTypeMismatch=false";
+}
+
int main(int argc __unused, char** argv)
{
limitProcessMemory(
diff --git a/services/mediaextractor/seccomp_policy/mediaextractor-x86_64.policy b/services/mediaextractor/seccomp_policy/mediaextractor-x86_64.policy
index 35ac458..607a03e 100644
--- a/services/mediaextractor/seccomp_policy/mediaextractor-x86_64.policy
+++ b/services/mediaextractor/seccomp_policy/mediaextractor-x86_64.policy
@@ -11,6 +11,7 @@
mmap: 1
madvise: 1
openat: 1
+open: 1
clock_gettime: 1
writev: 1
brk: 1
diff --git a/services/soundtrigger/SoundTriggerHalHidl.cpp b/services/soundtrigger/SoundTriggerHalHidl.cpp
index 1d37a8e..68d54c7 100644
--- a/services/soundtrigger/SoundTriggerHalHidl.cpp
+++ b/services/soundtrigger/SoundTriggerHalHidl.cpp
@@ -168,18 +168,23 @@
int ret;
SoundModelHandle halHandle;
sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger);
+ sp<V2_2_ISoundTriggerHw> soundtrigger_2_2 = toService2_2(soundtrigger);
if (sound_model->type == SOUND_MODEL_TYPE_KEYPHRASE) {
- if (!soundtrigger_2_1) {
- ISoundTriggerHw::PhraseSoundModel halSoundModel;
- convertPhraseSoundModelToHal(&halSoundModel, sound_model);
- AutoMutex lock(mHalLock);
- hidlReturn = soundtrigger->loadPhraseSoundModel(
- halSoundModel,
- this, modelId, [&](int32_t retval, auto res) {
- ret = retval;
- halHandle = res;
- });
- } else {
+ if (soundtrigger_2_2) {
+ V2_2_ISoundTriggerHw::PhraseSoundModel halSoundModel;
+ auto result = convertPhraseSoundModelToHal(&halSoundModel, sound_model);
+ if (result.first) {
+ AutoMutex lock(mHalLock);
+ hidlReturn = soundtrigger_2_2->loadPhraseSoundModel_2_1(
+ halSoundModel,
+ this, modelId, [&](int32_t retval, auto res) {
+ ret = retval;
+ halHandle = res;
+ });
+ } else {
+ return NO_MEMORY;
+ }
+ } else if (soundtrigger_2_1) {
V2_1_ISoundTriggerHw::PhraseSoundModel halSoundModel;
auto result = convertPhraseSoundModelToHal(&halSoundModel, sound_model);
if (result.first) {
@@ -193,18 +198,32 @@
} else {
return NO_MEMORY;
}
- }
- } else {
- if (!soundtrigger_2_1) {
- ISoundTriggerHw::SoundModel halSoundModel;
- convertSoundModelToHal(&halSoundModel, sound_model);
+ } else {
+ ISoundTriggerHw::PhraseSoundModel halSoundModel;
+ convertPhraseSoundModelToHal(&halSoundModel, sound_model);
AutoMutex lock(mHalLock);
- hidlReturn = soundtrigger->loadSoundModel(halSoundModel,
+ hidlReturn = soundtrigger->loadPhraseSoundModel(
+ halSoundModel,
this, modelId, [&](int32_t retval, auto res) {
ret = retval;
halHandle = res;
});
- } else {
+ }
+ } else {
+ if (soundtrigger_2_2) {
+ V2_2_ISoundTriggerHw::SoundModel halSoundModel;
+ auto result = convertSoundModelToHal(&halSoundModel, sound_model);
+ if (result.first) {
+ AutoMutex lock(mHalLock);
+ hidlReturn = soundtrigger_2_2->loadSoundModel_2_1(halSoundModel,
+ this, modelId, [&](int32_t retval, auto res) {
+ ret = retval;
+ halHandle = res;
+ });
+ } else {
+ return NO_MEMORY;
+ }
+ } else if (soundtrigger_2_1) {
V2_1_ISoundTriggerHw::SoundModel halSoundModel;
auto result = convertSoundModelToHal(&halSoundModel, sound_model);
if (result.first) {
@@ -217,6 +236,15 @@
} else {
return NO_MEMORY;
}
+ } else {
+ ISoundTriggerHw::SoundModel halSoundModel;
+ convertSoundModelToHal(&halSoundModel, sound_model);
+ AutoMutex lock(mHalLock);
+ hidlReturn = soundtrigger->loadSoundModel(halSoundModel,
+ this, modelId, [&](int32_t retval, auto res) {
+ ret = retval;
+ halHandle = res;
+ });
}
}
@@ -282,16 +310,20 @@
model->mRecognitionCookie = cookie;
sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger);
+ sp<V2_2_ISoundTriggerHw> soundtrigger_2_2 = toService2_2(soundtrigger);
Return<int32_t> hidlReturn(0);
- if (!soundtrigger_2_1) {
- ISoundTriggerHw::RecognitionConfig halConfig;
- convertRecognitionConfigToHal(&halConfig, config);
- {
+ if (soundtrigger_2_2) {
+ V2_2_ISoundTriggerHw::RecognitionConfig halConfig;
+ auto result = convertRecognitionConfigToHal(&halConfig, config);
+ if (result.first) {
AutoMutex lock(mHalLock);
- hidlReturn = soundtrigger->startRecognition(model->mHalHandle, halConfig, this, handle);
+ hidlReturn = soundtrigger_2_2->startRecognition_2_1(
+ model->mHalHandle, halConfig, this, handle);
+ } else {
+ return NO_MEMORY;
}
- } else {
+ } else if (soundtrigger_2_1) {
V2_1_ISoundTriggerHw::RecognitionConfig halConfig;
auto result = convertRecognitionConfigToHal(&halConfig, config);
if (result.first) {
@@ -301,6 +333,13 @@
} else {
return NO_MEMORY;
}
+ } else {
+ ISoundTriggerHw::RecognitionConfig halConfig;
+ convertRecognitionConfigToHal(&halConfig, config);
+ {
+ AutoMutex lock(mHalLock);
+ hidlReturn = soundtrigger->startRecognition(model->mHalHandle, halConfig, this, handle);
+ }
}
if (!hidlReturn.isOk()) {