Merge "MediaCodec: don't crash on concurrent release/start/configure"
diff --git a/camera/aidl/android/hardware/ICameraService.aidl b/camera/aidl/android/hardware/ICameraService.aidl
index 0e969c7..3e8992a 100644
--- a/camera/aidl/android/hardware/ICameraService.aidl
+++ b/camera/aidl/android/hardware/ICameraService.aidl
@@ -108,7 +108,7 @@
*
* Also returns the set of currently-known camera IDs and state of each device.
* Adding a listener will trigger the torch status listener to fire for all
- * devices that have a flash unit
+ * devices that have a flash unit.
*/
CameraStatus[] addListener(ICameraServiceListener listener);
diff --git a/camera/aidl/android/hardware/ICameraServiceListener.aidl b/camera/aidl/android/hardware/ICameraServiceListener.aidl
index f871ce4..e9dcbdb 100644
--- a/camera/aidl/android/hardware/ICameraServiceListener.aidl
+++ b/camera/aidl/android/hardware/ICameraServiceListener.aidl
@@ -76,4 +76,11 @@
const int TORCH_STATUS_UNKNOWN = -1;
oneway void onTorchStatusChanged(int status, String cameraId);
+
+ /**
+ * Notify registered clients about camera access priority changes.
+ * Clients which were previously unable to open a certain camera device
+ * can retry after receiving this callback.
+ */
+ oneway void onCameraAccessPrioritiesChanged();
}
diff --git a/camera/ndk/impl/ACameraManager.h b/camera/ndk/impl/ACameraManager.h
index 55bfa7e..c3407f0 100644
--- a/camera/ndk/impl/ACameraManager.h
+++ b/camera/ndk/impl/ACameraManager.h
@@ -86,6 +86,11 @@
return binder::Status::ok();
}
+ // Access priority API not implemented yet
+ virtual binder::Status onCameraAccessPrioritiesChanged() {
+ return binder::Status::ok();
+ }
+
private:
const wp<CameraManagerGlobal> mCameraManager;
};
diff --git a/camera/ndk/impl/ACameraMetadata.cpp b/camera/ndk/impl/ACameraMetadata.cpp
index de40990..359eaed 100644
--- a/camera/ndk/impl/ACameraMetadata.cpp
+++ b/camera/ndk/impl/ACameraMetadata.cpp
@@ -38,6 +38,8 @@
filterDurations(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS);
filterDurations(ANDROID_HEIC_AVAILABLE_HEIC_MIN_FRAME_DURATIONS);
filterDurations(ANDROID_HEIC_AVAILABLE_HEIC_STALL_DURATIONS);
+ filterDurations(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS);
+ filterDurations(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS);
}
// TODO: filter request/result keys
}
@@ -186,6 +188,16 @@
filteredDurations.push_back(duration);
}
break;
+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_MIN_FRAME_DURATIONS:
+ case ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STALL_DURATIONS:
+ if (format == HAL_PIXEL_FORMAT_BLOB) {
+ format = AIMAGE_FORMAT_DEPTH_JPEG;
+ filteredDurations.push_back(format);
+ filteredDurations.push_back(width);
+ filteredDurations.push_back(height);
+ filteredDurations.push_back(duration);
+ }
+ break;
default:
// Should not reach here
ALOGE("%s: Unkown tag 0x%x", __FUNCTION__, tag);
@@ -284,6 +296,32 @@
filteredHeicStreamConfigs.push_back(isInput);
}
mData.update(ANDROID_HEIC_AVAILABLE_HEIC_STREAM_CONFIGURATIONS, filteredHeicStreamConfigs);
+
+ entry = mData.find(ANDROID_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS);
+ Vector<int32_t> filteredDynamicDepthStreamConfigs;
+ filteredDynamicDepthStreamConfigs.setCapacity(entry.count);
+
+ for (size_t i = 0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
+ int32_t format = entry.data.i32[i + STREAM_FORMAT_OFFSET];
+ int32_t width = entry.data.i32[i + STREAM_WIDTH_OFFSET];
+ int32_t height = entry.data.i32[i + STREAM_HEIGHT_OFFSET];
+ int32_t isInput = entry.data.i32[i + STREAM_IS_INPUT_OFFSET];
+ if (isInput == ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS_INPUT) {
+ // Hide input streams
+ continue;
+ }
+ // Translate HAL formats to NDK format
+ if (format == HAL_PIXEL_FORMAT_BLOB) {
+ format = AIMAGE_FORMAT_DEPTH_JPEG;
+ }
+
+ filteredDynamicDepthStreamConfigs.push_back(format);
+ filteredDynamicDepthStreamConfigs.push_back(width);
+ filteredDynamicDepthStreamConfigs.push_back(height);
+ filteredDynamicDepthStreamConfigs.push_back(isInput);
+ }
+ mData.update(ACAMERA_DEPTH_AVAILABLE_DYNAMIC_DEPTH_STREAM_CONFIGURATIONS,
+ filteredDynamicDepthStreamConfigs);
}
bool
diff --git a/camera/ndk/include/camera/NdkCameraMetadataTags.h b/camera/ndk/include/camera/NdkCameraMetadataTags.h
index 8c19e1d..b200abf 100644
--- a/camera/ndk/include/camera/NdkCameraMetadataTags.h
+++ b/camera/ndk/include/camera/NdkCameraMetadataTags.h
@@ -5688,13 +5688,17 @@
*
* <p>The ID of the active physical camera that's backing the logical camera. All camera
* streams and metadata that are not physical camera specific will be originating from this
- * physical camera. This must be one of valid physical IDs advertised in the physicalIds
- * static tag.</p>
+ * physical camera.</p>
* <p>For a logical camera made up of physical cameras where each camera's lenses have
* different characteristics, the camera device may choose to switch between the physical
* cameras when application changes FOCAL_LENGTH or SCALER_CROP_REGION.
* At the time of lens switch, this result metadata reflects the new active physical camera
* ID.</p>
+ * <p>This key will be available if the camera device advertises this key via {@link ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS }.
+ * When available, this must be one of valid physical IDs backing this logical multi-camera.
+ * If this key is not available for a logical multi-camera, the camera device implementation
+ * may still switch between different active physical cameras based on use case, but the
+ * current active physical camera information won't be available to the application.</p>
*/
ACAMERA_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID = // byte
ACAMERA_LOGICAL_MULTI_CAMERA_START + 2,
diff --git a/camera/tests/CameraBinderTests.cpp b/camera/tests/CameraBinderTests.cpp
index 8534b28..8fe029a 100644
--- a/camera/tests/CameraBinderTests.cpp
+++ b/camera/tests/CameraBinderTests.cpp
@@ -90,6 +90,11 @@
return binder::Status::ok();
};
+ virtual binder::Status onCameraAccessPrioritiesChanged() {
+ // No op
+ return binder::Status::ok();
+ }
+
bool waitForNumCameras(size_t num) const {
Mutex::Autolock l(mLock);
diff --git a/include/media/AudioVolumeGroup.h b/include/media/AudioVolumeGroup.h
new file mode 120000
index 0000000..d6f1c99
--- /dev/null
+++ b/include/media/AudioVolumeGroup.h
@@ -0,0 +1 @@
+../../media/libaudioclient/include/media/AudioVolumeGroup.h
\ No newline at end of file
diff --git a/media/audioserver/Android.mk b/media/audioserver/Android.mk
index 10d8b13..1f24413 100644
--- a/media/audioserver/Android.mk
+++ b/media/audioserver/Android.mk
@@ -16,6 +16,7 @@
libhwbinder \
libmedia \
libmedialogservice \
+ libmediautils \
libnbaio \
libnblog \
libsoundtriggerservice \
diff --git a/media/bufferpool/2.0/Android.bp b/media/bufferpool/2.0/Android.bp
index cd4e06e..c71ac17 100644
--- a/media/bufferpool/2.0/Android.bp
+++ b/media/bufferpool/2.0/Android.bp
@@ -1,6 +1,9 @@
cc_library {
name: "libstagefright_bufferpool@2.0",
vendor_available: true,
+ vndk: {
+ enabled: true,
+ },
srcs: [
"Accessor.cpp",
"AccessorImpl.cpp",
diff --git a/media/codec2/core/Android.bp b/media/codec2/core/Android.bp
index b723755..a7e8997 100644
--- a/media/codec2/core/Android.bp
+++ b/media/codec2/core/Android.bp
@@ -7,6 +7,9 @@
cc_library_shared {
name: "libcodec2",
vendor_available: true,
+ vndk: {
+ enabled: true,
+ },
srcs: ["C2.cpp"],
diff --git a/media/codec2/hidl/1.0/utils/Android.bp b/media/codec2/hidl/1.0/utils/Android.bp
index d0296a5..f5aa65b 100644
--- a/media/codec2/hidl/1.0/utils/Android.bp
+++ b/media/codec2/hidl/1.0/utils/Android.bp
@@ -3,6 +3,9 @@
cc_library {
name: "libcodec2_hidl@1.0",
vendor_available: true,
+ vndk: {
+ enabled: true,
+ },
defaults: ["hidl_defaults"],
diff --git a/media/codec2/hidl/1.0/utils/Component.cpp b/media/codec2/hidl/1.0/utils/Component.cpp
index 0473b57..f3bf6f7 100644
--- a/media/codec2/hidl/1.0/utils/Component.cpp
+++ b/media/codec2/hidl/1.0/utils/Component.cpp
@@ -22,7 +22,6 @@
#include <codec2/hidl/1.0/ComponentStore.h>
#include <codec2/hidl/1.0/InputBufferManager.h>
-#include <android/hardware/media/c2/1.0/IInputSink.h>
#include <hidl/HidlBinderSupport.h>
#include <utils/Timers.h>
@@ -298,19 +297,12 @@
Return<void> Component::connectToInputSurface(
const sp<IInputSurface>& inputSurface,
connectToInputSurface_cb _hidl_cb) {
- sp<Sink> sink;
- {
- std::lock_guard<std::mutex> lock(mSinkMutex);
- if (!mSink) {
- mSink = new Sink(shared_from_this());
- }
- sink = mSink;
- }
Status status;
sp<IInputSurfaceConnection> connection;
- auto transStatus = inputSurface->connect(sink,
- [&status, &connection](Status s,
- const sp<IInputSurfaceConnection>& c) {
+ auto transStatus = inputSurface->connect(
+ asInputSink(),
+ [&status, &connection](
+ Status s, const sp<IInputSurfaceConnection>& c) {
status = s;
connection = c;
}
@@ -454,6 +446,14 @@
return sp<IComponentInterface>(mInterface);
}
+Return<sp<IInputSink>> Component::asInputSink() {
+ std::lock_guard<std::mutex> lock(mSinkMutex);
+ if (!mSink) {
+ mSink = new Sink(shared_from_this());
+ }
+ return {mSink};
+}
+
std::shared_ptr<C2Component> Component::findLocalComponent(
const sp<IInputSink>& sink) {
return Component::Sink::findLocalComponent(sink);
diff --git a/media/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h b/media/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
index 4ac95c5..e444013 100644
--- a/media/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
+++ b/media/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
@@ -26,6 +26,7 @@
#include <android/hardware/media/c2/1.0/IComponentInterface.h>
#include <android/hardware/media/c2/1.0/IComponentListener.h>
#include <android/hardware/media/c2/1.0/IComponentStore.h>
+#include <android/hardware/media/c2/1.0/IInputSink.h>
#include <hidl/Status.h>
#include <hwbinder/IBinder.h>
@@ -94,6 +95,7 @@
virtual Return<Status> reset() override;
virtual Return<Status> release() override;
virtual Return<sp<IComponentInterface>> getInterface() override;
+ virtual Return<sp<IInputSink>> asInputSink() override;
// Returns a C2Component associated to the given sink if the sink is indeed
// a local component. Returns nullptr otherwise.
diff --git a/media/codec2/sfplugin/CCodec.cpp b/media/codec2/sfplugin/CCodec.cpp
index 98e5951..2d10c67 100644
--- a/media/codec2/sfplugin/CCodec.cpp
+++ b/media/codec2/sfplugin/CCodec.cpp
@@ -761,13 +761,14 @@
{
config->mISConfig->mMinFps = 0;
int64_t value;
- if (msg->findInt64("repeat-previous-frame-after", &value) && value > 0) {
+ if (msg->findInt64(KEY_REPEAT_PREVIOUS_FRAME_AFTER, &value) && value > 0) {
config->mISConfig->mMinFps = 1e6 / value;
}
- (void)msg->findFloat("max-fps-to-encoder", &config->mISConfig->mMaxFps);
+ (void)msg->findFloat(
+ KEY_MAX_FPS_TO_ENCODER, &config->mISConfig->mMaxFps);
config->mISConfig->mMinAdjustedFps = 0;
config->mISConfig->mFixedAdjustedFps = 0;
- if (msg->findInt64("max-pts-gap-to-encoder", &value)) {
+ if (msg->findInt64(KEY_MAX_PTS_GAP_TO_ENCODER, &value)) {
if (value < 0 && value >= INT32_MIN) {
config->mISConfig->mFixedAdjustedFps = -1e6 / value;
} else if (value > 0 && value <= INT32_MAX) {
@@ -788,7 +789,7 @@
config->mISConfig->mSuspended = false;
config->mISConfig->mSuspendAtUs = -1;
int32_t value;
- if (msg->findInt32("create-input-buffers-suspended", &value) && value) {
+ if (msg->findInt32(KEY_CREATE_INPUT_SURFACE_SUSPENDED, &value) && value) {
config->mISConfig->mSuspended = true;
}
}
@@ -1496,7 +1497,7 @@
*/
if ((config->mDomain & (Config::IS_VIDEO | Config::IS_IMAGE))
&& (config->mDomain & Config::IS_ENCODER) && config->mInputSurface && config->mISConfig) {
- (void)params->findInt64("time-offset-us", &config->mISConfig->mTimeOffsetUs);
+ (void)params->findInt64(PARAMETER_KEY_OFFSET_TIME, &config->mISConfig->mTimeOffsetUs);
if (params->findInt64("skip-frames-before", &config->mISConfig->mStartAtUs)) {
config->mISConfig->mStopped = false;
@@ -1505,10 +1506,10 @@
}
int32_t value;
- if (params->findInt32("drop-input-frames", &value)) {
+ if (params->findInt32(PARAMETER_KEY_SUSPEND, &value)) {
config->mISConfig->mSuspended = value;
config->mISConfig->mSuspendAtUs = -1;
- (void)params->findInt64("drop-start-time-us", &config->mISConfig->mSuspendAtUs);
+ (void)params->findInt64(PARAMETER_KEY_SUSPEND_TIME, &config->mISConfig->mSuspendAtUs);
}
(void)config->mInputSurface->configure(*config->mISConfig);
diff --git a/media/codec2/sfplugin/CCodecBufferChannel.cpp b/media/codec2/sfplugin/CCodecBufferChannel.cpp
index 7a444a3..fb6af93 100644
--- a/media/codec2/sfplugin/CCodecBufferChannel.cpp
+++ b/media/codec2/sfplugin/CCodecBufferChannel.cpp
@@ -99,6 +99,34 @@
*/
virtual size_t numClientBuffers() const = 0;
+ void handleImageData(const sp<Codec2Buffer> &buffer) {
+ sp<ABuffer> imageDataCandidate = buffer->getImageData();
+ if (imageDataCandidate == nullptr) {
+ return;
+ }
+ sp<ABuffer> imageData;
+ if (!mFormat->findBuffer("image-data", &imageData)
+ || imageDataCandidate->size() != imageData->size()
+ || memcmp(imageDataCandidate->data(), imageData->data(), imageData->size()) != 0) {
+ ALOGD("[%s] updating image-data", mName);
+ sp<AMessage> newFormat = dupFormat();
+ newFormat->setBuffer("image-data", imageDataCandidate);
+ MediaImage2 *img = (MediaImage2*)imageDataCandidate->data();
+ if (img->mNumPlanes > 0 && img->mType != img->MEDIA_IMAGE_TYPE_UNKNOWN) {
+ int32_t stride = img->mPlane[0].mRowInc;
+ newFormat->setInt32(KEY_STRIDE, stride);
+ ALOGD("[%s] updating stride = %d", mName, stride);
+ if (img->mNumPlanes > 1 && stride > 0) {
+ int32_t vstride = (img->mPlane[1].mOffset - img->mPlane[0].mOffset) / stride;
+ newFormat->setInt32(KEY_SLICE_HEIGHT, vstride);
+ ALOGD("[%s] updating vstride = %d", mName, vstride);
+ }
+ }
+ setFormat(newFormat);
+ buffer->setFormat(newFormat);
+ }
+ }
+
protected:
std::string mComponentName; ///< name of component for debugging
std::string mChannelName; ///< name of channel for debugging
@@ -255,34 +283,6 @@
mSkipCutBuffer = scb;
}
- void handleImageData(const sp<Codec2Buffer> &buffer) {
- sp<ABuffer> imageDataCandidate = buffer->getImageData();
- if (imageDataCandidate == nullptr) {
- return;
- }
- sp<ABuffer> imageData;
- if (!mFormat->findBuffer("image-data", &imageData)
- || imageDataCandidate->size() != imageData->size()
- || memcmp(imageDataCandidate->data(), imageData->data(), imageData->size()) != 0) {
- ALOGD("[%s] updating image-data", mName);
- sp<AMessage> newFormat = dupFormat();
- newFormat->setBuffer("image-data", imageDataCandidate);
- MediaImage2 *img = (MediaImage2*)imageDataCandidate->data();
- if (img->mNumPlanes > 0 && img->mType != img->MEDIA_IMAGE_TYPE_UNKNOWN) {
- int32_t stride = img->mPlane[0].mRowInc;
- newFormat->setInt32(KEY_STRIDE, stride);
- ALOGD("[%s] updating stride = %d", mName, stride);
- if (img->mNumPlanes > 1 && stride > 0) {
- int32_t vstride = (img->mPlane[1].mOffset - img->mPlane[0].mOffset) / stride;
- newFormat->setInt32(KEY_SLICE_HEIGHT, vstride);
- ALOGD("[%s] updating vstride = %d", mName, vstride);
- }
- }
- setFormat(newFormat);
- buffer->setFormat(newFormat);
- }
- }
-
protected:
sp<SkipCutBuffer> mSkipCutBuffer;
@@ -783,6 +783,7 @@
status_t err = mImpl.grabBuffer(index, &c2Buffer);
if (err == OK) {
c2Buffer->setFormat(mFormat);
+ handleImageData(c2Buffer);
*buffer = c2Buffer;
return true;
}
@@ -1053,6 +1054,7 @@
return false;
}
*index = mImpl.assignSlot(newBuffer);
+ handleImageData(newBuffer);
*buffer = newBuffer;
return true;
}
diff --git a/media/codec2/vndk/Android.bp b/media/codec2/vndk/Android.bp
index e0b1355..ab6a105 100644
--- a/media/codec2/vndk/Android.bp
+++ b/media/codec2/vndk/Android.bp
@@ -14,6 +14,9 @@
cc_library_shared {
name: "libcodec2_vndk",
vendor_available: true,
+ vndk: {
+ enabled: true,
+ },
srcs: [
"C2AllocatorIon.cpp",
diff --git a/media/extractors/mkv/MatroskaExtractor.cpp b/media/extractors/mkv/MatroskaExtractor.cpp
index 4200a46..7239302 100644
--- a/media/extractors/mkv/MatroskaExtractor.cpp
+++ b/media/extractors/mkv/MatroskaExtractor.cpp
@@ -1557,6 +1557,21 @@
} else if (!strcmp("A_FLAC", codecID)) {
AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_FLAC);
err = addFlacMetadata(meta, codecPrivate, codecPrivateSize);
+ } else if ((!strcmp("A_MS/ACM", codecID))) {
+ if ((NULL == codecPrivate) || (codecPrivateSize < 30)) {
+ ALOGW("unsupported audio: A_MS/ACM has no valid private data: %s, size: %zu",
+ codecPrivate == NULL ? "null" : "non-null", codecPrivateSize);
+ continue;
+ } else {
+ uint16_t ID = *(uint16_t *)codecPrivate;
+ if (ID == 0x0055) {
+ AMediaFormat_setString(meta,
+ AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_MPEG);
+ } else {
+ ALOGW("A_MS/ACM unsupported type , continue");
+ continue;
+ }
+ }
} else {
ALOGW("%s is not supported.", codecID);
continue;
diff --git a/media/extractors/mp4/MPEG4Extractor.cpp b/media/extractors/mp4/MPEG4Extractor.cpp
index c776c51..4298b57 100755
--- a/media/extractors/mp4/MPEG4Extractor.cpp
+++ b/media/extractors/mp4/MPEG4Extractor.cpp
@@ -142,6 +142,7 @@
uint8_t *mSrcBuffer;
bool mIsHeif;
+ bool mIsAudio;
sp<ItemTable> mItemTable;
// Start offset from composition time to presentation time.
@@ -4530,6 +4531,7 @@
}
mIsPcm = !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW);
+ mIsAudio = !strncasecmp(mime, "audio/", 6);
if (mIsPcm) {
int32_t numChannels = 0;
@@ -5416,8 +5418,11 @@
findFlags = SampleTable::kFlagBefore;
}
- uint32_t syncSampleIndex;
- if (err == OK) {
+ uint32_t syncSampleIndex = sampleIndex;
+ // assume every audio sample is a sync sample. This works around
+ // seek issues with files that were incorrectly written with an
+ // empty or single-sample stss block for the audio track
+ if (err == OK && !mIsAudio) {
err = mSampleTable->findSyncSampleNear(
sampleIndex, &syncSampleIndex, findFlags);
}
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index b111b78..e9b6fb1 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -10,6 +10,7 @@
"AudioAttributes.cpp",
"AudioPolicy.cpp",
"AudioProductStrategy.cpp",
+ "AudioVolumeGroup.cpp",
],
shared_libs: [
"libaudioutils",
diff --git a/media/libaudioclient/AudioSystem.cpp b/media/libaudioclient/AudioSystem.cpp
index 01d9b3d..0ce2513 100644
--- a/media/libaudioclient/AudioSystem.cpp
+++ b/media/libaudioclient/AudioSystem.cpp
@@ -792,6 +792,7 @@
int64_t token = IPCThreadState::self()->clearCallingIdentity();
ap->registerClient(apc);
ap->setAudioPortCallbacksEnabled(apc->isAudioPortCbEnabled());
+ ap->setAudioVolumeGroupCallbacksEnabled(apc->isAudioVolumeGroupCbEnabled());
IPCThreadState::self()->restoreCallingIdentity(token);
}
@@ -987,6 +988,38 @@
return aps->getStreamVolumeIndex(stream, index, device);
}
+status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->setVolumeIndexForAttributes(attr, index, device);
+}
+
+status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->getVolumeIndexForAttributes(attr, index, device);
+}
+
+status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->getMaxVolumeIndexForAttributes(attr, index);
+}
+
+status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->getMinVolumeIndexForAttributes(attr, index);
+}
+
uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream)
{
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
@@ -1190,6 +1223,38 @@
return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
}
+status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+
+ Mutex::Autolock _l(gLockAPS);
+ if (gAudioPolicyServiceClient == 0) {
+ return NO_INIT;
+ }
+ int ret = gAudioPolicyServiceClient->addAudioVolumeGroupCallback(callback);
+ if (ret == 1) {
+ aps->setAudioVolumeGroupCallbacksEnabled(true);
+ }
+ return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
+}
+
+status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+
+ Mutex::Autolock _l(gLockAPS);
+ if (gAudioPolicyServiceClient == 0) {
+ return NO_INIT;
+ }
+ int ret = gAudioPolicyServiceClient->removeAudioVolumeGroupCallback(callback);
+ if (ret == 0) {
+ aps->setAudioVolumeGroupCallbacksEnabled(false);
+ }
+ return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
+}
+
status_t AudioSystem::addAudioDeviceCallback(
const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo)
{
@@ -1403,12 +1468,16 @@
audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t &attr)
{
- product_strategy_t strategyId =
- AudioSystem::getProductStrategyFromAudioAttributes(AudioAttributes(attr));
+ product_strategy_t psId;
+ status_t ret = AudioSystem::getProductStrategyFromAudioAttributes(AudioAttributes(attr), psId);
+ if (ret != NO_ERROR) {
+ ALOGE("no strategy found for attributes %s", toString(attr).c_str());
+ return AUDIO_STREAM_MUSIC;
+ }
AudioProductStrategyVector strategies;
listAudioProductStrategies(strategies);
for (const auto &strategy : strategies) {
- if (strategy.getId() == strategyId) {
+ if (strategy.getId() == psId) {
auto attrVect = strategy.getAudioAttributes();
auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto &refAttr) {
return AudioProductStrategy::attributesMatches(
@@ -1422,11 +1491,27 @@
return AUDIO_STREAM_MUSIC;
}
-product_strategy_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes &aa)
+status_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy)
{
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
- if (aps == 0) return PRODUCT_STRATEGY_NONE;
- return aps->getProductStrategyFromAudioAttributes(aa);
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->getProductStrategyFromAudioAttributes(aa,productStrategy);
+}
+
+status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->listAudioVolumeGroups(groups);
+}
+
+status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup)
+{
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ if (aps == 0) return PERMISSION_DENIED;
+ return aps->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
}
// ---------------------------------------------------------------------------
@@ -1478,6 +1563,47 @@
}
}
+// ----------------------------------------------------------------------------
+int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
+ const sp<AudioVolumeGroupCallback>& callback)
+{
+ Mutex::Autolock _l(mLock);
+ for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
+ if (mAudioVolumeGroupCallback[i] == callback) {
+ return -1;
+ }
+ }
+ mAudioVolumeGroupCallback.add(callback);
+ return mAudioVolumeGroupCallback.size();
+}
+
+int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
+ const sp<AudioVolumeGroupCallback>& callback)
+{
+ Mutex::Autolock _l(mLock);
+ size_t i;
+ for (i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
+ if (mAudioVolumeGroupCallback[i] == callback) {
+ break;
+ }
+ }
+ if (i == mAudioVolumeGroupCallback.size()) {
+ return -1;
+ }
+ mAudioVolumeGroupCallback.removeAt(i);
+ return mAudioVolumeGroupCallback.size();
+}
+
+void AudioSystem::AudioPolicyServiceClient::onAudioVolumeGroupChanged(volume_group_t group,
+ int flags)
+{
+ Mutex::Autolock _l(mLock);
+ for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
+ mAudioVolumeGroupCallback[i]->onAudioVolumeGroupChanged(group, flags);
+ }
+}
+// ----------------------------------------------------------------------------
+
void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
String8 regId, int32_t state)
{
@@ -1521,6 +1647,9 @@
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onServiceDied();
}
+ for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
+ mAudioVolumeGroupCallback[i]->onServiceDied();
+ }
}
{
Mutex::Autolock _l(gLockAPS);
diff --git a/media/libaudioclient/AudioVolumeGroup.cpp b/media/libaudioclient/AudioVolumeGroup.cpp
new file mode 100644
index 0000000..e79a362
--- /dev/null
+++ b/media/libaudioclient/AudioVolumeGroup.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AudioVolumeGroup"
+
+//#define LOG_NDEBUG 0
+
+#include <utils/Log.h>
+#include <binder/Parcel.h>
+
+#include <media/AudioVolumeGroup.h>
+#include <media/AudioAttributes.h>
+
+namespace android {
+
+status_t AudioVolumeGroup::readFromParcel(const Parcel *parcel)
+{
+ status_t ret = parcel->readUtf8FromUtf16(&mName);
+ if (ret != NO_ERROR) {
+ return ret;
+ }
+ mGroupId = static_cast<volume_group_t>(parcel->readInt32());
+ size_t size = static_cast<size_t>(parcel->readInt32());
+ for (size_t i = 0; i < size; i++) {
+ AudioAttributes attribute;
+ attribute.readFromParcel(parcel);
+ if (ret != NO_ERROR) {
+ mAudioAttributes.clear();
+ return ret;
+ }
+ mAudioAttributes.push_back(attribute.getAttributes());
+ }
+ size = static_cast<size_t>(parcel->readInt32());
+ for (size_t i = 0; i < size; i++) {
+ audio_stream_type_t stream = static_cast<audio_stream_type_t>(parcel->readInt32());
+ mStreams.push_back(stream);
+ }
+ return NO_ERROR;
+}
+
+status_t AudioVolumeGroup::writeToParcel(Parcel *parcel) const
+{
+ parcel->writeUtf8AsUtf16(mName);
+ parcel->writeInt32(static_cast<int32_t>(mGroupId));
+ size_t size = mAudioAttributes.size();
+ size_t sizePosition = parcel->dataPosition();
+ parcel->writeInt32(size);
+ size_t finalSize = size;
+ for (const auto &attributes : mAudioAttributes) {
+ size_t position = parcel->dataPosition();
+ AudioAttributes attribute(attributes);
+ status_t ret = attribute.writeToParcel(parcel);
+ if (ret != NO_ERROR) {
+ parcel->setDataPosition(position);
+ finalSize--;
+ }
+ }
+ if (size != finalSize) {
+ size_t position = parcel->dataPosition();
+ parcel->setDataPosition(sizePosition);
+ parcel->writeInt32(finalSize);
+ parcel->setDataPosition(position);
+ }
+ parcel->writeInt32(mStreams.size());
+ for (const auto &stream : mStreams) {
+ parcel->writeInt32(static_cast<int32_t>(stream));
+ }
+ return NO_ERROR;
+}
+
+} // namespace android
diff --git a/media/libaudioclient/IAudioPolicyService.cpp b/media/libaudioclient/IAudioPolicyService.cpp
index 1bce16f..3bac44f 100644
--- a/media/libaudioclient/IAudioPolicyService.cpp
+++ b/media/libaudioclient/IAudioPolicyService.cpp
@@ -51,6 +51,10 @@
INIT_STREAM_VOLUME,
SET_STREAM_VOLUME,
GET_STREAM_VOLUME,
+ SET_VOLUME_ATTRIBUTES,
+ GET_VOLUME_ATTRIBUTES,
+ GET_MIN_VOLUME_FOR_ATTRIBUTES,
+ GET_MAX_VOLUME_FOR_ATTRIBUTES,
GET_STRATEGY_FOR_STREAM,
GET_OUTPUT_FOR_EFFECT,
REGISTER_EFFECT,
@@ -78,6 +82,7 @@
START_AUDIO_SOURCE,
STOP_AUDIO_SOURCE,
SET_AUDIO_PORT_CALLBACK_ENABLED,
+ SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED,
SET_MASTER_MONO,
GET_MASTER_MONO,
GET_STREAM_VOLUME_DB,
@@ -95,6 +100,8 @@
GET_OFFLOAD_FORMATS_A2DP,
LIST_AUDIO_PRODUCT_STRATEGIES,
GET_STRATEGY_FOR_ATTRIBUTES,
+ LIST_AUDIO_VOLUME_GROUPS,
+ GET_VOLUME_GROUP_FOR_ATTRIBUTES
};
#define MAX_ITEMS_PER_LIST 1024
@@ -415,6 +422,70 @@
return static_cast <status_t> (reply.readInt32());
}
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, int index,
+ audio_devices_t device)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ data.write(&attr, sizeof(audio_attributes_t));
+ data.writeInt32(index);
+ data.writeInt32(static_cast <uint32_t>(device));
+ status_t status = remote()->transact(SET_VOLUME_ATTRIBUTES, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ return static_cast <status_t> (reply.readInt32());
+ }
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, int &index,
+ audio_devices_t device)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ data.write(&attr, sizeof(audio_attributes_t));
+ data.writeInt32(static_cast <uint32_t>(device));
+ status_t status = remote()->transact(GET_VOLUME_ATTRIBUTES, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = static_cast <status_t> (reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ index = reply.readInt32();
+ return NO_ERROR;
+ }
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ data.write(&attr, sizeof(audio_attributes_t));
+ status_t status = remote()->transact(GET_MIN_VOLUME_FOR_ATTRIBUTES, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = static_cast <status_t> (reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ index = reply.readInt32();
+ return NO_ERROR;
+ }
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ data.write(&attr, sizeof(audio_attributes_t));
+ status_t status = remote()->transact(GET_MAX_VOLUME_FOR_ATTRIBUTES, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = static_cast <status_t> (reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ index = reply.readInt32();
+ return NO_ERROR;
+ }
virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
{
Parcel data, reply;
@@ -692,6 +763,14 @@
remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply);
}
+ virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ data.writeInt32(enabled ? 1 : 0);
+ remote()->transact(SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, data, &reply);
+ }
+
virtual status_t acquireSoundTriggerSession(audio_session_t *session,
audio_io_handle_t *ioHandle,
audio_devices_t *device)
@@ -1085,35 +1164,90 @@
return status;
}
status = static_cast<status_t>(reply.readInt32());
- if (status == NO_ERROR) {
- uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32());
- for (size_t i = 0; i < numStrategies; i++) {
- AudioProductStrategy strategy;
- status = strategy.readFromParcel(&reply);
- if (status != NO_ERROR) {
- ALOGE("%s: failed to read strategies", __FUNCTION__);
- strategies.clear();
- return status;
- }
- strategies.push_back(strategy);
- }
+ if (status != NO_ERROR) {
+ return status;
}
- return status;
+ uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32());
+ for (size_t i = 0; i < numStrategies; i++) {
+ AudioProductStrategy strategy;
+ status = strategy.readFromParcel(&reply);
+ if (status != NO_ERROR) {
+ ALOGE("%s: failed to read strategies", __FUNCTION__);
+ strategies.clear();
+ return status;
+ }
+ strategies.push_back(strategy);
+ }
+ return NO_ERROR;
}
- virtual product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa)
+ virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy)
{
Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
status_t status = aa.writeToParcel(&data);
if (status != NO_ERROR) {
- return PRODUCT_STRATEGY_NONE;
+ return status;
}
status = remote()->transact(GET_STRATEGY_FOR_ATTRIBUTES, data, &reply);
- if (status == NO_ERROR) {
- return static_cast<product_strategy_t>(reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
}
- return PRODUCT_STRATEGY_NONE;
+ status = static_cast<status_t>(reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ productStrategy = static_cast<product_strategy_t>(reply.readInt32());
+ return NO_ERROR;
+ }
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+
+ status_t status = remote()->transact(LIST_AUDIO_VOLUME_GROUPS, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = static_cast<status_t>(reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ uint32_t numGroups = static_cast<uint32_t>(reply.readInt32());
+ for (size_t i = 0; i < numGroups; i++) {
+ AudioVolumeGroup group;
+ status = group.readFromParcel(&reply);
+ if (status != NO_ERROR) {
+ ALOGE("%s: failed to read volume groups", __FUNCTION__);
+ groups.clear();
+ return status;
+ }
+ groups.push_back(group);
+ }
+ return NO_ERROR;
+ }
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
+ status_t status = aa.writeToParcel(&data);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = remote()->transact(GET_VOLUME_GROUP_FOR_ATTRIBUTES, data, &reply);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ status = static_cast<status_t>(reply.readInt32());
+ if (status != NO_ERROR) {
+ return status;
+ }
+ volumeGroup = static_cast<volume_group_t>(reply.readInt32());
+ return NO_ERROR;
}
};
@@ -1173,7 +1307,9 @@
case SET_A11Y_SERVICES_UIDS:
case SET_UID_DEVICE_AFFINITY:
case REMOVE_UID_DEVICE_AFFINITY:
- case GET_OFFLOAD_FORMATS_A2DP: {
+ case GET_OFFLOAD_FORMATS_A2DP:
+ case LIST_AUDIO_VOLUME_GROUPS:
+ case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {
if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
__func__, code, IPCThreadState::self()->getCallingPid(),
@@ -1433,6 +1569,73 @@
return NO_ERROR;
} break;
+ case SET_VOLUME_ATTRIBUTES: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ audio_attributes_t attributes = {};
+ status_t status = data.read(&attributes, sizeof(audio_attributes_t));
+ if (status != NO_ERROR) {
+ return status;
+ }
+ int index = data.readInt32();
+ audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
+
+ reply->writeInt32(static_cast <uint32_t>(setVolumeIndexForAttributes(attributes,
+ index, device)));
+ return NO_ERROR;
+ } break;
+
+ case GET_VOLUME_ATTRIBUTES: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ audio_attributes_t attributes = {};
+ status_t status = data.read(&attributes, sizeof(audio_attributes_t));
+ if (status != NO_ERROR) {
+ return status;
+ }
+ audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
+
+ int index = 0;
+ status = getVolumeIndexForAttributes(attributes, index, device);
+ reply->writeInt32(static_cast <uint32_t>(status));
+ if (status == NO_ERROR) {
+ reply->writeInt32(index);
+ }
+ return NO_ERROR;
+ } break;
+
+ case GET_MIN_VOLUME_FOR_ATTRIBUTES: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ audio_attributes_t attributes = {};
+ status_t status = data.read(&attributes, sizeof(audio_attributes_t));
+ if (status != NO_ERROR) {
+ return status;
+ }
+
+ int index = 0;
+ status = getMinVolumeIndexForAttributes(attributes, index);
+ reply->writeInt32(static_cast <uint32_t>(status));
+ if (status == NO_ERROR) {
+ reply->writeInt32(index);
+ }
+ return NO_ERROR;
+ } break;
+
+ case GET_MAX_VOLUME_FOR_ATTRIBUTES: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ audio_attributes_t attributes = {};
+ status_t status = data.read(&attributes, sizeof(audio_attributes_t));
+ if (status != NO_ERROR) {
+ return status;
+ }
+
+ int index = 0;
+ status = getMaxVolumeIndexForAttributes(attributes, index);
+ reply->writeInt32(static_cast <uint32_t>(status));
+ if (status == NO_ERROR) {
+ reply->writeInt32(index);
+ }
+ return NO_ERROR;
+ } break;
+
case GET_DEVICES_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
@@ -1681,6 +1884,12 @@
return NO_ERROR;
} break;
+ case SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ setAudioVolumeGroupCallbacksEnabled(data.readInt32() == 1);
+ return NO_ERROR;
+ } break;
+
case ACQUIRE_SOUNDTRIGGER_SESSION: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
@@ -1992,7 +2201,7 @@
status_t status = listAudioProductStrategies(strategies);
reply->writeInt32(status);
if (status != NO_ERROR) {
- return status;
+ return NO_ERROR;
}
size_t size = strategies.size();
size_t sizePosition = reply->dataPosition();
@@ -2021,11 +2230,61 @@
if (status != NO_ERROR) {
return status;
}
- product_strategy_t strategy = getProductStrategyFromAudioAttributes(attributes);
+ product_strategy_t strategy;
+ status = getProductStrategyFromAudioAttributes(attributes, strategy);
+ reply->writeInt32(status);
+ if (status != NO_ERROR) {
+ return NO_ERROR;
+ }
reply->writeUint32(static_cast<int>(strategy));
return NO_ERROR;
}
+ case LIST_AUDIO_VOLUME_GROUPS: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ AudioVolumeGroupVector groups;
+ status_t status = listAudioVolumeGroups(groups);
+ reply->writeInt32(status);
+ if (status != NO_ERROR) {
+ return NO_ERROR;
+ }
+ size_t size = groups.size();
+ size_t sizePosition = reply->dataPosition();
+ reply->writeInt32(size);
+ size_t finalSize = size;
+ for (size_t i = 0; i < size; i++) {
+ size_t position = reply->dataPosition();
+ if (groups[i].writeToParcel(reply) != NO_ERROR) {
+ reply->setDataPosition(position);
+ finalSize--;
+ }
+ }
+ if (size != finalSize) {
+ size_t position = reply->dataPosition();
+ reply->setDataPosition(sizePosition);
+ reply->writeInt32(finalSize);
+ reply->setDataPosition(position);
+ }
+ return NO_ERROR;
+ }
+
+ case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {
+ CHECK_INTERFACE(IAudioPolicyService, data, reply);
+ AudioAttributes attributes;
+ status_t status = attributes.readFromParcel(&data);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ volume_group_t group;
+ status = getVolumeGroupFromAudioAttributes(attributes, group);
+ reply->writeInt32(status);
+ if (status != NO_ERROR) {
+ return NO_ERROR;
+ }
+ reply->writeUint32(static_cast<int>(group));
+ return NO_ERROR;
+ }
+
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/media/libaudioclient/IAudioPolicyServiceClient.cpp b/media/libaudioclient/IAudioPolicyServiceClient.cpp
index 1f9eab7..52d8ccd 100644
--- a/media/libaudioclient/IAudioPolicyServiceClient.cpp
+++ b/media/libaudioclient/IAudioPolicyServiceClient.cpp
@@ -31,7 +31,8 @@
PORT_LIST_UPDATE = IBinder::FIRST_CALL_TRANSACTION,
PATCH_LIST_UPDATE,
MIX_STATE_UPDATE,
- RECORDING_CONFIGURATION_UPDATE
+ RECORDING_CONFIGURATION_UPDATE,
+ VOLUME_GROUP_CHANGED,
};
// ----------------------------------------------------------------------
@@ -108,6 +109,15 @@
remote()->transact(PATCH_LIST_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);
}
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());
+ data.writeUint32(group);
+ data.writeInt32(flags);
+ remote()->transact(VOLUME_GROUP_CHANGED, data, &reply, IBinder::FLAG_ONEWAY);
+ }
+
void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state)
{
Parcel data, reply;
@@ -157,6 +167,13 @@
onAudioPatchListUpdate();
return NO_ERROR;
} break;
+ case VOLUME_GROUP_CHANGED: {
+ CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);
+ volume_group_t group = static_cast<volume_group_t>(data.readUint32());
+ int flags = data.readInt32();
+ onAudioVolumeGroupChanged(group, flags);
+ return NO_ERROR;
+ } break;
case MIX_STATE_UPDATE: {
CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);
String8 regId = data.readString8();
diff --git a/media/libaudioclient/include/media/AudioSystem.h b/media/libaudioclient/include/media/AudioSystem.h
index b9ee24a..e64f285 100644
--- a/media/libaudioclient/include/media/AudioSystem.h
+++ b/media/libaudioclient/include/media/AudioSystem.h
@@ -21,6 +21,7 @@
#include <media/AudioPolicy.h>
#include <media/AudioProductStrategy.h>
+#include <media/AudioVolumeGroup.h>
#include <media/AudioIoDescriptor.h>
#include <media/IAudioFlingerClient.h>
#include <media/IAudioPolicyServiceClient.h>
@@ -263,6 +264,17 @@
int *index,
audio_devices_t device);
+ static status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device);
+ static status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device);
+
+ static status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
+
+ static status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
+
static uint32_t getStrategyForStream(audio_stream_type_t stream);
static audio_devices_t getDevicesForStream(audio_stream_type_t stream);
@@ -367,13 +379,34 @@
static bool isHapticPlaybackSupported();
static status_t listAudioProductStrategies(AudioProductStrategyVector &strategies);
- static product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa);
+ static status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy);
static audio_attributes_t streamTypeToAttributes(audio_stream_type_t stream);
static audio_stream_type_t attributesToStreamType(const audio_attributes_t &attr);
+ static status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups);
+
+ static status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup);
+
// ----------------------------------------------------------------------------
+ class AudioVolumeGroupCallback : public RefBase
+ {
+ public:
+
+ AudioVolumeGroupCallback() {}
+ virtual ~AudioVolumeGroupCallback() {}
+
+ virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0;
+ virtual void onServiceDied() = 0;
+
+ };
+
+ static status_t addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
+ static status_t removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
+
class AudioPortCallback : public RefBase
{
public:
@@ -506,12 +539,17 @@
int removeAudioPortCallback(const sp<AudioPortCallback>& callback);
bool isAudioPortCbEnabled() const { return (mAudioPortCallbacks.size() != 0); }
+ int addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
+ int removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
+ bool isAudioVolumeGroupCbEnabled() const { return (mAudioVolumeGroupCallback.size() != 0); }
+
// DeathRecipient
virtual void binderDied(const wp<IBinder>& who);
// IAudioPolicyServiceClient
virtual void onAudioPortListUpdate();
virtual void onAudioPatchListUpdate();
+ virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags);
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
@@ -525,6 +563,7 @@
private:
Mutex mLock;
Vector <sp <AudioPortCallback> > mAudioPortCallbacks;
+ Vector <sp <AudioVolumeGroupCallback> > mAudioVolumeGroupCallback;
};
static audio_io_handle_t getOutput(audio_stream_type_t stream);
diff --git a/media/libaudioclient/include/media/AudioVolumeGroup.h b/media/libaudioclient/include/media/AudioVolumeGroup.h
new file mode 100644
index 0000000..9a6ea07
--- /dev/null
+++ b/media/libaudioclient/include/media/AudioVolumeGroup.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#pragma once
+
+#include <media/AudioProductStrategy.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <binder/Parcelable.h>
+
+namespace android {
+
+class AudioVolumeGroup : public Parcelable
+{
+public:
+ AudioVolumeGroup() {}
+ AudioVolumeGroup(const std::string &name,
+ volume_group_t group,
+ const AttributesVector &attributes,
+ const StreamTypeVector &streams) :
+ mName(name), mGroupId(group), mAudioAttributes(attributes), mStreams(streams) {}
+
+ const std::string &getName() const { return mName; }
+ volume_group_t getId() const { return mGroupId; }
+ AttributesVector getAudioAttributes() const { return mAudioAttributes; }
+ StreamTypeVector getStreamTypes() const { return mStreams; }
+
+ status_t readFromParcel(const Parcel *parcel) override;
+ status_t writeToParcel(Parcel *parcel) const override;
+
+private:
+ std::string mName;
+ volume_group_t mGroupId = VOLUME_GROUP_NONE;
+ AttributesVector mAudioAttributes;
+ StreamTypeVector mStreams;
+};
+
+using AudioVolumeGroupVector = std::vector<AudioVolumeGroup>;
+
+} // namespace android
diff --git a/media/libaudioclient/include/media/IAudioPolicyService.h b/media/libaudioclient/include/media/IAudioPolicyService.h
index e89a55d..35540f0 100644
--- a/media/libaudioclient/include/media/IAudioPolicyService.h
+++ b/media/libaudioclient/include/media/IAudioPolicyService.h
@@ -93,6 +93,17 @@
virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device) = 0;
+
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device) = 0;
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device) = 0;
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
+
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
+
virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
@@ -160,6 +171,8 @@
virtual void setAudioPortCallbacksEnabled(bool enabled) = 0;
+ virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) = 0;
+
virtual status_t acquireSoundTriggerSession(audio_session_t *session,
audio_io_handle_t *ioHandle,
audio_devices_t *device) = 0;
@@ -198,7 +211,12 @@
virtual bool isHapticPlaybackSupported() = 0;
virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0;
- virtual product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa) = 0;
+ virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy) = 0;
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0;
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup) = 0;
};
diff --git a/media/libaudioclient/include/media/IAudioPolicyServiceClient.h b/media/libaudioclient/include/media/IAudioPolicyServiceClient.h
index b3c0381..79008c3 100644
--- a/media/libaudioclient/include/media/IAudioPolicyServiceClient.h
+++ b/media/libaudioclient/include/media/IAudioPolicyServiceClient.h
@@ -23,6 +23,8 @@
#include <binder/IInterface.h>
#include <system/audio.h>
#include <system/audio_effect.h>
+#include <media/AudioPolicy.h>
+#include <media/AudioVolumeGroup.h>
namespace android {
@@ -45,6 +47,8 @@
public:
DECLARE_META_INTERFACE(AudioPolicyServiceClient);
+ // Notifies a change of volume group
+ virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0;
// Notifies a change of audio port configuration.
virtual void onAudioPortListUpdate() = 0;
// Notifies a change of audio patch configuration.
diff --git a/media/libaudiohal/impl/EffectHalHidl.cpp b/media/libaudiohal/impl/EffectHalHidl.cpp
index b0597b3..caf575c 100644
--- a/media/libaudiohal/impl/EffectHalHidl.cpp
+++ b/media/libaudiohal/impl/EffectHalHidl.cpp
@@ -18,6 +18,7 @@
//#define LOG_NDEBUG 0
#include <common/all-versions/VersionUtils.h>
+#include <cutils/native_handle.h>
#include <hwbinder/IPCThreadState.h>
#include <media/EffectsFactoryApi.h>
#include <utils/Log.h>
@@ -280,6 +281,15 @@
return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
}
+status_t EffectHalHidl::dump(int fd) {
+ if (mEffect == 0) return NO_INIT;
+ native_handle_t* hidlHandle = native_handle_create(1, 0);
+ hidlHandle->data[0] = fd;
+ Return<void> ret = mEffect->debug(hidlHandle, {} /* options */);
+ native_handle_delete(hidlHandle);
+ return ret.isOk() ? OK : FAILED_TRANSACTION;
+}
+
status_t EffectHalHidl::getConfigImpl(
uint32_t cmdCode, uint32_t *replySize, void *pReplyData) {
if (replySize == NULL || *replySize != sizeof(effect_config_t) || pReplyData == NULL) {
diff --git a/media/libaudiohal/impl/EffectHalHidl.h b/media/libaudiohal/impl/EffectHalHidl.h
index 9d9f707..1f238c0 100644
--- a/media/libaudiohal/impl/EffectHalHidl.h
+++ b/media/libaudiohal/impl/EffectHalHidl.h
@@ -61,6 +61,8 @@
// Whether it's a local implementation.
virtual bool isLocal() const { return false; }
+ virtual status_t dump(int fd);
+
uint64_t effectId() const { return mEffectId; }
static void effectDescriptorToHal(
diff --git a/media/libaudiohal/include/media/audiohal/EffectHalInterface.h b/media/libaudiohal/include/media/audiohal/EffectHalInterface.h
index 92622aa..03165bd 100644
--- a/media/libaudiohal/include/media/audiohal/EffectHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/EffectHalInterface.h
@@ -55,6 +55,8 @@
// Whether it's a local implementation.
virtual bool isLocal() const = 0;
+ virtual status_t dump(int fd) = 0;
+
protected:
// Subclasses can not be constructed directly by clients.
EffectHalInterface() {}
diff --git a/media/libmedia/NdkWrapper.cpp b/media/libmedia/NdkWrapper.cpp
index cbd64bb..ea0547c 100644
--- a/media/libmedia/NdkWrapper.cpp
+++ b/media/libmedia/NdkWrapper.cpp
@@ -96,6 +96,7 @@
static const char *AMediaFormatKeyGroupInt64[] = {
AMEDIAFORMAT_KEY_DURATION,
+ AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER,
AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER,
AMEDIAFORMAT_KEY_TIME_US,
};
@@ -127,6 +128,7 @@
static const char *AMediaFormatKeyGroupFloatInt32[] = {
AMEDIAFORMAT_KEY_FRAME_RATE,
AMEDIAFORMAT_KEY_I_FRAME_INTERVAL,
+ AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER,
AMEDIAFORMAT_KEY_OPERATING_RATE,
};
diff --git a/media/libstagefright/AACWriter.cpp b/media/libstagefright/AACWriter.cpp
index 2ea5fcd..9eba7e9 100644
--- a/media/libstagefright/AACWriter.cpp
+++ b/media/libstagefright/AACWriter.cpp
@@ -85,7 +85,7 @@
CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC));
CHECK(meta->findInt32(kKeyChannelCount, &mChannelCount));
CHECK(meta->findInt32(kKeySampleRate, &mSampleRate));
- CHECK(mChannelCount >= 1 && mChannelCount <= 2);
+ CHECK(mChannelCount >= 1 && mChannelCount <= 7);
// Optionally, we want to check whether AACProfile is also set.
if (meta->findInt32(kKeyAACProfile, &mAACProfile)) {
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index 9d3338b..1dee4f7 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -37,6 +37,7 @@
#include <media/stagefright/BufferProducerWrapper.h>
#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MediaCodecConstants.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/OMXClient.h>
#include <media/stagefright/PersistentSurface.h>
@@ -1817,20 +1818,19 @@
}
if (!msg->findInt64(
- "repeat-previous-frame-after",
- &mRepeatFrameDelayUs)) {
+ KEY_REPEAT_PREVIOUS_FRAME_AFTER, &mRepeatFrameDelayUs)) {
mRepeatFrameDelayUs = -1LL;
}
// only allow 32-bit value, since we pass it as U32 to OMX.
- if (!msg->findInt64("max-pts-gap-to-encoder", &mMaxPtsGapUs)) {
+ if (!msg->findInt64(KEY_MAX_PTS_GAP_TO_ENCODER, &mMaxPtsGapUs)) {
mMaxPtsGapUs = 0LL;
} else if (mMaxPtsGapUs > INT32_MAX || mMaxPtsGapUs < INT32_MIN) {
ALOGW("Unsupported value for max pts gap %lld", (long long) mMaxPtsGapUs);
mMaxPtsGapUs = 0LL;
}
- if (!msg->findFloat("max-fps-to-encoder", &mMaxFps)) {
+ if (!msg->findFloat(KEY_MAX_FPS_TO_ENCODER, &mMaxFps)) {
mMaxFps = -1;
}
@@ -1844,8 +1844,8 @@
}
if (!msg->findInt32(
- "create-input-buffers-suspended",
- (int32_t*)&mCreateInputBuffersSuspended)) {
+ KEY_CREATE_INPUT_SURFACE_SUSPENDED,
+ (int32_t*)&mCreateInputBuffersSuspended)) {
mCreateInputBuffersSuspended = false;
}
}
@@ -7431,7 +7431,7 @@
}
int64_t timeOffsetUs;
- if (params->findInt64("time-offset-us", &timeOffsetUs)) {
+ if (params->findInt64(PARAMETER_KEY_OFFSET_TIME, &timeOffsetUs)) {
if (mGraphicBufferSource == NULL) {
ALOGE("[%s] Invalid to set input buffer time offset without surface",
mComponentName.c_str());
@@ -7467,7 +7467,7 @@
}
int32_t dropInputFrames;
- if (params->findInt32("drop-input-frames", &dropInputFrames)) {
+ if (params->findInt32(PARAMETER_KEY_SUSPEND, &dropInputFrames)) {
if (mGraphicBufferSource == NULL) {
ALOGE("[%s] Invalid to set suspend without surface",
mComponentName.c_str());
@@ -7475,7 +7475,7 @@
}
int64_t suspendStartTimeUs = -1;
- (void) params->findInt64("drop-start-time-us", &suspendStartTimeUs);
+ (void) params->findInt64(PARAMETER_KEY_SUSPEND_TIME, &suspendStartTimeUs);
status_t err = statusFromBinderStatus(
mGraphicBufferSource->setSuspend(dropInputFrames != 0, suspendStartTimeUs));
diff --git a/media/libstagefright/Android.bp b/media/libstagefright/Android.bp
index 2bd7288..d8b825d 100644
--- a/media/libstagefright/Android.bp
+++ b/media/libstagefright/Android.bp
@@ -199,7 +199,6 @@
"libhidlallocatorutils",
"libhidlbase",
"libhidlmemory",
- "libziparchive",
"android.hidl.allocator@1.0",
"android.hardware.cas.native@1.0",
"android.hardware.media.omx@1.0",
diff --git a/media/libstagefright/MediaCodecSource.cpp b/media/libstagefright/MediaCodecSource.cpp
index 5d2291f..c3d85ee 100644
--- a/media/libstagefright/MediaCodecSource.cpp
+++ b/media/libstagefright/MediaCodecSource.cpp
@@ -32,6 +32,7 @@
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MediaCodecConstants.h>
#include <media/stagefright/MediaCodecList.h>
#include <media/stagefright/MediaCodecSource.h>
#include <media/stagefright/MediaErrors.h>
@@ -362,7 +363,7 @@
status_t MediaCodecSource::setInputBufferTimeOffset(int64_t timeOffsetUs) {
sp<AMessage> msg = new AMessage(kWhatSetInputBufferTimeOffset, mReflector);
- msg->setInt64("time-offset-us", timeOffsetUs);
+ msg->setInt64(PARAMETER_KEY_OFFSET_TIME, timeOffsetUs);
return postSynchronouslyAndReturnError(msg);
}
@@ -490,7 +491,7 @@
mCodecLooper->start();
if (mFlags & FLAG_USE_SURFACE_INPUT) {
- mOutputFormat->setInt32("create-input-buffers-suspended", 1);
+ mOutputFormat->setInt32(KEY_CREATE_INPUT_SURFACE_SUSPENDED, 1);
}
AString outputMIME;
@@ -677,9 +678,9 @@
CHECK(mFlags & FLAG_USE_SURFACE_INPUT);
if (mEncoder != NULL) {
sp<AMessage> params = new AMessage;
- params->setInt32("drop-input-frames", false);
+ params->setInt32(PARAMETER_KEY_SUSPEND, false);
if (resumeStartTimeUs > 0) {
- params->setInt64("drop-start-time-us", resumeStartTimeUs);
+ params->setInt64(PARAMETER_KEY_SUSPEND_TIME, resumeStartTimeUs);
}
mEncoder->setParameters(params);
}
@@ -799,7 +800,7 @@
if (mFlags & FLAG_USE_SURFACE_INPUT) {
if (mEncoder != NULL) {
sp<AMessage> params = new AMessage;
- params->setInt32("drop-input-frames", false);
+ params->setInt32(PARAMETER_KEY_SUSPEND, false);
if (startTimeUs >= 0) {
params->setInt64("skip-frames-before", startTimeUs);
}
@@ -832,8 +833,8 @@
void MediaCodecSource::onPause(int64_t pauseStartTimeUs) {
if ((mFlags & FLAG_USE_SURFACE_INPUT) && (mEncoder != NULL)) {
sp<AMessage> params = new AMessage;
- params->setInt32("drop-input-frames", true);
- params->setInt64("drop-start-time-us", pauseStartTimeUs);
+ params->setInt32(PARAMETER_KEY_SUSPEND, true);
+ params->setInt64(PARAMETER_KEY_SUSPEND_TIME, pauseStartTimeUs);
mEncoder->setParameters(params);
} else {
CHECK(mPuller != NULL);
@@ -1096,12 +1097,12 @@
sp<AReplyToken> replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
status_t err = OK;
- CHECK(msg->findInt64("time-offset-us", &mInputBufferTimeOffsetUs));
+ CHECK(msg->findInt64(PARAMETER_KEY_OFFSET_TIME, &mInputBufferTimeOffsetUs));
// Propagate the timestamp offset to GraphicBufferSource.
if (mFlags & FLAG_USE_SURFACE_INPUT) {
sp<AMessage> params = new AMessage;
- params->setInt64("time-offset-us", mInputBufferTimeOffsetUs);
+ params->setInt64(PARAMETER_KEY_OFFSET_TIME, mInputBufferTimeOffsetUs);
err = mEncoder->setParameters(params);
}
diff --git a/media/libstagefright/codecs/raw/SoftRaw.cpp b/media/libstagefright/codecs/raw/SoftRaw.cpp
index 1a527b3..0e31804 100644
--- a/media/libstagefright/codecs/raw/SoftRaw.cpp
+++ b/media/libstagefright/codecs/raw/SoftRaw.cpp
@@ -60,7 +60,7 @@
def.eDir = OMX_DirInput;
def.nBufferCountMin = kNumBuffers;
def.nBufferCountActual = def.nBufferCountMin;
- def.nBufferSize = 64 * 1024;
+ def.nBufferSize = 192 * 1024;
def.bEnabled = OMX_TRUE;
def.bPopulated = OMX_FALSE;
def.eDomain = OMX_PortDomainAudio;
@@ -78,7 +78,7 @@
def.eDir = OMX_DirOutput;
def.nBufferCountMin = kNumBuffers;
def.nBufferCountActual = def.nBufferCountMin;
- def.nBufferSize = 64 * 1024;
+ def.nBufferSize = 192 * 1024;
def.bEnabled = OMX_TRUE;
def.bPopulated = OMX_FALSE;
def.eDomain = OMX_PortDomainAudio;
diff --git a/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp b/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
index 82a0631..4302aee 100644
--- a/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
+++ b/media/libstagefright/rtsp/AMPEG4AudioAssembler.cpp
@@ -423,6 +423,11 @@
CHECK_LE(offset + (mOtherDataLenBits / 8), buffer->size());
offset += mOtherDataLenBits / 8;
}
+
+ if (i < mNumSubFrames && offset >= buffer->size()) {
+ ALOGW("Skip subframes after %d, total %d", (int)i, (int)mNumSubFrames);
+ break;
+ }
}
if (offset < buffer->size()) {
diff --git a/media/mediaserver/Android.bp b/media/mediaserver/Android.bp
index f01947a..8377723 100644
--- a/media/mediaserver/Android.bp
+++ b/media/mediaserver/Android.bp
@@ -21,6 +21,7 @@
"libutils",
"libbinder",
"libandroidicu",
+ "android.hardware.media.omx@1.0",
],
static_libs: [
@@ -33,6 +34,9 @@
"frameworks/av/services/mediaresourcemanager",
],
+ // back to 32-bit, b/126502613
+ compile_multilib: "32",
+
init_rc: ["mediaserver.rc"],
cflags: [
diff --git a/media/mtp/MtpFfsHandle.cpp b/media/mtp/MtpFfsHandle.cpp
index ad3c068..bd6a6c6 100644
--- a/media/mtp/MtpFfsHandle.cpp
+++ b/media/mtp/MtpFfsHandle.cpp
@@ -47,6 +47,9 @@
constexpr unsigned MAX_FILE_CHUNK_SIZE = AIO_BUFS_MAX * AIO_BUF_LEN;
constexpr uint32_t MAX_MTP_FILE_SIZE = 0xFFFFFFFF;
+// Note: POLL_TIMEOUT_MS = 0 means return immediately i.e. no sleep.
+// And this will cause high CPU usage.
+constexpr int32_t POLL_TIMEOUT_MS = 500;
struct timespec ZERO_TIMEOUT = { 0, 0 };
@@ -305,7 +308,7 @@
int error = 0;
while (num_events < min_events) {
- if (poll(mPollFds, 2, 0) == -1) {
+ if (poll(mPollFds, 2, POLL_TIMEOUT_MS) == -1) {
PLOG(ERROR) << "Mtp error during poll()";
return -1;
}
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 0b274a7..f9f1acc 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -85,7 +85,6 @@
"libutils",
"libcutils",
"libnativewindow",
- "libandroid_runtime",
"libbinder",
"libhidlbase",
"libgui",
@@ -94,6 +93,12 @@
"libmediandk_utils",
],
+ required: [
+ // libmediandk may be used by Java and non-Java things. When lower-level things use it,
+ // they shouldn't have to take on the cost of loading libandroid_runtime.
+ "libandroid_runtime",
+ ],
+
export_include_dirs: ["include"],
product_variables: {
diff --git a/media/ndk/NdkImageReader.cpp b/media/ndk/NdkImageReader.cpp
index b929f7f..bcc7ff3 100644
--- a/media/ndk/NdkImageReader.cpp
+++ b/media/ndk/NdkImageReader.cpp
@@ -25,7 +25,7 @@
#include <cutils/atomic.h>
#include <utils/Log.h>
#include <android_media_Utils.h>
-#include <android_runtime/android_view_Surface.h>
+#include <ui/PublicFormat.h>
#include <private/android/AHardwareBufferHelpers.h>
#include <grallocusage/GrallocUsageConversion.h>
#include <media/stagefright/bqhelper/WGraphicBufferProducer.h>
@@ -70,6 +70,7 @@
case AIMAGE_FORMAT_DEPTH_POINT_CLOUD:
case AIMAGE_FORMAT_Y8:
case AIMAGE_FORMAT_HEIC:
+ case AIMAGE_FORMAT_DEPTH_JPEG:
return true;
case AIMAGE_FORMAT_PRIVATE:
// For private format, cpu usage is prohibited.
@@ -98,6 +99,7 @@
case AIMAGE_FORMAT_DEPTH_POINT_CLOUD:
case AIMAGE_FORMAT_Y8:
case AIMAGE_FORMAT_HEIC:
+ case AIMAGE_FORMAT_DEPTH_JPEG:
return 1;
case AIMAGE_FORMAT_PRIVATE:
return 0;
@@ -270,8 +272,8 @@
media_status_t
AImageReader::init() {
PublicFormat publicFormat = static_cast<PublicFormat>(mFormat);
- mHalFormat = android_view_Surface_mapPublicFormatToHalFormat(publicFormat);
- mHalDataSpace = android_view_Surface_mapPublicFormatToHalDataspace(publicFormat);
+ mHalFormat = mapPublicFormatToHalFormat(publicFormat);
+ mHalDataSpace = mapPublicFormatToHalDataspace(publicFormat);
mHalUsage = AHardwareBuffer_convertToGrallocUsageBits(mUsage);
sp<IGraphicBufferProducer> gbProducer;
diff --git a/media/ndk/NdkMediaCrypto.cpp b/media/ndk/NdkMediaCrypto.cpp
index b8af5ff..ce2c660 100644
--- a/media/ndk/NdkMediaCrypto.cpp
+++ b/media/ndk/NdkMediaCrypto.cpp
@@ -29,7 +29,6 @@
#include <binder/IServiceManager.h>
#include <media/ICrypto.h>
#include <media/IMediaDrmService.h>
-#include <android_runtime/AndroidRuntime.h>
#include <android_util_Binder.h>
#include <jni.h>
diff --git a/media/ndk/NdkMediaDataSource.cpp b/media/ndk/NdkMediaDataSource.cpp
index 1abee93..0891f2a 100644
--- a/media/ndk/NdkMediaDataSource.cpp
+++ b/media/ndk/NdkMediaDataSource.cpp
@@ -23,9 +23,7 @@
#include <jni.h>
#include <unistd.h>
-#include <android_runtime/AndroidRuntime.h>
-#include <android_util_Binder.h>
-#include <binder/IServiceManager.h>
+#include <binder/IBinder.h>
#include <cutils/properties.h>
#include <utils/Log.h>
#include <utils/StrongPointer.h>
@@ -41,8 +39,67 @@
#include "../../libstagefright/include/NuCachedSource2.h"
#include "NdkMediaDataSourceCallbacksPriv.h"
+#include <mutex> // std::call_once,once_flag
+#include <dlfcn.h> // dlopen
+
using namespace android;
+// load libandroid_runtime.so lazily.
+// A vendor process may use libmediandk but should not depend on libandroid_runtime.
+// TODO(jooyung): remove duplicate (b/125550121)
+// frameworks/native/libs/binder/ndk/ibinder_jni.cpp
+namespace {
+
+typedef JNIEnv* (*getJNIEnv_t)();
+typedef sp<IBinder> (*ibinderForJavaObject_t)(JNIEnv* env, jobject obj);
+
+getJNIEnv_t getJNIEnv_;
+ibinderForJavaObject_t ibinderForJavaObject_;
+
+std::once_flag mLoadFlag;
+
+void load() {
+ std::call_once(mLoadFlag, []() {
+ void* handle = dlopen("libandroid_runtime.so", RTLD_LAZY);
+ if (handle == nullptr) {
+ ALOGE("Could not open libandroid_runtime.");
+ return;
+ }
+
+ getJNIEnv_ = reinterpret_cast<getJNIEnv_t>(
+ dlsym(handle, "_ZN7android14AndroidRuntime9getJNIEnvEv"));
+ if (getJNIEnv_ == nullptr) {
+ ALOGE("Could not find AndroidRuntime::getJNIEnv.");
+ // no return
+ }
+
+ ibinderForJavaObject_ = reinterpret_cast<ibinderForJavaObject_t>(
+ dlsym(handle, "_ZN7android20ibinderForJavaObjectEP7_JNIEnvP8_jobject"));
+ if (ibinderForJavaObject_ == nullptr) {
+ ALOGE("Could not find ibinderForJavaObject.");
+ // no return
+ }
+ });
+}
+
+JNIEnv* getJNIEnv() {
+ load();
+ if (getJNIEnv_ == nullptr) {
+ return nullptr;
+ }
+ return (getJNIEnv_)();
+}
+
+sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj) {
+ load();
+ if (ibinderForJavaObject_ == nullptr) {
+ return nullptr;
+ }
+ return (ibinderForJavaObject_)(env, obj);
+}
+
+} // namespace
+
struct AMediaDataSource {
void *userdata;
AMediaDataSourceReadAt readAt;
@@ -124,9 +181,14 @@
if (obj == NULL) {
return NULL;
}
+ sp<IBinder> binder;
switch (version) {
case 1:
- return interface_cast<IMediaHTTPService>(ibinderForJavaObject(env, obj));
+ binder = ibinderForJavaObject(env, obj);
+ if (binder == NULL) {
+ return NULL;
+ }
+ return interface_cast<IMediaHTTPService>(binder);
case 2:
return new JMedia2HTTPService(env, obj);
default:
@@ -179,7 +241,7 @@
switch (version) {
case 1:
- env = AndroidRuntime::getJNIEnv();
+ env = getJNIEnv();
clazz = "android/media/MediaHTTPService";
method = "createHttpServiceBinderIfNecessary";
signature = "(Ljava/lang/String;)Landroid/os/IBinder;";
diff --git a/media/ndk/NdkMediaExtractor.cpp b/media/ndk/NdkMediaExtractor.cpp
index 28e4f12..c83b255 100644
--- a/media/ndk/NdkMediaExtractor.cpp
+++ b/media/ndk/NdkMediaExtractor.cpp
@@ -34,7 +34,6 @@
#include <media/stagefright/MetaData.h>
#include <media/stagefright/NuMediaExtractor.h>
#include <media/IMediaHTTPService.h>
-#include <android_runtime/AndroidRuntime.h>
#include <android_util_Binder.h>
#include <jni.h>
diff --git a/media/ndk/NdkMediaFormat.cpp b/media/ndk/NdkMediaFormat.cpp
index 26a6238..768a7a9 100644
--- a/media/ndk/NdkMediaFormat.cpp
+++ b/media/ndk/NdkMediaFormat.cpp
@@ -26,7 +26,6 @@
#include <utils/StrongPointer.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h>
-#include <android_runtime/AndroidRuntime.h>
#include <android_util_Binder.h>
#include <jni.h>
@@ -344,8 +343,10 @@
EXPORT const char* AMEDIAFORMAT_KEY_LYRICIST = "lyricist";
EXPORT const char* AMEDIAFORMAT_KEY_MANUFACTURER = "manufacturer";
EXPORT const char* AMEDIAFORMAT_KEY_MAX_BIT_RATE = "max-bitrate";
+EXPORT const char* AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";
EXPORT const char* AMEDIAFORMAT_KEY_MAX_HEIGHT = "max-height";
EXPORT const char* AMEDIAFORMAT_KEY_MAX_INPUT_SIZE = "max-input-size";
+EXPORT const char* AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER = "max-pts-gap-to-encoder";
EXPORT const char* AMEDIAFORMAT_KEY_MAX_WIDTH = "max-width";
EXPORT const char* AMEDIAFORMAT_KEY_MIME = "mime";
EXPORT const char* AMEDIAFORMAT_KEY_MPEG_USER_DATA = "mpeg-user-data";
diff --git a/media/ndk/NdkMediaMuxer.cpp b/media/ndk/NdkMediaMuxer.cpp
index e79926d..d1992bf 100644
--- a/media/ndk/NdkMediaMuxer.cpp
+++ b/media/ndk/NdkMediaMuxer.cpp
@@ -30,7 +30,6 @@
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/MediaMuxer.h>
#include <media/IMediaHTTPService.h>
-#include <android_runtime/AndroidRuntime.h>
#include <android_util_Binder.h>
#include <jni.h>
diff --git a/media/ndk/include/media/NdkImage.h b/media/ndk/include/media/NdkImage.h
index 14d88cb..3e60de0 100644
--- a/media/ndk/include/media/NdkImage.h
+++ b/media/ndk/include/media/NdkImage.h
@@ -535,6 +535,15 @@
* Format as described in ISO/IEC 23008-12.</p>
*/
AIMAGE_FORMAT_HEIC = 0x48454946,
+
+ /**
+ * Depth augmented compressed JPEG format.
+ *
+ * <p>JPEG compressed main image along with XMP embedded depth metadata
+ * following ISO 16684-1:2011(E).</p>
+ */
+ AIMAGE_FORMAT_DEPTH_JPEG = 0x69656963,
+
};
/**
diff --git a/media/ndk/include/media/NdkMediaFormat.h b/media/ndk/include/media/NdkMediaFormat.h
index ddf5291..56bcaab 100644
--- a/media/ndk/include/media/NdkMediaFormat.h
+++ b/media/ndk/include/media/NdkMediaFormat.h
@@ -216,6 +216,8 @@
extern const char* AMEDIAFORMAT_KEY_LYRICIST __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_MANUFACTURER __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_MAX_BIT_RATE __INTRODUCED_IN(29);
+extern const char* AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER __INTRODUCED_IN(29);
+extern const char* AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_MPEG2_STREAM_HEADER __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_PCM_BIG_ENDIAN __INTRODUCED_IN(29);
extern const char* AMEDIAFORMAT_KEY_PSSH __INTRODUCED_IN(29);
diff --git a/media/ndk/libmediandk.map.txt b/media/ndk/libmediandk.map.txt
index 7bdd3ad..9756926 100644
--- a/media/ndk/libmediandk.map.txt
+++ b/media/ndk/libmediandk.map.txt
@@ -107,8 +107,10 @@
AMEDIAFORMAT_KEY_LYRICIST; # var introduced=29
AMEDIAFORMAT_KEY_MANUFACTURER; # var introduced=29
AMEDIAFORMAT_KEY_MAX_BIT_RATE; # var introduced=29
+ AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER; # var introduced=29
AMEDIAFORMAT_KEY_MAX_HEIGHT; # var introduced=21
AMEDIAFORMAT_KEY_MAX_INPUT_SIZE; # var introduced=21
+ AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER; # var introduced=29
AMEDIAFORMAT_KEY_MAX_WIDTH; # var introduced=21
AMEDIAFORMAT_KEY_MIME; # var introduced=21
AMEDIAFORMAT_KEY_MPEG_USER_DATA; # var introduced=28
diff --git a/media/utils/ServiceUtilities.cpp b/media/utils/ServiceUtilities.cpp
index 599c446..2fb24f5 100644
--- a/media/utils/ServiceUtilities.cpp
+++ b/media/utils/ServiceUtilities.cpp
@@ -22,6 +22,9 @@
#include <binder/PermissionCache.h>
#include "mediautils/ServiceUtilities.h"
+#include <iterator>
+#include <algorithm>
+
/* When performing permission checks we do not use permission cache for
* runtime permissions (protection level dangerous) as they may change at
* runtime. All other permissions (protection level normal and dangerous)
@@ -220,4 +223,85 @@
return NO_ERROR;
}
+sp<content::pm::IPackageManagerNative> MediaPackageManager::retreivePackageManager() {
+ const sp<IServiceManager> sm = defaultServiceManager();
+ if (sm == nullptr) {
+ ALOGW("%s: failed to retrieve defaultServiceManager", __func__);
+ return nullptr;
+ }
+ sp<IBinder> packageManager = sm->checkService(String16(nativePackageManagerName));
+ if (packageManager == nullptr) {
+ ALOGW("%s: failed to retrieve native package manager", __func__);
+ return nullptr;
+ }
+ return interface_cast<content::pm::IPackageManagerNative>(packageManager);
+}
+
+std::optional<bool> MediaPackageManager::doIsAllowed(uid_t uid) {
+ if (mPackageManager == nullptr) {
+ /** Can not fetch package manager at construction it may not yet be registered. */
+ mPackageManager = retreivePackageManager();
+ if (mPackageManager == nullptr) {
+ ALOGW("%s: Playback capture is denied as package manager is not reachable", __func__);
+ return std::nullopt;
+ }
+ }
+
+ std::vector<std::string> packageNames;
+ auto status = mPackageManager->getNamesForUids({(int32_t)uid}, &packageNames);
+ if (!status.isOk()) {
+ ALOGW("%s: Playback capture is denied for uid %u as the package names could not be "
+ "retrieved from the package manager: %s", __func__, uid, status.toString8().c_str());
+ return std::nullopt;
+ }
+ if (packageNames.empty()) {
+ ALOGW("%s: Playback capture for uid %u is denied as no package name could be retrieved "
+ "from the package manager: %s", __func__, uid, status.toString8().c_str());
+ return std::nullopt;
+ }
+ std::vector<bool> isAllowed;
+ status = mPackageManager->isAudioPlaybackCaptureAllowed(packageNames, &isAllowed);
+ if (!status.isOk()) {
+ ALOGW("%s: Playback capture is denied for uid %u as the manifest property could not be "
+ "retrieved from the package manager: %s", __func__, uid, status.toString8().c_str());
+ return std::nullopt;
+ }
+ if (packageNames.size() != isAllowed.size()) {
+ ALOGW("%s: Playback capture is denied for uid %u as the package manager returned incoherent"
+ " response size: %zu != %zu", __func__, uid, packageNames.size(), isAllowed.size());
+ return std::nullopt;
+ }
+
+ // Zip together packageNames and isAllowed for debug logs
+ Packages& packages = mDebugLog[uid];
+ packages.resize(packageNames.size()); // Reuse all objects
+ std::transform(begin(packageNames), end(packageNames), begin(isAllowed),
+ begin(packages), [] (auto& name, bool isAllowed) -> Package {
+ return {std::move(name), isAllowed};
+ });
+
+ // Only allow playback record if all packages in this UID allow it
+ bool playbackCaptureAllowed = std::all_of(begin(isAllowed), end(isAllowed),
+ [](bool b) { return b; });
+
+ return playbackCaptureAllowed;
+}
+
+void MediaPackageManager::dump(int fd, int spaces) const {
+ dprintf(fd, "%*sAllow playback capture log:\n", spaces, "");
+ if (mPackageManager == nullptr) {
+ dprintf(fd, "%*sNo package manager\n", spaces + 2, "");
+ }
+ dprintf(fd, "%*sPackage manager errors: %u\n", spaces + 2, "", mPackageManagerErrors);
+
+ for (const auto& uidCache : mDebugLog) {
+ for (const auto& package : std::get<Packages>(uidCache)) {
+ dprintf(fd, "%*s- uid=%5u, allowPlaybackCapture=%s, packageName=%s\n", spaces + 2, "",
+ std::get<const uid_t>(uidCache),
+ package.playbackCaptureAllowed ? "true " : "false",
+ package.name.c_str());
+ }
+ }
+}
+
} // namespace android
diff --git a/media/utils/include/mediautils/ServiceUtilities.h b/media/utils/include/mediautils/ServiceUtilities.h
index 98f54c2..94370ee 100644
--- a/media/utils/include/mediautils/ServiceUtilities.h
+++ b/media/utils/include/mediautils/ServiceUtilities.h
@@ -14,13 +14,22 @@
* limitations under the License.
*/
+#ifndef ANDROID_MEDIAUTILS_SERVICEUTILITIES_H
+#define ANDROID_MEDIAUTILS_SERVICEUTILITIES_H
+
#include <unistd.h>
+#include <android/content/pm/IPackageManagerNative.h>
#include <binder/IMemory.h>
#include <binder/PermissionController.h>
#include <cutils/multiuser.h>
#include <private/android_filesystem_config.h>
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
namespace android {
// Audio permission utilities
@@ -72,4 +81,31 @@
bool dumpAllowed();
bool modifyPhoneStateAllowed(pid_t pid, uid_t uid);
status_t checkIMemory(const sp<IMemory>& iMemory);
+
+class MediaPackageManager {
+public:
+ /** Query the PackageManager to check if all apps of an UID allow playback capture. */
+ bool allowPlaybackCapture(uid_t uid) {
+ auto result = doIsAllowed(uid);
+ if (!result) {
+ mPackageManagerErrors++;
+ }
+ return result.value_or(false);
+ }
+ void dump(int fd, int spaces = 0) const;
+private:
+ static constexpr const char* nativePackageManagerName = "package_native";
+ std::optional<bool> doIsAllowed(uid_t uid);
+ sp<content::pm::IPackageManagerNative> retreivePackageManager();
+ sp<content::pm::IPackageManagerNative> mPackageManager; // To check apps manifest
+ uint_t mPackageManagerErrors = 0;
+ struct Package {
+ std::string name;
+ bool playbackCaptureAllowed = false;
+ };
+ using Packages = std::vector<Package>;
+ std::map<uid_t, Packages> mDebugLog;
+};
}
+
+#endif // ANDROID_MEDIAUTILS_SERVICEUTILITIES_H
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 8455e54..ecaeb52 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -1500,6 +1500,11 @@
write(fd, result.string(), result.length());
+ if (mEffectInterface != 0) {
+ dprintf(fd, "\tEffect ID %d HAL dump:\n", mId);
+ (void)mEffectInterface->dump(fd);
+ }
+
if (locked) {
mLock.unlock();
}
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 8a45fc2..8f181a4 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -842,6 +842,12 @@
mIoJitterMs.toString().c_str());
}
+ if (mLatencyMs.getN() > 0) {
+ dprintf(fd, " Threadloop %s latency stats: %s\n",
+ isOutput() ? "write" : "read",
+ mLatencyMs.toString().c_str());
+ }
+
if (locked) {
mLock.unlock();
}
@@ -3380,6 +3386,14 @@
}
}
}
+
+ if (audio_has_proportional_frames(mFormat)) {
+ const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
+ if (latencyMs != 0.) { // note 0. means timestamp is empty.
+ mLatencyMs.add(latencyMs);
+ }
+ }
+
} // if (mType ... ) { // no indentation
#if 0
// logFormat example
@@ -5296,13 +5310,6 @@
dprintf(fd, " Master balance: %f (%s)\n", mMasterBalance.load(),
(hasFastMixer() ? std::to_string(mFastMixer->getMasterBalance())
: mBalance.toString()).c_str());
- const double latencyMs = mTimestamp.getOutputServerLatencyMs(mSampleRate);
- if (latencyMs != 0.) {
- dprintf(fd, " NormalMixer latency ms: %.2lf\n", latencyMs);
- } else {
- dprintf(fd, " NormalMixer latency ms: unavail\n");
- }
-
if (hasFastMixer()) {
dprintf(fd, " FastMixer thread %p tid=%d", mFastMixer.get(), mFastMixer->getTid());
@@ -7042,6 +7049,15 @@
mTimestampVerifier.error();
}
}
+
+ // From the timestamp, input read latency is negative output write latency.
+ const audio_input_flags_t flags = mInput != NULL ? mInput->flags : AUDIO_INPUT_FLAG_NONE;
+ const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
+ ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
+ if (latencyMs != 0.) { // note 0. means timestamp is empty.
+ mLatencyMs.add(latencyMs);
+ }
+
// Use this to track timestamp information
// ALOGD("%s", mTimestamp.toString().c_str());
@@ -7734,14 +7750,6 @@
(void)input->stream->dump(fd);
}
- const double latencyMs = RecordTrack::checkServerLatencySupported(mFormat, flags)
- ? - mTimestamp.getOutputServerLatencyMs(mSampleRate) : 0.;
- if (latencyMs != 0.) {
- dprintf(fd, " NormalRecord latency ms: %.2lf\n", latencyMs);
- } else {
- dprintf(fd, " NormalRecord latency ms: unavail\n");
- }
-
dprintf(fd, " Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
dprintf(fd, " Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index 4968829..1afea08 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -520,6 +520,7 @@
// This should be read under ThreadBase lock (if not on the threadLoop thread).
audio_utils::Statistics<double> mIoJitterMs{0.995 /* alpha */};
audio_utils::Statistics<double> mProcessTimeMs{0.995 /* alpha */};
+ audio_utils::Statistics<double> mLatencyMs{0.995 /* alpha */};
bool mIsMsdDevice = false;
// A condition that must be evaluated by the thread loop has changed and
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 65f799e..ad78a45 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -700,8 +700,13 @@
const AudioBufferProvider::Buffer& sourceBuffer) {
auto start = std::chrono::steady_clock::now();
const size_t frameCount = sourceBuffer.frameCount;
- for (auto& sink : mTeePatches) {
- RecordThread::PatchRecord* patchRecord = sink.patchRecord.get();
+ if (frameCount == 0) {
+ return; // No audio to intercept.
+ // Additionally PatchProxyBufferProvider::obtainBuffer (called by PathTrack::getNextBuffer)
+ // does not allow 0 frame size request contrary to getNextBuffer
+ }
+ for (auto& teePatch : mTeePatches) {
+ RecordThread::PatchRecord* patchRecord = teePatch.patchRecord.get();
size_t framesWritten = writeFrames(patchRecord, sourceBuffer.i8, frameCount);
// On buffer wrap, the buffer frame count will be less than requested,
diff --git a/services/audiopolicy/Android.mk b/services/audiopolicy/Android.mk
index f72f44a..9e4eebc 100644
--- a/services/audiopolicy/Android.mk
+++ b/services/audiopolicy/Android.mk
@@ -90,7 +90,7 @@
LOCAL_SHARED_LIBRARIES += libmedia_helper
LOCAL_SHARED_LIBRARIES += libmediametrics
-LOCAL_SHARED_LIBRARIES += libhidlbase libxml2
+LOCAL_SHARED_LIBRARIES += libbinder libhidlbase libxml2
ifeq ($(USE_XML_AUDIO_POLICY_CONF), 1)
LOCAL_CFLAGS += -DUSE_XML_AUDIO_POLICY_CONF
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index bb5441d..acbfc9e 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -58,10 +58,12 @@
typedef enum {
API_INPUT_INVALID = -1,
API_INPUT_LEGACY = 0,// e.g. audio recording from a microphone
- API_INPUT_MIX_CAPTURE,// used for "remote submix", capture of the media to play it remotely
+ API_INPUT_MIX_CAPTURE,// used for "remote submix" legacy mode (no DAP),
+ // capture of the media to play it remotely
API_INPUT_MIX_EXT_POLICY_REROUTE,// used for platform audio rerouting, where mixes are
// handled by external and dynamically installed
// policies which reroute audio mixes
+ API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK, // used for playback capture with a MediaProjection
API_INPUT_TELEPHONY_RX, // used for capture from telephony RX path
} input_type_t;
@@ -159,6 +161,19 @@
int *index,
audio_devices_t device) = 0;
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device) = 0;
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device) = 0;
+
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) = 0;
+
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index) = 0;
+
// return the strategy corresponding to a given stream type
virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
@@ -244,7 +259,13 @@
virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0;
- virtual product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa) = 0;
+ virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy) = 0;
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0;
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup) = 0;
};
@@ -341,6 +362,8 @@
virtual void onAudioPatchListUpdate() = 0;
+ virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0;
+
virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) = 0;
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) = 0;
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioGain.h b/services/audiopolicy/common/managerdefinitions/include/AudioGain.h
index 996347b..4af93e1 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioGain.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioGain.h
@@ -20,6 +20,7 @@
#include <utils/RefBase.h>
#include <utils/String8.h>
#include <system/audio.h>
+#include <vector>
namespace android {
@@ -59,12 +60,36 @@
void getDefaultConfig(struct audio_gain_config *config);
status_t checkConfig(const struct audio_gain_config *config);
+ void setUseForVolume(bool canUseForVolume) { mUseForVolume = canUseForVolume; }
+ bool canUseForVolume() const { return mUseForVolume; }
+
const struct audio_gain &getGain() const { return mGain; }
private:
int mIndex;
struct audio_gain mGain;
bool mUseInChannelMask;
+ bool mUseForVolume = false;
+};
+
+class AudioGains : public std::vector<sp<AudioGain> >
+{
+public:
+ bool canUseForVolume() const
+ {
+ for (const auto &gain: *this) {
+ if (gain->canUseForVolume()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ int32_t add(const sp<AudioGain> gain)
+ {
+ push_back(gain);
+ return 0;
+ }
};
} // namespace android
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
index cf9519b..704f404 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioOutputDescriptor.h
@@ -98,7 +98,7 @@
ActivityTracking::dump(dst, spaces);
dst->appendFormat(", Volume: %.03f, MuteCount: %02d\n", mCurVolumeDb, mMuteCount);
}
- void setVolume(float volume) { mCurVolumeDb = volume; }
+ void setVolume(float volumeDb) { mCurVolumeDb = volumeDb; }
float getVolume() const { return mCurVolumeDb; }
private:
@@ -156,7 +156,7 @@
virtual bool isDuplicated() const { return false; }
virtual uint32_t latency() { return 0; }
virtual bool isFixedVolume(audio_devices_t device);
- virtual bool setVolume(float volume,
+ virtual bool setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device,
uint32_t delayMs,
@@ -219,10 +219,10 @@
{
return mVolumeActivities[vs].decMuteCount();
}
- void setCurVolume(VolumeSource vs, float volume)
+ void setCurVolume(VolumeSource vs, float volumeDb)
{
// Even if not activity for this group registered, need to create anyway
- mVolumeActivities[vs].setVolume(volume);
+ mVolumeActivities[vs].setVolume(volumeDb);
}
float getCurVolume(VolumeSource vs) const
{
@@ -327,7 +327,7 @@
setClientActive(client, false);
}
}
- virtual bool setVolume(float volume,
+ virtual bool setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device,
uint32_t delayMs,
@@ -401,7 +401,7 @@
void dump(String8 *dst) const override;
- virtual bool setVolume(float volume,
+ virtual bool setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device,
uint32_t delayMs,
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioPort.h b/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
index 1b5a2d6..2d182bd 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioPort.h
@@ -18,6 +18,7 @@
#include "AudioCollections.h"
#include "AudioProfile.h"
+#include "AudioGain.h"
#include "HandleGenerator.h"
#include <utils/String8.h>
#include <utils/Vector.h>
@@ -29,9 +30,7 @@
namespace android {
class HwModule;
-class AudioGain;
class AudioRoute;
-typedef Vector<sp<AudioGain> > AudioGainCollection;
class AudioPort : public virtual RefBase, private HandleGenerator<audio_port_handle_t>
{
@@ -49,8 +48,8 @@
virtual const String8 getTagName() const = 0;
- void setGains(const AudioGainCollection &gains) { mGains = gains; }
- const AudioGainCollection &getGains() const { return mGains; }
+ void setGains(const AudioGains &gains) { mGains = gains; }
+ const AudioGains &getGains() const { return mGains; }
virtual void setFlags(uint32_t flags)
{
@@ -138,7 +137,7 @@
void log(const char* indent) const;
- AudioGainCollection mGains; // gain controllers
+ AudioGains mGains; // gain controllers
private:
void pickChannelMask(audio_channel_mask_t &channelMask, const ChannelsVector &channelMasks) const;
@@ -165,6 +164,8 @@
return (other != 0) && (other->getAudioPort() != 0) && (getAudioPort() != 0) &&
(other->getAudioPort()->getModuleHandle() == getAudioPort()->getModuleHandle());
}
+ bool hasGainController(bool canUseForVolume = false) const;
+
unsigned int mSamplingRate = 0u;
audio_format_t mFormat = AUDIO_FORMAT_INVALID;
audio_channel_mask_t mChannelMask = AUDIO_CHANNEL_NONE;
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
index 7293bc4..fd33649 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
@@ -149,7 +149,7 @@
return false;
}
-bool AudioOutputDescriptor::setVolume(float volume,
+bool AudioOutputDescriptor::setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device __unused,
uint32_t delayMs,
@@ -158,9 +158,9 @@
// We actually change the volume if:
// - the float value returned by computeVolume() changed
// - the force flag is set
- if (volume != getCurVolume(static_cast<VolumeSource>(stream)) || force) {
- ALOGV("setVolume() for stream %d, volume %f, delay %d", stream, volume, delayMs);
- setCurVolume(static_cast<VolumeSource>(stream), volume);
+ if (volumeDb != getCurVolume(static_cast<VolumeSource>(stream)) || force) {
+ ALOGV("setVolume() for stream %d, volume %f, delay %d", stream, volumeDb, delayMs);
+ setCurVolume(static_cast<VolumeSource>(stream), volumeDb);
return true;
}
return false;
@@ -388,15 +388,39 @@
mFlags & AUDIO_OUTPUT_FLAG_FAST ? AUDIO_LATENCY_LOW : AUDIO_LATENCY_NORMAL;
}
-bool SwAudioOutputDescriptor::setVolume(float volume,
+bool SwAudioOutputDescriptor::setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device,
uint32_t delayMs,
bool force)
{
- if (!AudioOutputDescriptor::setVolume(volume, stream, device, delayMs, force)) {
+ if (!AudioOutputDescriptor::setVolume(volumeDb, stream, device, delayMs, force)) {
return false;
}
+ if (!devices().isEmpty()) {
+ // Assume first device to check upon Gain Crontroller availability
+ const auto &devicePort = devices().itemAt(0);
+ ALOGV("%s: device %s hasGC %d", __FUNCTION__,
+ devicePort->toString().c_str(), devices().itemAt(0)->hasGainController(true));
+ if (devicePort->hasGainController(true)) {
+ // @todo: default stream volume to max (0) when using HW Port gain?
+ float volumeAmpl = Volume::DbToAmpl(0);
+ mClientInterface->setStreamVolume(stream, volumeAmpl, mIoHandle, delayMs);
+
+ AudioGains gains = devicePort->getGains();
+ int gainMinValueInMb = gains[0]->getMinValueInMb();
+ int gainMaxValueInMb = gains[0]->getMaxValueInMb();
+ int gainStepValueInMb = gains[0]->getStepValueInMb();
+ int gainValueMb = ((volumeDb * 100)/ gainStepValueInMb) * gainStepValueInMb;
+ gainValueMb = std::max(gainMinValueInMb, std::min(gainValueMb, gainMaxValueInMb));
+
+ audio_port_config config = {};
+ devicePort->toAudioPortConfig(&config);
+ config.config_mask = AUDIO_PORT_CONFIG_GAIN;
+ config.gain.values[0] = gainValueMb;
+ return mClientInterface->setAudioPortConfig(&config, 0) == NO_ERROR;
+ }
+ }
// Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is enabled
float volumeAmpl = Volume::DbToAmpl(getCurVolume(static_cast<VolumeSource>(stream)));
if (stream == AUDIO_STREAM_BLUETOOTH_SCO) {
@@ -591,13 +615,13 @@
}
-bool HwAudioOutputDescriptor::setVolume(float volume,
+bool HwAudioOutputDescriptor::setVolume(float volumeDb,
audio_stream_type_t stream,
audio_devices_t device,
uint32_t delayMs,
bool force)
{
- bool changed = AudioOutputDescriptor::setVolume(volume, stream, device, delayMs, force);
+ bool changed = AudioOutputDescriptor::setVolume(volumeDb, stream, device, delayMs, force);
if (changed) {
// TODO: use gain controller on source device if any to adjust volume
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
index 9fcf5e7..a66c695 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
@@ -479,4 +479,14 @@
dstConfig, srcConfig, AUDIO_PORT_CONFIG_FLAGS, { AUDIO_INPUT_FLAG_NONE });
}
+bool AudioPortConfig::hasGainController(bool canUseForVolume) const
+{
+ sp<AudioPort> audioport = getAudioPort();
+ if (audioport == nullptr) {
+ return false;
+ }
+ return canUseForVolume ? audioport->getGains().canUseForVolume()
+ : audioport->getGains().size() > 0;
+}
+
} // namespace android
diff --git a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
index 81d3968..5f820c2 100644
--- a/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
@@ -64,7 +64,7 @@
}
};
-struct AudioGainTraits : public AndroidCollectionTraits<AudioGain, AudioGainCollection>
+struct AudioGainTraits : public AndroidCollectionTraits<AudioGain, AudioGains>
{
static constexpr const char *tag = "gain";
static constexpr const char *collectionTag = "gains";
@@ -84,6 +84,9 @@
static constexpr const char *minRampMs = "minRampMs";
/** needed if mode AUDIO_GAIN_MODE_RAMP. */
static constexpr const char *maxRampMs = "maxRampMs";
+ /** needed to allow use setPortGain instead of setStreamVolume. */
+ static constexpr const char *useForVolume = "useForVolume";
+
};
static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);
@@ -375,9 +378,14 @@
if (!maxRampMsLiteral.empty() && convertTo(maxRampMsLiteral, maxRampMs)) {
gain->setMaxRampInMs(maxRampMs);
}
- ALOGV("%s: adding new gain mode %08x channel mask %08x min mB %d max mB %d", __func__,
- gain->getMode(), gain->getChannelMask(), gain->getMinValueInMb(),
- gain->getMaxValueInMb());
+ std::string useForVolumeLiteral = getXmlAttribute(cur, Attributes::useForVolume);
+ bool useForVolume = false;
+ if (!useForVolumeLiteral.empty() && convertTo(useForVolumeLiteral, useForVolume)) {
+ gain->setUseForVolume(useForVolume);
+ }
+ ALOGV("%s: adding new gain mode %08x channel mask %08x min mB %d max mB %d UseForVolume: %d",
+ __func__, gain->getMode(), gain->getChannelMask(), gain->getMinValueInMb(),
+ gain->getMaxValueInMb(), useForVolume);
if (gain->getMode() != 0) {
return gain;
diff --git a/services/audiopolicy/engine/common/include/EngineBase.h b/services/audiopolicy/engine/common/include/EngineBase.h
index 35d86ee..6ff8512 100644
--- a/services/audiopolicy/engine/common/include/EngineBase.h
+++ b/services/audiopolicy/engine/common/include/EngineBase.h
@@ -88,6 +88,8 @@
AttributesVector getAllAttributesForVolumeGroup(volume_group_t volumeGroup) const override;
+ status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) const override;
+
void dump(String8 *dst) const override;
diff --git a/services/audiopolicy/engine/common/src/EngineBase.cpp b/services/audiopolicy/engine/common/src/EngineBase.cpp
index 4d7c4a0..4fe7b42 100644
--- a/services/audiopolicy/engine/common/src/EngineBase.cpp
+++ b/services/audiopolicy/engine/common/src/EngineBase.cpp
@@ -274,6 +274,15 @@
mVolumeGroups.at(volumeGroup)->getSupportedAttributes() : AttributesVector();
}
+status_t EngineBase::listAudioVolumeGroups(AudioVolumeGroupVector &groups) const
+{
+ for (const auto &iter : mVolumeGroups) {
+ groups.push_back({iter.second->getName(), iter.second->getId(),
+ iter.second->getSupportedAttributes(), iter.second->getStreamTypes()});
+ }
+ return NO_ERROR;
+}
+
void EngineBase::dump(String8 *dst) const
{
mProductStrategies.dump(dst, 2);
diff --git a/services/audiopolicy/engine/interface/AudioPolicyManagerInterface.h b/services/audiopolicy/engine/interface/AudioPolicyManagerInterface.h
index 07acd2e..38f3401 100644
--- a/services/audiopolicy/engine/interface/AudioPolicyManagerInterface.h
+++ b/services/audiopolicy/engine/interface/AudioPolicyManagerInterface.h
@@ -18,6 +18,7 @@
#include <AudioPolicyManagerObserver.h>
#include <media/AudioProductStrategy.h>
+#include <media/AudioVolumeGroup.h>
#include <IVolumeCurves.h>
#include <policy.h>
#include <Volume.h>
@@ -286,6 +287,15 @@
virtual AttributesVector getAllAttributesForVolumeGroup(volume_group_t volumeGroup) const = 0;
+ /**
+ * @brief listAudioVolumeGroups introspection API to get the Audio Volume Groups, aka
+ * former stream aliases in Audio Service, defining volume curves attached to one or more
+ * Audio Attributes.
+ * @param groups
+ * @return NO_ERROR if the volume groups were retrieved successfully, error code otherwise
+ */
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) const = 0;
+
virtual void dump(String8 *dst) const = 0;
protected:
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 4540c4d..c969af3 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -479,36 +479,16 @@
std::vector<audio_format_t> *formats)
{
ALOGV("getHwOffloadEncodingFormatsSupportedForA2DP()");
- char *tok = NULL, *saveptr;
status_t status = NO_ERROR;
- char encoding_formats_list[PROPERTY_VALUE_MAX];
- audio_format_t format = AUDIO_FORMAT_DEFAULT;
- // FIXME This list should not come from a property but the supported encoded
- // formats of declared A2DP devices in primary module
- property_get("persist.bluetooth.a2dp_offload.cap", encoding_formats_list, "");
- tok = strtok_r(encoding_formats_list, "-", &saveptr);
- for (;tok != NULL; tok = strtok_r(NULL, "-", &saveptr)) {
- if (strcmp(tok, "sbc") == 0) {
- ALOGV("%s: SBC offload supported\n",__func__);
- format = AUDIO_FORMAT_SBC;
- } else if (strcmp(tok, "aptx") == 0) {
- ALOGV("%s: APTX offload supported\n",__func__);
- format = AUDIO_FORMAT_APTX;
- } else if (strcmp(tok, "aptxhd") == 0) {
- ALOGV("%s: APTX HD offload supported\n",__func__);
- format = AUDIO_FORMAT_APTX_HD;
- } else if (strcmp(tok, "ldac") == 0) {
- ALOGV("%s: LDAC offload supported\n",__func__);
- format = AUDIO_FORMAT_LDAC;
- } else if (strcmp(tok, "aac") == 0) {
- ALOGV("%s: AAC offload supported\n",__func__);
- format = AUDIO_FORMAT_AAC;
- } else {
- ALOGE("%s: undefined token - %s\n",__func__, tok);
- continue;
- }
- formats->push_back(format);
+ std::unordered_set<audio_format_t> formatSet;
+ sp<HwModule> primaryModule =
+ mHwModules.getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY);
+ DeviceVector declaredDevices = primaryModule->getDeclaredDevices().getDevicesFromTypeMask(
+ AUDIO_DEVICE_OUT_ALL_A2DP);
+ for (const auto& device : declaredDevices) {
+ formatSet.insert(device->encodedFormats().begin(), device->encodedFormats().end());
}
+ formats->assign(formatSet.begin(), formatSet.end());
return status;
}
@@ -1986,7 +1966,11 @@
if (status != NO_ERROR) {
goto error;
}
- *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
+ if (is_mix_loopback_render(policyMix->mRouteFlags)) {
+ *inputType = API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK;
+ } else {
+ *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
+ }
device = mAvailableInputDevices.getDevice(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
String8(attr->tags + strlen("addr=")),
AUDIO_FORMAT_DEFAULT);
@@ -2498,6 +2482,107 @@
return NO_ERROR;
}
+status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device)
+{
+ // Get Volume group matching the Audio Attributes
+ auto volumeGroup = mEngine->getVolumeGroupForAttributes(attr);
+ if (volumeGroup == VOLUME_GROUP_NONE) {
+ ALOGD("%s: could not find group matching with %s", __FUNCTION__, toString(attr).c_str());
+ return BAD_VALUE;
+ }
+ ALOGD("%s: FOUND group %d matching with %s", __FUNCTION__, volumeGroup, toString(attr).c_str());
+ return setVolumeGroupIndex(getVolumeCurves(attr), volumeGroup, index, device, attr);
+}
+
+status_t AudioPolicyManager::setVolumeGroupIndex(IVolumeCurves &curves, volume_group_t group,
+ int index,
+ audio_devices_t device,
+ const audio_attributes_t /*attributes*/)
+{
+ ALOGVV("%s: group=%d", __func__, group);
+ status_t status = NO_ERROR;
+ setVolumeCurveIndex(group, index, device, curves);
+ // update volume on all outputs and streams matching the following:
+ // - The requested stream (or a stream matching for volume control) is active on the output
+ // - The device (or devices) selected by the engine for this stream includes
+ // the requested device
+ // - For non default requested device, currently selected device on the output is either the
+ // requested device or one of the devices selected by the engine for this stream
+ // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
+ // no specific device volume value exists for currently selected device.
+ // @TODO
+ mpClientInterface->onAudioVolumeGroupChanged(group, 0 /*flags*/);
+ return status;
+}
+
+status_t AudioPolicyManager::setVolumeCurveIndex(volume_group_t volumeGroup,
+ int index,
+ audio_devices_t device,
+ IVolumeCurves &volumeCurves)
+{
+ // VOICE_CALL stream has minVolumeIndex > 0 but can be muted directly by an
+ // app that has MODIFY_PHONE_STATE permission.
+ // If voice is member of the volume group, it will contaminate all the member of this group
+ auto streams = mEngine->getStreamTypesForVolumeGroup(volumeGroup);
+ if (((index < volumeCurves.getVolumeIndexMin()) && !(hasVoiceStream(streams) && index == 0)) ||
+ (index > volumeCurves.getVolumeIndexMax())) {
+ ALOGD("%s: wrong index %d min=%d max=%d", __FUNCTION__, index,
+ volumeCurves.getVolumeIndexMin(), volumeCurves.getVolumeIndexMax());
+ return BAD_VALUE;
+ }
+ if (!audio_is_output_device(device)) {
+ return BAD_VALUE;
+ }
+
+ // Force max volume if stream cannot be muted
+ if (!volumeCurves.canBeMuted()) index = volumeCurves.getVolumeIndexMax();
+
+ ALOGD("%s device %08x, index %d", __FUNCTION__ , device, index);
+ volumeCurves.addCurrentVolumeIndex(device, index);
+ return NO_ERROR;
+}
+
+status_t AudioPolicyManager::getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device)
+{
+ // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device selected for this
+ // stream by the engine.
+ if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
+ device = mEngine->getOutputDevicesForAttributes(attr, nullptr, true /*fromCache*/).types();
+ }
+ return getVolumeIndex(getVolumeCurves(attr), index, device);
+}
+
+status_t AudioPolicyManager::getVolumeIndex(const IVolumeCurves &curves,
+ int &index,
+ audio_devices_t device) const
+{
+ if (!audio_is_output_device(device)) {
+ return BAD_VALUE;
+ }
+ device = Volume::getDeviceForVolume(device);
+ index = curves.getVolumeIndex(device);
+ ALOGV("%s: device %08x index %d", __FUNCTION__, device, index);
+ return NO_ERROR;
+}
+
+status_t AudioPolicyManager::getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index)
+{
+ index = getVolumeCurves(attr).getVolumeIndexMin();
+ return NO_ERROR;
+}
+
+status_t AudioPolicyManager::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index)
+{
+ index = getVolumeCurves(attr).getVolumeIndexMax();
+ return NO_ERROR;
+}
+
audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
{
// select one output among several suitable for global effects.
@@ -5054,7 +5139,7 @@
if ((hasVoiceStream(streams) &&
(isInCall() || mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc))) ||
- (hasStream(streams, AUDIO_STREAM_ALARM) &&
+ ((hasStream(streams, AUDIO_STREAM_ALARM) || hasStream(streams, AUDIO_STREAM_ENFORCED_AUDIBLE)) &&
mOutputs.isStrategyActiveOnSameModule(productStrategy, outputDesc)) ||
outputDesc->isStrategyActive(productStrategy)) {
// Retrieval of devices for voice DL is done on primary output profile, cannot
@@ -5527,7 +5612,7 @@
audio_devices_t device)
{
auto &curves = getVolumeCurves(stream);
- float volumeDB = curves.volIndexToDb(Volume::getDeviceCategory(device), index);
+ float volumeDb = curves.volIndexToDb(Volume::getDeviceCategory(device), index);
// handle the case of accessibility active while a ringtone is playing: if the ringtone is much
// louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
@@ -5537,7 +5622,7 @@
&& (AUDIO_MODE_RINGTONE == mEngine->getPhoneState())
&& isStreamActive(AUDIO_STREAM_RING, 0)) {
const float ringVolumeDB = computeVolume(AUDIO_STREAM_RING, index, device);
- return ringVolumeDB - 4 > volumeDB ? ringVolumeDB - 4 : volumeDB;
+ return ringVolumeDB - 4 > volumeDb ? ringVolumeDB - 4 : volumeDb;
}
// in-call: always cap volume by voice volume + some low headroom
@@ -5556,10 +5641,10 @@
const float maxVoiceVolDb =
computeVolume(AUDIO_STREAM_VOICE_CALL, voiceVolumeIndex, device)
+ IN_CALL_EARPIECE_HEADROOM_DB;
- if (volumeDB > maxVoiceVolDb) {
+ if (volumeDb > maxVoiceVolDb) {
ALOGV("computeVolume() stream %d at vol=%f overriden by stream %d at vol=%f",
- stream, volumeDB, AUDIO_STREAM_VOICE_CALL, maxVoiceVolDb);
- volumeDB = maxVoiceVolDb;
+ stream, volumeDb, AUDIO_STREAM_VOICE_CALL, maxVoiceVolDb);
+ volumeDb = maxVoiceVolDb;
}
} break;
default:
@@ -5592,7 +5677,7 @@
// just stopped
if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
mLimitRingtoneVolume) {
- volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
+ volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
audio_devices_t musicDevice =
mEngine->getOutputDevicesForAttributes(attributes_initializer(AUDIO_USAGE_MEDIA),
nullptr, true /*fromCache*/).types();
@@ -5601,29 +5686,29 @@
musicDevice);
float minVolDB = (musicVolDB > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
musicVolDB : SONIFICATION_HEADSET_VOLUME_MIN_DB;
- if (volumeDB > minVolDB) {
- volumeDB = minVolDB;
+ if (volumeDb > minVolDB) {
+ volumeDb = minVolDB;
ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDB, musicVolDB);
}
if (device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES)) {
// on A2DP, also ensure notification volume is not too low compared to media when
// intended to be played
- if ((volumeDB > -96.0f) &&
- (musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDB)) {
+ if ((volumeDb > -96.0f) &&
+ (musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDb)) {
ALOGV("computeVolume increasing volume for stream=%d device=0x%X from %f to %f",
stream, device,
- volumeDB, musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
- volumeDB = musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
+ volumeDb, musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
+ volumeDb = musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
}
}
} else if ((Volume::getDeviceForVolume(device) != AUDIO_DEVICE_OUT_SPEAKER) ||
(stream != AUDIO_STREAM_ALARM && stream != AUDIO_STREAM_RING)) {
- volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
+ volumeDb += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
}
}
- return volumeDB;
+ return volumeDb;
}
int AudioPolicyManager::rescaleVolumeIndex(int srcIndex,
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index 3e4d885..641a03a 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -161,6 +161,27 @@
int *index,
audio_devices_t device);
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device);
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device);
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
+
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
+
+ status_t setVolumeGroupIndex(IVolumeCurves &volumeCurves, volume_group_t group, int index,
+ audio_devices_t device, const audio_attributes_t attributes);
+
+ status_t setVolumeCurveIndex(volume_group_t volumeGroup,
+ int index,
+ audio_devices_t device,
+ IVolumeCurves &volumeCurves);
+
+ status_t getVolumeIndex(const IVolumeCurves &curves, int &index,
+ audio_devices_t device) const;
+
// return the strategy corresponding to a given stream type
virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
{
@@ -268,9 +289,23 @@
return mEngine->listAudioProductStrategies(strategies);
}
- virtual product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa)
+ virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy)
{
- return mEngine->getProductStrategyForAttributes(aa.getAttributes());
+ productStrategy = mEngine->getProductStrategyForAttributes(aa.getAttributes());
+ return productStrategy != PRODUCT_STRATEGY_NONE ? NO_ERROR : BAD_VALUE;
+ }
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+ {
+ return mEngine->listAudioVolumeGroups(groups);
+ }
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup)
+ {
+ volumeGroup = mEngine->getVolumeGroupForAttributes(aa.getAttributes());
+ return volumeGroup != VOLUME_GROUP_NONE ? NO_ERROR : BAD_VALUE;
}
protected:
diff --git a/services/audiopolicy/service/AudioPolicyClientImpl.cpp b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
index d826192..5748334 100644
--- a/services/audiopolicy/service/AudioPolicyClientImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
@@ -222,6 +222,12 @@
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
+void AudioPolicyService::AudioPolicyClient::onAudioVolumeGroupChanged(volume_group_t group,
+ int flags)
+{
+ mAudioPolicyService->onAudioVolumeGroupChanged(group, flags);
+}
+
audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
{
return AudioSystem::newAudioUniqueId(use);
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index 89dfd3e..a672521 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -20,7 +20,6 @@
#include "AudioPolicyService.h"
#include "TypeConverter.h"
#include <media/MediaAnalyticsItem.h>
-#include <mediautils/ServiceUtilities.h>
#include <media/AudioPolicy.h>
#include <utils/Log.h>
@@ -167,7 +166,7 @@
return mAudioPolicyManager->getOutput(stream);
}
-status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
+status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *originalAttr,
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
@@ -191,9 +190,13 @@
"%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
uid = callingUid;
}
+ audio_attributes_t attr = *originalAttr;
+ if (!mPackageManager.allowPlaybackCapture(uid)) {
+ attr.flags |= AUDIO_FLAG_NO_CAPTURE;
+ }
audio_output_flags_t originalFlags = flags;
AutoCallerClear acc;
- status_t result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
+ status_t result = mAudioPolicyManager->getOutputForAttr(&attr, output, session, stream, uid,
config,
&flags, selectedDeviceId, portId,
secondaryOutputs);
@@ -209,14 +212,14 @@
*selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
*portId = AUDIO_PORT_HANDLE_NONE;
secondaryOutputs->clear();
- result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid, config,
+ result = mAudioPolicyManager->getOutputForAttr(&attr, output, session, stream, uid, config,
&flags, selectedDeviceId, portId,
secondaryOutputs);
}
if (result == NO_ERROR) {
sp <AudioPlaybackClient> client =
- new AudioPlaybackClient(*attr, *output, uid, pid, session, *selectedDeviceId, *stream);
+ new AudioPlaybackClient(attr, *output, uid, pid, session, *selectedDeviceId, *stream);
mAudioPlaybackClients.add(*portId, client);
}
return result;
@@ -404,6 +407,9 @@
if (status == NO_ERROR) {
// enforce permission (if any) required for each type of input
switch (inputType) {
+ case AudioPolicyInterface::API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK:
+ // this use case has been validated in audio service with a MediaProjection token,
+ // and doesn't rely on regular permissions
case AudioPolicyInterface::API_INPUT_LEGACY:
break;
case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
@@ -689,6 +695,53 @@
device);
}
+status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
+ int index, audio_devices_t device)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ if (!settingsAllowed()) {
+ return PERMISSION_DENIED;
+ }
+ Mutex::Autolock _l(mLock);
+ AutoCallerClear acc;
+ return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
+}
+
+status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
+ int &index, audio_devices_t device)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ Mutex::Autolock _l(mLock);
+ AutoCallerClear acc;
+ return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
+}
+
+status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
+ int &index)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ Mutex::Autolock _l(mLock);
+ AutoCallerClear acc;
+ return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
+}
+
+status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
+ int &index)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ Mutex::Autolock _l(mLock);
+ AutoCallerClear acc;
+ return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
+}
+
uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
{
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
@@ -1190,13 +1243,32 @@
return mAudioPolicyManager->listAudioProductStrategies(strategies);
}
-product_strategy_t AudioPolicyService::getProductStrategyFromAudioAttributes(
- const AudioAttributes &aa)
+status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
+ const AudioAttributes &aa, product_strategy_t &productStrategy)
{
if (mAudioPolicyManager == NULL) {
- return PRODUCT_STRATEGY_NONE;
+ return NO_INIT;
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa);
+ return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
+}
+
+status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ Mutex::Autolock _l(mLock);
+ return mAudioPolicyManager->listAudioVolumeGroups(groups);
+}
+
+status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup)
+{
+ if (mAudioPolicyManager == NULL) {
+ return NO_INIT;
+ }
+ Mutex::Autolock _l(mLock);
+ return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
}
} // namespace android
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index 76ac191..8cbf3af 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -150,6 +150,20 @@
mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
}
+void AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
+{
+ Mutex::Autolock _l(mNotificationClientsLock);
+
+ uid_t uid = IPCThreadState::self()->getCallingUid();
+ pid_t pid = IPCThreadState::self()->getCallingPid();
+ int64_t token = ((int64_t)uid<<32) | pid;
+
+ if (mNotificationClients.indexOfKey(token) < 0) {
+ return;
+ }
+ mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
+}
+
// removeNotificationClient() is called when the client process dies.
void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
{
@@ -200,6 +214,19 @@
}
}
+void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
+{
+ mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
+}
+
+void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
+{
+ Mutex::Autolock _l(mNotificationClientsLock);
+ for (size_t i = 0; i < mNotificationClients.size(); i++) {
+ mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
+ }
+}
+
void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
{
ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
@@ -270,7 +297,7 @@
uid_t uid,
pid_t pid)
: mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
- mAudioPortCallbacksEnabled(false)
+ mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
{
}
@@ -301,6 +328,15 @@
}
}
+void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
+ int flags)
+{
+ if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
+ mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
+ }
+}
+
+
void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
const String8& regId, int32_t state)
{
@@ -330,6 +366,10 @@
mAudioPortCallbacksEnabled = enabled;
}
+void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
+{
+ mAudioVolumeGroupCallbacksEnabled = enabled;
+}
void AudioPolicyService::binderDied(const wp<IBinder>& who) {
ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
@@ -410,7 +450,7 @@
for (size_t i =0; i < mAudioRecordClients.size(); i++) {
sp<AudioRecordClient> current = mAudioRecordClients[i];
if (!current->active) continue;
- if (isPrivacySensitive(current->attributes.source)) {
+ if (isPrivacySensitiveSource(current->attributes.source)) {
if (current->startTimeNs > latestSensitiveStartNs) {
latestSensitiveActive = current;
latestSensitiveStartNs = current->startTimeNs;
@@ -449,7 +489,10 @@
bool isLatest = current == latestActive;
bool isLatestSensitive = current == latestSensitiveActive;
bool forceIdle = true;
- if (mUidPolicy->isAssistantUid(current->uid)) {
+
+ if (isVirtualSource(source)) {
+ forceIdle = false;
+ } else if (mUidPolicy->isAssistantUid(current->uid)) {
if (isA11yOnTop) {
if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
forceIdle = false;
@@ -465,10 +508,6 @@
(source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD)) {
forceIdle = false;
}
- } else if (source == AUDIO_SOURCE_VOICE_DOWNLINK ||
- source == AUDIO_SOURCE_VOICE_CALL ||
- (source == AUDIO_SOURCE_VOICE_UPLINK)) {
- forceIdle = false;
} else {
if (!isAssistantOnTop && (isOnTop || isLatest) &&
(!isSensitiveActive || isLatestSensitive)) {
@@ -502,14 +541,27 @@
}
/* static */
-bool AudioPolicyService::isPrivacySensitive(audio_source_t source)
+bool AudioPolicyService::isPrivacySensitiveSource(audio_source_t source)
+{
+ switch (source) {
+ case AUDIO_SOURCE_CAMCORDER:
+ case AUDIO_SOURCE_VOICE_COMMUNICATION:
+ return true;
+ default:
+ break;
+ }
+ return false;
+}
+
+/* static */
+bool AudioPolicyService::isVirtualSource(audio_source_t source)
{
switch (source) {
case AUDIO_SOURCE_VOICE_UPLINK:
case AUDIO_SOURCE_VOICE_DOWNLINK:
case AUDIO_SOURCE_VOICE_CALL:
- case AUDIO_SOURCE_CAMCORDER:
- case AUDIO_SOURCE_VOICE_COMMUNICATION:
+ case AUDIO_SOURCE_REMOTE_SUBMIX:
+ case AUDIO_SOURCE_FM_TUNER:
return true;
default:
break;
@@ -551,6 +603,8 @@
mAudioPolicyManager->dump(fd);
}
+ mPackageManager.dump(fd);
+
if (locked) mLock.unlock();
}
return NO_ERROR;
@@ -1058,6 +1112,18 @@
svc->doOnAudioPatchListUpdate();
mLock.lock();
}break;
+ case CHANGED_AUDIOVOLUMEGROUP: {
+ AudioVolumeGroupData *data =
+ static_cast<AudioVolumeGroupData *>(command->mParam.get());
+ ALOGV("AudioCommandThread() processing update audio volume group");
+ svc = mService.promote();
+ if (svc == 0) {
+ break;
+ }
+ mLock.unlock();
+ svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
+ mLock.lock();
+ }break;
case SET_AUDIOPORT_CONFIG: {
SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
ALOGV("AudioCommandThread() processing set port config");
@@ -1302,6 +1368,19 @@
sendCommand(command);
}
+void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
+ int flags)
+{
+ sp<AudioCommand>command = new AudioCommand();
+ command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
+ AudioVolumeGroupData *data= new AudioVolumeGroupData();
+ data->mGroup = group;
+ data->mFlags = flags;
+ command->mParam = data;
+ ALOGV("AudioCommandThread() adding audio volume group changed");
+ sendCommand(command);
+}
+
status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
const struct audio_port_config *config, int delayMs)
{
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index 8cd6e81..a2e75cd 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -31,6 +31,7 @@
#include <media/ToneGenerator.h>
#include <media/AudioEffect.h>
#include <media/AudioPolicy.h>
+#include <mediautils/ServiceUtilities.h>
#include "AudioPolicyEffects.h"
#include "managerdefault/AudioPolicyManager.h"
#include <android/hardware/BnSensorPrivacyListener.h>
@@ -111,6 +112,17 @@
int *index,
audio_devices_t device);
+ virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int index,
+ audio_devices_t device);
+ virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index,
+ audio_devices_t device);
+ virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index);
+ virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
+ int &index);
+
virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
@@ -192,6 +204,8 @@
virtual void setAudioPortCallbacksEnabled(bool enabled);
+ virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled);
+
virtual status_t acquireSoundTriggerSession(audio_session_t *session,
audio_io_handle_t *ioHandle,
audio_devices_t *device);
@@ -231,7 +245,13 @@
virtual bool isHapticPlaybackSupported();
virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies);
- virtual product_strategy_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa);
+ virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
+ product_strategy_t &productStrategy);
+
+ virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups);
+
+ virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
+ volume_group_t &volumeGroup);
status_t doStopOutput(audio_port_handle_t portId);
void doReleaseOutput(audio_port_handle_t portId);
@@ -269,6 +289,9 @@
audio_patch_handle_t patchHandle,
audio_source_t source);
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags);
+ void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
+
private:
AudioPolicyService() ANDROID_API;
virtual ~AudioPolicyService();
@@ -304,7 +327,8 @@
void silenceAllRecordings_l();
- static bool isPrivacySensitive(audio_source_t source);
+ static bool isPrivacySensitiveSource(audio_source_t source);
+ static bool isVirtualSource(audio_source_t source);
// If recording we need to make sure the UID is allowed to do that. If the UID is idle
// then it cannot record and gets buffers with zeros - silence. As soon as the UID
@@ -398,6 +422,7 @@
RELEASE_AUDIO_PATCH,
UPDATE_AUDIOPORT_LIST,
UPDATE_AUDIOPATCH_LIST,
+ CHANGED_AUDIOVOLUMEGROUP,
SET_AUDIOPORT_CONFIG,
DYN_POLICY_MIX_STATE_UPDATE,
RECORDING_CONFIGURATION_UPDATE
@@ -429,6 +454,7 @@
int delayMs);
void updateAudioPortListCommand();
void updateAudioPatchListCommand();
+ void changeAudioVolumeGroupCommand(volume_group_t group, int flags);
status_t setAudioPortConfigCommand(const struct audio_port_config *config,
int delayMs);
void dynamicPolicyMixStateUpdateCommand(const String8& regId,
@@ -510,6 +536,12 @@
audio_patch_handle_t mHandle;
};
+ class AudioVolumeGroupData : public AudioCommandData {
+ public:
+ volume_group_t mGroup;
+ int mFlags;
+ };
+
class SetAudioPortConfigData : public AudioCommandData {
public:
struct audio_port_config mConfig;
@@ -642,6 +674,8 @@
audio_patch_handle_t patchHandle,
audio_source_t source);
+ virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags);
+
virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
private:
@@ -660,6 +694,7 @@
void onAudioPatchListUpdate();
void onDynamicPolicyMixStateUpdate(const String8& regId,
int32_t state);
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags);
void onRecordingConfigurationUpdate(
int event,
const record_client_info_t *clientInfo,
@@ -670,6 +705,7 @@
audio_patch_handle_t patchHandle,
audio_source_t source);
void setAudioPortCallbacksEnabled(bool enabled);
+ void setAudioVolumeGroupCallbacksEnabled(bool enabled);
uid_t uid() {
return mUid;
@@ -687,6 +723,7 @@
const pid_t mPid;
const sp<IAudioPolicyServiceClient> mAudioPolicyServiceClient;
bool mAudioPortCallbacksEnabled;
+ bool mAudioVolumeGroupCallbacksEnabled;
};
class AudioClient : public virtual RefBase {
@@ -784,6 +821,8 @@
DefaultKeyedVector< audio_port_handle_t, sp<AudioRecordClient> > mAudioRecordClients;
DefaultKeyedVector< audio_port_handle_t, sp<AudioPlaybackClient> > mAudioPlaybackClients;
+
+ MediaPackageManager mPackageManager; // To check allowPlaybackCapture
};
} // namespace android
diff --git a/services/audiopolicy/tests/AudioPolicyTestClient.h b/services/audiopolicy/tests/AudioPolicyTestClient.h
index 6ae354b..8854eb2 100644
--- a/services/audiopolicy/tests/AudioPolicyTestClient.h
+++ b/services/audiopolicy/tests/AudioPolicyTestClient.h
@@ -73,6 +73,7 @@
int /*delayMs*/) override { return NO_INIT; }
void onAudioPortListUpdate() override { }
void onAudioPatchListUpdate() override { }
+ void onAudioVolumeGroupChanged(volume_group_t /*group*/, int /*flags*/) override { }
audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t /*use*/) override { return 0; }
void onDynamicPolicyMixStateUpdate(String8 /*regId*/, int32_t /*state*/) override { }
void onRecordingConfigurationUpdate(int event __unused,
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index e06897f..62ec955 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -227,7 +227,7 @@
Mutex::Autolock lock(mStatusListenerLock);
for (auto& i : mListenerList) {
- i.second->onTorchStatusChanged(mapToInterface(status), String16{cameraId});
+ i.second->getListener()->onTorchStatusChanged(mapToInterface(status), String16{cameraId});
}
}
@@ -1654,6 +1654,18 @@
return Status::ok();
}
+void CameraService::notifyMonitoredUids() {
+ Mutex::Autolock lock(mStatusListenerLock);
+
+ for (const auto& it : mListenerList) {
+ auto ret = it.second->getListener()->onCameraAccessPrioritiesChanged();
+ if (!ret.isOk()) {
+ ALOGE("%s: Failed to trigger permission callback: %d", __FUNCTION__,
+ ret.exceptionCode());
+ }
+ }
+}
+
Status CameraService::notifyDeviceStateChange(int64_t newState) {
const int pid = CameraThreadState::getCallingPid();
const int selfPid = getpid();
@@ -1721,15 +1733,25 @@
{
Mutex::Autolock lock(mStatusListenerLock);
- for (auto& it : mListenerList) {
- if (IInterface::asBinder(it.second) == IInterface::asBinder(listener)) {
+ for (const auto &it : mListenerList) {
+ if (IInterface::asBinder(it.second->getListener()) == IInterface::asBinder(listener)) {
ALOGW("%s: Tried to add listener %p which was already subscribed",
__FUNCTION__, listener.get());
return STATUS_ERROR(ERROR_ALREADY_EXISTS, "Listener already registered");
}
}
- mListenerList.emplace_back(isVendorListener, listener);
+ auto clientUid = CameraThreadState::getCallingUid();
+ sp<ServiceListener> serviceListener = new ServiceListener(this, listener, clientUid);
+ auto ret = serviceListener->initialize();
+ if (ret != NO_ERROR) {
+ String8 msg = String8::format("Failed to initialize service listener: %s (%d)",
+ strerror(-ret), ret);
+ ALOGE("%s: %s", __FUNCTION__, msg.string());
+ return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, msg.string());
+ }
+ mListenerList.emplace_back(isVendorListener, serviceListener);
+ mUidPolicy->registerMonitorUid(clientUid);
}
/* Collect current devices and status */
@@ -1776,7 +1798,9 @@
{
Mutex::Autolock lock(mStatusListenerLock);
for (auto it = mListenerList.begin(); it != mListenerList.end(); it++) {
- if (IInterface::asBinder(it->second) == IInterface::asBinder(listener)) {
+ if (IInterface::asBinder(it->second->getListener()) == IInterface::asBinder(listener)) {
+ mUidPolicy->unregisterMonitorUid(it->second->getListenerUid());
+ IInterface::asBinder(listener)->unlinkToDeath(it->second);
mListenerList.erase(it);
return Status::ok();
}
@@ -2396,6 +2420,8 @@
sCameraService->updateProxyDeviceState(ICameraServiceProxy::CAMERA_STATE_OPEN,
mCameraIdStr, mCameraFacing, mClientPackageName, apiLevel);
+ sCameraService->mUidPolicy->registerMonitorUid(mClientUid);
+
return OK;
}
@@ -2433,6 +2459,8 @@
}
mOpsCallback.clear();
+ sCameraService->mUidPolicy->unregisterMonitorUid(mClientUid);
+
return OK;
}
@@ -2523,7 +2551,7 @@
if (mRegistered) return;
am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
| ActivityManager::UID_OBSERVER_IDLE
- | ActivityManager::UID_OBSERVER_ACTIVE,
+ | ActivityManager::UID_OBSERVER_ACTIVE | ActivityManager::UID_OBSERVER_PROCSTATE,
ActivityManager::PROCESS_STATE_UNKNOWN,
String16("cameraserver"));
status_t res = am.linkToDeath(this);
@@ -2569,6 +2597,51 @@
}
}
+void CameraService::UidPolicy::onUidStateChanged(uid_t uid, int32_t procState,
+ int64_t /*procStateSeq*/) {
+ bool procStateChange = false;
+ {
+ Mutex::Autolock _l(mUidLock);
+ if ((mMonitoredUids.find(uid) != mMonitoredUids.end()) &&
+ (mMonitoredUids[uid].first != procState)) {
+ mMonitoredUids[uid].first = procState;
+ procStateChange = true;
+ }
+ }
+
+ if (procStateChange) {
+ sp<CameraService> service = mService.promote();
+ if (service != nullptr) {
+ service->notifyMonitoredUids();
+ }
+ }
+}
+
+void CameraService::UidPolicy::registerMonitorUid(uid_t uid) {
+ Mutex::Autolock _l(mUidLock);
+ auto it = mMonitoredUids.find(uid);
+ if (it != mMonitoredUids.end()) {
+ it->second.second++;
+ } else {
+ mMonitoredUids.emplace(
+ std::pair<uid_t, std::pair<int32_t, size_t>> (uid,
+ std::pair<int32_t, size_t> (ActivityManager::PROCESS_STATE_NONEXISTENT, 1)));
+ }
+}
+
+void CameraService::UidPolicy::unregisterMonitorUid(uid_t uid) {
+ Mutex::Autolock _l(mUidLock);
+ auto it = mMonitoredUids.find(uid);
+ if (it != mMonitoredUids.end()) {
+ it->second.second--;
+ if (it->second.second == 0) {
+ mMonitoredUids.erase(it);
+ }
+ } else {
+ ALOGE("%s: Trying to unregister uid: %d which is not monitored!", __FUNCTION__, uid);
+ }
+}
+
bool CameraService::UidPolicy::isUidActive(uid_t uid, String16 callingPackage) {
Mutex::Autolock _l(mUidLock);
return isUidActiveLocked(uid, callingPackage);
@@ -3118,7 +3191,8 @@
cameraId.c_str());
continue;
}
- listener.second->onStatusChanged(mapToInterface(status), String16(cameraId));
+ listener.second->getListener()->onStatusChanged(mapToInterface(status),
+ String16(cameraId));
}
});
}
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index cf0cef8..65727ec 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -179,6 +179,9 @@
/*out*/
std::vector<hardware::CameraStatus>* cameraStatuses, bool isVendor = false);
+ // Monitored UIDs availability notification
+ void notifyMonitoredUids();
+
/////////////////////////////////////////////////////////////////////
// Client functionality
@@ -543,11 +546,14 @@
void onUidGone(uid_t uid, bool disabled);
void onUidActive(uid_t uid);
void onUidIdle(uid_t uid, bool disabled);
- void onUidStateChanged(uid_t uid __unused, int32_t procState __unused, int64_t procStateSeq __unused) {}
+ void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq);
void addOverrideUid(uid_t uid, String16 callingPackage, bool active);
void removeOverrideUid(uid_t uid, String16 callingPackage);
+ void registerMonitorUid(uid_t uid);
+ void unregisterMonitorUid(uid_t uid);
+
// IBinder::DeathRecipient implementation
virtual void binderDied(const wp<IBinder> &who);
private:
@@ -558,6 +564,8 @@
bool mRegistered;
wp<CameraService> mService;
std::unordered_set<uid_t> mActiveUids;
+ // Monitored uid map to cached procState and refCount pair
+ std::unordered_map<uid_t, std::pair<int32_t, size_t>> mMonitoredUids;
std::unordered_map<uid_t, bool> mOverrideUids;
}; // class UidPolicy
@@ -790,8 +798,33 @@
sp<CameraProviderManager> mCameraProviderManager;
+ class ServiceListener : public virtual IBinder::DeathRecipient {
+ public:
+ ServiceListener(sp<CameraService> parent, sp<hardware::ICameraServiceListener> listener,
+ int uid) : mParent(parent), mListener(listener), mListenerUid(uid) {}
+
+ status_t initialize() {
+ return IInterface::asBinder(mListener)->linkToDeath(this);
+ }
+
+ virtual void binderDied(const wp<IBinder> &/*who*/) {
+ auto parent = mParent.promote();
+ if (parent.get() != nullptr) {
+ parent->removeListener(mListener);
+ }
+ }
+
+ int getListenerUid() { return mListenerUid; }
+ sp<hardware::ICameraServiceListener> getListener() { return mListener; }
+
+ private:
+ wp<CameraService> mParent;
+ sp<hardware::ICameraServiceListener> mListener;
+ int mListenerUid;
+ };
+
// Guarded by mStatusListenerMutex
- std::vector<std::pair<bool, sp<hardware::ICameraServiceListener>>> mListenerList;
+ std::vector<std::pair<bool, sp<ServiceListener>>> mListenerList;
Mutex mStatusListenerLock;
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index 923d17a..2794324 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -58,6 +58,8 @@
#include "CameraService.h"
#include "utils/CameraThreadState.h"
+#include <tuple>
+
using namespace android::camera3;
using namespace android::hardware::camera;
using namespace android::hardware::camera::device::V3_2;
@@ -1094,7 +1096,7 @@
hBuf.acquireFence.setTo(acquireFence, /*shouldOwn*/true);
hBuf.releaseFence = nullptr;
- res = mInterface->pushInflightRequestBuffer(bufferId, buffer);
+ res = mInterface->pushInflightRequestBuffer(bufferId, buffer, streamId);
if (res != OK) {
ALOGE("%s: Can't get register request buffers for stream %d: %s (%d)",
__FUNCTION__, streamId, strerror(-res), res);
@@ -2847,12 +2849,19 @@
}
streams.add(outputStream);
- if (outputStream->format == HAL_PIXEL_FORMAT_BLOB &&
- outputStream->data_space == HAL_DATASPACE_V0_JFIF) {
+ if (outputStream->format == HAL_PIXEL_FORMAT_BLOB) {
size_t k = i + ((mInputStream != nullptr) ? 1 : 0); // Input stream if present should
// always occupy the initial entry.
- bufferSizes[k] = static_cast<uint32_t>(
- getJpegBufferSize(outputStream->width, outputStream->height));
+ if (outputStream->data_space == HAL_DATASPACE_V0_JFIF) {
+ bufferSizes[k] = static_cast<uint32_t>(
+ getJpegBufferSize(outputStream->width, outputStream->height));
+ } else if (outputStream->data_space ==
+ static_cast<android_dataspace>(HAL_DATASPACE_JPEG_APP_SEGMENTS)) {
+ bufferSizes[k] = outputStream->width * outputStream->height;
+ } else {
+ ALOGW("%s: Blob dataSpace %d not supported",
+ __FUNCTION__, outputStream->data_space);
+ }
}
}
@@ -3270,7 +3279,15 @@
std::vector<std::pair<int32_t, int32_t>> inflightKeys;
mInterface->getInflightBufferKeys(&inflightKeys);
- int32_t inputStreamId = (mInputStream != nullptr) ? mInputStream->getId() : -1;
+ // Inflight buffers for HAL buffer manager
+ std::vector<uint64_t> inflightRequestBufferKeys;
+ mInterface->getInflightRequestBufferKeys(&inflightRequestBufferKeys);
+
+ // (streamId, frameNumber, buffer_handle_t*) tuple for all inflight buffers.
+ // frameNumber will be -1 for buffers from HAL buffer manager
+ std::vector<std::tuple<int32_t, int32_t, buffer_handle_t*>> inflightBuffers;
+ inflightBuffers.reserve(inflightKeys.size() + inflightRequestBufferKeys.size());
+
for (auto& pair : inflightKeys) {
int32_t frameNumber = pair.first;
int32_t streamId = pair.second;
@@ -3281,6 +3298,26 @@
__FUNCTION__, frameNumber, streamId);
continue;
}
+ inflightBuffers.push_back(std::make_tuple(streamId, frameNumber, buffer));
+ }
+
+ for (auto& bufferId : inflightRequestBufferKeys) {
+ int32_t streamId = -1;
+ buffer_handle_t* buffer = nullptr;
+ status_t res = mInterface->popInflightRequestBuffer(bufferId, &buffer, &streamId);
+ if (res != OK) {
+ ALOGE("%s: cannot find in-flight buffer %" PRIu64, __FUNCTION__, bufferId);
+ continue;
+ }
+ inflightBuffers.push_back(std::make_tuple(streamId, /*frameNumber*/-1, buffer));
+ }
+
+ int32_t inputStreamId = (mInputStream != nullptr) ? mInputStream->getId() : -1;
+ for (auto& tuple : inflightBuffers) {
+ status_t res = OK;
+ int32_t streamId = std::get<0>(tuple);
+ int32_t frameNumber = std::get<1>(tuple);
+ buffer_handle_t* buffer = std::get<2>(tuple);
camera3_stream_buffer_t streamBuffer;
streamBuffer.buffer = buffer;
@@ -4583,6 +4620,17 @@
return;
}
+void Camera3Device::HalInterface::getInflightRequestBufferKeys(
+ std::vector<uint64_t>* out) {
+ std::lock_guard<std::mutex> lock(mRequestedBuffersLock);
+ out->clear();
+ out->reserve(mRequestedBuffers.size());
+ for (auto& pair : mRequestedBuffers) {
+ out->push_back(pair.first);
+ }
+ return;
+}
+
status_t Camera3Device::HalInterface::pushInflightBufferLocked(
int32_t frameNumber, int32_t streamId, buffer_handle_t *buffer, int acquireFence) {
uint64_t key = static_cast<uint64_t>(frameNumber) << 32 | static_cast<uint64_t>(streamId);
@@ -4610,9 +4658,9 @@
}
status_t Camera3Device::HalInterface::pushInflightRequestBuffer(
- uint64_t bufferId, buffer_handle_t* buf) {
+ uint64_t bufferId, buffer_handle_t* buf, int32_t streamId) {
std::lock_guard<std::mutex> lock(mRequestedBuffersLock);
- auto pair = mRequestedBuffers.insert({bufferId, buf});
+ auto pair = mRequestedBuffers.insert({bufferId, {streamId, buf}});
if (!pair.second) {
ALOGE("%s: bufId %" PRIu64 " is already inflight!",
__FUNCTION__, bufferId);
@@ -4623,7 +4671,13 @@
// Find and pop a buffer_handle_t based on bufferId
status_t Camera3Device::HalInterface::popInflightRequestBuffer(
- uint64_t bufferId, /*out*/ buffer_handle_t **buffer) {
+ uint64_t bufferId,
+ /*out*/ buffer_handle_t** buffer,
+ /*optional out*/ int32_t* streamId) {
+ if (buffer == nullptr) {
+ ALOGE("%s: buffer (%p) must not be null", __FUNCTION__, buffer);
+ return BAD_VALUE;
+ }
std::lock_guard<std::mutex> lock(mRequestedBuffersLock);
auto it = mRequestedBuffers.find(bufferId);
if (it == mRequestedBuffers.end()) {
@@ -4631,7 +4685,10 @@
__FUNCTION__, bufferId);
return BAD_VALUE;
}
- *buffer = it->second;
+ *buffer = it->second.second;
+ if (streamId != nullptr) {
+ *streamId = it->second.first;
+ }
mRequestedBuffers.erase(it);
return OK;
}
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index b25d89d..d3bb212 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -320,16 +320,22 @@
status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
/*out*/ buffer_handle_t **buffer);
- // Register a bufId/buffer_handle_t to inflight request buffer
- status_t pushInflightRequestBuffer(uint64_t bufferId, buffer_handle_t* buf);
+ // Register a bufId (streamId, buffer_handle_t) to inflight request buffer
+ status_t pushInflightRequestBuffer(
+ uint64_t bufferId, buffer_handle_t* buf, int32_t streamId);
// Find a buffer_handle_t based on bufferId
- status_t popInflightRequestBuffer(uint64_t bufferId, /*out*/ buffer_handle_t **buffer);
+ status_t popInflightRequestBuffer(uint64_t bufferId,
+ /*out*/ buffer_handle_t** buffer,
+ /*optional out*/ int32_t* streamId = nullptr);
// Get a vector of (frameNumber, streamId) pair of currently inflight
// buffers
void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);
+ // Get a vector of bufferId of currently inflight buffers
+ void getInflightRequestBufferKeys(std::vector<uint64_t>* out);
+
static const uint64_t BUFFER_ID_NO_BUFFER = 0;
private:
// Always valid
@@ -398,7 +404,7 @@
// Buffers given to HAL through requestStreamBuffer API
std::mutex mRequestedBuffersLock;
- std::unordered_map<uint64_t, buffer_handle_t*> mRequestedBuffers;
+ std::unordered_map<uint64_t, std::pair<int32_t, buffer_handle_t*>> mRequestedBuffers;
uint32_t mNextStreamConfigCounter = 1;
diff --git a/services/camera/libcameraservice/hidl/AidlCameraServiceListener.h b/services/camera/libcameraservice/hidl/AidlCameraServiceListener.h
index ca9143d..0f6be79 100644
--- a/services/camera/libcameraservice/hidl/AidlCameraServiceListener.h
+++ b/services/camera/libcameraservice/hidl/AidlCameraServiceListener.h
@@ -50,6 +50,10 @@
virtual ::android::binder::Status onTorchStatusChanged(
int32_t status, const ::android::String16& cameraId) override;
+ virtual binder::Status onCameraAccessPrioritiesChanged() {
+ // TODO: no implementation yet.
+ return binder::Status::ok();
+ }
};
} // implementation
diff --git a/services/mediaextractor/Android.mk b/services/mediaextractor/Android.mk
index 65fcf40..661a475 100644
--- a/services/mediaextractor/Android.mk
+++ b/services/mediaextractor/Android.mk
@@ -6,7 +6,7 @@
LOCAL_SRC_FILES := \
MediaExtractorService.cpp
-LOCAL_SHARED_LIBRARIES := libmedia libstagefright libbinder libutils liblog
+LOCAL_SHARED_LIBRARIES := libmedia libstagefright libbinder libutils
LOCAL_MODULE:= libmediaextractorservice
include $(BUILD_SHARED_LIBRARY)
@@ -21,7 +21,7 @@
LOCAL_SRC_FILES := main_extractorservice.cpp
LOCAL_SHARED_LIBRARIES := libmedia libmediaextractorservice libbinder libutils \
- liblog libbase libandroidicu libavservices_minijail
+ liblog libandroidicu libavservices_minijail
LOCAL_STATIC_LIBRARIES := libicuandroid_utils
LOCAL_MODULE:= mediaextractor
LOCAL_INIT_RC := mediaextractor.rc