Merge "EffectProxy return the active sub-effect descriptor" into main
diff --git a/camera/ndk/impl/ACameraMetadata.cpp b/camera/ndk/impl/ACameraMetadata.cpp
index 4995dc4..1fd4a86 100644
--- a/camera/ndk/impl/ACameraMetadata.cpp
+++ b/camera/ndk/impl/ACameraMetadata.cpp
@@ -400,7 +400,6 @@
camera_metadata_ro_entry rawEntry = static_cast<const CameraMetadata*>(mData.get())->find(tag);
if (rawEntry.count == 0) {
- ALOGE("%s: cannot find metadata tag %d", __FUNCTION__, tag);
return ACAMERA_ERROR_METADATA_NOT_FOUND;
}
entry->tag = tag;
diff --git a/cmds/stagefright/stagefright.cpp b/cmds/stagefright/stagefright.cpp
index 2edc0fe..379f244 100644
--- a/cmds/stagefright/stagefright.cpp
+++ b/cmds/stagefright/stagefright.cpp
@@ -106,6 +106,12 @@
decodeTimesUs->sort(CompareIncreasing);
size_t n = decodeTimesUs->size();
+
+ if (n == 0) {
+ printf("no decode histogram to display\n");
+ return;
+ }
+
int64_t minUs = decodeTimesUs->itemAt(0);
int64_t maxUs = decodeTimesUs->itemAt(n - 1);
diff --git a/drm/libmediadrmrkp/Android.bp b/drm/libmediadrmrkp/Android.bp
index e4a7a81..f13eb62 100644
--- a/drm/libmediadrmrkp/Android.bp
+++ b/drm/libmediadrmrkp/Android.bp
@@ -9,9 +9,15 @@
],
shared_libs: [
"libbinder_ndk",
+ "libcrypto",
"liblog",
+ ],
+ static_libs: [
+ "android.hardware.common-V2-ndk",
"android.hardware.drm-V1-ndk",
"android.hardware.security.rkp-V3-ndk",
+ "libbase",
+ "libcppbor_external",
],
defaults: [
"keymint_use_latest_hal_aidl_ndk_shared",
@@ -30,10 +36,13 @@
shared_libs: [
"libbinder_ndk",
"liblog",
- "android.hardware.drm-V1-ndk",
- "android.hardware.security.rkp-V3-ndk",
],
static_libs: [
+ "android.hardware.common-V2-ndk",
+ "android.hardware.drm-V1-ndk",
+ "android.hardware.security.rkp-V3-ndk",
+ "libbase",
+ "libcppbor_external",
"libmediadrmrkp",
],
vendor: true,
diff --git a/drm/libmediadrmrkp/include/DrmRemotelyProvisionedComponent.h b/drm/libmediadrmrkp/include/DrmRemotelyProvisionedComponent.h
index 893f560..f046785 100644
--- a/drm/libmediadrmrkp/include/DrmRemotelyProvisionedComponent.h
+++ b/drm/libmediadrmrkp/include/DrmRemotelyProvisionedComponent.h
@@ -20,6 +20,7 @@
#include <aidl/android/hardware/drm/IDrmPlugin.h>
#include <aidl/android/hardware/security/keymint/BnRemotelyProvisionedComponent.h>
#include <aidl/android/hardware/security/keymint/RpcHardwareInfo.h>
+#include <cppbor.h>
namespace android::mediadrm {
@@ -34,7 +35,7 @@
class DrmRemotelyProvisionedComponent : public BnRemotelyProvisionedComponent {
public:
DrmRemotelyProvisionedComponent(std::shared_ptr<IDrmPlugin> drm, std::string drmVendor,
- std::string drmDesc);
+ std::string drmDesc, std::vector<uint8_t> bcc);
ScopedAStatus getHardwareInfo(RpcHardwareInfo* info) override;
ScopedAStatus generateEcdsaP256KeyPair(bool testMode, MacedPublicKey* macedPublicKey,
@@ -52,9 +53,13 @@
std::vector<uint8_t>* csr) override;
private:
+ ScopedAStatus getVerifiedDeviceInfo(cppbor::Map& deviceInfoMap);
+ ScopedAStatus getDeviceInfo(std::vector<uint8_t>* deviceInfo);
+
std::shared_ptr<IDrmPlugin> mDrm;
std::string mDrmVendor;
std::string mDrmDesc;
+ std::vector<uint8_t> mBcc;
};
} // namespace android::mediadrm
diff --git a/drm/libmediadrmrkp/src/DrmRemotelyProvisionedComponent.cpp b/drm/libmediadrmrkp/src/DrmRemotelyProvisionedComponent.cpp
index 9d11811..440be79 100644
--- a/drm/libmediadrmrkp/src/DrmRemotelyProvisionedComponent.cpp
+++ b/drm/libmediadrmrkp/src/DrmRemotelyProvisionedComponent.cpp
@@ -16,13 +16,24 @@
#define LOG_TAG "DrmRemotelyProvisionedComponent"
#include "DrmRemotelyProvisionedComponent.h"
+
+#include <android-base/properties.h>
+#include <cppbor.h>
+#include <cppbor_parse.h>
#include <log/log.h>
+#include <map>
+#include <string>
namespace android::mediadrm {
DrmRemotelyProvisionedComponent::DrmRemotelyProvisionedComponent(std::shared_ptr<IDrmPlugin> drm,
std::string drmVendor,
- std::string drmDesc)
- : mDrm(std::move(drm)), mDrmVendor(std::move(drmVendor)), mDrmDesc(std::move(drmDesc)) {}
+ std::string drmDesc,
+ std::vector<uint8_t> bcc)
+ : mDrm(std::move(drm)),
+ mDrmVendor(std::move(drmVendor)),
+ mDrmDesc(std::move(drmDesc)),
+ mBcc(std::move(bcc)) {}
+
ScopedAStatus DrmRemotelyProvisionedComponent::getHardwareInfo(RpcHardwareInfo* info) {
info->versionNumber = 3;
info->rpcAuthorName = mDrmVendor;
@@ -47,10 +58,79 @@
"generateCertificateRequest not supported."));
}
+ScopedAStatus DrmRemotelyProvisionedComponent::getVerifiedDeviceInfo(cppbor::Map& deviceInfoMap) {
+ std::vector<uint8_t> verifiedDeviceInfo;
+ auto status = mDrm->getPropertyByteArray("verifiedDeviceInfo", &verifiedDeviceInfo);
+ if (!status.isOk()) {
+ ALOGE("getPropertyByteArray verifiedDeviceInfo failed. Details: [%s].",
+ status.getDescription().c_str());
+ return status;
+ }
+
+ auto [parsed, _, err] = cppbor::parse(
+ reinterpret_cast<const uint8_t*>(verifiedDeviceInfo.data()), verifiedDeviceInfo.size());
+
+ if (!parsed || !parsed->asMap()) {
+ ALOGE("Failed to parse the verified device info cbor: %s", err.c_str());
+ return ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(
+ IRemotelyProvisionedComponent::STATUS_FAILED,
+ "Failed to parse the verified device info cbor."));
+ }
+
+ const cppbor::Map* verifiedDeviceInfoMap = parsed->asMap();
+ for (size_t i = 0; i < verifiedDeviceInfoMap->size(); i++) {
+ auto& [keyItem, valueItem] = (*verifiedDeviceInfoMap)[i];
+ ALOGI("Found device info %s", keyItem->asTstr()->value().data());
+ if (valueItem != nullptr && valueItem->asTstr() != nullptr &&
+ valueItem->asTstr()->value().empty()) {
+ ALOGI("Value is empty. Skip");
+ continue;
+ }
+ deviceInfoMap.add(keyItem->clone(), valueItem->clone());
+ }
+
+ return ScopedAStatus::ok();
+}
+
+ScopedAStatus DrmRemotelyProvisionedComponent::getDeviceInfo(std::vector<uint8_t>* deviceInfo) {
+ auto deviceInfoMap = cppbor::Map();
+ auto status = getVerifiedDeviceInfo(deviceInfoMap);
+ if (!status.isOk()) {
+ ALOGE("getVerifiedDeviceInfo failed. Details: [%s].", status.getDescription().c_str());
+ return status;
+ }
+ const std::map<std::string, std::string> keyToProp{{"brand", "ro.product.brand"},
+ {"manufacturer", "ro.product.manufacturer"},
+ {"model", "ro.product.model"},
+ {"device", "ro.product.device"},
+ {"product", "ro.product.name"}};
+ for (auto i : keyToProp) {
+ auto key = i.first;
+ auto prop = i.second;
+ const auto& val= deviceInfoMap.get(key);
+ if (val == nullptr || val->asTstr()->value().empty()) {
+ std::string propValue = android::base::GetProperty(prop, "");
+ if (propValue.empty()) {
+ ALOGE("Failed to get OS property %s", prop.c_str());
+ return ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(
+ IRemotelyProvisionedComponent::STATUS_FAILED,
+ "Failed to get OS property."));
+ }
+ deviceInfoMap.add(cppbor::Tstr(key), cppbor::Tstr(propValue));
+ ALOGI("use OS property %s: %s", prop.c_str(), propValue.c_str());
+ } else {
+ ALOGI("use verified key %s: %s", key.c_str(), val->asTstr()->value().data());
+ }
+ }
+ deviceInfoMap.canonicalize();
+ *deviceInfo = deviceInfoMap.encode();
+ return ScopedAStatus::ok();
+}
+
ScopedAStatus DrmRemotelyProvisionedComponent::generateCertificateRequestV2(
const std::vector<MacedPublicKey>&, const std::vector<uint8_t>& challenge,
- std::vector<uint8_t>* csr) {
- // extract csr using setPropertyByteArray/getPropertyByteArray
+ std::vector<uint8_t>* out) {
+ // access csr input/output via setPropertyByteArray/getPropertyByteArray
auto status = mDrm->setPropertyByteArray("certificateSigningRequestChallenge", challenge);
if (!status.isOk()) {
ALOGE("setPropertyByteArray certificateSigningRequestChallenge failed. Details: [%s].",
@@ -58,13 +138,35 @@
return status;
}
- status = mDrm->getPropertyByteArray("certificateSigningRequest", csr);
+ std::vector<uint8_t> deviceInfo;
+ status = getDeviceInfo(&deviceInfo);
if (!status.isOk()) {
- ALOGE("getPropertyByteArray certificateSigningRequest failed. Details: [%s].",
+ ALOGE("getDeviceInfo failed. Details: [%s].", status.getDescription().c_str());
+ return status;
+ }
+
+ status = mDrm->setPropertyByteArray("deviceInfo", deviceInfo);
+ if (!status.isOk()) {
+ ALOGE("setPropertyByteArray deviceInfo failed. Details: [%s].",
status.getDescription().c_str());
return status;
}
+ std::vector<uint8_t> deviceSignedCsrPayload;
+ status = mDrm->getPropertyByteArray("deviceSignedCsrPayload", &deviceSignedCsrPayload);
+ if (!status.isOk()) {
+ ALOGE("getPropertyByteArray deviceSignedCsrPayload failed. Details: [%s].",
+ status.getDescription().c_str());
+ return status;
+ }
+
+ // assemble AuthenticatedRequest (definition in IRemotelyProvisionedComponent.aidl)
+ *out = cppbor::Array()
+ .add(1 /* version */)
+ .add(cppbor::Map() /* UdsCerts */)
+ .add(cppbor::EncodedItem(mBcc))
+ .add(cppbor::EncodedItem(std::move(deviceSignedCsrPayload)))
+ .encode();
return ScopedAStatus::ok();
}
} // namespace android::mediadrm
\ No newline at end of file
diff --git a/drm/libmediadrmrkp/src/DrmRkpAdapter.cpp b/drm/libmediadrmrkp/src/DrmRkpAdapter.cpp
index a2d4cc1..515d157 100644
--- a/drm/libmediadrmrkp/src/DrmRkpAdapter.cpp
+++ b/drm/libmediadrmrkp/src/DrmRkpAdapter.cpp
@@ -79,12 +79,21 @@
return;
}
- std::string compName = "DrmRemotelyProvisionedComponent_" + std::string(instance);
+ std::vector<uint8_t> bcc;
+ status = mDrm->getPropertyByteArray("bootCertificateChain", &bcc);
+ if (!status.isOk()) {
+ ALOGE("mDrm->getPropertyByteArray(\"bootCertificateChain\") failed."
+ "Detail: [%s].",
+ status.getDescription().c_str());
+ return;
+ }
+
+ std::string compName(instance);
auto comps = static_cast<
std::map<std::string, std::shared_ptr<IRemotelyProvisionedComponent>>*>(
context);
(*comps)[compName] = ::ndk::SharedRefBase::make<DrmRemotelyProvisionedComponent>(
- mDrm, drmVendor, drmDesc);
+ mDrm, drmVendor, drmDesc, bcc);
});
return comps;
}
diff --git a/include/media/VolumeShaper.h b/include/media/VolumeShaper.h
index 5271e10..6208db3 100644
--- a/include/media/VolumeShaper.h
+++ b/include/media/VolumeShaper.h
@@ -1099,7 +1099,7 @@
* internal to the VolumeHandler.
*/
void setIdIfNecessary(const sp<VolumeShaper::Configuration> &configuration) {
- if (configuration->getType() == VolumeShaper::Configuration::TYPE_SCALE) {
+ if (configuration && configuration->getType() == VolumeShaper::Configuration::TYPE_SCALE) {
const int id = configuration->getId();
if (id == -1) {
// Reassign to a unique id, skipping system ids.
diff --git a/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp b/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
index bb6c1b8..f428fce 100644
--- a/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
+++ b/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
@@ -83,7 +83,7 @@
}
// Default scenario --- the consumer is display or GPU
- const AHardwareBuffer_Desc desc = {
+ const AHardwareBuffer_Desc consumableForDisplayOrGpu = {
.width = 320,
.height = 240,
.format = format,
@@ -98,7 +98,7 @@
};
// The consumer is a HW encoder
- const AHardwareBuffer_Desc descHwEncoder = {
+ const AHardwareBuffer_Desc consumableForHwEncoder = {
.width = 320,
.height = 240,
.format = format,
@@ -114,7 +114,7 @@
};
// The consumer is a SW encoder
- const AHardwareBuffer_Desc descSwEncoder = {
+ const AHardwareBuffer_Desc consumableForSwEncoder = {
.width = 320,
.height = 240,
.format = format,
@@ -128,9 +128,9 @@
.rfu1 = 0,
};
- return AHardwareBuffer_isSupported(&desc)
- && AHardwareBuffer_isSupported(&descHwEncoder)
- && AHardwareBuffer_isSupported(&descSwEncoder);
+ return AHardwareBuffer_isSupported(&consumableForDisplayOrGpu)
+ && AHardwareBuffer_isSupported(&consumableForHwEncoder)
+ && AHardwareBuffer_isSupported(&consumableForSwEncoder);
}
} // namespace android
diff --git a/media/libaaudio/src/core/AudioStream.cpp b/media/libaaudio/src/core/AudioStream.cpp
index 56ef1e6..e0fd325 100644
--- a/media/libaaudio/src/core/AudioStream.cpp
+++ b/media/libaaudio/src/core/AudioStream.cpp
@@ -134,7 +134,8 @@
.set(AMEDIAMETRICS_PROP_ENCODINGHARDWARE,
android::toString(getHardwareFormat()).c_str())
.set(AMEDIAMETRICS_PROP_CHANNELCOUNTHARDWARE, (int32_t)getHardwareSamplesPerFrame())
- .set(AMEDIAMETRICS_PROP_SAMPLERATEHARDWARE, (int32_t)getHardwareSampleRate());
+ .set(AMEDIAMETRICS_PROP_SAMPLERATEHARDWARE, (int32_t)getHardwareSampleRate())
+ .set(AMEDIAMETRICS_PROP_SAMPLERATECLIENT, (int32_t)getSampleRate());
if (getDirection() == AAUDIO_DIRECTION_OUTPUT) {
item.set(AMEDIAMETRICS_PROP_PLAYERIID, mPlayerBase->getPlayerIId());
diff --git a/media/libaudioclient/aidl/fuzzer/Android.bp b/media/libaudioclient/aidl/fuzzer/Android.bp
index 1ca3042..67258d9 100644
--- a/media/libaudioclient/aidl/fuzzer/Android.bp
+++ b/media/libaudioclient/aidl/fuzzer/Android.bp
@@ -20,11 +20,8 @@
"android.hardware.audio.common@7.0-enums",
"effect-aidl-cpp",
"liblog",
- "libbinder_random_parcel",
- "libbase",
"libcgrouprc",
"libcgrouprc_format",
- "libcutils",
"libjsoncpp",
"libmediametricsservice",
"libmedia_helper",
@@ -55,14 +52,11 @@
"libaudiopolicy",
"libaudioutils",
"libdl",
- "libutils",
"libxml2",
"mediametricsservice-aidl-cpp",
"framework-permission-aidl-cpp",
"libvndksupport",
"libmediametrics",
- "libbinder_ndk",
- "libbinder",
"libfakeservicemanager",
"libactivitymanager_aidl",
"libheadtracking",
@@ -100,5 +94,8 @@
cc_fuzz {
name: "audioflinger_aidl_fuzzer",
srcs: ["audioflinger_aidl_fuzzer.cpp"],
- defaults: ["libaudioclient_aidl_fuzzer_defaults"],
+ defaults: [
+ "libaudioclient_aidl_fuzzer_defaults",
+ "service_fuzzer_defaults"
+ ],
}
diff --git a/media/libaudioclient/tests/audiorouting_tests.cpp b/media/libaudioclient/tests/audiorouting_tests.cpp
index 19d1abc..e6916cc 100644
--- a/media/libaudioclient/tests/audiorouting_tests.cpp
+++ b/media/libaudioclient/tests/audiorouting_tests.cpp
@@ -53,7 +53,7 @@
ASSERT_NE(nullptr, ap);
ASSERT_EQ(OK, ap->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
<< "Unable to open Resource";
- EXPECT_EQ(OK, ap->create()) << "track creation failed";
+ ASSERT_EQ(OK, ap->create()) << "track creation failed";
sp<OnAudioDeviceUpdateNotifier> cb = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, ap->getAudioTrackHandle()->addAudioDeviceCallback(cb));
EXPECT_EQ(OK, ap->start()) << "audio track start failed";
@@ -87,7 +87,7 @@
sp<AudioCapture> capture = sp<AudioCapture>::make(
AUDIO_SOURCE_REMOTE_SUBMIX, 48000, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO);
ASSERT_NE(nullptr, capture);
- EXPECT_EQ(OK, capture->create()) << "record creation failed";
+ ASSERT_EQ(OK, capture->create()) << "record creation failed";
sp<OnAudioDeviceUpdateNotifier> cbCapture = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, capture->getAudioRecordHandle()->addAudioDeviceCallback(cbCapture));
@@ -98,7 +98,7 @@
ASSERT_NE(nullptr, playback);
ASSERT_EQ(OK, playback->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
<< "Unable to open Resource";
- EXPECT_EQ(OK, playback->create()) << "track creation failed";
+ ASSERT_EQ(OK, playback->create()) << "track creation failed";
sp<OnAudioDeviceUpdateNotifier> cbPlayback = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, playback->getAudioTrackHandle()->addAudioDeviceCallback(cbPlayback));
@@ -180,7 +180,7 @@
ASSERT_NE(nullptr, playback);
ASSERT_EQ(OK, playback->loadResource("/data/local/tmp/bbb_2ch_24kHz_s16le.raw"))
<< "Unable to open Resource";
- EXPECT_EQ(OK, playback->create()) << "track creation failed";
+ ASSERT_EQ(OK, playback->create()) << "track creation failed";
sp<OnAudioDeviceUpdateNotifier> cbPlayback = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, playback->getAudioTrackHandle()->addAudioDeviceCallback(cbPlayback));
@@ -188,7 +188,7 @@
sp<AudioCapture> captureA = sp<AudioCapture>::make(
AUDIO_SOURCE_REMOTE_SUBMIX, 48000, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO);
ASSERT_NE(nullptr, captureA);
- EXPECT_EQ(OK, captureA->create()) << "record creation failed";
+ ASSERT_EQ(OK, captureA->create()) << "record creation failed";
sp<OnAudioDeviceUpdateNotifier> cbCaptureA = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, captureA->getAudioRecordHandle()->addAudioDeviceCallback(cbCaptureA));
@@ -199,7 +199,7 @@
AUDIO_SOURCE_REMOTE_SUBMIX, 48000, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
AUDIO_INPUT_FLAG_NONE, AUDIO_SESSION_ALLOCATE, AudioRecord::TRANSFER_CALLBACK, &attr);
ASSERT_NE(nullptr, captureB);
- EXPECT_EQ(OK, captureB->create()) << "record creation failed";
+ ASSERT_EQ(OK, captureB->create()) << "record creation failed";
sp<OnAudioDeviceUpdateNotifier> cbCaptureB = sp<OnAudioDeviceUpdateNotifier>::make();
EXPECT_EQ(OK, captureB->getAudioRecordHandle()->addAudioDeviceCallback(cbCaptureB));
diff --git a/media/libeffects/visualizer/aidl/VisualizerContext.cpp b/media/libeffects/visualizer/aidl/VisualizerContext.cpp
index 5d0d08d..a1726ad 100644
--- a/media/libeffects/visualizer/aidl/VisualizerContext.cpp
+++ b/media/libeffects/visualizer/aidl/VisualizerContext.cpp
@@ -223,8 +223,7 @@
deltaSamples = kMaxCaptureBufSize;
}
- int32_t capturePoint;
- //capturePoint = (int32_t)mCaptureIdx - deltaSamples;
+ int32_t capturePoint, captureSamples = mCaptureSamples;
__builtin_sub_overflow((int32_t) mCaptureIdx, deltaSamples, &capturePoint);
// a negative capturePoint means we wrap the buffer.
if (capturePoint < 0) {
@@ -232,13 +231,14 @@
if (size > mCaptureSamples) {
size = mCaptureSamples;
}
+ // first part of two stages copy, capture to the end of buffer and reset the size/point
result.insert(result.end(), &mCaptureBuf[kMaxCaptureBufSize + capturePoint],
&mCaptureBuf[kMaxCaptureBufSize + capturePoint + size]);
- mCaptureSamples -= size;
+ captureSamples -= size;
capturePoint = 0;
}
result.insert(result.end(), &mCaptureBuf[capturePoint],
- &mCaptureBuf[capturePoint + mCaptureSamples]);
+ &mCaptureBuf[capturePoint + captureSamples]);
mLastCaptureIdx = mCaptureIdx;
return result;
}
diff --git a/media/libmediametrics/include/MediaMetricsConstants.h b/media/libmediametrics/include/MediaMetricsConstants.h
index f80a467..26aa375 100644
--- a/media/libmediametrics/include/MediaMetricsConstants.h
+++ b/media/libmediametrics/include/MediaMetricsConstants.h
@@ -184,6 +184,7 @@
#define AMEDIAMETRICS_PROP_PLAYERIID "playerIId" // int32 (-1 invalid/unset IID)
#define AMEDIAMETRICS_PROP_ROUTEDDEVICEID "routedDeviceId" // int32
#define AMEDIAMETRICS_PROP_SAMPLERATE "sampleRate" // int32
+#define AMEDIAMETRICS_PROP_SAMPLERATECLIENT "sampleRateClient" // int32
#define AMEDIAMETRICS_PROP_SAMPLERATEHARDWARE "sampleRateHardware" // int32
#define AMEDIAMETRICS_PROP_SELECTEDDEVICEID "selectedDeviceId" // int32
#define AMEDIAMETRICS_PROP_SELECTEDMICDIRECTION "selectedMicDirection" // int32
diff --git a/media/libmediaplayerservice/MediaPlayerService.cpp b/media/libmediaplayerservice/MediaPlayerService.cpp
index 73c3390..2e1fdcf 100644
--- a/media/libmediaplayerservice/MediaPlayerService.cpp
+++ b/media/libmediaplayerservice/MediaPlayerService.cpp
@@ -2627,6 +2627,16 @@
Mutex::Autolock lock(mLock);
ALOGV("AudioOutput::applyVolumeShaper");
+ if (configuration == nullptr) {
+ ALOGE("AudioOutput::applyVolumeShaper Null configuration parameter");
+ return VolumeShaper::Status(BAD_VALUE);
+ }
+
+ if (operation == nullptr) {
+ ALOGE("AudioOutput::applyVolumeShaper Null operation parameter");
+ return VolumeShaper::Status(BAD_VALUE);
+ }
+
mVolumeHandler->setIdIfNecessary(configuration);
VolumeShaper::Status status;
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 28d554f..a0d56f8 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -6183,7 +6183,9 @@
// presentation timestamp is used instead, which almost certainly occurs in the past,
// since it's almost always a zero-based offset from the start of the stream. In these
// scenarios, we expect the frame to be rendered with no delay.
- int64_t delayUs = noRenderTime ? 0 : renderTimeNs / 1000 - ALooper::GetNowUs();
+ int64_t nowUs = ALooper::GetNowUs();
+ int64_t renderTimeUs = renderTimeNs / 1000;
+ int64_t delayUs = renderTimeUs < nowUs ? 0 : renderTimeUs - nowUs;
delayUs += 100 * 1000; /* 100ms in microseconds */
status_t err =
mMsgPollForRenderedBuffers->postUnique(/* token= */ mMsgPollForRenderedBuffers,
diff --git a/media/mtp/MtpPacket.cpp b/media/mtp/MtpPacket.cpp
index f069a83..5faaac2 100644
--- a/media/mtp/MtpPacket.cpp
+++ b/media/mtp/MtpPacket.cpp
@@ -92,24 +92,46 @@
}
uint16_t MtpPacket::getUInt16(int offset) const {
- return ((uint16_t)mBuffer[offset + 1] << 8) | (uint16_t)mBuffer[offset];
+ if ((unsigned long)(offset+2) <= mBufferSize) {
+ return ((uint16_t)mBuffer[offset + 1] << 8) | (uint16_t)mBuffer[offset];
+ }
+ else {
+ ALOGE("offset for buffer read is greater than buffer size!");
+ abort();
+ }
}
uint32_t MtpPacket::getUInt32(int offset) const {
- return ((uint32_t)mBuffer[offset + 3] << 24) | ((uint32_t)mBuffer[offset + 2] << 16) |
- ((uint32_t)mBuffer[offset + 1] << 8) | (uint32_t)mBuffer[offset];
+ if ((unsigned long)(offset+4) <= mBufferSize) {
+ return ((uint32_t)mBuffer[offset + 3] << 24) | ((uint32_t)mBuffer[offset + 2] << 16) |
+ ((uint32_t)mBuffer[offset + 1] << 8) | (uint32_t)mBuffer[offset];
+ }
+ else {
+ ALOGE("offset for buffer read is greater than buffer size!");
+ abort();
+ }
}
void MtpPacket::putUInt16(int offset, uint16_t value) {
- mBuffer[offset++] = (uint8_t)(value & 0xFF);
- mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
+ if ((unsigned long)(offset+2) <= mBufferSize) {
+ mBuffer[offset++] = (uint8_t)(value & 0xFF);
+ mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
+ }
+ else {
+ ALOGE("offset for buffer write is greater than buffer size!");
+ }
}
void MtpPacket::putUInt32(int offset, uint32_t value) {
- mBuffer[offset++] = (uint8_t)(value & 0xFF);
- mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
- mBuffer[offset++] = (uint8_t)((value >> 16) & 0xFF);
- mBuffer[offset++] = (uint8_t)((value >> 24) & 0xFF);
+ if ((unsigned long)(offset+4) <= mBufferSize) {
+ mBuffer[offset++] = (uint8_t)(value & 0xFF);
+ mBuffer[offset++] = (uint8_t)((value >> 8) & 0xFF);
+ mBuffer[offset++] = (uint8_t)((value >> 16) & 0xFF);
+ mBuffer[offset++] = (uint8_t)((value >> 24) & 0xFF);
+ }
+ else {
+ ALOGE("offset for buffer write is greater than buffer size!");
+ }
}
uint16_t MtpPacket::getContainerCode() const {
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 0f4fedc..5929969 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -328,7 +328,6 @@
mTotalMemory(0),
mClientSharedHeapSize(kMinimumClientSharedHeapSizeBytes),
mGlobalEffectEnableTime(0),
- mPatchPanel(this),
mPatchCommandThread(sp<PatchCommandThread>::make()),
mDeviceEffectManager(sp<DeviceEffectManager>::make(*this)),
mMelReporter(sp<MelReporter>::make(*this)),
@@ -433,8 +432,8 @@
for (const auto& [trackId, secondaryOutputs] : trackSecondaryOutputs) {
size_t i = 0;
for (; i < mPlaybackThreads.size(); ++i) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
- Mutex::Autolock _tl(thread->mLock);
+ IAfPlaybackThread* thread = mPlaybackThreads.valueAt(i).get();
+ Mutex::Autolock _tl(thread->mutex());
sp<IAfTrack> track = thread->getTrackById_l(trackId);
if (track != nullptr) {
ALOGD("%s trackId: %u", __func__, trackId);
@@ -678,9 +677,9 @@
// at this stage, a MmapThread was created when openOutput() or openInput() was called by
// audio policy manager and we can retrieve it
- sp<MmapThread> thread = mMmapThreads.valueFor(io);
+ const sp<IAfMmapThread> thread = mMmapThreads.valueFor(io);
if (thread != 0) {
- interface = new MmapThreadHandle(thread);
+ interface = IAfMmapThread::createMmapStreamInterfaceAdapter(thread);
thread->configure(&localAttr, streamType, actualSessionId, callback, *deviceId, portId);
*handle = portId;
*sessionId = actualSessionId;
@@ -934,7 +933,7 @@
dev->dump(fd, args);
}
- mPatchPanel.dump(fd);
+ mPatchPanel->dump(fd);
mDeviceEffectManager->dump(fd);
@@ -1191,7 +1190,7 @@
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
+ IAfPlaybackThread* thread = checkPlaybackThread_l(output.outputId);
if (thread == NULL) {
ALOGE("no playback thread found for output handle %d", output.outputId);
lStatus = BAD_VALUE;
@@ -1200,14 +1199,14 @@
client = registerPid(clientPid);
- PlaybackThread *effectThread = NULL;
+ IAfPlaybackThread* effectThread = nullptr;
// check if an effect chain with the same session ID is present on another
// output thread and move it here.
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
+ sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
if (mPlaybackThreads.keyAt(i) != output.outputId) {
uint32_t sessions = t->hasAudioSession(sessionId);
- if (sessions & ThreadBase::EFFECT_SESSION) {
+ if (sessions & IAfThreadBase::EFFECT_SESSION) {
effectThread = t.get();
break;
}
@@ -1242,7 +1241,7 @@
if (lStatus == NO_ERROR) {
// no risk of deadlock because AudioFlinger::mLock is held
- Mutex::Autolock _dl(thread->mLock);
+ Mutex::Autolock _dl(thread->mutex());
// Connect secondary outputs. Failure on a secondary output must not imped the primary
// Any secondary output setup failure will lead to a desync between the AP and AF until
// the track is destroyed.
@@ -1250,7 +1249,7 @@
// move effect chain to this output thread if an effect on same session was waiting
// for a track to be created
if (effectThread != nullptr) {
- Mutex::Autolock _sl(effectThread->mLock);
+ Mutex::Autolock _sl(effectThread->mutex());
if (moveEffectChain_l(sessionId, effectThread, thread) == NO_ERROR) {
effectThreadId = thread->id();
effectIds = thread->getEffectIds_l(sessionId);
@@ -1310,7 +1309,7 @@
uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("sampleRate() unknown thread %d", ioHandle);
return 0;
@@ -1321,7 +1320,7 @@
audio_format_t AudioFlinger::format(audio_io_handle_t output) const
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
ALOGW("format() unknown thread %d", output);
return AUDIO_FORMAT_INVALID;
@@ -1332,7 +1331,7 @@
size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("frameCount() unknown thread %d", ioHandle);
return 0;
@@ -1345,7 +1344,7 @@
size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const
{
Mutex::Autolock _l(mLock);
- ThreadBase *thread = checkThread_l(ioHandle);
+ IAfThreadBase* const thread = checkThread_l(ioHandle);
if (thread == NULL) {
ALOGW("frameCountHAL() unknown thread %d", ioHandle);
return 0;
@@ -1356,7 +1355,7 @@
uint32_t AudioFlinger::latency(audio_io_handle_t output) const
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
ALOGW("latency(): no playback thread found for output handle %d", output);
return 0;
@@ -1585,7 +1584,7 @@
// assigned to HALs which do not have master mute support will apply master mute
// during the mix operation. Threads with HALs which do support master mute
// will simply ignore the setting.
- Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
+ std::vector<sp<VolumeInterface>> volumeInterfaces = getAllVolumeInterfaces_l();
for (size_t i = 0; i < volumeInterfaces.size(); i++) {
volumeInterfaces[i]->setMasterMute(muted);
}
@@ -1661,7 +1660,7 @@
"AUDIO_STREAM_PATCH must have full scale volume");
AutoMutex lock(mLock);
- VolumeInterface *volumeInterface = getVolumeInterface_l(output);
+ sp<VolumeInterface> volumeInterface = getVolumeInterface_l(output);
if (volumeInterface == NULL) {
return BAD_VALUE;
}
@@ -1676,7 +1675,7 @@
return BAD_VALUE;
}
AutoMutex lock(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == nullptr) {
return BAD_VALUE;
}
@@ -1689,7 +1688,7 @@
return BAD_VALUE;
}
AutoMutex lock(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == nullptr) {
return BAD_VALUE;
}
@@ -1764,7 +1763,7 @@
AutoMutex lock(mLock);
mStreamTypes[stream].mute = muted;
- Vector<VolumeInterface *> volumeInterfaces = getAllVolumeInterfaces_l();
+ std::vector<sp<VolumeInterface>> volumeInterfaces = getAllVolumeInterfaces_l();
for (size_t i = 0; i < volumeInterfaces.size(); i++) {
volumeInterfaces[i]->setStreamMute(stream, muted);
}
@@ -1783,7 +1782,7 @@
}
AutoMutex lock(mLock);
- VolumeInterface *volumeInterface = getVolumeInterface_l(output);
+ sp<VolumeInterface> volumeInterface = getVolumeInterface_l(output);
if (volumeInterface == NULL) {
return 0.0f;
}
@@ -1820,14 +1819,15 @@
// forwardAudioHwSyncToDownstreamPatches_l() must be called with AudioFlinger::mLock held
void AudioFlinger::forwardParametersToDownstreamPatches_l(
audio_io_handle_t upStream, const String8& keyValuePairs,
- const std::function<bool(const sp<PlaybackThread>&)>& useThread)
+ const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread)
{
- std::vector<PatchPanel::SoftwarePatch> swPatches;
- if (mPatchPanel.getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
+ std::vector<SoftwarePatch> swPatches;
+ if (mPatchPanel->getDownstreamSoftwarePatches(upStream, &swPatches) != OK) return;
ALOGV_IF(!swPatches.empty(), "%s found %zu downstream patches for stream ID %d",
__func__, swPatches.size(), upStream);
for (const auto& swPatch : swPatches) {
- sp<PlaybackThread> downStream = checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
+ const sp<IAfPlaybackThread> downStream =
+ checkPlaybackThread_l(swPatch.getPlaybackThreadHandle());
if (downStream != NULL && (useThread == nullptr || useThread(downStream))) {
downStream->setParameters(keyValuePairs);
}
@@ -1839,7 +1839,7 @@
const std::set<audio_io_handle_t>& streams)
{
for (const audio_io_handle_t stream : streams) {
- PlaybackThread *playbackThread = checkPlaybackThread_l(stream);
+ IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(stream);
if (playbackThread == nullptr || !playbackThread->isMsdDevice()) {
continue;
}
@@ -1962,7 +1962,7 @@
// hold a strong ref on thread in case closeOutput() or closeInput() is called
// and the thread is exited once the lock is released
- sp<ThreadBase> thread;
+ sp<IAfThreadBase> thread;
{
Mutex::Autolock _l(mLock);
thread = checkPlaybackThread_l(ioHandle);
@@ -2011,11 +2011,11 @@
return out_s8;
}
- ThreadBase *thread = (ThreadBase *)checkPlaybackThread_l(ioHandle);
+ IAfThreadBase* thread = checkPlaybackThread_l(ioHandle);
if (thread == NULL) {
- thread = (ThreadBase *)checkRecordThread_l(ioHandle);
+ thread = checkRecordThread_l(ioHandle);
if (thread == NULL) {
- thread = (ThreadBase *)checkMmapThread_l(ioHandle);
+ thread = checkMmapThread_l(ioHandle);
if (thread == NULL) {
return String8("");
}
@@ -2111,7 +2111,7 @@
{
Mutex::Autolock _l(mLock);
- RecordThread *recordThread = checkRecordThread_l(ioHandle);
+ IAfRecordThread* const recordThread = checkRecordThread_l(ioHandle);
if (recordThread != NULL) {
return recordThread->getInputFramesLost();
}
@@ -2151,7 +2151,7 @@
{
Mutex::Autolock _l(mLock);
- PlaybackThread *playbackThread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const playbackThread = checkPlaybackThread_l(output);
if (playbackThread != NULL) {
return playbackThread->getRenderPosition(halFrames, dspFrames);
}
@@ -2277,10 +2277,10 @@
}
// getEffectThread_l() must be called with AudioFlinger::mLock held
-sp<AudioFlinger::ThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
+sp<IAfThreadBase> AudioFlinger::getEffectThread_l(audio_session_t sessionId,
int effectId)
{
- sp<ThreadBase> thread;
+ sp<IAfThreadBase> thread;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, effectId) != 0) {
@@ -2483,7 +2483,7 @@
{
Mutex::Autolock _l(mLock);
- RecordThread *thread = checkRecordThread_l(output.inputId);
+ IAfRecordThread* const thread = checkRecordThread_l(output.inputId);
if (thread == NULL) {
ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
lStatus = FAILED_TRANSACTION;
@@ -2539,7 +2539,7 @@
// session and move it to this thread.
sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
if (chain != 0) {
- Mutex::Autolock _l2(thread->mLock);
+ Mutex::Autolock _l2(thread->mutex());
thread->addEffectChain_l(chain);
}
break;
@@ -2741,14 +2741,14 @@
uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = fastPlaybackThread_l();
+ IAfPlaybackThread* const thread = fastPlaybackThread_l();
return thread != NULL ? thread->sampleRate() : 0;
}
size_t AudioFlinger::getPrimaryOutputFrameCount()
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = fastPlaybackThread_l();
+ IAfPlaybackThread* const thread = fastPlaybackThread_l();
return thread != NULL ? thread->frameCountHAL() : 0;
}
@@ -2873,15 +2873,15 @@
mHwAvSyncIds.add(sessionId, value);
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i);
+ const sp<IAfPlaybackThread> thread = mPlaybackThreads.valueAt(i);
uint32_t sessions = thread->hasAudioSession(sessionId);
- if (sessions & ThreadBase::TRACK_SESSION) {
+ if (sessions & IAfThreadBase::TRACK_SESSION) {
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyStreamHwAvSync), value);
String8 keyValuePairs = param.toString();
thread->setParameters(keyValuePairs);
forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
- [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
+ [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
break;
}
}
@@ -2900,15 +2900,15 @@
}
mSystemReady = true;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mPlaybackThreads.valueAt(i).get();
thread->systemReady();
}
for (size_t i = 0; i < mRecordThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mRecordThreads.valueAt(i).get();
thread->systemReady();
}
for (size_t i = 0; i < mMmapThreads.size(); i++) {
- ThreadBase *thread = (ThreadBase *)mMmapThreads.valueAt(i).get();
+ IAfThreadBase* const thread = mMmapThreads.valueAt(i).get();
thread->systemReady();
}
@@ -2960,7 +2960,8 @@
}
// setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId)
+void AudioFlinger::setAudioHwSyncForSession_l(
+ IAfPlaybackThread* const thread, audio_session_t sessionId)
{
ssize_t index = mHwAvSyncIds.indexOfKey(sessionId);
if (index >= 0) {
@@ -2971,7 +2972,7 @@
String8 keyValuePairs = param.toString();
thread->setParameters(keyValuePairs);
forwardParametersToDownstreamPatches_l(thread->id(), keyValuePairs,
- [](const sp<PlaybackThread>& thread) { return thread->usesHwAvSync(); });
+ [](const sp<IAfPlaybackThread>& thread) { return thread->usesHwAvSync(); });
}
}
@@ -2979,7 +2980,7 @@
// ----------------------------------------------------------------------------
-sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
+sp<IAfThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t *halConfig,
audio_config_base_t *mixerConfig,
@@ -3037,43 +3038,45 @@
if (status == NO_ERROR) {
if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
- sp<MmapPlaybackThread> thread =
- new MmapPlaybackThread(this, *output, outHwDev, outputStream, mSystemReady);
+ const sp<IAfMmapPlaybackThread> thread = IAfMmapPlaybackThread::create(
+ this, *output, outHwDev, outputStream, mSystemReady);
mMmapThreads.add(*output, thread);
ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
*output, thread.get());
return thread;
} else {
- sp<PlaybackThread> thread;
+ sp<IAfPlaybackThread> thread;
if (flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) {
- thread = sp<BitPerfectThread>::make(this, outputStream, *output, mSystemReady);
+ thread = IAfPlaybackThread::createBitPerfectThread(
+ this, outputStream, *output, mSystemReady);
ALOGV("%s() created bit-perfect output: ID %d thread %p",
__func__, *output, thread.get());
} else if (flags & AUDIO_OUTPUT_FLAG_SPATIALIZER) {
- thread = new SpatializerThread(this, outputStream, *output,
+ thread = IAfPlaybackThread::createSpatializerThread(this, outputStream, *output,
mSystemReady, mixerConfig);
ALOGV("openOutput_l() created spatializer output: ID %d thread %p",
*output, thread.get());
} else if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
- thread = new OffloadThread(this, outputStream, *output,
+ thread = IAfPlaybackThread::createOffloadThread(this, outputStream, *output,
mSystemReady, halConfig->offload_info);
ALOGV("openOutput_l() created offload output: ID %d thread %p",
*output, thread.get());
} else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
|| !isValidPcmSinkFormat(halConfig->format)
|| !isValidPcmSinkChannelMask(halConfig->channel_mask)) {
- thread = new DirectOutputThread(this, outputStream, *output,
+ thread = IAfPlaybackThread::createDirectOutputThread(this, outputStream, *output,
mSystemReady, halConfig->offload_info);
ALOGV("openOutput_l() created direct output: ID %d thread %p",
*output, thread.get());
} else {
- thread = new MixerThread(this, outputStream, *output, mSystemReady);
+ thread = IAfPlaybackThread::createMixerThread(
+ this, outputStream, *output, mSystemReady);
ALOGV("openOutput_l() created mixer output: ID %d thread %p",
*output, thread.get());
}
mPlaybackThreads.add(*output, thread);
struct audio_patch patch;
- mPatchPanel.notifyStreamOpened(outHwDev, *output, &patch);
+ mPatchPanel->notifyStreamOpened(outHwDev, *output, &patch);
if (thread->isMsdDevice()) {
thread->setDownStreamPatch(&patch);
}
@@ -3119,12 +3122,12 @@
Mutex::Autolock _l(mLock);
- sp<ThreadBase> thread = openOutput_l(module, &output, &halConfig,
+ const sp<IAfThreadBase> thread = openOutput_l(module, &output, &halConfig,
&mixerConfig, deviceType, address, flags);
if (thread != 0) {
uint32_t latencyMs = 0;
if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
- PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
+ const auto playbackThread = thread->asIAfPlaybackThread();
latencyMs = playbackThread->latency();
// notify client processes of the new output creation
@@ -3142,8 +3145,7 @@
mHardwareStatus = AUDIO_HW_IDLE;
}
} else {
- MmapThread *mmapThread = (MmapThread *)thread.get();
- mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
+ thread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
}
response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
response->config = VALUE_OR_RETURN_STATUS(
@@ -3161,8 +3163,8 @@
audio_io_handle_t output2)
{
Mutex::Autolock _l(mLock);
- MixerThread *thread1 = checkMixerThread_l(output1);
- MixerThread *thread2 = checkMixerThread_l(output2);
+ IAfPlaybackThread* const thread1 = checkMixerThread_l(output1);
+ IAfPlaybackThread* const thread2 = checkMixerThread_l(output2);
if (thread1 == NULL || thread2 == NULL) {
ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
@@ -3171,7 +3173,8 @@
}
audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
- DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady);
+ const sp<IAfDuplicatingThread> thread = IAfDuplicatingThread::create(
+ this, thread1, id, mSystemReady);
thread->addOutputTrack(thread2);
mPlaybackThreads.add(id, thread);
// notify client processes of the new output creation
@@ -3188,8 +3191,8 @@
{
// keep strong reference on the playback thread so that
// it is not destroyed while exit() is executed
- sp<PlaybackThread> playbackThread;
- sp<MmapPlaybackThread> mmapThread;
+ sp<IAfPlaybackThread> playbackThread;
+ sp<IAfMmapPlaybackThread> mmapThread;
{
Mutex::Autolock _l(mLock);
playbackThread = checkPlaybackThread_l(output);
@@ -3198,12 +3201,12 @@
dumpToThreadLog_l(playbackThread);
- if (playbackThread->type() == ThreadBase::MIXER) {
+ if (playbackThread->type() == IAfThreadBase::MIXER) {
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
if (mPlaybackThreads.valueAt(i)->isDuplicating()) {
- DuplicatingThread *dupThread =
- (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
- dupThread->removeOutputTrack((MixerThread *)playbackThread.get());
+ IAfDuplicatingThread* const dupThread =
+ mPlaybackThreads.valueAt(i)->asIAfDuplicatingThread().get();
+ dupThread->removeOutputTrack(playbackThread.get());
}
}
}
@@ -3212,11 +3215,12 @@
mPlaybackThreads.removeItem(output);
// save all effects to the default thread
if (mPlaybackThreads.size()) {
- PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
+ IAfPlaybackThread* const dstThread =
+ checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
if (dstThread != NULL) {
// audioflinger lock is held so order of thread lock acquisition doesn't matter
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(playbackThread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(playbackThread->mutex());
Vector<sp<IAfEffectChain>> effectChains = playbackThread->getEffectChains_l();
for (size_t i = 0; i < effectChains.size(); i ++) {
moveEffectChain_l(effectChains[i]->sessionId(), playbackThread.get(),
@@ -3225,7 +3229,8 @@
}
}
} else {
- mmapThread = (MmapPlaybackThread *)checkMmapThread_l(output);
+ const sp<IAfMmapThread> mt = checkMmapThread_l(output);
+ mmapThread = mt ? mt->asIAfMmapPlaybackThread().get() : nullptr;
if (mmapThread == 0) {
return BAD_VALUE;
}
@@ -3234,10 +3239,10 @@
ALOGD("closing mmapThread %p", mmapThread.get());
}
ioConfigChanged(AUDIO_OUTPUT_CLOSED, sp<AudioIoDescriptor>::make(output));
- mPatchPanel.notifyStreamClosed(output);
+ mPatchPanel->notifyStreamClosed(output);
}
// The thread entity (active unit of execution) is no longer running here,
- // but the ThreadBase container still exists.
+ // but the IAfThreadBase container still exists.
if (playbackThread != 0) {
playbackThread->exit();
@@ -3255,7 +3260,7 @@
return NO_ERROR;
}
-void AudioFlinger::closeOutputFinish(const sp<PlaybackThread>& thread)
+void AudioFlinger::closeOutputFinish(const sp<IAfPlaybackThread>& thread)
{
AudioStreamOut *out = thread->clearOutput();
ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
@@ -3263,9 +3268,9 @@
delete out;
}
-void AudioFlinger::closeThreadInternal_l(const sp<PlaybackThread>& thread)
+void AudioFlinger::closeThreadInternal_l(const sp<IAfPlaybackThread>& thread)
{
- mPlaybackThreads.removeItem(thread->mId);
+ mPlaybackThreads.removeItem(thread->id());
thread->exit();
closeOutputFinish(thread);
}
@@ -3273,7 +3278,7 @@
status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
return BAD_VALUE;
@@ -3288,7 +3293,7 @@
status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
{
Mutex::Autolock _l(mLock);
- PlaybackThread *thread = checkPlaybackThread_l(output);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(output);
if (thread == NULL) {
return BAD_VALUE;
@@ -3317,7 +3322,7 @@
audio_config_t config = VALUE_OR_RETURN_STATUS(
aidl2legacy_AudioConfig_audio_config_t(request.config, true /*isInput*/));
- sp<ThreadBase> thread = openInput_l(
+ const sp<IAfThreadBase> thread = openInput_l(
VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(request.module)),
&input,
&config,
@@ -3341,7 +3346,7 @@
return NO_INIT;
}
-sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
+sp<IAfThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
audio_io_handle_t *input,
audio_config_t *config,
audio_devices_t devices,
@@ -3407,17 +3412,18 @@
if (status == NO_ERROR && inStream != 0) {
AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
- sp<MmapCaptureThread> thread =
- new MmapCaptureThread(this, *input, inHwDev, inputStream, mSystemReady);
+ const sp<IAfMmapCaptureThread> thread =
+ IAfMmapCaptureThread::create(this, *input, inHwDev, inputStream, mSystemReady);
mMmapThreads.add(*input, thread);
ALOGV("openInput_l() created mmap capture thread: ID %d thread %p", *input,
thread.get());
return thread;
} else {
// Start record thread
- // RecordThread requires both input and output device indication to forward to audio
- // pre processing modules
- sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);
+ // IAfRecordThread requires both input and output device indication
+ // to forward to audio pre processing modules
+ const sp<IAfRecordThread> thread =
+ IAfRecordThread::create(this, inputStream, *input, mSystemReady);
mRecordThreads.add(*input, thread);
ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get());
return thread;
@@ -3437,8 +3443,8 @@
{
// keep strong reference on the record thread so that
// it is not destroyed while exit() is executed
- sp<RecordThread> recordThread;
- sp<MmapCaptureThread> mmapThread;
+ sp<IAfRecordThread> recordThread;
+ sp<IAfMmapCaptureThread> mmapThread;
{
Mutex::Autolock _l(mLock);
recordThread = checkRecordThread_l(input);
@@ -3453,8 +3459,8 @@
// new capture on the same session
sp<IAfEffectChain> chain;
{
- Mutex::Autolock _sl(recordThread->mLock);
- Vector< sp<IAfEffectChain> > effectChains = recordThread->getEffectChains_l();
+ Mutex::Autolock _sl(recordThread->mutex());
+ const Vector<sp<IAfEffectChain>> effectChains = recordThread->getEffectChains_l();
// Note: maximum one chain per record thread
if (effectChains.size() != 0) {
chain = effectChains[0];
@@ -3466,12 +3472,12 @@
// creation of its replacement
size_t i;
for (i = 0; i < mRecordThreads.size(); i++) {
- sp<RecordThread> t = mRecordThreads.valueAt(i);
+ const sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
if (t == recordThread) {
continue;
}
if (t->hasAudioSession(chain->sessionId()) != 0) {
- Mutex::Autolock _l2(t->mLock);
+ Mutex::Autolock _l2(t->mutex());
ALOGV("closeInput() found thread %d for effect session %d",
t->id(), chain->sessionId());
t->addEffectChain_l(chain);
@@ -3485,7 +3491,8 @@
}
mRecordThreads.removeItem(input);
} else {
- mmapThread = (MmapCaptureThread *)checkMmapThread_l(input);
+ const sp<IAfMmapThread> mt = checkMmapThread_l(input);
+ mmapThread = mt ? mt->asIAfMmapCaptureThread().get() : nullptr;
if (mmapThread == 0) {
return BAD_VALUE;
}
@@ -3508,7 +3515,7 @@
return NO_ERROR;
}
-void AudioFlinger::closeInputFinish(const sp<RecordThread>& thread)
+void AudioFlinger::closeInputFinish(const sp<IAfRecordThread>& thread)
{
thread->exit();
AudioStreamIn *in = thread->clearInput();
@@ -3517,9 +3524,9 @@
delete in;
}
-void AudioFlinger::closeThreadInternal_l(const sp<RecordThread>& thread)
+void AudioFlinger::closeThreadInternal_l(const sp<IAfRecordThread>& thread)
{
- mRecordThreads.removeItem(thread->mId);
+ mRecordThreads.removeItem(thread->id());
closeInputFinish(thread);
}
@@ -3529,7 +3536,7 @@
std::set<audio_port_handle_t> portIdSet(portIds.begin(), portIds.end());
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
thread->invalidateTracks(portIdSet);
if (portIdSet.empty()) {
return NO_ERROR;
@@ -3649,14 +3656,15 @@
ALOGV("purging stale effects");
- Vector< sp<IAfEffectChain> > chains;
+ Vector<sp<IAfEffectChain>> chains;
std::vector< sp<IAfEffectModule> > removedEffects;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
if (!audio_is_global_session(ec->sessionId())) {
chains.push(ec);
}
@@ -3664,19 +3672,21 @@
}
for (size_t i = 0; i < mRecordThreads.size(); i++) {
- sp<RecordThread> t = mRecordThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ sp<IAfRecordThread> t = mRecordThreads.valueAt(i);
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
chains.push(ec);
}
}
for (size_t i = 0; i < mMmapThreads.size(); i++) {
- sp<MmapThread> t = mMmapThreads.valueAt(i);
- Mutex::Autolock _l(t->mLock);
- for (size_t j = 0; j < t->mEffectChains.size(); j++) {
- sp<IAfEffectChain> ec = t->mEffectChains[j];
+ const sp<IAfMmapThread> t = mMmapThreads.valueAt(i);
+ Mutex::Autolock _l(t->mutex());
+ const Vector<sp<IAfEffectChain>> threadChains = t->getEffectChains_l();
+ for (size_t j = 0; j < threadChains.size(); j++) {
+ sp<IAfEffectChain> ec = threadChains[j];
chains.push(ec);
}
}
@@ -3685,7 +3695,7 @@
// clang-tidy suggests const ref
sp<IAfEffectChain> ec = chains[i]; // NOLINT(performance-unnecessary-copy-initialization)
int sessionid = ec->sessionId();
- sp<ThreadBase> t = sp<ThreadBase>::cast(ec->thread().promote()); // TODO(b/288339104)
+ const auto t = ec->thread().promote();
if (t == 0) {
continue;
}
@@ -3701,7 +3711,7 @@
}
}
if (!found) {
- Mutex::Autolock _l(t->mLock);
+ Mutex::Autolock _l(t->mutex());
// remove all effects from the chain
while (ec->numberOfEffects()) {
sp<IAfEffectModule> effect = ec->getEffectModule(0);
@@ -3754,7 +3764,7 @@
}
// dumpToThreadLog_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::dumpToThreadLog_l(const sp<ThreadBase> &thread)
+void AudioFlinger::dumpToThreadLog_l(const sp<IAfThreadBase> &thread)
{
constexpr int THREAD_DUMP_TIMEOUT_MS = 2;
audio_utils::FdToString fdToString("- ", THREAD_DUMP_TIMEOUT_MS);
@@ -3766,9 +3776,9 @@
}
// checkThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
+IAfThreadBase* AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const
{
- ThreadBase *thread = checkMmapThread_l(ioHandle);
+ IAfThreadBase* thread = checkMmapThread_l(ioHandle);
if (thread == 0) {
switch (audio_unique_id_get_use(ioHandle)) {
case AUDIO_UNIQUE_ID_USE_OUTPUT:
@@ -3785,13 +3795,13 @@
}
// checkOutputThread_l() must be called with AudioFlinger::mLock held
-sp<AudioFlinger::ThreadBase> AudioFlinger::checkOutputThread_l(audio_io_handle_t ioHandle) const
+sp<IAfThreadBase> AudioFlinger::checkOutputThread_l(audio_io_handle_t ioHandle) const
{
if (audio_unique_id_get_use(ioHandle) != AUDIO_UNIQUE_ID_USE_OUTPUT) {
return nullptr;
}
- sp<AudioFlinger::ThreadBase> thread = mPlaybackThreads.valueFor(ioHandle);
+ sp<IAfThreadBase> thread = mPlaybackThreads.valueFor(ioHandle);
if (thread == nullptr) {
thread = mMmapThreads.valueFor(ioHandle);
}
@@ -3799,41 +3809,41 @@
}
// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
+IAfPlaybackThread* AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
{
return mPlaybackThreads.valueFor(output).get();
}
// checkMixerThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
+IAfPlaybackThread* AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
{
- PlaybackThread *thread = checkPlaybackThread_l(output);
- return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
+ IAfPlaybackThread * const thread = checkPlaybackThread_l(output);
+ return thread != nullptr && thread->type() != IAfThreadBase::DIRECT ? thread : nullptr;
}
// checkRecordThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
+IAfRecordThread* AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
{
return mRecordThreads.valueFor(input).get();
}
// checkMmapThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::MmapThread *AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
+IAfMmapThread* AudioFlinger::checkMmapThread_l(audio_io_handle_t io) const
{
return mMmapThreads.valueFor(io).get();
}
// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
-AudioFlinger::VolumeInterface *AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const
+sp<VolumeInterface> AudioFlinger::getVolumeInterface_l(audio_io_handle_t output) const
{
- VolumeInterface *volumeInterface = mPlaybackThreads.valueFor(output).get();
+ sp<VolumeInterface> volumeInterface = mPlaybackThreads.valueFor(output).get();
if (volumeInterface == nullptr) {
- MmapThread *mmapThread = mMmapThreads.valueFor(output).get();
+ IAfMmapThread* const mmapThread = mMmapThreads.valueFor(output).get();
if (mmapThread != nullptr) {
if (mmapThread->isOutput()) {
- MmapPlaybackThread *mmapPlaybackThread =
- static_cast<MmapPlaybackThread *>(mmapThread);
+ IAfMmapPlaybackThread* const mmapPlaybackThread =
+ mmapThread->asIAfMmapPlaybackThread().get();
volumeInterface = mmapPlaybackThread;
}
}
@@ -3841,17 +3851,17 @@
return volumeInterface;
}
-Vector <AudioFlinger::VolumeInterface *> AudioFlinger::getAllVolumeInterfaces_l() const
+std::vector<sp<VolumeInterface>> AudioFlinger::getAllVolumeInterfaces_l() const
{
- Vector <VolumeInterface *> volumeInterfaces;
+ std::vector<sp<VolumeInterface>> volumeInterfaces;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- volumeInterfaces.add(mPlaybackThreads.valueAt(i).get());
+ volumeInterfaces.push_back(mPlaybackThreads.valueAt(i).get());
}
for (size_t i = 0; i < mMmapThreads.size(); i++) {
if (mMmapThreads.valueAt(i)->isOutput()) {
- MmapPlaybackThread *mmapPlaybackThread =
- static_cast<MmapPlaybackThread *>(mMmapThreads.valueAt(i).get());
- volumeInterfaces.add(mmapPlaybackThread);
+ IAfMmapPlaybackThread* const mmapPlaybackThread =
+ mMmapThreads.valueAt(i)->asIAfMmapPlaybackThread().get();
+ volumeInterfaces.push_back(mmapPlaybackThread);
}
}
return volumeInterfaces;
@@ -3878,14 +3888,14 @@
// TODO Use a floor after wraparound. This may need a mutex.
}
-AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
+IAfPlaybackThread* AudioFlinger::primaryPlaybackThread_l() const
{
AutoMutex lock(mHardwareLock);
if (mPrimaryHardwareDev == nullptr) {
return nullptr;
}
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if(thread->isDuplicating()) {
continue;
}
@@ -3899,7 +3909,7 @@
DeviceTypeSet AudioFlinger::primaryOutputDevice_l() const
{
- PlaybackThread *thread = primaryPlaybackThread_l();
+ IAfPlaybackThread* const thread = primaryPlaybackThread_l();
if (thread == NULL) {
return {};
@@ -3908,12 +3918,12 @@
return thread->outDeviceTypes();
}
-AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const
+IAfPlaybackThread* AudioFlinger::fastPlaybackThread_l() const
{
size_t minFrameCount = 0;
- PlaybackThread *minThread = NULL;
+ IAfPlaybackThread* minThread = nullptr;
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if (!thread->isDuplicating()) {
size_t frameCount = thread->frameCountHAL();
if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount ||
@@ -3927,9 +3937,9 @@
return minThread;
}
-AudioFlinger::ThreadBase *AudioFlinger::hapticPlaybackThread_l() const {
+IAfThreadBase* AudioFlinger::hapticPlaybackThread_l() const {
for (size_t i = 0; i < mPlaybackThreads.size(); ++i) {
- PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
+ IAfPlaybackThread* const thread = mPlaybackThreads.valueAt(i).get();
if (thread->hapticChannelMask() != AUDIO_CHANNEL_NONE) {
return thread;
}
@@ -3939,11 +3949,11 @@
void AudioFlinger::updateSecondaryOutputsForTrack_l(
IAfTrack* track,
- PlaybackThread* thread,
+ IAfPlaybackThread* thread,
const std::vector<audio_io_handle_t> &secondaryOutputs) const {
TeePatches teePatches;
for (audio_io_handle_t secondaryOutput : secondaryOutputs) {
- PlaybackThread *secondaryThread = checkPlaybackThread_l(secondaryOutput);
+ IAfPlaybackThread* const secondaryThread = checkPlaybackThread_l(secondaryOutput);
if (secondaryThread == nullptr) {
ALOGE("no playback thread found for secondary output %d", thread->id());
continue;
@@ -3969,10 +3979,10 @@
// The frameCount should also not be smaller than the secondary thread min frame
// count
size_t minFrameCount = AudioSystem::calculateMinFrameCount(
- [&] { Mutex::Autolock _l(secondaryThread->mLock);
+ [&] { Mutex::Autolock _l(secondaryThread->mutex());
return secondaryThread->latency_l(); }(),
- secondaryThread->mNormalFrameCount,
- secondaryThread->mSampleRate,
+ secondaryThread->frameCount(), // normal frame count
+ secondaryThread->sampleRate(),
track->sampleRate(),
track->getSpeed());
frameCount = std::max(frameCount, minFrameCount);
@@ -4028,7 +4038,7 @@
patchTrack->setPeerProxy(patchRecord, true /* holdReference */);
patchRecord->setPeerProxy(patchTrack, false /* holdReference */);
}
- track->setTeePatchesToUpdate_l(&teePatches); // TODO(b/288339104) void* to std::move()
+ track->setTeePatchesToUpdate_l(std::move(teePatches));
}
sp<audioflinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
@@ -4221,7 +4231,7 @@
lStatus = BAD_VALUE;
goto Exit;
}
- PlaybackThread *thread = checkPlaybackThread_l(io);
+ IAfPlaybackThread* const thread = checkPlaybackThread_l(io);
if (thread == nullptr) {
ALOGE("%s: invalid output %d specified for AUDIO_SESSION_OUTPUT_STAGE", __func__, io);
lStatus = BAD_VALUE;
@@ -4318,7 +4328,7 @@
sp<Client> client = registerPid(currentPid);
ALOGV("%s device type %#x address %s", __func__, device.mType, device.getAddress());
handle = mDeviceEffectManager->createEffect_l(
- &descOut, device, client, effectClient, mPatchPanel.patches_l(),
+ &descOut, device, client, effectClient, mPatchPanel->patches_l(),
&enabledOut, &lStatus, probe, request.notifyFramesProcessed);
if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
// remove local strong reference to Client with mClientLock held
@@ -4390,7 +4400,7 @@
}
const uint32_t sessionType =
mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId);
- if ((sessionType & ThreadBase::EFFECT_SESSION) != 0) {
+ if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) {
ALOGE("%s: effect %s io %d denied because session %d effect exists on io %d",
__func__, descOut.name, (int) io, (int) sessionId, (int) checkIo);
android_errorWriteLog(0x534e4554, "123237974");
@@ -4399,7 +4409,7 @@
}
}
}
- ThreadBase *thread = checkRecordThread_l(io);
+ IAfThreadBase* thread = checkRecordThread_l(io);
if (thread == NULL) {
thread = checkPlaybackThread_l(io);
if (thread == NULL) {
@@ -4415,7 +4425,7 @@
// session and used it instead of creating a new one.
sp<IAfEffectChain> chain = getOrphanEffectChain_l(sessionId);
if (chain != 0) {
- Mutex::Autolock _l2(thread->mLock);
+ Mutex::Autolock _l2(thread->mutex());
thread->addEffectChain_l(chain);
}
}
@@ -4424,9 +4434,9 @@
// create effect on selected output thread
bool pinned = !audio_is_global_session(sessionId) && isSessionAcquired_l(sessionId);
- ThreadBase *oriThread = nullptr;
+ IAfThreadBase* oriThread = nullptr;
if (hapticPlaybackRequired && thread->hapticChannelMask() == AUDIO_CHANNEL_NONE) {
- ThreadBase *hapticThread = hapticPlaybackThread_l();
+ IAfThreadBase* const hapticThread = hapticPlaybackThread_l();
if (hapticThread == nullptr) {
ALOGE("%s haptic thread not found while it is required", __func__);
lStatus = INVALID_OPERATION;
@@ -4496,37 +4506,37 @@
ALOGW("%s() same dst and src outputs %d", __func__, dstIo);
return NO_ERROR;
}
- RecordThread *srcRecordThread = checkRecordThread_l(srcIo);
- RecordThread *dstRecordThread = checkRecordThread_l(dstIo);
+ IAfRecordThread* const srcRecordThread = checkRecordThread_l(srcIo);
+ IAfRecordThread* const dstRecordThread = checkRecordThread_l(dstIo);
if (srcRecordThread != nullptr || dstRecordThread != nullptr) {
if (srcRecordThread != nullptr) {
- srcRecordThread->mLock.lock();
+ srcRecordThread->mutex().lock();
}
if (dstRecordThread != nullptr) {
- dstRecordThread->mLock.lock();
+ dstRecordThread->mutex().lock();
}
status_t ret = moveEffectChain_l(sessionId, srcRecordThread, dstRecordThread);
if (srcRecordThread != nullptr) {
- srcRecordThread->mLock.unlock();
+ srcRecordThread->mutex().unlock();
}
if (dstRecordThread != nullptr) {
- dstRecordThread->mLock.unlock();
+ dstRecordThread->mutex().unlock();
}
return ret;
}
- PlaybackThread *srcThread = checkPlaybackThread_l(srcIo);
+ IAfPlaybackThread* const srcThread = checkPlaybackThread_l(srcIo);
if (srcThread == nullptr) {
ALOGW("%s() bad srcIo %d", __func__, srcIo);
return BAD_VALUE;
}
- PlaybackThread *dstThread = checkPlaybackThread_l(dstIo);
+ IAfPlaybackThread* const dstThread = checkPlaybackThread_l(dstIo);
if (dstThread == nullptr) {
ALOGW("%s() bad dstIo %d", __func__, dstIo);
return BAD_VALUE;
}
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(srcThread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(srcThread->mutex());
return moveEffectChain_l(sessionId, srcThread, dstThread);
}
@@ -4537,11 +4547,11 @@
{
Mutex::Autolock _l(mLock);
- sp<ThreadBase> thread = getEffectThread_l(sessionId, effectId);
+ sp<IAfThreadBase> thread = getEffectThread_l(sessionId, effectId);
if (thread == nullptr) {
return;
}
- Mutex::Autolock _sl(thread->mLock);
+ Mutex::Autolock _sl(thread->mutex());
sp<IAfEffectModule> effect = thread->getEffect_l(sessionId, effectId);
thread->setEffectSuspended_l(&effect->desc().type, suspended, sessionId);
}
@@ -4549,8 +4559,7 @@
// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
- AudioFlinger::PlaybackThread *srcThread,
- AudioFlinger::PlaybackThread *dstThread)
+ IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread)
NO_THREAD_SAFETY_ANALYSIS // requires srcThread and dstThread locks
{
ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
@@ -4663,13 +4672,12 @@
// moveEffectChain_l must be called with both srcThread (if not null) and dstThread (if not null)
// mLocks held
status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId,
- RecordThread *srcThread,
- RecordThread *dstThread)
+ IAfRecordThread* srcThread, IAfRecordThread* dstThread)
NO_THREAD_SAFETY_ANALYSIS // requires srcThread and dstThread locks
{
sp<IAfEffectChain> chain = nullptr;
if (srcThread != 0) {
- Vector< sp<IAfEffectChain> > effectChains = srcThread->getEffectChains_l();
+ const Vector<sp<IAfEffectChain>> effectChains = srcThread->getEffectChains_l();
for (size_t i = 0; i < effectChains.size(); i ++) {
if (effectChains[i]->sessionId() == sessionId) {
chain = effectChains[i];
@@ -4704,17 +4712,16 @@
}
status_t AudioFlinger::moveAuxEffectToIo(int EffectId,
- const sp<PlaybackThread>& dstThread,
- sp<PlaybackThread> *srcThread)
+ const sp<IAfPlaybackThread>& dstThread, sp<IAfPlaybackThread>* srcThread)
{
status_t status = NO_ERROR;
Mutex::Autolock _l(mLock);
- sp<PlaybackThread> thread =
- static_cast<PlaybackThread *>(getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId).get());
+ const sp<IAfThreadBase> threadBase = getEffectThread_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
+ const sp<IAfPlaybackThread> thread = threadBase ? threadBase->asIAfPlaybackThread() : nullptr;
if (EffectId != 0 && thread != 0 && dstThread != thread.get()) {
- Mutex::Autolock _dl(dstThread->mLock);
- Mutex::Autolock _sl(thread->mLock);
+ Mutex::Autolock _dl(dstThread->mutex());
+ Mutex::Autolock _sl(thread->mutex());
sp<IAfEffectChain> srcChain = thread->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
sp<IAfEffectChain> dstChain;
if (srcChain == 0) {
@@ -4778,8 +4785,8 @@
mGlobalEffectEnableTime = systemTime();
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
- sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
- if (t->mType == ThreadBase::OFFLOAD) {
+ const sp<IAfPlaybackThread> t = mPlaybackThreads.valueAt(i);
+ if (t->type() == IAfThreadBase::OFFLOAD) {
t->invalidateTracks(AUDIO_STREAM_MUSIC);
}
}
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index 0e7bd1b..e3910ea 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -98,10 +98,12 @@
#include <timing/SynchronizedRecordState.h>
#include <datapath/AudioHwDevice.h>
+#include <datapath/AudioStreamIn.h>
#include <datapath/AudioStreamOut.h>
#include <datapath/SpdifStreamOut.h>
#include <datapath/ThreadMetrics.h>
#include <datapath/TrackMetrics.h>
+#include <datapath/VolumeInterface.h>
#include <fastpath/FastCapture.h>
#include <fastpath/FastMixer.h>
#include <media/nbaio/NBAIO.h>
@@ -122,9 +124,16 @@
#include "ResamplerBufferProvider.h"
// include AudioFlinger component interfaces
+#include "IAfPatchPanel.h" // this should be listed before other IAf* interfaces.
#include "IAfEffect.h"
+#include "IAfThread.h"
#include "IAfTrack.h"
+// Classes that depend on IAf* interfaces but are not cross-dependent.
+#include "PatchCommandThread.h"
+#include "DeviceEffectManager.h"
+#include "MelReporter.h"
+
namespace android {
class AudioMixer;
@@ -143,14 +152,31 @@
static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
-#define INCLUDING_FROM_AUDIOFLINGER_H
-
using android::content::AttributionSourceState;
+struct stream_type_t {
+ float volume = 1.f;
+ bool mute = false;
+};
+
class AudioFlinger : public AudioFlingerServerAdapter::Delegate
{
friend class sp<AudioFlinger>;
+ // TODO(b/291319167) Create interface and remove friends.
friend class Client; // removeClient_l();
+ friend class DeviceEffectManager;
+ friend class DeviceEffectManagerCallback;
+ friend class MelReporter;
+ friend class PatchPanel;
+ // TODO(b/291012167) replace the Thread friends with an interface.
+ friend class DirectOutputThread;
+ friend class MixerThread;
+ friend class MmapPlaybackThread;
+ friend class MmapThread;
+ friend class PlaybackThread;
+ friend class RecordThread;
+ friend class ThreadBase;
+
public:
static void instantiate() ANDROID_API;
@@ -487,7 +513,7 @@
// Internal dump utilities.
static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
public:
- // TODO(b/288339104) extract to afutils
+ // TODO(b/291319167) extract to afutils
static bool dumpTryLock(Mutex& mutex);
private:
void dumpPermissionDenial(int fd, const Vector<String16>& args);
@@ -496,11 +522,7 @@
SimpleLog mThreadLog{16}; // 16 Thread history limit
-public:
- // TODO(b/288339104)
- class ThreadBase;
-private:
- void dumpToThreadLog_l(const sp<ThreadBase> &thread);
+ void dumpToThreadLog_l(const sp<IAfThreadBase>& thread);
// --- Notification Client ---
class NotificationClient : public IBinder::DeathRecipient {
@@ -560,51 +582,6 @@
// Requests media.log to start merging log buffers
void requestLogMerge();
- // TODO(b/288339104) replace these forward declaration classes with interfaces.
-public:
- class RecordThread;
- class PlaybackThread;
- class MixerThread;
- class DirectOutputThread;
- class OffloadThread;
- class DuplicatingThread;
- class AsyncCallbackThread;
- class BitPerfectThread;
-private:
- class DeviceEffectManager;
- // TODO(b/288339104) these should be separate files
-public:
- class PatchPanel;
- class DeviceEffectManagerCallback;
-private:
- struct AudioStreamIn;
- struct TeePatch;
-public:
- using TeePatches = std::vector<TeePatch>;
-private:
-
- struct stream_type_t {
- stream_type_t()
- : volume(1.0f),
- mute(false)
- {
- }
- float volume;
- bool mute;
- };
-
- // --- PlaybackThread ---
-
-#include "Threads.h"
-
-#include "PatchPanel.h"
-
-#include "PatchCommandThread.h"
-
-#include "DeviceEffectManager.h"
-
-#include "MelReporter.h"
-
// Find io handle by session id.
// Preference is given to an io handle with a matching effect chain to session id.
// If none found, AUDIO_IO_HANDLE_NONE is returned.
@@ -617,7 +594,7 @@
const uint32_t sessionType = threads.valueAt(i)->hasAudioSession(sessionId);
if (sessionType != 0) {
io = threads.keyAt(i);
- if ((sessionType & AudioFlinger::ThreadBase::EFFECT_SESSION) != 0) {
+ if ((sessionType & IAfThreadBase::EFFECT_SESSION) != 0) {
break; // effect chain here.
}
}
@@ -625,40 +602,16 @@
return io;
}
- // Mmap stream control interface implementation. Each MmapThreadHandle controls one
- // MmapPlaybackThread or MmapCaptureThread instance.
- class MmapThreadHandle : public MmapStreamInterface {
- public:
- explicit MmapThreadHandle(const sp<MmapThread>& thread);
- virtual ~MmapThreadHandle();
+ IAfThreadBase* checkThread_l(audio_io_handle_t ioHandle) const;
+ sp<IAfThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const REQUIRES(mLock);
+ IAfPlaybackThread* checkPlaybackThread_l(audio_io_handle_t output) const;
+ IAfPlaybackThread* checkMixerThread_l(audio_io_handle_t output) const;
+ IAfRecordThread* checkRecordThread_l(audio_io_handle_t input) const;
+ IAfMmapThread* checkMmapThread_l(audio_io_handle_t io) const;
+ sp<VolumeInterface> getVolumeInterface_l(audio_io_handle_t output) const;
+ std::vector<sp<VolumeInterface>> getAllVolumeInterfaces_l() const;
- // MmapStreamInterface virtuals
- virtual status_t createMmapBuffer(int32_t minSizeFrames,
- struct audio_mmap_buffer_info *info);
- virtual status_t getMmapPosition(struct audio_mmap_position *position);
- virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNanos);
- virtual status_t start(const AudioClient& client,
- const audio_attributes_t *attr,
- audio_port_handle_t *handle);
- virtual status_t stop(audio_port_handle_t handle);
- virtual status_t standby();
- status_t reportData(const void* buffer, size_t frameCount) override;
-
- private:
- const sp<MmapThread> mThread;
- };
-
- ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const;
- sp<AudioFlinger::ThreadBase> checkOutputThread_l(audio_io_handle_t ioHandle) const
- REQUIRES(mLock);
- PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
- MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
- RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
- MmapThread *checkMmapThread_l(audio_io_handle_t io) const;
- VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const;
- Vector <VolumeInterface *> getAllVolumeInterfaces_l() const;
-
- sp<ThreadBase> openInput_l(audio_module_handle_t module,
+ sp<IAfThreadBase> openInput_l(audio_module_handle_t module,
audio_io_handle_t *input,
audio_config_t *config,
audio_devices_t device,
@@ -667,7 +620,7 @@
audio_input_flags_t flags,
audio_devices_t outputDevice,
const String8& outputDeviceAddress);
- sp<ThreadBase> openOutput_l(audio_module_handle_t module,
+ sp<IAfThreadBase> openOutput_l(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t *halConfig,
audio_config_base_t *mixerConfig,
@@ -675,8 +628,8 @@
const String8& address,
audio_output_flags_t flags);
- void closeOutputFinish(const sp<PlaybackThread>& thread);
- void closeInputFinish(const sp<RecordThread>& thread);
+ void closeOutputFinish(const sp<IAfPlaybackThread>& thread);
+ void closeInputFinish(const sp<IAfRecordThread>& thread);
// no range check, AudioFlinger::mLock held
bool streamMute_l(audio_stream_type_t stream) const
@@ -701,40 +654,37 @@
audio_unique_id_t nextUniqueId(audio_unique_id_use_t use);
status_t moveEffectChain_l(audio_session_t sessionId,
- PlaybackThread *srcThread,
- PlaybackThread *dstThread);
+ IAfPlaybackThread* srcThread, IAfPlaybackThread* dstThread);
status_t moveEffectChain_l(audio_session_t sessionId,
- RecordThread *srcThread,
- RecordThread *dstThread);
+ IAfRecordThread* srcThread, IAfRecordThread* dstThread);
public:
- // TODO(b/288339104) cluster together
+ // TODO(b/291319167) cluster together
status_t moveAuxEffectToIo(int EffectId,
- const sp<PlaybackThread>& dstThread,
- sp<PlaybackThread> *srcThread);
+ const sp<IAfPlaybackThread>& dstThread, sp<IAfPlaybackThread>* srcThread);
private:
// return thread associated with primary hardware device, or NULL
- PlaybackThread *primaryPlaybackThread_l() const;
+ IAfPlaybackThread* primaryPlaybackThread_l() const;
DeviceTypeSet primaryOutputDevice_l() const;
// return the playback thread with smallest HAL buffer size, and prefer fast
- PlaybackThread *fastPlaybackThread_l() const;
+ IAfPlaybackThread* fastPlaybackThread_l() const;
- sp<ThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId);
+ sp<IAfThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId);
- ThreadBase *hapticPlaybackThread_l() const;
+ IAfThreadBase* hapticPlaybackThread_l() const;
void updateSecondaryOutputsForTrack_l(
IAfTrack* track,
- PlaybackThread* thread,
+ IAfPlaybackThread* thread,
const std::vector<audio_io_handle_t>& secondaryOutputs) const;
void removeClient_l(pid_t pid);
void removeNotificationClient(pid_t pid);
public:
- // TODO(b/288339104) cluster together
+ // TODO(b/291319167) cluster together
bool isNonOffloadableGlobalEffectEnabled_l();
private:
void onNonOffloadableGlobalEffectEnable();
@@ -756,7 +706,7 @@
// and removed from mOrphanEffectChains if it does not contain any effect.
// Return true if the effect was found in mOrphanEffectChains, false otherwise.
public:
-// TODO(b/288339104) suggest better grouping
+// TODO(b/291319167) suggest better grouping
bool updateOrphanEffectChains(const sp<IAfEffectModule>& effect);
private:
std::vector< sp<IAfEffectModule> > purgeStaleEffects_l();
@@ -768,35 +718,7 @@
void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices);
void forwardParametersToDownstreamPatches_l(
audio_io_handle_t upStream, const String8& keyValuePairs,
- const std::function<bool(const sp<PlaybackThread>&)>& useThread = nullptr);
-
- // AudioStreamIn is immutable, so their fields are const.
- // For emphasis, we could also make all pointers to them be "const *",
- // but that would clutter the code unnecessarily.
-
- struct AudioStreamIn : public Source {
- AudioHwDevice* const audioHwDev;
- sp<StreamInHalInterface> stream;
- audio_input_flags_t flags;
-
- sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); }
-
- AudioStreamIn(AudioHwDevice *dev, const sp<StreamInHalInterface>& in,
- audio_input_flags_t flags) :
- audioHwDev(dev), stream(in), flags(flags) {}
- status_t read(void *buffer, size_t bytes, size_t *read) override {
- return stream->read(buffer, bytes, read);
- }
- status_t getCapturePosition(int64_t *frames, int64_t *time) override {
- return stream->getCapturePosition(frames, time);
- }
- status_t standby() override { return stream->standby(); }
- };
-
- struct TeePatch {
- sp<IAfPatchRecord> patchRecord;
- sp<IAfPatchTrack> patchTrack;
- };
+ const std::function<bool(const sp<IAfPlaybackThread>&)>& useThread = nullptr);
// for mAudioSessionRefs only
struct AudioSessionRef {
@@ -809,13 +731,13 @@
};
public:
- // TODO(b/288339104) access by getter,
+ // TODO(b/291319167) access by getter,
mutable Mutex mLock;
// protects mClients and mNotificationClients.
// must be locked after mLock and ThreadBase::mLock if both must be locked
// avoids acquiring AudioFlinger::mLock from inside thread loop.
- // TODO(b/288339104) access by getter,
+ // TODO(b/291319167) access by getter,
mutable Mutex mClientLock;
private:
// protected by mClientLock
@@ -864,7 +786,7 @@
mutable hardware_call_state mHardwareStatus; // for dump only
- DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads;
+ DefaultKeyedVector<audio_io_handle_t, sp<IAfPlaybackThread>> mPlaybackThreads;
stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
// member variables below are protected by mLock
@@ -873,7 +795,7 @@
float mMasterBalance = 0.f;
// end of variables protected by mLock
- DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads;
+ DefaultKeyedVector<audio_io_handle_t, sp<IAfRecordThread>> mRecordThreads;
// protected by mClientLock
DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients;
@@ -904,17 +826,17 @@
// list of MMAP stream control threads. Those threads allow for wake lock, routing
// and volume control for activity on the associated MMAP stream at the HAL.
// Audio data transfer is directly handled by the client creating the MMAP stream
- DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads;
+ DefaultKeyedVector<audio_io_handle_t, sp<IAfMmapThread>> mMmapThreads;
private:
sp<Client> registerPid(pid_t pid); // always returns non-0
// for use from destructor
status_t closeOutput_nonvirtual(audio_io_handle_t output);
- void closeThreadInternal_l(const sp<PlaybackThread>& thread);
+ void closeThreadInternal_l(const sp<IAfPlaybackThread>& thread);
status_t closeInput_nonvirtual(audio_io_handle_t input);
- void closeThreadInternal_l(const sp<RecordThread>& thread);
- void setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId);
+ void closeThreadInternal_l(const sp<IAfRecordThread>& thread);
+ void setAudioHwSyncForSession_l(IAfPlaybackThread* thread, audio_session_t sessionId);
status_t checkStreamType(audio_stream_type_t stream) const;
@@ -941,9 +863,10 @@
nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled
// protected by mLock
- PatchPanel mPatchPanel;
+ const sp<IAfPatchPanel> mPatchPanel = IAfPatchPanel::create(this);
+
public:
- // TODO(b/288339104) access by getter.
+ // TODO(b/291319167) access by getter.
sp<EffectsFactoryHalInterface> mEffectsFactoryHal;
private:
@@ -979,8 +902,6 @@
std::atomic_bool mBluetoothLatencyModesEnabled;
};
-#undef INCLUDING_FROM_AUDIOFLINGER_H
-
std::string formatToString(audio_format_t format);
std::string inputFlagsToString(audio_input_flags_t flags);
std::string outputFlagsToString(audio_output_flags_t flags);
diff --git a/services/audioflinger/Client.h b/services/audioflinger/Client.h
index cb507fe..142d384 100644
--- a/services/audioflinger/Client.h
+++ b/services/audioflinger/Client.h
@@ -16,7 +16,7 @@
#pragma once
-// TODO(b/288339104) Move to nested namespace
+// TODO(b/291318727) Move to nested namespace
namespace android {
class AudioFlinger;
diff --git a/services/audioflinger/DeviceEffectManager.cpp b/services/audioflinger/DeviceEffectManager.cpp
index 8e78e4a..0f645cd 100644
--- a/services/audioflinger/DeviceEffectManager.cpp
+++ b/services/audioflinger/DeviceEffectManager.cpp
@@ -16,7 +16,7 @@
*/
-#define LOG_TAG "AudioFlinger::DeviceEffectManager"
+#define LOG_TAG "DeviceEffectManager"
//#define LOG_NDEBUG 0
#include <utils/Log.h>
@@ -34,22 +34,40 @@
using detail::AudioHalVersionInfo;
using media::IEffectClient;
-void AudioFlinger::DeviceEffectManager::onCreateAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) {
+DeviceEffectManager::DeviceEffectManager(AudioFlinger& audioFlinger)
+ : mAudioFlinger(audioFlinger),
+ mMyCallback(new DeviceEffectManagerCallback(*this)) {}
+
+void DeviceEffectManager::onFirstRef() {
+ mAudioFlinger.mPatchCommandThread->addListener(this);
+}
+
+status_t DeviceEffectManager::addEffectToHal(const struct audio_port_config* device,
+ const sp<EffectHalInterface>& effect) {
+ return mAudioFlinger.addEffectToHal(device, effect);
+};
+
+status_t DeviceEffectManager::removeEffectFromHal(const struct audio_port_config* device,
+ const sp<EffectHalInterface>& effect) {
+ return mAudioFlinger.removeEffectFromHal(device, effect);
+};
+
+void DeviceEffectManager::onCreateAudioPatch(audio_patch_handle_t handle,
+ const IAfPatchPanel::Patch& patch) {
ALOGV("%s handle %d mHalHandle %d device sink %08x",
__func__, handle, patch.mHalHandle,
patch.mAudioPatch.num_sinks > 0 ? patch.mAudioPatch.sinks[0].ext.device.type : 0);
Mutex::Autolock _l(mLock);
for (auto& effectProxies : mDeviceEffects) {
for (auto& effect : effectProxies.second) {
- status_t status = effect->onCreatePatch(handle, &patch); // TODO(b/288339104) void*
+ const status_t status = effect->onCreatePatch(handle, patch);
ALOGV("%s Effect onCreatePatch status %d", __func__, status);
ALOGW_IF(status == BAD_VALUE, "%s onCreatePatch error %d", __func__, status);
}
}
}
-void AudioFlinger::DeviceEffectManager::onReleaseAudioPatch(audio_patch_handle_t handle) {
+void DeviceEffectManager::onReleaseAudioPatch(audio_patch_handle_t handle) {
ALOGV("%s", __func__);
Mutex::Autolock _l(mLock);
for (auto& effectProxies : mDeviceEffects) {
@@ -59,16 +77,15 @@
}
}
-void AudioFlinger::DeviceEffectManager::onUpdateAudioPatch(audio_patch_handle_t oldHandle,
- audio_patch_handle_t newHandle, const PatchPanel::Patch& patch) {
+void DeviceEffectManager::onUpdateAudioPatch(audio_patch_handle_t oldHandle,
+ audio_patch_handle_t newHandle, const IAfPatchPanel::Patch& patch) {
ALOGV("%s oldhandle %d newHandle %d mHalHandle %d device sink %08x",
__func__, oldHandle, newHandle, patch.mHalHandle,
patch.mAudioPatch.num_sinks > 0 ? patch.mAudioPatch.sinks[0].ext.device.type : 0);
Mutex::Autolock _l(mLock);
for (auto& effectProxies : mDeviceEffects) {
for (auto& effect : effectProxies.second) {
- // TODO(b/288339104) void*
- status_t status = effect->onUpdatePatch(oldHandle, newHandle, &patch);
+ const status_t status = effect->onUpdatePatch(oldHandle, newHandle, patch);
ALOGV("%s Effect onUpdatePatch status %d", __func__, status);
ALOGW_IF(status != NO_ERROR, "%s onUpdatePatch error %d", __func__, status);
}
@@ -76,12 +93,12 @@
}
// DeviceEffectManager::createEffect_l() must be called with AudioFlinger::mLock held
-sp<IAfEffectHandle> AudioFlinger::DeviceEffectManager::createEffect_l(
+sp<IAfEffectHandle> DeviceEffectManager::createEffect_l(
effect_descriptor_t *descriptor,
const AudioDeviceTypeAddr& device,
const sp<Client>& client,
const sp<IEffectClient>& effectClient,
- const std::map<audio_patch_handle_t, PatchPanel::Patch>& patches,
+ const std::map<audio_patch_handle_t, IAfPatchPanel::Patch>& patches,
int *enabled,
status_t *status,
bool probe,
@@ -123,7 +140,7 @@
if (lStatus == NO_ERROR) {
lStatus = effect->addHandle(handle.get());
if (lStatus == NO_ERROR) {
- lStatus = effect->init(&patches); // TODO(b/288339104) void*
+ lStatus = effect->init(patches);
if (lStatus == NAME_NOT_FOUND) {
lStatus = NO_ERROR;
}
@@ -141,7 +158,7 @@
return handle;
}
-status_t AudioFlinger::DeviceEffectManager::checkEffectCompatibility(
+status_t DeviceEffectManager::checkEffectCompatibility(
const effect_descriptor_t *desc) {
const sp<EffectsFactoryHalInterface> effectsFactory =
audioflinger::EffectConfiguration::getEffectsFactoryHal();
@@ -167,7 +184,7 @@
return NO_ERROR;
}
-status_t AudioFlinger::DeviceEffectManager::createEffectHal(
+status_t DeviceEffectManager::createEffectHal(
const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
sp<EffectHalInterface> *effect) {
status_t status = NO_INIT;
@@ -180,10 +197,10 @@
return status;
}
-void AudioFlinger::DeviceEffectManager::dump(int fd)
+void DeviceEffectManager::dump(int fd)
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
- const bool locked = dumpTryLock(mLock);
+ const bool locked = AudioFlinger::dumpTryLock(mLock);
if (!locked) {
String8 result("DeviceEffectManager may be deadlocked\n");
write(fd, result.string(), result.size());
@@ -206,7 +223,7 @@
}
}
-size_t AudioFlinger::DeviceEffectManager::removeEffect(const sp<IAfDeviceEffectProxy>& effect)
+size_t DeviceEffectManager::removeEffect(const sp<IAfDeviceEffectProxy>& effect)
{
Mutex::Autolock _l(mLock);
const auto& iter = mDeviceEffects.find(effect->device());
@@ -226,7 +243,7 @@
return mDeviceEffects.size();
}
-bool AudioFlinger::DeviceEffectManagerCallback::disconnectEffectHandle(
+bool DeviceEffectManagerCallback::disconnectEffectHandle(
IAfEffectHandle *handle, bool unpinIfLast) {
sp<IAfEffectBase> effectBase = handle->effect().promote();
if (effectBase == nullptr) {
@@ -248,4 +265,12 @@
return true;
}
+bool DeviceEffectManagerCallback::isAudioPolicyReady() const {
+ return mManager.audioFlinger().isAudioPolicyReady();
+}
+
+int DeviceEffectManagerCallback::newEffectId() const {
+ return mManager.audioFlinger().nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
+}
+
} // namespace android
diff --git a/services/audioflinger/DeviceEffectManager.h b/services/audioflinger/DeviceEffectManager.h
index bb031d6..54b88d0 100644
--- a/services/audioflinger/DeviceEffectManager.h
+++ b/services/audioflinger/DeviceEffectManager.h
@@ -15,26 +15,24 @@
** limitations under the License.
*/
-#ifndef INCLUDING_FROM_AUDIOFLINGER_H
- #error This header file should only be included from AudioFlinger.h
-#endif
+#pragma once
+
+namespace android {
+
+class DeviceEffectManagerCallback;
// DeviceEffectManager is concealed within AudioFlinger, their lifetimes are the same.
class DeviceEffectManager : public PatchCommandThread::PatchCommandListener {
public:
- explicit DeviceEffectManager(AudioFlinger& audioFlinger)
- : mAudioFlinger(audioFlinger),
- mMyCallback(new DeviceEffectManagerCallback(*this)) {}
+ explicit DeviceEffectManager(AudioFlinger& audioFlinger);
- void onFirstRef() override {
- mAudioFlinger.mPatchCommandThread->addListener(this);
- }
+ void onFirstRef() override;
sp<IAfEffectHandle> createEffect_l(effect_descriptor_t *descriptor,
const AudioDeviceTypeAddr& device,
const sp<Client>& client,
const sp<media::IEffectClient>& effectClient,
- const std::map<audio_patch_handle_t, PatchPanel::Patch>& patches,
+ const std::map<audio_patch_handle_t, IAfPatchPanel::Patch>& patches,
int *enabled,
status_t *status,
bool probe,
@@ -45,13 +43,9 @@
int32_t sessionId, int32_t deviceId,
sp<EffectHalInterface> *effect);
status_t addEffectToHal(const struct audio_port_config *device,
- const sp<EffectHalInterface>& effect) {
- return mAudioFlinger.addEffectToHal(device, effect);
- };
+ const sp<EffectHalInterface>& effect);
status_t removeEffectFromHal(const struct audio_port_config *device,
- const sp<EffectHalInterface>& effect) {
- return mAudioFlinger.removeEffectFromHal(device, effect);
- };
+ const sp<EffectHalInterface>& effect);
AudioFlinger& audioFlinger() const { return mAudioFlinger; }
@@ -60,11 +54,11 @@
// PatchCommandThread::PatchCommandListener implementation
void onCreateAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) override;
- void onReleaseAudioPatch(audio_patch_handle_t handle) override;
+ const IAfPatchPanel::Patch& patch) final;
+ void onReleaseAudioPatch(audio_patch_handle_t handle) final;
void onUpdateAudioPatch(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch) override;
+ const IAfPatchPanel::Patch& patch) final;
private:
status_t checkEffectCompatibility(const effect_descriptor_t *desc);
@@ -75,7 +69,6 @@
std::map<AudioDeviceTypeAddr, std::vector<sp<IAfDeviceEffectProxy>>> mDeviceEffects;
};
-public: // TODO(b/288339104) extract inner class.
class DeviceEffectManagerCallback : public EffectCallbackInterface {
public:
explicit DeviceEffectManagerCallback(DeviceEffectManager& manager)
@@ -132,11 +125,9 @@
wp<IAfEffectChain> chain() const override { return nullptr; }
- bool isAudioPolicyReady() const override {
- return mManager.audioFlinger().isAudioPolicyReady();
- }
+ bool isAudioPolicyReady() const final;
- int newEffectId() { return mManager.audioFlinger().nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT); }
+ int newEffectId() const;
status_t addEffectToHal(const struct audio_port_config *device,
const sp<EffectHalInterface>& effect) {
@@ -149,4 +140,5 @@
private:
DeviceEffectManager& mManager;
};
-private:
+
+} // namespace android
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 2a33991..5780d5d 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -2118,21 +2118,20 @@
/* static */
sp<IAfEffectChain> IAfEffectChain::create(
- const wp<Thread /*ThreadBase*/>& wThread, // TODO(b/288339104) update type
+ const wp<IAfThreadBase>& wThread,
audio_session_t sessionId)
{
- // TODO(b/288339104) no weak pointer cast.
- return sp<EffectChain>::make(sp<AudioFlinger::ThreadBase>::cast(wThread.promote()), sessionId);
+ return sp<EffectChain>::make(wThread, sessionId);
}
-EffectChain::EffectChain(const wp<AudioFlinger::ThreadBase>& thread,
+EffectChain::EffectChain(const wp<IAfThreadBase>& thread,
audio_session_t sessionId)
: mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),
mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread))
{
- sp<AudioFlinger::ThreadBase> p = thread.promote();
+ const sp<IAfThreadBase> p = thread.promote();
if (p == nullptr) {
return;
}
@@ -2145,7 +2144,7 @@
{
}
-// getEffectFromDesc_l() must be called with AudioFlinger::ThreadBase::mLock held
+// getEffectFromDesc_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromDesc_l(
effect_descriptor_t *descriptor) const
{
@@ -2159,7 +2158,7 @@
return 0;
}
-// getEffectFromId_l() must be called with AudioFlinger::ThreadBase::mLock held
+// getEffectFromId_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const
{
size_t size = mEffects.size();
@@ -2173,7 +2172,7 @@
return 0;
}
-// getEffectFromType_l() must be called with AudioFlinger::ThreadBase::mLock held
+// getEffectFromType_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromType_l(
const effect_uuid_t *type) const
{
@@ -2268,7 +2267,7 @@
}
}
-// createEffect_l() must be called with AudioFlinger::ThreadBase::mLock held
+// createEffect_l() must be called with IAfThreadBase::mutex() held
status_t EffectChain::createEffect_l(sp<IAfEffectModule>& effect,
effect_descriptor_t *desc,
int id,
@@ -2287,13 +2286,13 @@
return lStatus;
}
-// addEffect_l() must be called with AudioFlinger::ThreadBase::mLock held
+// addEffect_l() must be called with IAfThreadBase::mutex() held
status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)
{
Mutex::Autolock _l(mLock);
return addEffect_ll(effect);
}
-// addEffect_l() must be called with AudioFlinger::ThreadBase::mLock and EffectChain::mLock held
+// addEffect_l() must be called with IAfThreadBase::mLock and EffectChain::mutex() held
status_t EffectChain::addEffect_ll(const sp<IAfEffectModule>& effect)
{
effect->setCallback(mEffectCallback);
@@ -2447,7 +2446,7 @@
return idx_insert;
}
-// removeEffect_l() must be called with AudioFlinger::ThreadBase::mLock held
+// removeEffect_l() must be called with IAfThreadBase::mutex() held
size_t EffectChain::removeEffect_l(const sp<IAfEffectModule>& effect,
bool release)
{
@@ -2495,7 +2494,7 @@
return mEffects.size();
}
-// setDevices_l() must be called with AudioFlinger::ThreadBase::mLock held
+// setDevices_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices)
{
size_t size = mEffects.size();
@@ -2504,7 +2503,7 @@
}
}
-// setInputDevice_l() must be called with AudioFlinger::ThreadBase::mLock held
+// setInputDevice_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device)
{
size_t size = mEffects.size();
@@ -2513,7 +2512,7 @@
}
}
-// setMode_l() must be called with AudioFlinger::ThreadBase::mLock held
+// setMode_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setMode_l(audio_mode_t mode)
{
size_t size = mEffects.size();
@@ -2522,7 +2521,7 @@
}
}
-// setAudioSource_l() must be called with AudioFlinger::ThreadBase::mLock held
+// setAudioSource_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setAudioSource_l(audio_source_t source)
{
size_t size = mEffects.size();
@@ -2538,7 +2537,7 @@
return false;
}
-// setVolume_l() must be called with AudioFlinger::ThreadBase::mLock or EffectChain::mLock held
+// setVolume_l() must be called with IAfThreadBase::mLock or EffectChain::mLock held
bool EffectChain::setVolume_l(uint32_t *left, uint32_t *right, bool force)
{
uint32_t newLeft = *left;
@@ -2605,7 +2604,7 @@
return hasControl;
}
-// resetVolume_l() must be called with AudioFlinger::ThreadBase::mLock or EffectChain::mLock held
+// resetVolume_l() must be called with IAfThreadBase::mutex() or EffectChain::mLock held
void EffectChain::resetVolume_l()
{
if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) {
@@ -2616,7 +2615,7 @@
}
// containsHapticGeneratingEffect_l must be called with
-// AudioFlinger::ThreadBase::mLock or EffectChain::mLock held
+// IAfThreadBase::mutex() or EffectChain::mLock held
bool EffectChain::containsHapticGeneratingEffect_l()
{
for (size_t i = 0; i < mEffects.size(); ++i) {
@@ -2685,7 +2684,7 @@
}
}
-// must be called with AudioFlinger::ThreadBase::mLock held
+// must be called with IAfThreadBase::mutex() held
void EffectChain::setEffectSuspended_l(
const effect_uuid_t *type, bool suspend)
{
@@ -2741,7 +2740,7 @@
}
}
-// must be called with AudioFlinger::ThreadBase::mLock held
+// must be called with IAfThreadBase::mutex() held
void EffectChain::setEffectSuspendedAll_l(bool suspend)
{
sp<SuspendedEffectDesc> desc;
@@ -2897,7 +2896,7 @@
return false;
}
-void EffectChain::setThread(const sp<AudioFlinger::ThreadBase>& thread)
+void EffectChain::setThread(const sp<IAfThreadBase>& thread)
{
Mutex::Autolock _l(mLock);
mEffectCallback->setThread(thread);
@@ -2964,7 +2963,7 @@
}
// isCompatibleWithThread_l() must be called with thread->mLock held
-bool EffectChain::isCompatibleWithThread_l(const sp<AudioFlinger::ThreadBase>& thread) const
+bool EffectChain::isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const
{
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mEffects.size(); i++) {
@@ -3002,7 +3001,7 @@
status_t EffectChain::EffectCallback::addEffectToHal(
const sp<EffectHalInterface>& effect) {
status_t result = NO_INIT;
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return result;
}
@@ -3018,7 +3017,7 @@
status_t EffectChain::EffectCallback::removeEffectFromHal(
const sp<EffectHalInterface>& effect) {
status_t result = NO_INIT;
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return result;
}
@@ -3032,7 +3031,7 @@
}
audio_io_handle_t EffectChain::EffectCallback::io() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_IO_HANDLE_NONE;
}
@@ -3040,7 +3039,7 @@
}
bool EffectChain::EffectCallback::isOutput() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return true;
}
@@ -3048,19 +3047,19 @@
}
bool EffectChain::EffectCallback::isOffload() const {
- return mThreadType == AudioFlinger::ThreadBase::OFFLOAD;
+ return mThreadType == IAfThreadBase::OFFLOAD;
}
bool EffectChain::EffectCallback::isOffloadOrDirect() const {
- return mThreadType == AudioFlinger::ThreadBase::OFFLOAD
- || mThreadType == AudioFlinger::ThreadBase::DIRECT;
+ return mThreadType == IAfThreadBase::OFFLOAD
+ || mThreadType == IAfThreadBase::DIRECT;
}
bool EffectChain::EffectCallback::isOffloadOrMmap() const {
switch (mThreadType) {
- case AudioFlinger::ThreadBase::OFFLOAD:
- case AudioFlinger::ThreadBase::MMAP_PLAYBACK:
- case AudioFlinger::ThreadBase::MMAP_CAPTURE:
+ case IAfThreadBase::OFFLOAD:
+ case IAfThreadBase::MMAP_PLAYBACK:
+ case IAfThreadBase::MMAP_CAPTURE:
return true;
default:
return false;
@@ -3068,11 +3067,11 @@
}
bool EffectChain::EffectCallback::isSpatializer() const {
- return mThreadType == AudioFlinger::ThreadBase::SPATIALIZER;
+ return mThreadType == IAfThreadBase::SPATIALIZER;
}
uint32_t EffectChain::EffectCallback::sampleRate() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
@@ -3080,7 +3079,7 @@
}
audio_channel_mask_t EffectChain::EffectCallback::inChannelMask(int id) const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
@@ -3089,7 +3088,7 @@
return AUDIO_CHANNEL_NONE;
}
- if (mThreadType == AudioFlinger::ThreadBase::SPATIALIZER) {
+ if (mThreadType == IAfThreadBase::SPATIALIZER) {
if (c->sessionId() == AUDIO_SESSION_OUTPUT_STAGE) {
if (c->isFirstEffect(id)) {
return t->mixerChannelMask();
@@ -3098,7 +3097,7 @@
}
} else if (!audio_is_global_session(c->sessionId())) {
if ((t->hasAudioSession_l(c->sessionId())
- & AudioFlinger::ThreadBase::SPATIALIZED_SESSION) != 0) {
+ & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
return t->mixerChannelMask();
} else {
return t->channelMask();
@@ -3116,7 +3115,7 @@
}
audio_channel_mask_t EffectChain::EffectCallback::outChannelMask() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
@@ -3125,10 +3124,10 @@
return AUDIO_CHANNEL_NONE;
}
- if (mThreadType == AudioFlinger::ThreadBase::SPATIALIZER) {
+ if (mThreadType == IAfThreadBase::SPATIALIZER) {
if (!audio_is_global_session(c->sessionId())) {
if ((t->hasAudioSession_l(c->sessionId())
- & AudioFlinger::ThreadBase::SPATIALIZED_SESSION) != 0) {
+ & IAfThreadBase::SPATIALIZED_SESSION) != 0) {
return t->mixerChannelMask();
} else {
return t->channelMask();
@@ -3146,7 +3145,7 @@
}
audio_channel_mask_t EffectChain::EffectCallback::hapticChannelMask() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
@@ -3154,7 +3153,7 @@
}
size_t EffectChain::EffectCallback::frameCount() const {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
@@ -3164,7 +3163,7 @@
uint32_t EffectChain::EffectCallback::latency() const
NO_THREAD_SAFETY_ANALYSIS // latency_l() access
{
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
@@ -3175,7 +3174,7 @@
void EffectChain::EffectCallback::setVolumeForOutput(float left, float right) const
NO_THREAD_SAFETY_ANALYSIS // setVolumeForOutput_l() access
{
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
@@ -3184,7 +3183,7 @@
void EffectChain::EffectCallback::checkSuspendOnEffectEnabled(
const sp<IAfEffectBase>& effect, bool enabled, bool threadLocked) {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
@@ -3199,7 +3198,7 @@
}
void EffectChain::EffectCallback::onEffectEnable(const sp<IAfEffectBase>& effect) {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
@@ -3210,7 +3209,7 @@
void EffectChain::EffectCallback::onEffectDisable(const sp<IAfEffectBase>& effect) {
checkSuspendOnEffectEnabled(effect, false, false /*threadLocked*/);
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
@@ -3219,7 +3218,7 @@
bool EffectChain::EffectCallback::disconnectEffectHandle(IAfEffectHandle *handle,
bool unpinIfLast) {
- sp<AudioFlinger::ThreadBase> t = thread().promote();
+ const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return false;
}
@@ -3259,11 +3258,11 @@
/* static */
sp<IAfDeviceEffectProxy> IAfDeviceEffectProxy::create(
const AudioDeviceTypeAddr& device,
- const sp</* DeviceEffectManagerCallback */ RefBase>& callback, // TODO(b/288339104) type
+ const sp<DeviceEffectManagerCallback>& callback,
effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
{
return sp<DeviceEffectProxy>::make(device,
- sp<AudioFlinger::DeviceEffectManagerCallback>::cast(callback),
+ callback,
desc, id, notifyFramesProcessed);
}
@@ -3289,7 +3288,7 @@
}
status_t DeviceEffectProxy::init(
- const std::map <audio_patch_handle_t, AudioFlinger::PatchPanel::Patch>& patches) {
+ const std::map <audio_patch_handle_t, IAfPatchPanel::Patch>& patches) {
//For all audio patches
//If src or sink device match
//If the effect is HW accelerated
@@ -3313,7 +3312,7 @@
status_t DeviceEffectProxy::onUpdatePatch(audio_patch_handle_t oldPatchHandle,
audio_patch_handle_t newPatchHandle,
- const AudioFlinger::PatchPanel::Patch& patch __unused) {
+ const IAfPatchPanel::Patch& /* patch */) {
status_t status = NAME_NOT_FOUND;
ALOGV("%s", __func__);
Mutex::Autolock _l(mProxyLock);
@@ -3329,7 +3328,7 @@
}
status_t DeviceEffectProxy::onCreatePatch(
- audio_patch_handle_t patchHandle, const AudioFlinger::PatchPanel::Patch& patch) {
+ audio_patch_handle_t patchHandle, const IAfPatchPanel::Patch& patch) {
status_t status = NAME_NOT_FOUND;
sp<IAfEffectHandle> handle;
// only consider source[0] as this is the only "true" source of a patch
@@ -3352,7 +3351,7 @@
return status;
}
-status_t DeviceEffectProxy::checkPort(const AudioFlinger::PatchPanel::Patch& patch,
+status_t DeviceEffectProxy::checkPort(const IAfPatchPanel::Patch& patch,
const struct audio_port_config *port, sp<IAfEffectHandle> *handle) {
ALOGV("%s type %d device type %d address %s device ID %d patch.isSoftware() %d",
@@ -3401,7 +3400,7 @@
mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
}
} else if (patch.isSoftware() || patch.thread().promote() != nullptr) {
- sp <AudioFlinger::ThreadBase> thread;
+ sp<IAfThreadBase> thread;
if (audio_port_config_has_input_direction(port)) {
if (patch.isSoftware()) {
thread = patch.mRecord.thread();
diff --git a/services/audioflinger/Effects.h b/services/audioflinger/Effects.h
index 4f4df53..365cd45 100644
--- a/services/audioflinger/Effects.h
+++ b/services/audioflinger/Effects.h
@@ -382,7 +382,7 @@
// it also provide it's own input buffer used by the track as accumulation buffer.
class EffectChain : public IAfEffectChain {
public:
- EffectChain(const wp<AudioFlinger::ThreadBase>& wThread, audio_session_t sessionId);
+ EffectChain(const wp<IAfThreadBase>& wThread, audio_session_t sessionId);
~EffectChain() override;
void process_l() final;
@@ -479,12 +479,7 @@
bool isBitPerfectCompatible() const final;
// isCompatibleWithThread_l() must be called with thread->mLock held
- // TODO(b/288339104) type
- bool isCompatibleWithThread_l(const sp<Thread>& thread) const final {
- return isCompatibleWithThread_l(sp<AudioFlinger::ThreadBase>::cast(thread));
- }
-
- bool isCompatibleWithThread_l(const sp<AudioFlinger::ThreadBase>& thread) const;
+ bool isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const final;
bool containsHapticGeneratingEffect_l() final;
@@ -492,8 +487,7 @@
sp<EffectCallbackInterface> effectCallback() const final { return mEffectCallback; }
- // TODO(b/288339104) type
- wp<Thread> thread() const final { return mEffectCallback->thread(); }
+ wp<IAfThreadBase> thread() const final { return mEffectCallback->thread(); }
bool isFirstEffect(int id) const final {
return !mEffects.isEmpty() && id == mEffects[0]->id();
@@ -507,12 +501,7 @@
return mEffects[index];
}
- // TODO(b/288339104) type
- void setThread(const sp<Thread>& thread) final {
- setThread(sp<AudioFlinger::ThreadBase>::cast(thread));
- }
-
- void setThread(const sp<AudioFlinger::ThreadBase>& thread);
+ void setThread(const sp<IAfThreadBase>& thread) final;
private:
@@ -527,15 +516,15 @@
// Note: ctors taking a weak pointer to their owner must not promote it
// during construction (but may keep a reference for later promotion).
EffectCallback(const wp<EffectChain>& owner,
- const wp<AudioFlinger::ThreadBase>& thread)
+ const wp<IAfThreadBase>& thread)
: mChain(owner)
, mThread(thread)
, mAudioFlinger(*AudioFlinger::gAudioFlinger) {
- sp<AudioFlinger::ThreadBase> base = thread.promote();
+ const sp<IAfThreadBase> base = thread.promote();
if (base != nullptr) {
mThreadType = base->type();
} else {
- mThreadType = AudioFlinger::ThreadBase::MIXER; // assure a consistent value.
+ mThreadType = IAfThreadBase::MIXER; // assure a consistent value.
}
}
@@ -580,18 +569,18 @@
return mAudioFlinger.isAudioPolicyReady();
}
- wp<AudioFlinger::ThreadBase> thread() const { return mThread.load(); }
+ wp<IAfThreadBase> thread() const { return mThread.load(); }
- void setThread(const sp<AudioFlinger::ThreadBase>& thread) {
+ void setThread(const sp<IAfThreadBase>& thread) {
mThread = thread;
mThreadType = thread->type();
}
private:
const wp<IAfEffectChain> mChain;
- mediautils::atomic_wp<AudioFlinger::ThreadBase> mThread;
+ mediautils::atomic_wp<IAfThreadBase> mThread;
AudioFlinger &mAudioFlinger; // implementation detail: outer instance always exists.
- AudioFlinger::ThreadBase::type_t mThreadType;
+ IAfThreadBase::type_t mThreadType;
};
DISALLOW_COPY_AND_ASSIGN(EffectChain);
@@ -657,7 +646,7 @@
class DeviceEffectProxy : public IAfDeviceEffectProxy, public EffectBase {
public:
DeviceEffectProxy(const AudioDeviceTypeAddr& device,
- const sp<AudioFlinger::DeviceEffectManagerCallback>& callback,
+ const sp<DeviceEffectManagerCallback>& callback,
effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
: EffectBase(callback, desc, id, AUDIO_SESSION_DEVICE, false),
mDevice(device), mManagerCallback(callback),
@@ -667,31 +656,14 @@
status_t setEnabled(bool enabled, bool fromHandle) final;
sp<IAfDeviceEffectProxy> asDeviceEffectProxy() final { return this; }
- // TODO(b/288339104) type
- status_t init(const /* std::map<audio_patch_handle_t,
- PatchPanel::Patch>& */ void * patches) final {
- return init(*reinterpret_cast<const std::map<
- audio_patch_handle_t, AudioFlinger::PatchPanel::Patch> *>(patches));
- }
- // TODO(b/288339104) type
+ status_t init(const std::map<audio_patch_handle_t,
+ IAfPatchPanel::Patch>& patches) final;
+
status_t onCreatePatch(audio_patch_handle_t patchHandle,
- /* const PatchPanel::Patch& */ const void * patch) final {
- return onCreatePatch(patchHandle,
- *reinterpret_cast<const AudioFlinger::PatchPanel::Patch *>(patch));
- }
- // TODO(b/288339104) type
- status_t onUpdatePatch(audio_patch_handle_t oldPatchHandle, audio_patch_handle_t newPatchHandle,
- /* const PatchPanel::Patch& */ const void * patch) final {
- return onUpdatePatch(oldPatchHandle, newPatchHandle,
- *reinterpret_cast<const AudioFlinger::PatchPanel::Patch *>(patch));
- }
-
- status_t init(const std::map<audio_patch_handle_t, AudioFlinger::PatchPanel::Patch>& patches);
- status_t onCreatePatch(
- audio_patch_handle_t patchHandle, const AudioFlinger::PatchPanel::Patch& patch);
+ const IAfPatchPanel::Patch& patch) final;
status_t onUpdatePatch(audio_patch_handle_t oldPatchHandle, audio_patch_handle_t newPatchHandle,
- const AudioFlinger::PatchPanel::Patch& patch);
+ const IAfPatchPanel::Patch& patch) final;
void onReleasePatch(audio_patch_handle_t patchHandle) final;
@@ -720,7 +692,7 @@
// Note: ctors taking a weak pointer to their owner must not promote it
// during construction (but may keep a reference for later promotion).
ProxyCallback(const wp<DeviceEffectProxy>& owner,
- const sp<AudioFlinger::DeviceEffectManagerCallback>& callback)
+ const sp<DeviceEffectManagerCallback>& callback)
: mProxy(owner), mManagerCallback(callback) {}
status_t createEffectHal(const effect_uuid_t *pEffectUuid,
@@ -771,14 +743,14 @@
private:
const wp<DeviceEffectProxy> mProxy;
- const sp<AudioFlinger::DeviceEffectManagerCallback> mManagerCallback;
+ const sp<DeviceEffectManagerCallback> mManagerCallback;
};
- status_t checkPort(const AudioFlinger::PatchPanel::Patch& patch,
+ status_t checkPort(const IAfPatchPanel::Patch& patch,
const struct audio_port_config *port, sp<IAfEffectHandle> *handle);
const AudioDeviceTypeAddr mDevice;
- const sp<AudioFlinger::DeviceEffectManagerCallback> mManagerCallback;
+ const sp<DeviceEffectManagerCallback> mManagerCallback;
const sp<ProxyCallback> mMyCallback;
mutable Mutex mProxyLock;
diff --git a/services/audioflinger/IAfEffect.h b/services/audioflinger/IAfEffect.h
index 29f1862..ece0081 100644
--- a/services/audioflinger/IAfEffect.h
+++ b/services/audioflinger/IAfEffect.h
@@ -18,11 +18,13 @@
namespace android {
+class DeviceEffectManagerCallback;
class IAfDeviceEffectProxy;
class IAfEffectBase;
class IAfEffectChain;
class IAfEffectHandle;
class IAfEffectModule;
+class IAfThreadBase;
// Interface implemented by the EffectModule parent or owner (e.g an EffectChain) to abstract
// interactions between the EffectModule and the reset of the audio framework.
@@ -190,7 +192,7 @@
// Most of these methods are accessed from AudioFlinger::Thread
public:
static sp<IAfEffectChain> create(
- const wp<Thread /*ThreadBase*/>& wThread, // TODO(b/288339104) type
+ const wp<IAfThreadBase>& wThread,
audio_session_t sessionId);
// special key used for an entry in mSuspendedEffects keyed vector
@@ -279,8 +281,7 @@
virtual bool isBitPerfectCompatible() const = 0;
// isCompatibleWithThread_l() must be called with thread->mLock held
- // TODO(b/288339104) type
- virtual bool isCompatibleWithThread_l(const sp<Thread>& thread) const = 0;
+ virtual bool isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const = 0;
virtual bool containsHapticGeneratingEffect_l() = 0;
@@ -288,8 +289,8 @@
virtual sp<EffectCallbackInterface> effectCallback() const = 0;
- virtual wp<Thread> thread() const = 0; // TODO(b/288339104) type
- virtual void setThread(const sp<Thread>& thread) = 0; // TODO(b/288339104) type
+ virtual wp<IAfThreadBase> thread() const = 0;
+ virtual void setThread(const sp<IAfThreadBase>& thread) = 0;
virtual bool isFirstEffect(int id) const = 0;
@@ -335,25 +336,24 @@
class IAfDeviceEffectProxy : public virtual IAfEffectBase {
public:
- // TODO(b/288339104) type
static sp<IAfDeviceEffectProxy> create(const AudioDeviceTypeAddr& device,
- const sp</* DeviceEffectManagerCallback */ RefBase>& callback,
+ const sp<DeviceEffectManagerCallback>& callback,
effect_descriptor_t *desc, int id, bool notifyFramesProcessed);
virtual status_t init(
- const /* std::map<audio_patch_handle_t,
- PatchPanel::Patch>& */ void * patches) = 0; // TODO(b/288339104) type
+ const std::map<audio_patch_handle_t,
+ IAfPatchPanel::Patch>& patches) = 0;
virtual const AudioDeviceTypeAddr& device() const = 0;
virtual status_t onCreatePatch(
audio_patch_handle_t patchHandle,
- /* const PatchPanel::Patch& */ const void * patch) = 0;
+ const IAfPatchPanel::Patch& patch) = 0;
virtual status_t onUpdatePatch(audio_patch_handle_t oldPatchHandle,
audio_patch_handle_t newPatchHandle,
- /* const PatchPanel::Patch& */ const void * patch) = 0;
+ const IAfPatchPanel::Patch& patch) = 0;
virtual void onReleasePatch(audio_patch_handle_t patchHandle) = 0;
- virtual void dump2(int fd, int spaces) const = 0; // TODO(b/288339104) naming?
+ virtual void dump2(int fd, int spaces) const = 0; // TODO(b/291319101) naming?
private:
// used by DeviceEffectProxy
@@ -367,4 +367,4 @@
virtual status_t removeEffectFromHal(const sp<EffectHalInterface>& effect) = 0;
};
-} // namespace android
+} // namespace android
diff --git a/services/audioflinger/IAfPatchPanel.h b/services/audioflinger/IAfPatchPanel.h
new file mode 100644
index 0000000..29bd4ab
--- /dev/null
+++ b/services/audioflinger/IAfPatchPanel.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2023 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
+
+namespace android {
+
+class IAfPatchPanel;
+class IAfPatchRecord;
+class IAfPatchTrack;
+class IAfPlaybackThread;
+class IAfRecordThread;
+class IAfThreadBase;
+
+class SoftwarePatch {
+public:
+ SoftwarePatch(
+ const sp<const IAfPatchPanel>& patchPanel,
+ audio_patch_handle_t patchHandle,
+ audio_io_handle_t playbackThreadHandle,
+ audio_io_handle_t recordThreadHandle)
+ : mPatchPanel(patchPanel),
+ mPatchHandle(patchHandle),
+ mPlaybackThreadHandle(playbackThreadHandle),
+ mRecordThreadHandle(recordThreadHandle) {}
+ SoftwarePatch(const SoftwarePatch&) = default;
+
+ // Must be called under AudioFlinger::mLock
+ status_t getLatencyMs_l(double* latencyMs) const;
+ audio_patch_handle_t getPatchHandle() const { return mPatchHandle; };
+ audio_io_handle_t getPlaybackThreadHandle() const { return mPlaybackThreadHandle; };
+ audio_io_handle_t getRecordThreadHandle() const { return mRecordThreadHandle; };
+
+private:
+ const sp<const IAfPatchPanel> mPatchPanel;
+ const audio_patch_handle_t mPatchHandle;
+ const audio_io_handle_t mPlaybackThreadHandle;
+ const audio_io_handle_t mRecordThreadHandle;
+};
+
+class IAfPatchPanel : public virtual RefBase {
+public:
+ static sp<IAfPatchPanel> create(AudioFlinger* audioFlinger);
+
+ // Extraction of inner Endpoint and Patch classes would require interfaces
+ // (in the Endpoint case a templated interface) but that seems
+ // excessive for now. We keep them as inner classes until extraction
+ // is needed.
+ template <typename ThreadType, typename TrackType>
+ class Endpoint final {
+ public:
+ Endpoint() = default;
+ Endpoint(const Endpoint&) = delete;
+ Endpoint& operator=(const Endpoint& other) noexcept {
+ mThread = other.mThread;
+ mCloseThread = other.mCloseThread;
+ mHandle = other.mHandle;
+ mTrack = other.mTrack;
+ return *this;
+ }
+ Endpoint(Endpoint&& other) noexcept { swap(other); }
+ Endpoint& operator=(Endpoint&& other) noexcept {
+ swap(other);
+ return *this;
+ }
+ ~Endpoint() {
+ ALOGE_IF(
+ mHandle != AUDIO_PATCH_HANDLE_NONE,
+ "A non empty Patch Endpoint leaked, handle %d", mHandle);
+ }
+
+ status_t checkTrack(TrackType* trackOrNull) const {
+ if (trackOrNull == nullptr) return NO_MEMORY;
+ return trackOrNull->initCheck();
+ }
+ audio_patch_handle_t handle() const { return mHandle; }
+ sp<ThreadType> thread() const { return mThread; }
+ sp<TrackType> track() const { return mTrack; }
+ sp<const ThreadType> const_thread() const { return mThread; }
+ sp<const TrackType> const_track() const { return mTrack; }
+
+ void closeConnections(const sp<IAfPatchPanel>& panel) {
+ if (mHandle != AUDIO_PATCH_HANDLE_NONE) {
+ panel->releaseAudioPatch(mHandle);
+ mHandle = AUDIO_PATCH_HANDLE_NONE;
+ }
+ if (mThread != nullptr) {
+ if (mTrack != nullptr) {
+ mThread->deletePatchTrack(mTrack);
+ }
+ if (mCloseThread) {
+ panel->closeThreadInternal_l(mThread);
+ }
+ }
+ }
+ audio_patch_handle_t* handlePtr() { return &mHandle; }
+ void setThread(const sp<ThreadType>& thread, bool closeThread = true) {
+ mThread = thread;
+ mCloseThread = closeThread;
+ }
+ template <typename T>
+ void setTrackAndPeer(const sp<TrackType>& track, const sp<T>& peer, bool holdReference) {
+ mTrack = track;
+ mThread->addPatchTrack(mTrack);
+ mTrack->setPeerProxy(peer, holdReference);
+ mClearPeerProxy = holdReference;
+ }
+ void clearTrackPeer() {
+ if (mClearPeerProxy && mTrack) mTrack->clearPeerProxy();
+ }
+ void stopTrack() {
+ if (mTrack) mTrack->stop();
+ }
+
+ void swap(Endpoint& other) noexcept {
+ using std::swap;
+ swap(mThread, other.mThread);
+ swap(mCloseThread, other.mCloseThread);
+ swap(mClearPeerProxy, other.mClearPeerProxy);
+ swap(mHandle, other.mHandle);
+ swap(mTrack, other.mTrack);
+ }
+
+ friend void swap(Endpoint& a, Endpoint& b) noexcept { a.swap(b); }
+
+ private:
+ sp<ThreadType> mThread;
+ bool mCloseThread = true;
+ bool mClearPeerProxy = true;
+ audio_patch_handle_t mHandle = AUDIO_PATCH_HANDLE_NONE;
+ sp<TrackType> mTrack;
+ };
+
+ class Patch final {
+ public:
+ Patch(const struct audio_patch& patch, bool endpointPatch)
+ : mAudioPatch(patch), mIsEndpointPatch(endpointPatch) {}
+ Patch() = default;
+ ~Patch();
+ Patch(const Patch& other) noexcept {
+ mAudioPatch = other.mAudioPatch;
+ mHalHandle = other.mHalHandle;
+ mPlayback = other.mPlayback;
+ mRecord = other.mRecord;
+ mThread = other.mThread;
+ mIsEndpointPatch = other.mIsEndpointPatch;
+ }
+ Patch(Patch&& other) noexcept { swap(other); }
+ Patch& operator=(Patch&& other) noexcept {
+ swap(other);
+ return *this;
+ }
+
+ void swap(Patch& other) noexcept {
+ using std::swap;
+ swap(mAudioPatch, other.mAudioPatch);
+ swap(mHalHandle, other.mHalHandle);
+ swap(mPlayback, other.mPlayback);
+ swap(mRecord, other.mRecord);
+ swap(mThread, other.mThread);
+ swap(mIsEndpointPatch, other.mIsEndpointPatch);
+ }
+
+ friend void swap(Patch& a, Patch& b) noexcept { a.swap(b); }
+
+ status_t createConnections(const sp<IAfPatchPanel>& panel);
+ void clearConnections(const sp<IAfPatchPanel>& panel);
+ bool isSoftware() const {
+ return mRecord.handle() != AUDIO_PATCH_HANDLE_NONE ||
+ mPlayback.handle() != AUDIO_PATCH_HANDLE_NONE;
+ }
+
+ void setThread(const sp<IAfThreadBase>& thread) { mThread = thread; }
+ wp<IAfThreadBase> thread() const { return mThread; }
+
+ // returns the latency of the patch (from record to playback).
+ status_t getLatencyMs(double* latencyMs) const;
+
+ String8 dump(audio_patch_handle_t myHandle) const;
+
+ // Note that audio_patch::id is only unique within a HAL module
+ struct audio_patch mAudioPatch;
+ // handle for audio HAL patch handle present only when the audio HAL version is >= 3.0
+ audio_patch_handle_t mHalHandle = AUDIO_PATCH_HANDLE_NONE;
+ // below members are used by a software audio patch connecting a source device from a
+ // given audio HW module to a sink device on an other audio HW module.
+ // the objects are created by createConnections() and released by clearConnections()
+ // playback thread is created if no existing playback thread can be used
+ // connects playback thread output to sink device
+ Endpoint<IAfPlaybackThread, IAfPatchTrack> mPlayback;
+ // connects source device to record thread input
+ Endpoint<IAfRecordThread, IAfPatchRecord> mRecord;
+
+ wp<IAfThreadBase> mThread;
+ bool mIsEndpointPatch;
+ };
+
+ /* List connected audio ports and their attributes */
+ virtual status_t listAudioPorts(unsigned int* num_ports, struct audio_port* ports) = 0;
+
+ /* Get supported attributes for a given audio port */
+ virtual status_t getAudioPort(struct audio_port_v7* port) = 0;
+
+ /* Create a patch between several source and sink ports */
+ virtual status_t createAudioPatch(
+ const struct audio_patch* patch,
+ audio_patch_handle_t* handle,
+ bool endpointPatch = false) = 0;
+
+ /* Release a patch */
+ virtual status_t releaseAudioPatch(audio_patch_handle_t handle) = 0;
+
+ /* List connected audio devices and they attributes */
+ virtual status_t listAudioPatches(unsigned int* num_patches, struct audio_patch* patches) = 0;
+
+ // Retrieves all currently estrablished software patches for a stream
+ // opened on an intermediate module.
+ virtual status_t getDownstreamSoftwarePatches(
+ audio_io_handle_t stream, std::vector<SoftwarePatch>* patches) const = 0;
+
+ // Notifies patch panel about all opened and closed streams.
+ virtual void notifyStreamOpened(
+ AudioHwDevice* audioHwDevice, audio_io_handle_t stream, struct audio_patch* patch) = 0;
+
+ virtual void notifyStreamClosed(audio_io_handle_t stream) = 0;
+
+ virtual void dump(int fd) const = 0;
+
+ // Must be called under AudioFlinger::mLock
+
+ virtual const std::map<audio_patch_handle_t, Patch>& patches_l() const = 0;
+
+ virtual status_t getLatencyMs_l(audio_patch_handle_t patchHandle, double* latencyMs) const = 0;
+
+ virtual void closeThreadInternal_l(const sp<IAfThreadBase>& thread) const = 0;
+};
+
+} // namespace android
diff --git a/services/audioflinger/IAfThread.h b/services/audioflinger/IAfThread.h
new file mode 100644
index 0000000..ce4d62d
--- /dev/null
+++ b/services/audioflinger/IAfThread.h
@@ -0,0 +1,517 @@
+/*
+ * Copyright (C) 2023 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 "IAfTrack.h"
+
+namespace android {
+
+class IAfDirectOutputThread;
+class IAfDuplicatingThread;
+class IAfMmapCaptureThread;
+class IAfMmapPlaybackThread;
+class IAfPlaybackThread;
+class IAfRecordThread;
+
+class IAfThreadBase : public virtual RefBase {
+public:
+ enum type_t {
+ MIXER, // Thread class is MixerThread
+ DIRECT, // Thread class is DirectOutputThread
+ DUPLICATING, // Thread class is DuplicatingThread
+ RECORD, // Thread class is RecordThread
+ OFFLOAD, // Thread class is OffloadThread
+ MMAP_PLAYBACK, // Thread class for MMAP playback stream
+ MMAP_CAPTURE, // Thread class for MMAP capture stream
+ SPATIALIZER, //
+ BIT_PERFECT, // Thread class for BitPerfectThread
+ // When adding a value, also update IAfThreadBase::threadTypeToString()
+ };
+
+ static const char* threadTypeToString(type_t type);
+ virtual status_t readyToRun() = 0;
+ virtual void clearPowerManager() = 0;
+ virtual status_t initCheck() const = 0;
+ virtual type_t type() const = 0;
+ virtual bool isDuplicating() const = 0;
+ virtual audio_io_handle_t id() const = 0;
+ virtual uint32_t sampleRate() const = 0;
+ virtual audio_channel_mask_t channelMask() const = 0;
+ virtual audio_channel_mask_t mixerChannelMask() const = 0;
+ virtual audio_format_t format() const = 0;
+ virtual uint32_t channelCount() const = 0;
+
+ // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
+ // and returns the [normal mix] buffer's frame count.
+ virtual size_t frameCount() const = 0;
+ virtual audio_channel_mask_t hapticChannelMask() const = 0;
+ virtual uint32_t hapticChannelCount() const = 0;
+ virtual uint32_t latency_l() const = 0;
+ virtual void setVolumeForOutput_l(float left, float right) const = 0;
+
+ // Return's the HAL's frame count i.e. fast mixer buffer size.
+ virtual size_t frameCountHAL() const = 0;
+ virtual size_t frameSize() const = 0;
+ // Should be "virtual status_t requestExitAndWait()" and override same
+ // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
+ virtual void exit() = 0;
+ virtual bool checkForNewParameter_l(const String8& keyValuePair, status_t& status) = 0;
+ virtual status_t setParameters(const String8& keyValuePairs) = 0;
+ virtual String8 getParameters(const String8& keys) = 0;
+ virtual void ioConfigChanged(
+ audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
+
+ // sendConfigEvent_l() must be called with ThreadBase::mLock held
+ // Can temporarily release the lock if waiting for a reply from
+ // processConfigEvents_l().
+ // status_t sendConfigEvent_l(sp<ConfigEvent>& event);
+ virtual void sendIoConfigEvent(
+ audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
+ virtual void sendIoConfigEvent_l(
+ audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
+ virtual void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) = 0;
+ virtual void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp) = 0;
+ virtual status_t sendSetParameterConfigEvent_l(const String8& keyValuePair) = 0;
+ virtual status_t sendCreateAudioPatchConfigEvent(
+ const struct audio_patch* patch, audio_patch_handle_t* handle) = 0;
+ virtual status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle) = 0;
+ virtual status_t sendUpdateOutDeviceConfigEvent(
+ const DeviceDescriptorBaseVector& outDevices) = 0;
+ virtual void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs) = 0;
+ virtual void sendCheckOutputStageEffectsEvent() = 0;
+ virtual void sendCheckOutputStageEffectsEvent_l() = 0;
+ virtual void sendHalLatencyModesChangedEvent_l() = 0;
+
+ virtual void processConfigEvents_l() = 0;
+ virtual void setCheckOutputStageEffects() = 0;
+ virtual void cacheParameters_l() = 0;
+ virtual status_t createAudioPatch_l(
+ const struct audio_patch* patch, audio_patch_handle_t* handle) = 0;
+ virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
+ virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) = 0;
+ virtual void toAudioPortConfig(struct audio_port_config* config) = 0;
+ virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) = 0;
+
+ // see note at declaration of mStandby, mOutDevice and mInDevice
+ virtual bool inStandby() const = 0;
+ virtual const DeviceTypeSet outDeviceTypes() const = 0;
+ virtual audio_devices_t inDeviceType() const = 0;
+ virtual DeviceTypeSet getDeviceTypes() const = 0;
+ virtual const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const = 0;
+ virtual const AudioDeviceTypeAddr& inDeviceTypeAddr() const = 0;
+ virtual bool isOutput() const = 0;
+ virtual bool isOffloadOrMmap() const = 0;
+ virtual sp<StreamHalInterface> stream() const = 0;
+ virtual sp<IAfEffectHandle> createEffect_l(
+ const sp<Client>& client,
+ const sp<media::IEffectClient>& effectClient,
+ int32_t priority,
+ audio_session_t sessionId,
+ effect_descriptor_t* desc,
+ int* enabled,
+ status_t* status /*non-NULL*/,
+ bool pinned,
+ bool probe,
+ bool notifyFramesProcessed) = 0;
+
+ // return values for hasAudioSession (bit field)
+ enum effect_state {
+ EFFECT_SESSION = 0x1, // the audio session corresponds to at least one
+ // effect
+ TRACK_SESSION = 0x2, // the audio session corresponds to at least one
+ // track
+ FAST_SESSION = 0x4, // the audio session corresponds to at least one
+ // fast track
+ SPATIALIZED_SESSION = 0x8, // the audio session corresponds to at least one
+ // spatialized track
+ BIT_PERFECT_SESSION = 0x10 // the audio session corresponds to at least one
+ // bit-perfect track
+ };
+
+ // get effect chain corresponding to session Id.
+ virtual sp<IAfEffectChain> getEffectChain(audio_session_t sessionId) const = 0;
+ // same as getEffectChain() but must be called with ThreadBase mutex locked
+ virtual sp<IAfEffectChain> getEffectChain_l(audio_session_t sessionId) const = 0;
+ virtual std::vector<int> getEffectIds_l(audio_session_t sessionId) const = 0;
+ // add an effect chain to the chain list (mEffectChains)
+ virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
+ // remove an effect chain from the chain list (mEffectChains)
+ virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
+ // lock all effect chains Mutexes. Must be called before releasing the
+ // ThreadBase mutex before processing the mixer and effects. This guarantees the
+ // integrity of the chains during the process.
+ // Also sets the parameter 'effectChains' to current value of mEffectChains.
+ virtual void lockEffectChains_l(Vector<sp<IAfEffectChain>>& effectChains) = 0;
+ // unlock effect chains after process
+ virtual void unlockEffectChains(const Vector<sp<IAfEffectChain>>& effectChains) = 0;
+ // get a copy of mEffectChains vector
+ virtual Vector<sp<IAfEffectChain>> getEffectChains_l() const = 0;
+ // set audio mode to all effect chains
+ virtual void setMode(audio_mode_t mode) = 0;
+ // get effect module with corresponding ID on specified audio session
+ virtual sp<IAfEffectModule> getEffect(audio_session_t sessionId, int effectId) const = 0;
+ virtual sp<IAfEffectModule> getEffect_l(audio_session_t sessionId, int effectId) const = 0;
+ // add and effect module. Also creates the effect chain is none exists for
+ // the effects audio session. Only called in a context of moving an effect
+ // from one thread to another
+ virtual status_t addEffect_l(const sp<IAfEffectModule>& effect) = 0;
+ // remove and effect module. Also removes the effect chain is this was the last
+ // effect
+ virtual void removeEffect_l(const sp<IAfEffectModule>& effect, bool release = false) = 0;
+ // disconnect an effect handle from module and destroy module if last handle
+ virtual void disconnectEffectHandle(IAfEffectHandle* handle, bool unpinIfLast) = 0;
+ // detach all tracks connected to an auxiliary effect
+ virtual void detachAuxEffect_l(int effectId) = 0;
+ // returns a combination of:
+ // - EFFECT_SESSION if effects on this audio session exist in one chain
+ // - TRACK_SESSION if tracks on this audio session exist
+ // - FAST_SESSION if fast tracks on this audio session exist
+ // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
+ virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
+ virtual uint32_t hasAudioSession(audio_session_t sessionId) const = 0;
+
+ // the value returned by default implementation is not important as the
+ // strategy is only meaningful for PlaybackThread which implements this method
+ virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId) const = 0;
+
+ // check if some effects must be suspended/restored when an effect is enabled
+ // or disabled
+ virtual void checkSuspendOnEffectEnabled(
+ bool enabled, audio_session_t sessionId, bool threadLocked) = 0;
+
+ virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) = 0;
+ virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const = 0;
+
+ // Return a reference to a per-thread heap which can be used to allocate IMemory
+ // objects that will be read-only to client processes, read/write to mediaserver,
+ // and shared by all client processes of the thread.
+ // The heap is per-thread rather than common across all threads, because
+ // clients can't be trusted not to modify the offset of the IMemory they receive.
+ // If a thread does not have such a heap, this method returns 0.
+ virtual sp<MemoryDealer> readOnlyHeap() const = 0;
+
+ virtual sp<IMemory> pipeMemory() const = 0;
+
+ virtual void systemReady() = 0;
+
+ // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
+ virtual status_t checkEffectCompatibility_l(
+ const effect_descriptor_t* desc, audio_session_t sessionId) = 0;
+
+ virtual void broadcast_l() = 0;
+
+ virtual bool isTimestampCorrectionEnabled() const = 0;
+
+ virtual bool isMsdDevice() const = 0;
+
+ virtual void dump(int fd, const Vector<String16>& args) = 0;
+
+ // deliver stats to mediametrics.
+ virtual void sendStatistics(bool force) = 0;
+
+ virtual Mutex& mutex() const = 0;
+
+ virtual void onEffectEnable(const sp<IAfEffectModule>& effect) = 0;
+ virtual void onEffectDisable() = 0;
+
+ // invalidateTracksForAudioSession_l must be called with holding mLock.
+ virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId) const = 0;
+ // Invalidate all the tracks with the given audio session.
+ virtual void invalidateTracksForAudioSession(audio_session_t sessionId) const = 0;
+
+ virtual bool isStreamInitialized() const = 0;
+ virtual void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) = 0;
+ virtual void stopMelComputation_l() = 0;
+
+ virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) const = 0;
+
+ virtual void setEffectSuspended_l(
+ const effect_uuid_t* type, bool suspend, audio_session_t sessionId) = 0;
+
+ // Dynamic cast to derived interface
+ virtual sp<IAfDirectOutputThread> asIAfDirectOutputThread() { return nullptr; }
+ virtual sp<IAfDuplicatingThread> asIAfDuplicatingThread() { return nullptr; }
+ virtual sp<IAfPlaybackThread> asIAfPlaybackThread() { return nullptr; }
+ virtual sp<IAfRecordThread> asIAfRecordThread() { return nullptr; }
+ virtual AudioFlinger* audioFlinger() const = 0;
+};
+
+class IAfPlaybackThread : public virtual IAfThreadBase, public virtual VolumeInterface {
+public:
+ static sp<IAfPlaybackThread> createBitPerfectThread(
+ const sp<AudioFlinger>& audioflinger, AudioStreamOut* output, audio_io_handle_t id,
+ bool systemReady);
+
+ static sp<IAfPlaybackThread> createDirectOutputThread(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
+ bool systemReady, const audio_offload_info_t& offloadInfo);
+
+ static sp<IAfPlaybackThread> createMixerThread(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
+ bool systemReady, type_t type = MIXER, audio_config_base_t* mixerConfig = nullptr);
+
+ static sp<IAfPlaybackThread> createOffloadThread(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
+ bool systemReady, const audio_offload_info_t& offloadInfo);
+
+ static sp<IAfPlaybackThread> createSpatializerThread(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, audio_io_handle_t id,
+ bool systemReady, audio_config_base_t* mixerConfig);
+
+ static constexpr int8_t kMaxTrackStopRetriesOffload = 2;
+
+ enum mixer_state {
+ MIXER_IDLE, // no active tracks
+ MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
+ MIXER_TRACKS_READY, // at least one active track, and at least one track has data
+ MIXER_DRAIN_TRACK, // drain currently playing track
+ MIXER_DRAIN_ALL, // fully drain the hardware
+ // standby mode does not have an enum value
+ // suspend by audio policy manager is orthogonal to mixer state
+ };
+
+ // return estimated latency in milliseconds, as reported by HAL
+ virtual uint32_t latency() const = 0; // should be in IAfThreadBase?
+
+ virtual uint32_t& fastTrackAvailMask_l() = 0;
+
+ virtual sp<IAfTrack> createTrack_l(
+ const sp<Client>& client,
+ audio_stream_type_t streamType,
+ const audio_attributes_t& attr,
+ uint32_t* sampleRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ size_t* pFrameCount,
+ size_t* pNotificationFrameCount,
+ uint32_t notificationsPerBuffer,
+ float speed,
+ const sp<IMemory>& sharedBuffer,
+ audio_session_t sessionId,
+ audio_output_flags_t* flags,
+ pid_t creatorPid,
+ const AttributionSourceState& attributionSource,
+ pid_t tid,
+ status_t* status /*non-NULL*/,
+ audio_port_handle_t portId,
+ const sp<media::IAudioTrackCallback>& callback,
+ bool isSpatialized,
+ bool isBitPerfect) = 0;
+
+ virtual status_t addTrack_l(const sp<IAfTrack>& track) = 0;
+ virtual bool destroyTrack_l(const sp<IAfTrack>& track) = 0;
+ virtual bool isTrackActive(const sp<IAfTrack>& track) const = 0;
+ virtual void addOutputTrack_l(const sp<IAfTrack>& track) = 0;
+
+ virtual AudioStreamOut* getOutput_l() const = 0;
+ virtual AudioStreamOut* getOutput() const = 0;
+ virtual AudioStreamOut* clearOutput() = 0;
+
+ // a very large number of suspend() will eventually wraparound, but unlikely
+ virtual void suspend() = 0;
+ virtual void restore() = 0;
+ virtual bool isSuspended() const = 0;
+ virtual status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames) const = 0;
+ // Consider also removing and passing an explicit mMainBuffer initialization
+ // parameter to AF::IAfTrack::Track().
+ virtual float* sinkBuffer() const = 0;
+
+ virtual status_t attachAuxEffect(const sp<IAfTrack>& track, int EffectId) = 0;
+ virtual status_t attachAuxEffect_l(const sp<IAfTrack>& track, int EffectId) = 0;
+
+ // called with AudioFlinger lock held
+ virtual bool invalidateTracks_l(audio_stream_type_t streamType) = 0;
+ virtual bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds) = 0;
+ virtual void invalidateTracks(audio_stream_type_t streamType) = 0;
+ // Invalidate tracks by a set of port ids. The port id will be removed from
+ // the given set if the corresponding track is found and invalidated.
+ virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds) = 0;
+
+ virtual status_t getTimestamp_l(AudioTimestamp& timestamp) = 0;
+ virtual void addPatchTrack(const sp<IAfPatchTrack>& track) = 0;
+ virtual void deletePatchTrack(const sp<IAfPatchTrack>& track) = 0;
+
+ // Return the asynchronous signal wait time.
+ virtual int64_t computeWaitTimeNs_l() const = 0;
+ // returns true if the track is allowed to be added to the thread.
+ virtual bool isTrackAllowed_l(
+ audio_channel_mask_t channelMask, audio_format_t format, audio_session_t sessionId,
+ uid_t uid) const = 0;
+
+ virtual bool supportsHapticPlayback() const = 0;
+
+ virtual void setDownStreamPatch(const struct audio_patch* patch) = 0;
+
+ virtual IAfTrack* getTrackById_l(audio_port_handle_t trackId) = 0;
+
+ virtual bool hasMixer() const = 0;
+
+ virtual status_t setRequestedLatencyMode(audio_latency_mode_t mode) = 0;
+
+ virtual status_t getSupportedLatencyModes(std::vector<audio_latency_mode_t>* modes) = 0;
+
+ virtual status_t setBluetoothVariableLatencyEnabled(bool enabled) = 0;
+
+ virtual void setStandby() = 0;
+ virtual void setStandby_l() = 0;
+ virtual bool waitForHalStart() = 0;
+
+ virtual bool hasFastMixer() const = 0;
+ virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const = 0;
+ virtual const std::atomic<int64_t>& framesWritten() const = 0;
+
+ virtual bool usesHwAvSync() const = 0;
+};
+
+class IAfDirectOutputThread : public virtual IAfPlaybackThread {
+public:
+ virtual status_t selectPresentation(int presentationId, int programId) = 0;
+};
+
+class IAfDuplicatingThread : public virtual IAfPlaybackThread {
+public:
+ static sp<IAfDuplicatingThread> create(
+ const sp<AudioFlinger>& audioFlinger, IAfPlaybackThread* mainThread,
+ audio_io_handle_t id, bool systemReady);
+
+ virtual void addOutputTrack(IAfPlaybackThread* thread) = 0;
+ virtual uint32_t waitTimeMs() const = 0;
+ virtual void removeOutputTrack(IAfPlaybackThread* thread) = 0;
+};
+
+class IAfRecordThread : public virtual IAfThreadBase {
+public:
+ static sp<IAfRecordThread> create(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamIn* input, audio_io_handle_t id,
+ bool systemReady);
+
+ virtual sp<IAfRecordTrack> createRecordTrack_l(
+ const sp<Client>& client,
+ const audio_attributes_t& attr,
+ uint32_t* pSampleRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ size_t* pFrameCount,
+ audio_session_t sessionId,
+ size_t* pNotificationFrameCount,
+ pid_t creatorPid,
+ const AttributionSourceState& attributionSource,
+ audio_input_flags_t* flags,
+ pid_t tid,
+ status_t* status /*non-NULL*/,
+ audio_port_handle_t portId,
+ int32_t maxSharedAudioHistoryMs) = 0;
+ virtual void destroyTrack_l(const sp<IAfRecordTrack>& track) = 0;
+ virtual void removeTrack_l(const sp<IAfRecordTrack>& track) = 0;
+
+ virtual status_t start(
+ IAfRecordTrack* recordTrack, AudioSystem::sync_event_t event,
+ audio_session_t triggerSession) = 0;
+
+ // ask the thread to stop the specified track, and
+ // return true if the caller should then do it's part of the stopping process
+ virtual bool stop(IAfRecordTrack* recordTrack) = 0;
+
+ virtual AudioStreamIn* getInput() const = 0;
+ virtual AudioStreamIn* clearInput() = 0;
+
+ virtual status_t getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) const = 0;
+ virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) = 0;
+ virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
+
+ virtual void addPatchTrack(const sp<IAfPatchRecord>& record) = 0;
+ virtual void deletePatchTrack(const sp<IAfPatchRecord>& record) = 0;
+ virtual bool fastTrackAvailable() const = 0;
+ virtual void setFastTrackAvailable(bool available) = 0;
+
+ virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced) = 0;
+ virtual bool hasFastCapture() const = 0;
+
+ virtual void checkBtNrec() = 0;
+ virtual uint32_t getInputFramesLost() const = 0;
+
+ virtual status_t shareAudioHistory(
+ const std::string& sharedAudioPackageName,
+ audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
+ int64_t sharedAudioStartMs = -1) = 0;
+ virtual void resetAudioHistory_l() = 0;
+};
+
+class IAfMmapThread : public virtual IAfThreadBase {
+public:
+ // createIAudioTrackAdapter() is a static constructor which creates an
+ // MmapStreamInterface AIDL interface adapter from the MmapThread object that
+ // may be passed back to the client.
+ //
+ // Only one AIDL MmapStreamInterface interface adapter should be created per MmapThread.
+ static sp<MmapStreamInterface> createMmapStreamInterfaceAdapter(
+ const sp<IAfMmapThread>& mmapThread);
+
+ virtual void configure(
+ const audio_attributes_t* attr,
+ audio_stream_type_t streamType,
+ audio_session_t sessionId,
+ const sp<MmapStreamCallback>& callback,
+ audio_port_handle_t deviceId,
+ audio_port_handle_t portId) = 0;
+ virtual void disconnect() = 0;
+
+ // MmapStreamInterface handling (see adapter)
+ virtual status_t createMmapBuffer(
+ int32_t minSizeFrames, struct audio_mmap_buffer_info* info) = 0;
+ virtual status_t getMmapPosition(struct audio_mmap_position* position) const = 0;
+ virtual status_t start(
+ const AudioClient& client, const audio_attributes_t* attr,
+ audio_port_handle_t* handle) = 0;
+ virtual status_t stop(audio_port_handle_t handle) = 0;
+ virtual status_t standby() = 0;
+ virtual status_t getExternalPosition(uint64_t* position, int64_t* timeNanos) const = 0;
+ virtual status_t reportData(const void* buffer, size_t frameCount) = 0;
+
+ // TODO(b/291317898) move to IAfThreadBase?
+ virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds) = 0;
+
+ // Sets the UID records silence - TODO(b/291317898) move to IAfMmapCaptureThread
+ virtual void setRecordSilenced(audio_port_handle_t portId, bool silenced) = 0;
+
+ virtual sp<IAfMmapPlaybackThread> asIAfMmapPlaybackThread() { return nullptr; }
+ virtual sp<IAfMmapCaptureThread> asIAfMmapCaptureThread() { return nullptr; }
+};
+
+class IAfMmapPlaybackThread : public virtual IAfMmapThread, public virtual VolumeInterface {
+public:
+ static sp<IAfMmapPlaybackThread> create(
+ const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, AudioHwDevice* hwDev,
+ AudioStreamOut* output, bool systemReady);
+
+ virtual AudioStreamOut* clearOutput() = 0;
+};
+
+class IAfMmapCaptureThread : public virtual IAfMmapThread {
+public:
+ static sp<IAfMmapCaptureThread> create(
+ const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, AudioHwDevice* hwDev,
+ AudioStreamIn* input, bool systemReady);
+
+ virtual AudioStreamIn* clearInput() = 0;
+};
+
+} // namespace android
diff --git a/services/audioflinger/IAfTrack.h b/services/audioflinger/IAfTrack.h
index 541be0a..2763157 100644
--- a/services/audioflinger/IAfTrack.h
+++ b/services/audioflinger/IAfTrack.h
@@ -18,6 +18,20 @@
namespace android {
+class IAfDuplicatingThread;
+class IAfPatchRecord;
+class IAfPatchTrack;
+class IAfPlaybackThread;
+class IAfRecordThread;
+class IAfThreadBase;
+
+struct TeePatch {
+ sp<IAfPatchRecord> patchRecord;
+ sp<IAfPatchTrack> patchTrack;
+};
+
+using TeePatches = std::vector<TeePatch>;
+
// Common interface to all Playback and Record tracks.
class IAfTrackBase : public virtual RefBase {
public:
@@ -97,8 +111,7 @@
virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer) = 0;
// Added for RecordTrack and OutputTrack
- // TODO(b/288339104) type
- virtual wp<Thread> thread() const = 0;
+ virtual wp<IAfThreadBase> thread() const = 0;
virtual const sp<ServerProxy>& serverProxy() const = 0;
// TEE_SINK
@@ -208,12 +221,12 @@
/**
* For RecordTrack
- * TODO(b/288339104) either use this or add asRecordTrack or asTrack etc.
+ * TODO(b/291317964) either use this or add asRecordTrack or asTrack etc.
*/
virtual void handleSyncStartEvent(const sp<audioflinger::SyncEvent>& event __unused){};
// For Thread use, fast tracks and offloaded tracks only
- // TODO(b/288339104) rearrange to IAfTrack.
+ // TODO(b/291317964) rearrange to IAfTrack.
virtual bool isStopped() const = 0;
virtual bool isStopping() const = 0;
virtual bool isStopping_1() const = 0;
@@ -233,8 +246,8 @@
// Only one AIDL IAudioTrack interface adapter should be created per Track.
static sp<media::IAudioTrack> createIAudioTrackAdapter(const sp<IAfTrack>& track);
- static sp<IAfTrack> create( // TODO(b/288339104) void*
- void* /* AudioFlinger::PlaybackThread */ thread,
+ static sp<IAfTrack> create(
+ IAfPlaybackThread* thread,
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -321,9 +334,8 @@
// This function should be called with holding thread lock.
virtual void updateTeePatches_l() = 0;
- // TODO(b/288339104) type
- virtual void setTeePatchesToUpdate_l(
- const void* teePatchesToUpdate /* TeePatches& teePatchesToUpdate */) = 0;
+ // Argument teePatchesToUpdate is by value, use std::move to optimize.
+ virtual void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate) = 0;
static bool checkServerLatencySupported(audio_format_t format, audio_output_flags_t flags) {
return audio_is_linear_pcm(format) && (flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) == 0;
@@ -388,7 +400,7 @@
virtual ExtendedAudioBufferProvider* asExtendedAudioBufferProvider() = 0;
virtual VolumeProvider* asVolumeProvider() = 0;
- // TODO(b/288339104) split into getter/setter
+ // TODO(b/291317964) split into getter/setter
virtual FillingStatus& fillingStatus() = 0;
virtual int8_t& retryCount() = 0;
virtual FastTrackUnderruns& fastTrackUnderruns() = 0;
@@ -397,10 +409,9 @@
// playback track, used by DuplicatingThread
class IAfOutputTrack : public virtual IAfTrack {
public:
- // TODO(b/288339104) void*
static sp<IAfOutputTrack> create(
- void* /* AudioFlinger::PlaybackThread */ playbackThread,
- void* /* AudioFlinger::DuplicatingThread */ sourceThread, uint32_t sampleRate,
+ IAfPlaybackThread* playbackThread,
+ IAfDuplicatingThread* sourceThread, uint32_t sampleRate,
audio_format_t format, audio_channel_mask_t channelMask, size_t frameCount,
const AttributionSourceState& attributionSource);
@@ -416,8 +427,7 @@
class IAfMmapTrack : public virtual IAfTrackBase {
public:
- // TODO(b/288339104) void*
- static sp<IAfMmapTrack> create(void* /*AudioFlinger::ThreadBase */ thread,
+ static sp<IAfMmapTrack> create(IAfThreadBase* thread,
const audio_attributes_t& attr,
uint32_t sampleRate,
audio_format_t format,
@@ -454,8 +464,7 @@
// Only one AIDL IAudioRecord interface adapter should be created per RecordTrack.
static sp<media::IAudioRecord> createIAudioRecordAdapter(const sp<IAfRecordTrack>& recordTrack);
- // TODO(b/288339104) void*
- static sp<IAfRecordTrack> create(void* /* AudioFlinger::RecordThread */ thread,
+ static sp<IAfRecordTrack> create(IAfRecordThread* thread,
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t sampleRate,
@@ -477,7 +486,7 @@
// set the buffer overflow flag and return previous value
virtual bool setOverflow() = 0;
- // TODO(b/288339104) handleSyncStartEvent in IAfTrackBase should move here.
+ // TODO(b/291317964) handleSyncStartEvent in IAfTrackBase should move here.
virtual void clearSyncStartEvent() = 0;
virtual void updateTrackFrameInfo(
int64_t trackFramesReleased, int64_t sourceFramesRead, uint32_t halSampleRate,
@@ -533,7 +542,7 @@
class IAfPatchTrack : public virtual IAfTrack, public virtual IAfPatchTrackBase {
public:
static sp<IAfPatchTrack> create(
- void * /* PlaybackThread */ playbackThread, // TODO(b/288339104)
+ IAfPlaybackThread* playbackThread,
audio_stream_type_t streamType,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
@@ -549,19 +558,10 @@
* even if it might glitch. */);
};
-// Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).
-struct Source {
- virtual ~Source() = default;
- // The following methods have the same signatures as in StreamHalInterface.
- virtual status_t read(void* buffer, size_t bytes, size_t* read) = 0;
- virtual status_t getCapturePosition(int64_t* frames, int64_t* time) = 0;
- virtual status_t standby() = 0;
-};
-
class IAfPatchRecord : public virtual IAfRecordTrack, public virtual IAfPatchTrackBase {
public:
static sp<IAfPatchRecord> create(
- void* /* RecordThread */ recordThread, // TODO(b/288339104)
+ IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -573,7 +573,7 @@
audio_source_t source = AUDIO_SOURCE_DEFAULT);
static sp<IAfPatchRecord> createPassThru(
- void* /* RecordThread */ recordThread, // TODO(b/288339104)
+ IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
diff --git a/services/audioflinger/MelReporter.cpp b/services/audioflinger/MelReporter.cpp
index 53d5837..0f739b0 100644
--- a/services/audioflinger/MelReporter.cpp
+++ b/services/audioflinger/MelReporter.cpp
@@ -16,7 +16,7 @@
*/
// #define LOG_NDEBUG 0
-#define LOG_TAG "AudioFlinger::MelReporter"
+#define LOG_TAG "MelReporter"
#include "AudioFlinger.h"
@@ -28,7 +28,7 @@
namespace android {
-bool AudioFlinger::MelReporter::activateHalSoundDoseComputation(const std::string& module,
+bool MelReporter::activateHalSoundDoseComputation(const std::string& module,
const sp<DeviceHalInterface>& device) {
if (mSoundDoseManager->forceUseFrameworkMel()) {
ALOGD("%s: Forcing use of internal MEL computation.", __func__);
@@ -63,7 +63,7 @@
return true;
}
-void AudioFlinger::MelReporter::activateInternalSoundDoseComputation() {
+void MelReporter::activateInternalSoundDoseComputation() {
{
std::lock_guard _l(mLock);
if (!mUseHalSoundDoseInterface) {
@@ -76,11 +76,11 @@
mSoundDoseManager->setHalSoundDoseInterface(nullptr);
}
-void AudioFlinger::MelReporter::onFirstRef() {
+void MelReporter::onFirstRef() {
mAudioFlinger.mPatchCommandThread->addListener(this);
}
-bool AudioFlinger::MelReporter::shouldComputeMelForDeviceType(audio_devices_t device) {
+bool MelReporter::shouldComputeMelForDeviceType(audio_devices_t device) {
if (!mSoundDoseManager->isCsdEnabled()) {
ALOGV("%s csd is disabled", __func__);
return false;
@@ -104,7 +104,7 @@
}
}
-void AudioFlinger::MelReporter::updateMetadataForCsd(audio_io_handle_t streamHandle,
+void MelReporter::updateMetadataForCsd(audio_io_handle_t streamHandle,
const std::vector<playback_track_metadata_v7_t>& metadataVec) {
if (!mSoundDoseManager->isCsdEnabled()) {
ALOGV("%s csd is disabled", __func__);
@@ -140,8 +140,8 @@
}
}
-void AudioFlinger::MelReporter::onCreateAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) {
+void MelReporter::onCreateAudioPatch(audio_patch_handle_t handle,
+ const IAfPatchPanel::Patch& patch) {
if (!mSoundDoseManager->isCsdEnabled()) {
ALOGV("%s csd is disabled", __func__);
return;
@@ -180,7 +180,7 @@
}
}
-void AudioFlinger::MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch)
+void MelReporter::startMelComputationForActivePatch_l(const ActiveMelPatch& patch)
NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
{
auto outputThread = mAudioFlinger.checkOutputThread_l(patch.streamHandle);
@@ -198,14 +198,14 @@
outputThread->startMelComputation_l(mSoundDoseManager->getOrCreateProcessorForDevice(
deviceHandle,
patch.streamHandle,
- outputThread->mSampleRate,
- outputThread->mChannelCount,
- outputThread->mFormat));
+ outputThread->sampleRate(),
+ outputThread->channelCount(),
+ outputThread->format()));
}
}
}
-void AudioFlinger::MelReporter::onReleaseAudioPatch(audio_patch_handle_t handle) {
+void MelReporter::onReleaseAudioPatch(audio_patch_handle_t handle) {
if (!mSoundDoseManager->isCsdEnabled()) {
ALOGV("%s csd is disabled", __func__);
return;
@@ -231,26 +231,26 @@
stopMelComputationForPatch_l(melPatch);
}
-void AudioFlinger::MelReporter::onUpdateAudioPatch(audio_patch_handle_t oldHandle,
- audio_patch_handle_t newHandle, const PatchPanel::Patch& patch) {
+void MelReporter::onUpdateAudioPatch(audio_patch_handle_t oldHandle,
+ audio_patch_handle_t newHandle, const IAfPatchPanel::Patch& patch) {
onReleaseAudioPatch(oldHandle);
onCreateAudioPatch(newHandle, patch);
}
-sp<media::ISoundDose> AudioFlinger::MelReporter::getSoundDoseInterface(
+sp<media::ISoundDose> MelReporter::getSoundDoseInterface(
const sp<media::ISoundDoseCallback>& callback) {
// no need to lock since getSoundDoseInterface is synchronized
return mSoundDoseManager->getSoundDoseInterface(callback);
}
-void AudioFlinger::MelReporter::stopInternalMelComputation() {
+void MelReporter::stopInternalMelComputation() {
ALOGV("%s", __func__);
std::lock_guard _l(mLock);
mActiveMelPatches.clear();
mUseHalSoundDoseInterface = true;
}
-void AudioFlinger::MelReporter::stopMelComputationForPatch_l(const ActiveMelPatch& patch)
+void MelReporter::stopMelComputationForPatch_l(const ActiveMelPatch& patch)
NO_THREAD_SAFETY_ANALYSIS // access of AudioFlinger::checkOutputThread_l
{
if (!patch.csdActive) {
@@ -278,7 +278,7 @@
}
-std::optional<audio_patch_handle_t> AudioFlinger::MelReporter::activePatchStreamHandle_l(
+std::optional<audio_patch_handle_t> MelReporter::activePatchStreamHandle_l(
audio_io_handle_t streamHandle) {
for(const auto& patchIt : mActiveMelPatches) {
if (patchIt.second.streamHandle == streamHandle) {
@@ -288,11 +288,11 @@
return std::nullopt;
}
-bool AudioFlinger::MelReporter::useHalSoundDoseInterface_l() {
+bool MelReporter::useHalSoundDoseInterface_l() {
return !mSoundDoseManager->forceUseFrameworkMel() & mUseHalSoundDoseInterface;
}
-std::string AudioFlinger::MelReporter::dump() {
+std::string MelReporter::dump() {
std::lock_guard _l(mLock);
std::string output("\nSound Dose:\n");
output.append(mSoundDoseManager->dump());
diff --git a/services/audioflinger/MelReporter.h b/services/audioflinger/MelReporter.h
index 08bbd13..f191c9c 100644
--- a/services/audioflinger/MelReporter.h
+++ b/services/audioflinger/MelReporter.h
@@ -15,14 +15,14 @@
** limitations under the License.
*/
-#ifndef INCLUDING_FROM_AUDIOFLINGER_H
- #error This header file should only be included from AudioFlinger.h
-#endif
+#pragma once
#include <mutex>
#include <sounddose/SoundDoseManager.h>
#include <unordered_map>
+namespace android {
+
constexpr static int kMaxTimestampDeltaInSec = 120;
/**
@@ -67,11 +67,11 @@
// PatchCommandListener methods
void onCreateAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) override;
- void onReleaseAudioPatch(audio_patch_handle_t handle) override;
+ const IAfPatchPanel::Patch& patch) final;
+ void onReleaseAudioPatch(audio_patch_handle_t handle) final;
void onUpdateAudioPatch(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch) override;
+ const IAfPatchPanel::Patch& patch) final;
/**
* The new metadata can determine whether we should compute MEL for the given thread.
@@ -112,9 +112,9 @@
* Locking order AudioFlinger::mLock -> PatchCommandThread::mLock -> MelReporter::mLock.
*/
std::mutex mLock;
- std::unordered_map<audio_patch_handle_t, ActiveMelPatch>
- mActiveMelPatches GUARDED_BY(AudioFlinger::MelReporter::mLock);
- std::unordered_map<audio_port_handle_t, int>
- mActiveDevices GUARDED_BY(AudioFlinger::MelReporter::mLock);
- bool mUseHalSoundDoseInterface GUARDED_BY(AudioFlinger::MelReporter::mLock) = false;
+ std::unordered_map<audio_patch_handle_t, ActiveMelPatch> mActiveMelPatches GUARDED_BY(mLock);
+ std::unordered_map<audio_port_handle_t, int> mActiveDevices GUARDED_BY(mLock);
+ bool mUseHalSoundDoseInterface GUARDED_BY(mLock) = false;
};
+
+} // namespace android
diff --git a/services/audioflinger/MmapTracks.h b/services/audioflinger/MmapTracks.h
index 081af74..c695098 100644
--- a/services/audioflinger/MmapTracks.h
+++ b/services/audioflinger/MmapTracks.h
@@ -22,7 +22,7 @@
// playback track
class MmapTrack : public TrackBase, public IAfMmapTrack {
public:
- MmapTrack(AudioFlinger::ThreadBase* thread,
+ MmapTrack(IAfThreadBase* thread,
const audio_attributes_t& attr,
uint32_t sampleRate,
audio_format_t format,
@@ -60,10 +60,8 @@
*/
void processMuteEvent_l(const sp<IAudioManager>& audioManager,
mute_state_t muteState)
- REQUIRES(AudioFlinger::MmapPlaybackThread::mLock) final;
+ /* REQUIRES(MmapPlaybackThread::mLock) */ final;
private:
- friend class MmapThread;
-
DISALLOW_COPY_AND_ASSIGN(MmapTrack);
// AudioBufferProvider interface
@@ -82,9 +80,9 @@
// TODO: replace PersistableBundle with own struct
// access these two variables only when holding player thread lock.
std::unique_ptr<os::PersistableBundle> mMuteEventExtras
- GUARDED_BY(AudioFlinger::MmapPlaybackThread::mLock);
+ /* GUARDED_BY(MmapPlaybackThread::mLock) */;
mute_state_t mMuteState
- GUARDED_BY(AudioFlinger::MmapPlaybackThread::mLock);
+ /* GUARDED_BY(MmapPlaybackThread::mLock) */;
}; // end of Track
} // namespace android
\ No newline at end of file
diff --git a/services/audioflinger/PatchCommandThread.cpp b/services/audioflinger/PatchCommandThread.cpp
index 858784d..2849da4 100644
--- a/services/audioflinger/PatchCommandThread.cpp
+++ b/services/audioflinger/PatchCommandThread.cpp
@@ -24,25 +24,25 @@
constexpr char kPatchCommandThreadName[] = "AudioFlinger_PatchCommandThread";
-AudioFlinger::PatchCommandThread::~PatchCommandThread() {
+PatchCommandThread::~PatchCommandThread() {
exit();
std::lock_guard _l(mLock);
mCommands.clear();
}
-void AudioFlinger::PatchCommandThread::onFirstRef() {
+void PatchCommandThread::onFirstRef() {
run(kPatchCommandThreadName, ANDROID_PRIORITY_AUDIO);
}
-void AudioFlinger::PatchCommandThread::addListener(const sp<PatchCommandListener>& listener) {
+void PatchCommandThread::addListener(const sp<PatchCommandListener>& listener) {
ALOGV("%s add listener %p", __func__, static_cast<void*>(listener.get()));
std::lock_guard _l(mListenerLock);
mListeners.emplace_back(listener);
}
-void AudioFlinger::PatchCommandThread::createAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) {
+void PatchCommandThread::createAudioPatch(audio_patch_handle_t handle,
+ const IAfPatchPanel::Patch& patch) {
ALOGV("%s handle %d mHalHandle %d num sinks %d device sink %08x",
__func__, handle, patch.mHalHandle,
patch.mAudioPatch.num_sinks,
@@ -51,13 +51,13 @@
createAudioPatchCommand(handle, patch);
}
-void AudioFlinger::PatchCommandThread::releaseAudioPatch(audio_patch_handle_t handle) {
+void PatchCommandThread::releaseAudioPatch(audio_patch_handle_t handle) {
ALOGV("%s", __func__);
releaseAudioPatchCommand(handle);
}
-void AudioFlinger::PatchCommandThread::updateAudioPatch(audio_patch_handle_t oldHandle,
- audio_patch_handle_t newHandle, const PatchPanel::Patch& patch) {
+void PatchCommandThread::updateAudioPatch(audio_patch_handle_t oldHandle,
+ audio_patch_handle_t newHandle, const IAfPatchPanel::Patch& patch) {
ALOGV("%s handle %d mHalHandle %d num sinks %d device sink %08x",
__func__, oldHandle, patch.mHalHandle,
patch.mAudioPatch.num_sinks,
@@ -66,7 +66,7 @@
updateAudioPatchCommand(oldHandle, newHandle, patch);
}
-bool AudioFlinger::PatchCommandThread::threadLoop()
+bool PatchCommandThread::threadLoop()
NO_THREAD_SAFETY_ANALYSIS // bug in clang compiler.
{
std::unique_lock _l(mLock);
@@ -144,14 +144,14 @@
return false;
}
-void AudioFlinger::PatchCommandThread::sendCommand(const sp<Command>& command) {
+void PatchCommandThread::sendCommand(const sp<Command>& command) {
std::lock_guard _l(mLock);
mCommands.emplace_back(command);
mWaitWorkCV.notify_one();
}
-void AudioFlinger::PatchCommandThread::createAudioPatchCommand(
- audio_patch_handle_t handle, const PatchPanel::Patch& patch) {
+void PatchCommandThread::createAudioPatchCommand(
+ audio_patch_handle_t handle, const IAfPatchPanel::Patch& patch) {
auto command = sp<Command>::make(CREATE_AUDIO_PATCH,
new CreateAudioPatchData(handle, patch));
ALOGV("%s adding create patch handle %d mHalHandle %d.",
@@ -161,16 +161,16 @@
sendCommand(command);
}
-void AudioFlinger::PatchCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle) {
+void PatchCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle) {
sp<Command> command =
sp<Command>::make(RELEASE_AUDIO_PATCH, new ReleaseAudioPatchData(handle));
ALOGV("%s adding release patch", __func__);
sendCommand(command);
}
-void AudioFlinger::PatchCommandThread::updateAudioPatchCommand(
+void PatchCommandThread::updateAudioPatchCommand(
audio_patch_handle_t oldHandle, audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch) {
+ const IAfPatchPanel::Patch& patch) {
sp<Command> command = sp<Command>::make(UPDATE_AUDIO_PATCH,
new UpdateAudioPatchData(oldHandle, newHandle, patch));
ALOGV("%s adding update patch old handle %d new handle %d mHalHandle %d.",
@@ -178,7 +178,7 @@
sendCommand(command);
}
-void AudioFlinger::PatchCommandThread::exit() {
+void PatchCommandThread::exit() {
ALOGV("%s", __func__);
{
std::lock_guard _l(mLock);
diff --git a/services/audioflinger/PatchCommandThread.h b/services/audioflinger/PatchCommandThread.h
index ea87c0f..6cf0505 100644
--- a/services/audioflinger/PatchCommandThread.h
+++ b/services/audioflinger/PatchCommandThread.h
@@ -15,14 +15,14 @@
** limitations under the License.
*/
-#ifndef INCLUDING_FROM_AUDIOFLINGER_H
- #error This header file should only be included from AudioFlinger.h
-#endif
+#pragma once
+
+namespace android {
class Command;
// Thread to execute create and release patch commands asynchronously. This is needed because
-// PatchPanel::createAudioPatch and releaseAudioPatch are executed from audio policy service
+// IAfPatchPanel::createAudioPatch and releaseAudioPatch are executed from audio policy service
// with mutex locked and effect management requires to call back into audio policy service
class PatchCommandThread : public Thread {
public:
@@ -36,11 +36,11 @@
class PatchCommandListener : public virtual RefBase {
public:
virtual void onCreateAudioPatch(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch) = 0;
+ const IAfPatchPanel::Patch& patch) = 0;
virtual void onReleaseAudioPatch(audio_patch_handle_t handle) = 0;
virtual void onUpdateAudioPatch(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch) = 0;
+ const IAfPatchPanel::Patch& patch) = 0;
};
PatchCommandThread() : Thread(false /* canCallJava */) {}
@@ -48,11 +48,11 @@
void addListener(const sp<PatchCommandListener>& listener);
- void createAudioPatch(audio_patch_handle_t handle, const PatchPanel::Patch& patch);
+ void createAudioPatch(audio_patch_handle_t handle, const IAfPatchPanel::Patch& patch);
void releaseAudioPatch(audio_patch_handle_t handle);
void updateAudioPatch(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch);
+ const IAfPatchPanel::Patch& patch);
// Thread virtuals
void onFirstRef() override;
@@ -61,11 +61,11 @@
void exit();
void createAudioPatchCommand(audio_patch_handle_t handle,
- const PatchPanel::Patch& patch);
+ const IAfPatchPanel::Patch& patch);
void releaseAudioPatchCommand(audio_patch_handle_t handle);
void updateAudioPatchCommand(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch);
+ const IAfPatchPanel::Patch& patch);
private:
class CommandData;
@@ -84,11 +84,11 @@
class CreateAudioPatchData : public CommandData {
public:
- CreateAudioPatchData(audio_patch_handle_t handle, const PatchPanel::Patch& patch)
+ CreateAudioPatchData(audio_patch_handle_t handle, const IAfPatchPanel::Patch& patch)
: mHandle(handle), mPatch(patch) {}
const audio_patch_handle_t mHandle;
- const PatchPanel::Patch mPatch;
+ const IAfPatchPanel::Patch mPatch;
};
class ReleaseAudioPatchData : public CommandData {
@@ -103,12 +103,12 @@
public:
UpdateAudioPatchData(audio_patch_handle_t oldHandle,
audio_patch_handle_t newHandle,
- const PatchPanel::Patch& patch)
+ const IAfPatchPanel::Patch& patch)
: mOldHandle(oldHandle), mNewHandle(newHandle), mPatch(patch) {}
const audio_patch_handle_t mOldHandle;
const audio_patch_handle_t mNewHandle;
- const PatchPanel::Patch mPatch;
+ const IAfPatchPanel::Patch mPatch;
};
void sendCommand(const sp<Command>& command);
@@ -121,3 +121,5 @@
std::mutex mListenerLock;
std::vector<wp<PatchCommandListener>> mListeners GUARDED_BY(mListenerLock);
};
+
+} // namespace android
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index 6deb093..bede225 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -24,6 +24,7 @@
#include <audio_utils/primitives.h>
#include "AudioFlinger.h"
+#include "PatchPanel.h"
#include <media/AudioParameter.h>
#include <media/AudioValidator.h>
#include <media/DeviceDescriptorBase.h>
@@ -52,7 +53,7 @@
struct audio_port *ports)
{
Mutex::Autolock _l(mLock);
- return mPatchPanel.listAudioPorts(num_ports, ports);
+ return mPatchPanel->listAudioPorts(num_ports, ports);
}
/* Get supported attributes for a given audio port */
@@ -63,7 +64,7 @@
}
Mutex::Autolock _l(mLock);
- return mPatchPanel.getAudioPort(port);
+ return mPatchPanel->getAudioPort(port);
}
/* Connect a patch between several source and sink ports */
@@ -76,14 +77,14 @@
}
Mutex::Autolock _l(mLock);
- return mPatchPanel.createAudioPatch(patch, handle);
+ return mPatchPanel->createAudioPatch(patch, handle);
}
/* Disconnect a patch */
status_t AudioFlinger::releaseAudioPatch(audio_patch_handle_t handle)
{
Mutex::Autolock _l(mLock);
- return mPatchPanel.releaseAudioPatch(handle);
+ return mPatchPanel->releaseAudioPatch(handle);
}
/* List connected audio ports and they attributes */
@@ -91,21 +92,46 @@
struct audio_patch *patches)
{
Mutex::Autolock _l(mLock);
- return mPatchPanel.listAudioPatches(num_patches, patches);
+ return mPatchPanel->listAudioPatches(num_patches, patches);
}
-status_t AudioFlinger::PatchPanel::SoftwarePatch::getLatencyMs_l(double *latencyMs) const
+/* static */
+sp<IAfPatchPanel> IAfPatchPanel::create(AudioFlinger* audioFlinger) {
+ return sp<PatchPanel>::make(audioFlinger);
+}
+
+status_t SoftwarePatch::getLatencyMs_l(double* latencyMs) const {
+ return mPatchPanel->getLatencyMs_l(mPatchHandle, latencyMs);
+}
+
+status_t PatchPanel::getLatencyMs_l(
+ audio_patch_handle_t patchHandle, double* latencyMs) const
{
- const auto& iter = mPatchPanel.mPatches.find(mPatchHandle);
- if (iter != mPatchPanel.mPatches.end()) {
+ const auto& iter = mPatches.find(patchHandle);
+ if (iter != mPatches.end()) {
return iter->second.getLatencyMs(latencyMs);
} else {
return BAD_VALUE;
}
}
+void PatchPanel::closeThreadInternal_l(const sp<IAfThreadBase>& thread) const
+{
+ if (const auto recordThread = thread->asIAfRecordThread();
+ recordThread) {
+ mAudioFlinger.closeThreadInternal_l(recordThread);
+ } else if (const auto playbackThread = thread->asIAfPlaybackThread();
+ playbackThread) {
+ mAudioFlinger.closeThreadInternal_l(playbackThread);
+ } else {
+ LOG_ALWAYS_FATAL("%s: Endpoints only accept IAfPlayback and IAfRecord threads, "
+ "invalid thread, id: %d type: %d",
+ __func__, thread->id(), thread->type());
+ }
+}
+
/* List connected audio ports and their attributes */
-status_t AudioFlinger::PatchPanel::listAudioPorts(unsigned int *num_ports __unused,
+status_t PatchPanel::listAudioPorts(unsigned int* /* num_ports */,
struct audio_port *ports __unused)
{
ALOGV(__func__);
@@ -113,7 +139,7 @@
}
/* Get supported attributes for a given audio port */
-status_t AudioFlinger::PatchPanel::getAudioPort(struct audio_port_v7 *port)
+status_t PatchPanel::getAudioPort(struct audio_port_v7* port)
{
if (port->type != AUDIO_PORT_TYPE_DEVICE) {
// Only query the HAL when the port is a device.
@@ -132,10 +158,10 @@
}
/* Connect a patch between several source and sink ports */
-status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *patch,
+status_t PatchPanel::createAudioPatch(const struct audio_patch* patch,
audio_patch_handle_t *handle,
bool endpointPatch)
- //unlocks AudioFlinger::mLock when calling ThreadBase::sendCreateAudioPatchConfigEvent
+ //unlocks AudioFlinger::mLock when calling IAfThreadBase::sendCreateAudioPatchConfigEvent
//to avoid deadlocks if the thread loop needs to acquire AudioFlinger::mLock
//before processing the create patch request.
NO_THREAD_SAFETY_ANALYSIS
@@ -255,7 +281,7 @@
status = INVALID_OPERATION;
goto exit;
}
- sp<ThreadBase> thread =
+ const sp<IAfThreadBase> thread =
mAudioFlinger.checkPlaybackThread_l(patch->sources[1].ext.mix.handle);
if (thread == 0) {
ALOGW("%s() cannot get playback thread", __func__);
@@ -264,7 +290,7 @@
}
// existing playback thread is reused, so it is not closed when patch is cleared
newPatch.mPlayback.setThread(
- reinterpret_cast<PlaybackThread*>(thread.get()), false /*closeThread*/);
+ thread->asIAfPlaybackThread().get(), false /*closeThread*/);
} else {
audio_config_t config = AUDIO_CONFIG_INITIALIZER;
audio_config_base_t mixerConfig = AUDIO_CONFIG_BASE_INITIALIZER;
@@ -282,7 +308,7 @@
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS) {
flags = patch->sinks[0].flags.output;
}
- sp<ThreadBase> thread = mAudioFlinger.openOutput_l(
+ const sp<IAfThreadBase> thread = mAudioFlinger.openOutput_l(
patch->sinks[0].ext.device.hw_module,
&output,
&config,
@@ -295,7 +321,7 @@
status = NO_MEMORY;
goto exit;
}
- newPatch.mPlayback.setThread(reinterpret_cast<PlaybackThread*>(thread.get()));
+ newPatch.mPlayback.setThread(thread->asIAfPlaybackThread().get());
}
audio_devices_t device = patch->sources[0].ext.device.type;
String8 address = String8(patch->sources[0].ext.device.address);
@@ -329,7 +355,7 @@
== AUDIO_STREAM_VOICE_CALL) {
source = AUDIO_SOURCE_VOICE_COMMUNICATION;
}
- sp<ThreadBase> thread = mAudioFlinger.openInput_l(srcModule,
+ const sp<IAfThreadBase> thread = mAudioFlinger.openInput_l(srcModule,
&input,
&config,
device,
@@ -344,7 +370,7 @@
status = NO_MEMORY;
goto exit;
}
- newPatch.mRecord.setThread(reinterpret_cast<RecordThread*>(thread.get()));
+ newPatch.mRecord.setThread(thread->asIAfRecordThread().get());
status = newPatch.createConnections(this);
if (status != NO_ERROR) {
goto exit;
@@ -354,7 +380,7 @@
}
} else {
if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
- sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(
+ sp<IAfThreadBase> thread = mAudioFlinger.checkRecordThread_l(
patch->sinks[0].ext.mix.handle);
if (thread == 0) {
thread = mAudioFlinger.checkMmapThread_l(patch->sinks[0].ext.mix.handle);
@@ -417,7 +443,7 @@
device->applyAudioPortConfig(&patch->sinks[i]);
devices.push_back(device);
}
- sp<ThreadBase> thread =
+ sp<IAfThreadBase> thread =
mAudioFlinger.checkPlaybackThread_l(patch->sources[0].ext.mix.handle);
if (thread == 0) {
thread = mAudioFlinger.checkMmapThread_l(patch->sources[0].ext.mix.handle);
@@ -476,13 +502,13 @@
return status;
}
-AudioFlinger::PatchPanel::Patch::~Patch()
+PatchPanel::Patch::~Patch()
{
ALOGE_IF(isSoftware(), "Software patch connections leaked %d %d",
mRecord.handle(), mPlayback.handle());
}
-status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
+status_t PatchPanel::Patch::createConnections(const sp<IAfPatchPanel>& panel)
{
// create patch from source device to record thread input
status_t status = panel->createAudioPatch(
@@ -646,7 +672,7 @@
return status;
}
-void AudioFlinger::PatchPanel::Patch::clearConnections(PatchPanel *panel)
+void PatchPanel::Patch::clearConnections(const sp<IAfPatchPanel>& panel)
{
ALOGV("%s() mRecord.handle %d mPlayback.handle %d",
__func__, mRecord.handle(), mPlayback.handle());
@@ -657,7 +683,7 @@
mPlayback.closeConnections(panel);
}
-status_t AudioFlinger::PatchPanel::Patch::getLatencyMs(double *latencyMs) const
+status_t PatchPanel::Patch::getLatencyMs(double* latencyMs) const
{
if (!isSoftware()) return INVALID_OPERATION;
@@ -716,7 +742,7 @@
return INVALID_OPERATION;
}
-String8 AudioFlinger::PatchPanel::Patch::dump(audio_patch_handle_t myHandle) const
+String8 PatchPanel::Patch::dump(audio_patch_handle_t myHandle) const
{
// TODO: Consider table dump form for patches, just like tracks.
String8 result = String8::format("Patch %d: %s (thread %p => thread %p)",
@@ -744,8 +770,8 @@
}
/* Disconnect a patch */
-status_t AudioFlinger::PatchPanel::releaseAudioPatch(audio_patch_handle_t handle)
- //unlocks AudioFlinger::mLock when calling ThreadBase::sendReleaseAudioPatchConfigEvent
+status_t PatchPanel::releaseAudioPatch(audio_patch_handle_t handle)
+ //unlocks AudioFlinger::mLock when calling IAfThreadBase::sendReleaseAudioPatchConfigEvent
//to avoid deadlocks if the thread loop needs to acquire AudioFlinger::mLock
//before processing the release patch request.
NO_THREAD_SAFETY_ANALYSIS
@@ -777,7 +803,7 @@
if (patch.sinks[0].type == AUDIO_PORT_TYPE_MIX) {
audio_io_handle_t ioHandle = patch.sinks[0].ext.mix.handle;
- sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(ioHandle);
+ sp<IAfThreadBase> thread = mAudioFlinger.checkRecordThread_l(ioHandle);
if (thread == 0) {
thread = mAudioFlinger.checkMmapThread_l(ioHandle);
if (thread == 0) {
@@ -800,7 +826,7 @@
break;
}
audio_io_handle_t ioHandle = src.ext.mix.handle;
- sp<ThreadBase> thread = mAudioFlinger.checkPlaybackThread_l(ioHandle);
+ sp<IAfThreadBase> thread = mAudioFlinger.checkPlaybackThread_l(ioHandle);
if (thread == 0) {
thread = mAudioFlinger.checkMmapThread_l(ioHandle);
if (thread == 0) {
@@ -821,7 +847,7 @@
return status;
}
-void AudioFlinger::PatchPanel::erasePatch(audio_patch_handle_t handle, bool reuseExistingHalPatch) {
+void PatchPanel::erasePatch(audio_patch_handle_t handle, bool reuseExistingHalPatch) {
mPatches.erase(handle);
removeSoftwarePatchFromInsertedModules(handle);
if (!reuseExistingHalPatch) {
@@ -830,16 +856,16 @@
}
/* List connected audio ports and they attributes */
-status_t AudioFlinger::PatchPanel::listAudioPatches(unsigned int *num_patches __unused,
+status_t PatchPanel::listAudioPatches(unsigned int* /* num_patches */,
struct audio_patch *patches __unused)
{
ALOGV(__func__);
return NO_ERROR;
}
-status_t AudioFlinger::PatchPanel::getDownstreamSoftwarePatches(
+status_t PatchPanel::getDownstreamSoftwarePatches(
audio_io_handle_t stream,
- std::vector<AudioFlinger::PatchPanel::SoftwarePatch> *patches) const
+ std::vector<SoftwarePatch>* patches) const
{
for (const auto& module : mInsertedModules) {
if (module.second.streams.count(stream)) {
@@ -847,7 +873,8 @@
const auto& patch_iter = mPatches.find(patchHandle);
if (patch_iter != mPatches.end()) {
const Patch &patch = patch_iter->second;
- patches->emplace_back(*this, patchHandle,
+ patches->emplace_back(sp<const IAfPatchPanel>::fromExisting(this),
+ patchHandle,
patch.mPlayback.const_thread()->id(),
patch.mRecord.const_thread()->id());
} else {
@@ -861,7 +888,7 @@
return BAD_VALUE;
}
-void AudioFlinger::PatchPanel::notifyStreamOpened(
+void PatchPanel::notifyStreamOpened(
AudioHwDevice *audioHwDevice, audio_io_handle_t stream, struct audio_patch *patch)
{
if (audioHwDevice->isInsert()) {
@@ -879,14 +906,14 @@
}
}
-void AudioFlinger::PatchPanel::notifyStreamClosed(audio_io_handle_t stream)
+void PatchPanel::notifyStreamClosed(audio_io_handle_t stream)
{
for (auto& module : mInsertedModules) {
module.second.streams.erase(stream);
}
}
-AudioHwDevice* AudioFlinger::PatchPanel::findAudioHwDeviceByModule(audio_module_handle_t module)
+AudioHwDevice* PatchPanel::findAudioHwDeviceByModule(audio_module_handle_t module)
{
if (module == AUDIO_MODULE_HANDLE_NONE) return nullptr;
ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(module);
@@ -897,13 +924,13 @@
return mAudioFlinger.mAudioHwDevs.valueAt(index);
}
-sp<DeviceHalInterface> AudioFlinger::PatchPanel::findHwDeviceByModule(audio_module_handle_t module)
+sp<DeviceHalInterface> PatchPanel::findHwDeviceByModule(audio_module_handle_t module)
{
AudioHwDevice *audioHwDevice = findAudioHwDeviceByModule(module);
return audioHwDevice ? audioHwDevice->hwDevice() : nullptr;
}
-void AudioFlinger::PatchPanel::addSoftwarePatchToInsertedModules(
+void PatchPanel::addSoftwarePatchToInsertedModules(
audio_module_handle_t module, audio_patch_handle_t handle,
const struct audio_patch *patch)
{
@@ -913,7 +940,7 @@
}
}
-void AudioFlinger::PatchPanel::removeSoftwarePatchFromInsertedModules(
+void PatchPanel::removeSoftwarePatchFromInsertedModules(
audio_patch_handle_t handle)
{
for (auto& module : mInsertedModules) {
@@ -921,7 +948,7 @@
}
}
-void AudioFlinger::PatchPanel::dump(int fd) const
+void PatchPanel::dump(int fd) const
{
String8 patchPanelDump;
const char *indent = " ";
diff --git a/services/audioflinger/PatchPanel.h b/services/audioflinger/PatchPanel.h
index 63c5630..6ef4d1a 100644
--- a/services/audioflinger/PatchPanel.h
+++ b/services/audioflinger/PatchPanel.h
@@ -15,217 +15,52 @@
** limitations under the License.
*/
-#ifndef INCLUDING_FROM_AUDIOFLINGER_H
- #error This header file should only be included from AudioFlinger.h
-#endif
+#pragma once
-public: // TODO(b/288339104) extract out of AudioFlinger class
-// PatchPanel is concealed within AudioFlinger, their lifetimes are the same.
-class PatchPanel {
+namespace android {
+
+class PatchPanel : public IAfPatchPanel {
public:
- class SoftwarePatch {
- public:
- SoftwarePatch(const PatchPanel &patchPanel, audio_patch_handle_t patchHandle,
- audio_io_handle_t playbackThreadHandle, audio_io_handle_t recordThreadHandle)
- : mPatchPanel(patchPanel), mPatchHandle(patchHandle),
- mPlaybackThreadHandle(playbackThreadHandle),
- mRecordThreadHandle(recordThreadHandle) {}
- SoftwarePatch(const SoftwarePatch&) = default;
-
- // Must be called under AudioFlinger::mLock
- status_t getLatencyMs_l(double *latencyMs) const;
- audio_patch_handle_t getPatchHandle() const { return mPatchHandle; };
- audio_io_handle_t getPlaybackThreadHandle() const { return mPlaybackThreadHandle; };
- audio_io_handle_t getRecordThreadHandle() const { return mRecordThreadHandle; };
- private:
- const PatchPanel &mPatchPanel;
- const audio_patch_handle_t mPatchHandle;
- const audio_io_handle_t mPlaybackThreadHandle;
- const audio_io_handle_t mRecordThreadHandle;
- };
-
explicit PatchPanel(AudioFlinger* audioFlinger) : mAudioFlinger(*audioFlinger) {}
/* List connected audio ports and their attributes */
status_t listAudioPorts(unsigned int *num_ports,
- struct audio_port *ports);
+ struct audio_port* ports) final;
/* Get supported attributes for a given audio port */
- status_t getAudioPort(struct audio_port_v7 *port);
+ status_t getAudioPort(struct audio_port_v7* port) final;
/* Create a patch between several source and sink ports */
status_t createAudioPatch(const struct audio_patch *patch,
audio_patch_handle_t *handle,
- bool endpointPatch = false);
+ bool endpointPatch = false) final;
/* Release a patch */
- status_t releaseAudioPatch(audio_patch_handle_t handle);
+ status_t releaseAudioPatch(audio_patch_handle_t handle) final;
/* List connected audio devices and they attributes */
status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches);
+ struct audio_patch* patches) final;
// Retrieves all currently estrablished software patches for a stream
// opened on an intermediate module.
status_t getDownstreamSoftwarePatches(audio_io_handle_t stream,
- std::vector<SoftwarePatch> *patches) const;
+ std::vector<SoftwarePatch>* patches) const final;
// Notifies patch panel about all opened and closed streams.
void notifyStreamOpened(AudioHwDevice *audioHwDevice, audio_io_handle_t stream,
- struct audio_patch *patch);
- void notifyStreamClosed(audio_io_handle_t stream);
+ struct audio_patch* patch) final;
+ void notifyStreamClosed(audio_io_handle_t stream) final;
- void dump(int fd) const;
-
- template<typename ThreadType, typename TrackType>
- class Endpoint final {
- public:
- Endpoint() = default;
- Endpoint(const Endpoint&) = delete;
- Endpoint& operator=(const Endpoint& other) noexcept {
- mThread = other.mThread;
- mCloseThread = other.mCloseThread;
- mHandle = other.mHandle;
- mTrack = other.mTrack;
- return *this;
- }
- Endpoint(Endpoint&& other) noexcept { swap(other); }
- Endpoint& operator=(Endpoint&& other) noexcept {
- swap(other);
- return *this;
- }
- ~Endpoint() {
- ALOGE_IF(mHandle != AUDIO_PATCH_HANDLE_NONE,
- "A non empty Patch Endpoint leaked, handle %d", mHandle);
- }
-
- status_t checkTrack(TrackType *trackOrNull) const {
- if (trackOrNull == nullptr) return NO_MEMORY;
- return trackOrNull->initCheck();
- }
- audio_patch_handle_t handle() const { return mHandle; }
- sp<ThreadType> thread() const { return mThread; }
- sp<TrackType> track() const { return mTrack; }
- sp<const ThreadType> const_thread() const { return mThread; }
- sp<const TrackType> const_track() const { return mTrack; }
-
- void closeConnections(PatchPanel *panel) {
- if (mHandle != AUDIO_PATCH_HANDLE_NONE) {
- panel->releaseAudioPatch(mHandle);
- mHandle = AUDIO_PATCH_HANDLE_NONE;
- }
- if (mThread != 0) {
- if (mTrack != 0) {
- mThread->deletePatchTrack(mTrack);
- }
- if (mCloseThread) {
- panel->mAudioFlinger.closeThreadInternal_l(mThread);
- }
- }
- }
- audio_patch_handle_t* handlePtr() { return &mHandle; }
- void setThread(const sp<ThreadType>& thread, bool closeThread = true) {
- mThread = thread;
- mCloseThread = closeThread;
- }
- template <typename T>
- void setTrackAndPeer(const sp<TrackType>& track, const sp<T> &peer, bool holdReference) {
- mTrack = track;
- mThread->addPatchTrack(mTrack);
- mTrack->setPeerProxy(peer, holdReference);
- mClearPeerProxy = holdReference;
- }
- void clearTrackPeer() { if (mClearPeerProxy && mTrack) mTrack->clearPeerProxy(); }
- void stopTrack() { if (mTrack) mTrack->stop(); }
-
- void swap(Endpoint &other) noexcept {
- using std::swap;
- swap(mThread, other.mThread);
- swap(mCloseThread, other.mCloseThread);
- swap(mClearPeerProxy, other.mClearPeerProxy);
- swap(mHandle, other.mHandle);
- swap(mTrack, other.mTrack);
- }
-
- friend void swap(Endpoint &a, Endpoint &b) noexcept {
- a.swap(b);
- }
-
- private:
- sp<ThreadType> mThread;
- bool mCloseThread = true;
- bool mClearPeerProxy = true;
- audio_patch_handle_t mHandle = AUDIO_PATCH_HANDLE_NONE;
- sp<TrackType> mTrack;
- };
-
- class Patch final {
- public:
- Patch(const struct audio_patch &patch, bool endpointPatch) :
- mAudioPatch(patch), mIsEndpointPatch(endpointPatch) {}
- Patch() = default;
- ~Patch();
- Patch(const Patch& other) noexcept {
- mAudioPatch = other.mAudioPatch;
- mHalHandle = other.mHalHandle;
- mPlayback = other.mPlayback;
- mRecord = other.mRecord;
- mThread = other.mThread;
- mIsEndpointPatch = other.mIsEndpointPatch;
- }
- Patch(Patch&& other) noexcept { swap(other); }
- Patch& operator=(Patch&& other) noexcept {
- swap(other);
- return *this;
- }
-
- void swap(Patch &other) noexcept {
- using std::swap;
- swap(mAudioPatch, other.mAudioPatch);
- swap(mHalHandle, other.mHalHandle);
- swap(mPlayback, other.mPlayback);
- swap(mRecord, other.mRecord);
- swap(mThread, other.mThread);
- swap(mIsEndpointPatch, other.mIsEndpointPatch);
- }
-
- friend void swap(Patch &a, Patch &b) noexcept {
- a.swap(b);
- }
-
- status_t createConnections(PatchPanel *panel);
- void clearConnections(PatchPanel *panel);
- bool isSoftware() const {
- return mRecord.handle() != AUDIO_PATCH_HANDLE_NONE ||
- mPlayback.handle() != AUDIO_PATCH_HANDLE_NONE; }
-
- void setThread(const sp<ThreadBase>& thread) { mThread = thread; }
- wp<ThreadBase> thread() const { return mThread; }
-
- // returns the latency of the patch (from record to playback).
- status_t getLatencyMs(double *latencyMs) const;
-
- String8 dump(audio_patch_handle_t myHandle) const;
-
- // Note that audio_patch::id is only unique within a HAL module
- struct audio_patch mAudioPatch;
- // handle for audio HAL patch handle present only when the audio HAL version is >= 3.0
- audio_patch_handle_t mHalHandle = AUDIO_PATCH_HANDLE_NONE;
- // below members are used by a software audio patch connecting a source device from a
- // given audio HW module to a sink device on an other audio HW module.
- // the objects are created by createConnections() and released by clearConnections()
- // playback thread is created if no existing playback thread can be used
- // connects playback thread output to sink device
- Endpoint<PlaybackThread, IAfPatchTrack> mPlayback;
- // connects source device to record thread input
- Endpoint<RecordThread, IAfPatchRecord> mRecord;
-
- wp<ThreadBase> mThread;
- bool mIsEndpointPatch;
- };
+ void dump(int fd) const final;
// Call with AudioFlinger mLock held
- std::map<audio_patch_handle_t, Patch>& patches_l() { return mPatches; }
+ const std::map<audio_patch_handle_t, Patch>& patches_l() const final { return mPatches; }
+
+ // Must be called under AudioFlinger::mLock
+ status_t getLatencyMs_l(audio_patch_handle_t patchHandle, double* latencyMs) const final;
+
+ void closeThreadInternal_l(const sp<IAfThreadBase>& thread) const final;
private:
AudioHwDevice* findAudioHwDeviceByModule(audio_module_handle_t module);
@@ -297,4 +132,4 @@
std::map<audio_module_handle_t, ModuleConnections> mInsertedModules;
};
-private:
+} // namespace android
diff --git a/services/audioflinger/PlaybackTracks.h b/services/audioflinger/PlaybackTracks.h
index 40ed89b..1d50621 100644
--- a/services/audioflinger/PlaybackTracks.h
+++ b/services/audioflinger/PlaybackTracks.h
@@ -17,23 +17,27 @@
#pragma once
#include <math.h>
+#include <sys/types.h>
namespace android {
// Checks and monitors OP_PLAY_AUDIO
class OpPlayAudioMonitor : public RefBase {
+ friend class sp<OpPlayAudioMonitor>;
public:
~OpPlayAudioMonitor() override;
bool hasOpPlayAudio() const;
static sp<OpPlayAudioMonitor> createIfNeeded(
+ IAfThreadBase* thread,
const AttributionSourceState& attributionSource,
const audio_attributes_t& attr, int id,
audio_stream_type_t streamType);
private:
- OpPlayAudioMonitor(const AttributionSourceState& attributionSource,
- audio_usage_t usage, int id);
+ OpPlayAudioMonitor(IAfThreadBase* thread,
+ const AttributionSourceState& attributionSource,
+ audio_usage_t usage, int id, uid_t uid);
void onFirstRef() override;
static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
@@ -52,16 +56,19 @@
// called by PlayAudioOpCallback when OP_PLAY_AUDIO is updated in AppOp callback
void checkPlayAudioForUsage();
+ wp<IAfThreadBase> mThread;
std::atomic_bool mHasOpPlayAudio;
const AttributionSourceState mAttributionSource;
const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
const int mId; // for logging purposes only
+ const uid_t mUid;
+ const String16 mPackageName;
};
// playback track
class Track : public TrackBase, public virtual IAfTrack, public VolumeProvider {
public:
- Track(AudioFlinger::PlaybackThread* thread,
+ Track(IAfPlaybackThread* thread,
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -182,11 +189,7 @@
// This function should be called with holding thread lock.
void updateTeePatches_l() final;
- void setTeePatchesToUpdate_l(const void* teePatchesToUpdate) final {
- setTeePatchesToUpdate_l( // TODO(b/288339104) void*
- *reinterpret_cast<const AudioFlinger::TeePatches*>(teePatchesToUpdate));
- }
- void setTeePatchesToUpdate_l(AudioFlinger::TeePatches teePatchesToUpdate);
+ void setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate) final;
void tallyUnderrunFrames(size_t frames) final {
if (isOut()) { // we expect this from output tracks only
@@ -211,11 +214,6 @@
void processMuteEvent_l(const sp<IAudioManager>& audioManager, mute_state_t muteState) final;
protected:
- // for numerous
- friend class PlaybackThread;
- friend class MixerThread;
- friend class DirectOutputThread;
- friend class OffloadThread;
DISALLOW_COPY_AND_ASSIGN(Track);
@@ -303,7 +301,7 @@
mutable FillingStatus mFillingStatus;
int8_t mRetryCount;
- // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
+ // see comment at ~Track for why this can't be const
sp<IMemory> mSharedBuffer;
bool mResetDone;
@@ -382,8 +380,8 @@
bool mFlushHwPending; // track requests for thread flush
bool mPauseHwPending = false; // direct/offload track request for thread pause
audio_output_flags_t mFlags;
- AudioFlinger::TeePatches mTeePatches;
- std::optional<AudioFlinger::TeePatches> mTeePatchesToUpdate;
+ TeePatches mTeePatches;
+ std::optional<TeePatches> mTeePatchesToUpdate;
const float mSpeed;
const bool mIsSpatialized;
const bool mIsBitPerfect;
@@ -404,8 +402,8 @@
void *mBuffer;
};
- OutputTrack(AudioFlinger::PlaybackThread* thread,
- AudioFlinger::DuplicatingThread* sourceThread,
+ OutputTrack(IAfPlaybackThread* thread,
+ IAfDuplicatingThread* sourceThread,
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
@@ -450,7 +448,7 @@
Vector < Buffer* > mBufferQueue;
AudioBufferProvider::Buffer mOutBuffer;
bool mActive;
- AudioFlinger::DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
+ IAfDuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
sp<AudioTrackClientProxy> mClientProxy;
/** Attributes of the source tracks.
@@ -472,7 +470,7 @@
// playback track, used by PatchPanel
class PatchTrack : public Track, public PatchTrackBase, public IAfPatchTrack {
public:
- PatchTrack(AudioFlinger::PlaybackThread* playbackThread,
+ PatchTrack(IAfPlaybackThread* playbackThread,
audio_stream_type_t streamType,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
diff --git a/services/audioflinger/RecordTracks.h b/services/audioflinger/RecordTracks.h
index 9d25ba4..89e2f66 100644
--- a/services/audioflinger/RecordTracks.h
+++ b/services/audioflinger/RecordTracks.h
@@ -24,7 +24,7 @@
// record track
class RecordTrack : public TrackBase, public virtual IAfRecordTrack {
public:
- RecordTrack(AudioFlinger::RecordThread* thread,
+ RecordTrack(IAfRecordThread* thread,
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t sampleRate,
@@ -95,8 +95,6 @@
}
private:
- friend class AudioFlinger; // for mState
-
DISALLOW_COPY_AND_ASSIGN(RecordTrack);
protected:
@@ -133,7 +131,7 @@
// playback track, used by PatchPanel
class PatchRecord : public RecordTrack, public PatchTrackBase, public IAfPatchRecord {
public:
- PatchRecord(AudioFlinger::RecordThread* recordThread,
+ PatchRecord(IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -169,7 +167,7 @@
class PassthruPatchRecord : public PatchRecord, public Source {
public:
- PassthruPatchRecord(AudioFlinger::RecordThread* recordThread,
+ PassthruPatchRecord(IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -212,7 +210,7 @@
PassthruPatchRecord& mPassthru;
};
- sp<StreamInHalInterface> obtainStream(sp<AudioFlinger::ThreadBase>* thread);
+ sp<StreamInHalInterface> obtainStream(sp<IAfThreadBase>* thread);
PatchRecordAudioBufferProvider mPatchRecordAudioBufferProvider;
std::unique_ptr<void, decltype(free)*> mSinkBuffer; // frame size aligned continuous buffer
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 14e4aab..9e29ba3 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -76,6 +76,8 @@
#include <media/audiohal/StreamHalInterface.h>
#include "AudioFlinger.h"
+#include "Threads.h"
+
#include <mediautils/SchedulingPolicyService.h>
#include <mediautils/ServiceUtilities.h>
@@ -120,6 +122,7 @@
namespace android {
+using audioflinger::SyncEvent;
using media::IEffectClient;
using content::AttributionSourceState;
@@ -515,7 +518,7 @@
// ----------------------------------------------------------------------------
// static
-const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
+const char* ThreadBase::threadTypeToString(ThreadBase::type_t type)
{
switch (type) {
case MIXER:
@@ -541,7 +544,7 @@
}
}
-AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
type_t type, bool systemReady, bool isOut)
: Thread(false /*canCallJava*/),
mType(type),
@@ -564,7 +567,7 @@
memset(&mPatch, 0, sizeof(struct audio_patch));
}
-AudioFlinger::ThreadBase::~ThreadBase()
+ThreadBase::~ThreadBase()
{
// mConfigEvents should be empty, but just in case it isn't, free the memory it owns
mConfigEvents.clear();
@@ -579,7 +582,7 @@
sendStatistics(true /* force */);
}
-status_t AudioFlinger::ThreadBase::readyToRun()
+status_t ThreadBase::readyToRun()
{
status_t status = initCheck();
if (status == NO_ERROR) {
@@ -590,7 +593,7 @@
return status;
}
-void AudioFlinger::ThreadBase::exit()
+void ThreadBase::exit()
{
ALOGV("ThreadBase::exit");
// do any cleanup required for exit to succeed
@@ -614,7 +617,7 @@
requestExitAndWait();
}
-status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
+status_t ThreadBase::setParameters(const String8& keyValuePairs)
{
ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
Mutex::Autolock _l(mLock);
@@ -624,7 +627,7 @@
// sendConfigEvent_l() must be called with ThreadBase::mLock held
// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
-status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
+status_t ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
NO_THREAD_SAFETY_ANALYSIS // condition variable
{
status_t status = NO_ERROR;
@@ -652,7 +655,7 @@
return status;
}
-void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event_t event, pid_t pid,
+void ThreadBase::sendIoConfigEvent(audio_io_config_event_t event, pid_t pid,
audio_port_handle_t portId)
{
Mutex::Autolock _l(mLock);
@@ -660,7 +663,7 @@
}
// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
-void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid,
+void ThreadBase::sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid,
audio_port_handle_t portId)
{
// The audio statistics history is exponentially weighted to forget events
@@ -677,14 +680,14 @@
sendConfigEvent_l(configEvent);
}
-void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
+void ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp)
{
Mutex::Autolock _l(mLock);
sendPrioConfigEvent_l(pid, tid, prio, forApp);
}
// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
-void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(
+void ThreadBase::sendPrioConfigEvent_l(
pid_t pid, pid_t tid, int32_t prio, bool forApp)
{
sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio, forApp);
@@ -692,7 +695,7 @@
}
// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
-status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
+status_t ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
{
sp<ConfigEvent> configEvent;
AudioParameter param(keyValuePair);
@@ -710,7 +713,7 @@
return sendConfigEvent_l(configEvent);
}
-status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
+status_t ThreadBase::sendCreateAudioPatchConfigEvent(
const struct audio_patch *patch,
audio_patch_handle_t *handle)
{
@@ -725,7 +728,7 @@
return status;
}
-status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
+status_t ThreadBase::sendReleaseAudioPatchConfigEvent(
const audio_patch_handle_t handle)
{
Mutex::Autolock _l(mLock);
@@ -733,7 +736,7 @@
return sendConfigEvent_l(configEvent);
}
-status_t AudioFlinger::ThreadBase::sendUpdateOutDeviceConfigEvent(
+status_t ThreadBase::sendUpdateOutDeviceConfigEvent(
const DeviceDescriptorBaseVector& outDevices)
{
if (type() != RECORD) {
@@ -745,7 +748,7 @@
return sendConfigEvent_l(configEvent);
}
-void AudioFlinger::ThreadBase::sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs)
+void ThreadBase::sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs)
{
ALOG_ASSERT(type() == RECORD, "sendResizeBufferConfigEvent_l() called on non record thread");
sp<ConfigEvent> configEvent =
@@ -753,27 +756,27 @@
sendConfigEvent_l(configEvent);
}
-void AudioFlinger::ThreadBase::sendCheckOutputStageEffectsEvent()
+void ThreadBase::sendCheckOutputStageEffectsEvent()
{
Mutex::Autolock _l(mLock);
sendCheckOutputStageEffectsEvent_l();
}
-void AudioFlinger::ThreadBase::sendCheckOutputStageEffectsEvent_l()
+void ThreadBase::sendCheckOutputStageEffectsEvent_l()
{
sp<ConfigEvent> configEvent =
(ConfigEvent *)new CheckOutputStageEffectsEvent();
sendConfigEvent_l(configEvent);
}
-void AudioFlinger::ThreadBase::sendHalLatencyModesChangedEvent_l()
+void ThreadBase::sendHalLatencyModesChangedEvent_l()
{
sp<ConfigEvent> configEvent = sp<HalLatencyModesChangedEvent>::make();
sendConfigEvent_l(configEvent);
}
// post condition: mConfigEvents.isEmpty()
-void AudioFlinger::ThreadBase::processConfigEvents_l()
+void ThreadBase::processConfigEvents_l()
{
bool configChanged = false;
@@ -940,7 +943,7 @@
}
}
-void AudioFlinger::ThreadBase::dump(int fd, const Vector<String16>& args)
+void ThreadBase::dump(int fd, const Vector<String16>& args)
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
dprintf(fd, "\n%s thread %p, name %s, tid %d, type %d (%s):\n", isOutput() ? "Output" : "Input",
@@ -978,7 +981,7 @@
}
}
-void AudioFlinger::ThreadBase::dumpBase_l(int fd, const Vector<String16>& args __unused)
+void ThreadBase::dumpBase_l(int fd, const Vector<String16>& /* args */)
{
dprintf(fd, " I/O handle: %d\n", mId);
dprintf(fd, " Standby: %s\n", mStandby ? "yes" : "no");
@@ -1051,7 +1054,7 @@
}
}
-void AudioFlinger::ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
+void ThreadBase::dumpEffectChains_l(int fd, const Vector<String16>& args)
{
const size_t SIZE = 256;
char buffer[SIZE];
@@ -1068,13 +1071,13 @@
}
}
-void AudioFlinger::ThreadBase::acquireWakeLock()
+void ThreadBase::acquireWakeLock()
{
Mutex::Autolock _l(mLock);
acquireWakeLock_l();
}
-String16 AudioFlinger::ThreadBase::getWakeLockTag()
+String16 ThreadBase::getWakeLockTag()
{
switch (mType) {
case MIXER:
@@ -1099,7 +1102,7 @@
}
}
-void AudioFlinger::ThreadBase::acquireWakeLock_l()
+void ThreadBase::acquireWakeLock_l()
{
getPowerManager_l();
if (mPowerManager != 0) {
@@ -1122,13 +1125,13 @@
gBoottime.getBoottimeOffset();
}
-void AudioFlinger::ThreadBase::releaseWakeLock()
+void ThreadBase::releaseWakeLock()
{
Mutex::Autolock _l(mLock);
releaseWakeLock_l();
}
-void AudioFlinger::ThreadBase::releaseWakeLock_l()
+void ThreadBase::releaseWakeLock_l()
{
gBoottime.release(mWakeLockToken);
if (mWakeLockToken != 0) {
@@ -1140,7 +1143,7 @@
}
}
-void AudioFlinger::ThreadBase::getPowerManager_l() {
+void ThreadBase::getPowerManager_l() {
if (mSystemReady && mPowerManager == 0) {
// use checkService() to avoid blocking if power service is not up yet
sp<IBinder> binder =
@@ -1154,7 +1157,7 @@
}
}
-void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t> &uids) {
+void ThreadBase::updateWakeLockUids_l(const SortedVector<uid_t>& uids) {
getPowerManager_l();
#if !LOG_NDEBUG
@@ -1181,25 +1184,25 @@
}
}
-void AudioFlinger::ThreadBase::clearPowerManager()
+void ThreadBase::clearPowerManager()
{
Mutex::Autolock _l(mLock);
releaseWakeLock_l();
mPowerManager.clear();
}
-void AudioFlinger::ThreadBase::updateOutDevices(
+void ThreadBase::updateOutDevices(
const DeviceDescriptorBaseVector& outDevices __unused)
{
ALOGE("%s should only be called in RecordThread", __func__);
}
-void AudioFlinger::ThreadBase::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs __unused)
+void ThreadBase::resizeInputBuffer_l(int32_t /* maxSharedAudioHistoryMs */)
{
ALOGE("%s should only be called in RecordThread", __func__);
}
-void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
+void ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& /* who */)
{
sp<ThreadBase> thread = mThread.promote();
if (thread != 0) {
@@ -1208,7 +1211,7 @@
ALOGW("power manager service died !!!");
}
-void AudioFlinger::ThreadBase::setEffectSuspended_l(
+void ThreadBase::setEffectSuspended_l(
const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
{
sp<IAfEffectChain> chain = getEffectChain_l(sessionId);
@@ -1223,7 +1226,7 @@
updateSuspendedSessions_l(type, suspend, sessionId);
}
-void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<IAfEffectChain>& chain)
+void ThreadBase::checkSuspendOnAddEffectChain_l(const sp<IAfEffectChain>& chain)
{
ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
if (index < 0) {
@@ -1247,7 +1250,7 @@
}
}
-void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
+void ThreadBase::updateSuspendedSessions_l(const effect_uuid_t* type,
bool suspend,
audio_session_t sessionId)
{
@@ -1308,7 +1311,7 @@
}
}
-void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
+void ThreadBase::checkSuspendOnEffectEnabled(bool enabled,
audio_session_t sessionId,
bool threadLocked)
NO_THREAD_SAFETY_ANALYSIS // manual locking
@@ -1334,7 +1337,7 @@
}
// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
-status_t AudioFlinger::RecordThread::checkEffectCompatibility_l(
+status_t RecordThread::checkEffectCompatibility_l(
const effect_descriptor_t *desc, audio_session_t sessionId)
{
// No global output effect sessions on record threads
@@ -1378,7 +1381,7 @@
}
// checkEffectCompatibility_l() must be called with ThreadBase::mLock held
-status_t AudioFlinger::PlaybackThread::checkEffectCompatibility_l(
+status_t PlaybackThread::checkEffectCompatibility_l(
const effect_descriptor_t *desc, audio_session_t sessionId)
{
// no preprocessing on playback threads
@@ -1533,7 +1536,7 @@
}
// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
-sp<IAfEffectHandle> AudioFlinger::ThreadBase::createEffect_l(
+sp<IAfEffectHandle> ThreadBase::createEffect_l(
const sp<Client>& client,
const sp<IEffectClient>& effectClient,
int32_t priority,
@@ -1638,7 +1641,7 @@
return handle;
}
-void AudioFlinger::ThreadBase::disconnectEffectHandle(IAfEffectHandle *handle,
+void ThreadBase::disconnectEffectHandle(IAfEffectHandle* handle,
bool unpinIfLast)
{
bool remove = false;
@@ -1668,7 +1671,7 @@
}
}
-void AudioFlinger::ThreadBase::onEffectEnable(const sp<IAfEffectModule>& effect) {
+void ThreadBase::onEffectEnable(const sp<IAfEffectModule>& effect) {
if (isOffloadOrMmap()) {
Mutex::Autolock _l(mLock);
broadcast_l();
@@ -1684,28 +1687,28 @@
}
}
-void AudioFlinger::ThreadBase::onEffectDisable() {
+void ThreadBase::onEffectDisable() {
if (isOffloadOrMmap()) {
Mutex::Autolock _l(mLock);
broadcast_l();
}
}
-sp<IAfEffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
- int effectId)
+sp<IAfEffectModule> ThreadBase::getEffect(audio_session_t sessionId,
+ int effectId) const
{
Mutex::Autolock _l(mLock);
return getEffect_l(sessionId, effectId);
}
-sp<IAfEffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
- int effectId)
+sp<IAfEffectModule> ThreadBase::getEffect_l(audio_session_t sessionId,
+ int effectId) const
{
sp<IAfEffectChain> chain = getEffectChain_l(sessionId);
return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
}
-std::vector<int> AudioFlinger::ThreadBase::getEffectIds_l(audio_session_t sessionId)
+std::vector<int> ThreadBase::getEffectIds_l(audio_session_t sessionId) const
{
sp<IAfEffectChain> chain = getEffectChain_l(sessionId);
return chain != nullptr ? chain->getEffectIds() : std::vector<int>{};
@@ -1713,7 +1716,7 @@
// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
// PlaybackThread::mLock held
-status_t AudioFlinger::ThreadBase::addEffect_l(const sp<IAfEffectModule>& effect)
+status_t ThreadBase::addEffect_l(const sp<IAfEffectModule>& effect)
{
// check for existing effect chain with the requested audio session
audio_session_t sessionId = effect->sessionId();
@@ -1758,7 +1761,7 @@
return NO_ERROR;
}
-void AudioFlinger::ThreadBase::removeEffect_l(const sp<IAfEffectModule>& effect, bool release) {
+void ThreadBase::removeEffect_l(const sp<IAfEffectModule>& effect, bool release) {
ALOGV("%s %p effect %p", __FUNCTION__, this, effect.get());
effect_descriptor_t desc = effect->desc();
@@ -1777,7 +1780,7 @@
}
}
-void AudioFlinger::ThreadBase::lockEffectChains_l(
+void ThreadBase::lockEffectChains_l(
Vector<sp<IAfEffectChain>>& effectChains)
NO_THREAD_SAFETY_ANALYSIS // calls EffectChain::lock()
{
@@ -1787,7 +1790,7 @@
}
}
-void AudioFlinger::ThreadBase::unlockEffectChains(
+void ThreadBase::unlockEffectChains(
const Vector<sp<IAfEffectChain>>& effectChains)
NO_THREAD_SAFETY_ANALYSIS // calls EffectChain::unlock()
{
@@ -1796,13 +1799,13 @@
}
}
-sp<IAfEffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
+sp<IAfEffectChain> ThreadBase::getEffectChain(audio_session_t sessionId) const
{
Mutex::Autolock _l(mLock);
return getEffectChain_l(sessionId);
}
-sp<IAfEffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
+sp<IAfEffectChain> ThreadBase::getEffectChain_l(audio_session_t sessionId)
const
{
size_t size = mEffectChains.size();
@@ -1814,7 +1817,7 @@
return 0;
}
-void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
+void ThreadBase::setMode(audio_mode_t mode)
{
Mutex::Autolock _l(mLock);
size_t size = mEffectChains.size();
@@ -1823,7 +1826,7 @@
}
}
-void AudioFlinger::ThreadBase::toAudioPortConfig(struct audio_port_config *config)
+void ThreadBase::toAudioPortConfig(struct audio_port_config* config)
{
config->type = AUDIO_PORT_TYPE_MIX;
config->ext.mix.handle = mId;
@@ -1834,7 +1837,7 @@
AUDIO_PORT_CONFIG_FORMAT;
}
-void AudioFlinger::ThreadBase::systemReady()
+void ThreadBase::systemReady()
{
Mutex::Autolock _l(mLock);
if (mSystemReady) {
@@ -1849,7 +1852,7 @@
}
template <typename T>
-ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::add(const sp<T> &track) {
+ssize_t ThreadBase::ActiveTracks<T>::add(const sp<T>& track) {
ssize_t index = mActiveTracks.indexOf(track);
if (index >= 0) {
ALOGW("ActiveTracks<T>::add track %p already there", track.get());
@@ -1864,7 +1867,7 @@
}
template <typename T>
-ssize_t AudioFlinger::ThreadBase::ActiveTracks<T>::remove(const sp<T> &track) {
+ssize_t ThreadBase::ActiveTracks<T>::remove(const sp<T>& track) {
ssize_t index = mActiveTracks.remove(track);
if (index < 0) {
ALOGW("ActiveTracks<T>::remove nonexistent track %p", track.get());
@@ -1883,7 +1886,7 @@
}
template <typename T>
-void AudioFlinger::ThreadBase::ActiveTracks<T>::clear() {
+void ThreadBase::ActiveTracks<T>::clear() {
for (const sp<T> &track : mActiveTracks) {
track->endBatteryAttribution();
logTrack("clear", track);
@@ -1895,7 +1898,7 @@
}
template <typename T>
-void AudioFlinger::ThreadBase::ActiveTracks<T>::updatePowerState(
+void ThreadBase::ActiveTracks<T>::updatePowerState(
const sp<ThreadBase>& thread, bool force) {
// Updates ActiveTracks client uids to the thread wakelock.
if (mActiveTracksGeneration != mLastActiveTracksGeneration || force) {
@@ -1905,7 +1908,7 @@
}
template <typename T>
-bool AudioFlinger::ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
+bool ThreadBase::ActiveTracks<T>::readAndClearHasChanged() {
bool hasChanged = mHasChanged;
mHasChanged = false;
@@ -1918,7 +1921,7 @@
}
template <typename T>
-void AudioFlinger::ThreadBase::ActiveTracks<T>::logTrack(
+void ThreadBase::ActiveTracks<T>::logTrack(
const char *funcName, const sp<T> &track) const {
if (mLocalLog != nullptr) {
String8 result;
@@ -1927,7 +1930,7 @@
}
}
-void AudioFlinger::ThreadBase::broadcast_l()
+void ThreadBase::broadcast_l()
{
// Thread could be blocked waiting for async
// so signal it to handle state changes immediately
@@ -1939,7 +1942,7 @@
// Call only from threadLoop() or when it is idle.
// Do not call from high performance code as this may do binder rpc to the MediaMetrics service.
-void AudioFlinger::ThreadBase::sendStatistics(bool force)
+void ThreadBase::sendStatistics(bool force)
{
// Do not log if we have no stats.
// We choose the timestamp verifier because it is the most likely item to be present.
@@ -2002,7 +2005,7 @@
item->selfrecord();
}
-product_strategy_t AudioFlinger::ThreadBase::getStrategyForStream(audio_stream_type_t stream) const
+product_strategy_t ThreadBase::getStrategyForStream(audio_stream_type_t stream) const
{
if (!mAudioFlinger->isAudioPolicyReady()) {
return PRODUCT_STRATEGY_NONE;
@@ -2011,7 +2014,7 @@
}
// startMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::ThreadBase::startMelComputation_l(
+void ThreadBase::startMelComputation_l(
const sp<audio_utils::MelProcessor>& /*processor*/)
{
// Do nothing
@@ -2019,7 +2022,7 @@
}
// stopMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::ThreadBase::stopMelComputation_l()
+void ThreadBase::stopMelComputation_l()
{
// Do nothing
ALOGW("%s: ThreadBase does not support CSD", __func__);
@@ -2029,7 +2032,7 @@
// Playback
// ----------------------------------------------------------------------------
-AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
+PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamOut* output,
audio_io_handle_t id,
type_t type,
@@ -2129,7 +2132,7 @@
mStreamTypes[AUDIO_STREAM_CALL_ASSISTANT].mute = false;
}
-AudioFlinger::PlaybackThread::~PlaybackThread()
+PlaybackThread::~PlaybackThread()
{
mAudioFlinger->unregisterWriter(mNBLogWriter);
free(mSinkBuffer);
@@ -2140,7 +2143,7 @@
// Thread virtuals
-void AudioFlinger::PlaybackThread::onFirstRef()
+void PlaybackThread::onFirstRef()
{
if (!isStreamInitialized()) {
ALOGE("The stream is not open yet"); // This should not happen.
@@ -2155,7 +2158,7 @@
if (mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING &&
mOutput->stream->setCallback(this) == OK) {
mUseAsyncWrite = true;
- mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
+ mCallbackThread = sp<AsyncCallbackThread>::make(this);
}
if (mOutput->stream->setEventCallback(this) != OK) {
@@ -2167,14 +2170,14 @@
}
// ThreadBase virtuals
-void AudioFlinger::PlaybackThread::preExit()
+void PlaybackThread::preExit()
{
ALOGV(" preExit()");
status_t result = mOutput->stream->exit();
ALOGE_IF(result != OK, "Error when calling exit(): %d", result);
}
-void AudioFlinger::PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
+void PlaybackThread::dumpTracks_l(int fd, const Vector<String16>& /* args */)
{
String8 result;
@@ -2239,7 +2242,7 @@
write(fd, result.string(), result.size());
}
-void AudioFlinger::PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
+void PlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
{
dprintf(fd, " Master volume: %f\n", mMasterVolume);
dprintf(fd, " Master mute: %s\n", mMasterMute ? "on" : "off");
@@ -2275,7 +2278,7 @@
}
// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
-sp<IAfTrack> AudioFlinger::PlaybackThread::createTrack_l(
+sp<IAfTrack> PlaybackThread::createTrack_l(
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -2660,7 +2663,7 @@
}
template<typename T>
-ssize_t AudioFlinger::PlaybackThread::Tracks<T>::remove(const sp<T> &track)
+ssize_t PlaybackThread::Tracks<T>::remove(const sp<T>& track)
{
const int trackId = track->id();
const ssize_t index = mTracks.remove(track);
@@ -2675,17 +2678,17 @@
return index;
}
-uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
+uint32_t PlaybackThread::correctLatency_l(uint32_t latency) const
{
return latency;
}
-uint32_t AudioFlinger::PlaybackThread::latency() const
+uint32_t PlaybackThread::latency() const
{
Mutex::Autolock _l(mLock);
return latency_l();
}
-uint32_t AudioFlinger::PlaybackThread::latency_l() const
+uint32_t PlaybackThread::latency_l() const
{
uint32_t latency;
if (initCheck() == NO_ERROR && mOutput->stream->getLatency(&latency) == OK) {
@@ -2694,7 +2697,7 @@
return 0;
}
-void AudioFlinger::PlaybackThread::setMasterVolume(float value)
+void PlaybackThread::setMasterVolume(float value)
{
Mutex::Autolock _l(mLock);
// Don't apply master volume in SW if our HAL can do it for us.
@@ -2706,12 +2709,12 @@
}
}
-void AudioFlinger::PlaybackThread::setMasterBalance(float balance)
+void PlaybackThread::setMasterBalance(float balance)
{
mMasterBalance.store(balance);
}
-void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
+void PlaybackThread::setMasterMute(bool muted)
{
if (isDuplicating()) {
return;
@@ -2726,33 +2729,33 @@
}
}
-void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
+void PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
{
Mutex::Autolock _l(mLock);
mStreamTypes[stream].volume = value;
broadcast_l();
}
-void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
+void PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
{
Mutex::Autolock _l(mLock);
mStreamTypes[stream].mute = muted;
broadcast_l();
}
-float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
+float PlaybackThread::streamVolume(audio_stream_type_t stream) const
{
Mutex::Autolock _l(mLock);
return mStreamTypes[stream].volume;
}
-void AudioFlinger::PlaybackThread::setVolumeForOutput_l(float left, float right) const
+void PlaybackThread::setVolumeForOutput_l(float left, float right) const
{
mOutput->stream->setVolume(left, right);
}
// addTrack_l() must be called with ThreadBase::mLock held
-status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<IAfTrack>& track)
+status_t PlaybackThread::addTrack_l(const sp<IAfTrack>& track)
NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
{
status_t status = ALREADY_EXISTS;
@@ -2858,7 +2861,7 @@
return status;
}
-bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<IAfTrack>& track)
+bool PlaybackThread::destroyTrack_l(const sp<IAfTrack>& track)
{
track->terminate();
// active tracks are removed by threadLoop()
@@ -2876,7 +2879,7 @@
return trackActive;
}
-void AudioFlinger::PlaybackThread::removeTrack_l(const sp<IAfTrack>& track)
+void PlaybackThread::removeTrack_l(const sp<IAfTrack>& track)
{
track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
@@ -2903,7 +2906,7 @@
}
}
-String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
+String8 PlaybackThread::getParameters(const String8& keys)
{
Mutex::Autolock _l(mLock);
String8 out_s8;
@@ -2913,7 +2916,7 @@
return {};
}
-status_t AudioFlinger::DirectOutputThread::selectPresentation(int presentationId, int programId) {
+status_t DirectOutputThread::selectPresentation(int presentationId, int programId) {
Mutex::Autolock _l(mLock);
if (!isStreamInitialized()) {
return NO_INIT;
@@ -2921,7 +2924,7 @@
return mOutput->stream->selectPresentation(presentationId, programId);
}
-void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
+void PlaybackThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
audio_port_handle_t portId) {
ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
sp<AudioIoDescriptor> desc;
@@ -2946,27 +2949,27 @@
mAudioFlinger->ioConfigChanged(event, desc, pid);
}
-void AudioFlinger::PlaybackThread::onWriteReady()
+void PlaybackThread::onWriteReady()
{
mCallbackThread->resetWriteBlocked();
}
-void AudioFlinger::PlaybackThread::onDrainReady()
+void PlaybackThread::onDrainReady()
{
mCallbackThread->resetDraining();
}
-void AudioFlinger::PlaybackThread::onError()
+void PlaybackThread::onError()
{
mCallbackThread->setAsyncError();
}
-void AudioFlinger::PlaybackThread::onCodecFormatChanged(
+void PlaybackThread::onCodecFormatChanged(
const std::basic_string<uint8_t>& metadataBs)
{
- wp<AudioFlinger::PlaybackThread> weakPointerThis = this;
+ const auto weakPointerThis = wp<PlaybackThread>::fromExisting(this);
std::thread([this, metadataBs, weakPointerThis]() {
- sp<AudioFlinger::PlaybackThread> playbackThread = weakPointerThis.promote();
+ const sp<PlaybackThread> playbackThread = weakPointerThis.promote();
if (playbackThread == nullptr) {
ALOGW("PlaybackThread was destroyed, skip codec format change event");
return;
@@ -2991,7 +2994,7 @@
}).detach();
}
-void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
+void PlaybackThread::resetWriteBlocked(uint32_t sequence)
{
Mutex::Autolock _l(mLock);
// reject out of sequence requests
@@ -3001,7 +3004,7 @@
}
}
-void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
+void PlaybackThread::resetDraining(uint32_t sequence)
{
Mutex::Autolock _l(mLock);
// reject out of sequence requests
@@ -3016,7 +3019,7 @@
}
}
-void AudioFlinger::PlaybackThread::readOutputParameters_l()
+void PlaybackThread::readOutputParameters_l()
{
// unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
const audio_config_base_t audioConfig = mOutput->getAudioProperties();
@@ -3025,7 +3028,7 @@
if (!audio_is_output_channel(mChannelMask)) {
LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
}
- if (hasMixer() && !isValidPcmSinkChannelMask(mChannelMask)) {
+ if (hasMixer() && !AudioFlinger::isValidPcmSinkChannelMask(mChannelMask)) {
LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
mChannelMask);
}
@@ -3048,7 +3051,7 @@
if (!audio_is_valid_format(mFormat)) {
LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
}
- if (hasMixer() && !isValidPcmSinkFormat(mFormat)) {
+ if (hasMixer() && !AudioFlinger::isValidPcmSinkFormat(mFormat)) {
LOG_FATAL("HAL format %#x not supported for mixed output",
mFormat);
}
@@ -3216,7 +3219,7 @@
item.record();
}
-AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::PlaybackThread::updateMetadata_l()
+ThreadBase::MetadataUpdate PlaybackThread::updateMetadata_l()
{
if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
return {}; // nothing to do
@@ -3233,13 +3236,14 @@
return change;
}
-void AudioFlinger::PlaybackThread::sendMetadataToBackend_l(
+void PlaybackThread::sendMetadataToBackend_l(
const StreamOutHalInterface::SourceMetadata& metadata)
{
mOutput->stream->updateSourceMetadata(metadata);
};
-status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
+status_t PlaybackThread::getRenderPosition(
+ uint32_t* halFrames, uint32_t* dspFrames) const
{
if (halFrames == NULL || dspFrames == NULL) {
return BAD_VALUE;
@@ -3266,7 +3270,7 @@
}
}
-product_strategy_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
+product_strategy_t PlaybackThread::getStrategyForSession_l(audio_session_t sessionId) const
{
// session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
// it is moved to correct output by audio policy manager when A2DP is connected or disconnected
@@ -3283,13 +3287,13 @@
}
-AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
+AudioStreamOut* PlaybackThread::getOutput() const
{
Mutex::Autolock _l(mLock);
return mOutput;
}
-AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
+AudioStreamOut* PlaybackThread::clearOutput()
{
Mutex::Autolock _l(mLock);
AudioStreamOut *output = mOutput;
@@ -3303,7 +3307,7 @@
}
// this method must always be called either with ThreadBase mLock held or inside the thread loop
-sp<StreamHalInterface> AudioFlinger::PlaybackThread::stream() const
+sp<StreamHalInterface> PlaybackThread::stream() const
{
if (mOutput == NULL) {
return NULL;
@@ -3311,12 +3315,12 @@
return mOutput->stream;
}
-uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
+uint32_t PlaybackThread::activeSleepTimeUs() const
{
return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
}
-status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<audioflinger::SyncEvent>& event)
+status_t PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
{
if (!isValidSyncEvent(event)) {
return BAD_VALUE;
@@ -3335,13 +3339,12 @@
return NAME_NOT_FOUND;
}
-bool AudioFlinger::PlaybackThread::isValidSyncEvent(
- const sp<audioflinger::SyncEvent>& event) const
+bool PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
{
return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
}
-void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
+void PlaybackThread::threadLoop_removeTracks(
[[maybe_unused]] const Vector<sp<IAfTrack>>& tracksToRemove)
{
// Miscellaneous track cleanup when removed from the active list,
@@ -3356,7 +3359,7 @@
#endif
}
-void AudioFlinger::PlaybackThread::checkSilentMode_l()
+void PlaybackThread::checkSilentMode_l()
{
if (!mMasterMute) {
char value[PROPERTY_VALUE_MAX];
@@ -3382,7 +3385,7 @@
}
// shared by MIXER and DIRECT, overridden by DUPLICATING
-ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
+ssize_t PlaybackThread::threadLoop_write()
{
LOG_HIST_TS();
mInWrite = true;
@@ -3454,7 +3457,7 @@
}
// startMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::PlaybackThread::startMelComputation_l(
+void PlaybackThread::startMelComputation_l(
const sp<audio_utils::MelProcessor>& processor)
{
auto outputSink = static_cast<AudioStreamOutSink*>(mOutputSink.get());
@@ -3464,7 +3467,7 @@
}
// stopMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::PlaybackThread::stopMelComputation_l()
+void PlaybackThread::stopMelComputation_l()
{
auto outputSink = static_cast<AudioStreamOutSink*>(mOutputSink.get());
if (outputSink != nullptr) {
@@ -3472,7 +3475,7 @@
}
}
-void AudioFlinger::PlaybackThread::threadLoop_drain()
+void PlaybackThread::threadLoop_drain()
{
bool supportsDrain = false;
if (mOutput->stream->supportsDrain(&supportsDrain) == OK && supportsDrain) {
@@ -3488,7 +3491,7 @@
}
}
-void AudioFlinger::PlaybackThread::threadLoop_exit()
+void PlaybackThread::threadLoop_exit()
{
{
Mutex::Autolock _l(mLock);
@@ -3524,7 +3527,7 @@
- idle sleep time
*/
-void AudioFlinger::PlaybackThread::cacheParameters_l()
+void PlaybackThread::cacheParameters_l()
{
mSinkBufferSize = mNormalFrameCount * mFrameSize;
mActiveSleepTimeUs = activeSleepTimeUs();
@@ -3541,7 +3544,7 @@
}
}
-bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
+bool PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
{
ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
this, streamType, mTracks.size());
@@ -3557,18 +3560,18 @@
return trackMatch;
}
-void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
+void PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
{
Mutex::Autolock _l(mLock);
invalidateTracks_l(streamType);
}
-void AudioFlinger::PlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
+void PlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
Mutex::Autolock _l(mLock);
invalidateTracks_l(portIds);
}
-bool AudioFlinger::PlaybackThread::invalidateTracks_l(std::set<audio_port_handle_t>& portIds) {
+bool PlaybackThread::invalidateTracks_l(std::set<audio_port_handle_t>& portIds) {
bool trackMatch = false;
const size_t size = mTracks.size();
for (size_t i = 0; i < size; i++) {
@@ -3586,7 +3589,7 @@
}
// getTrackById_l must be called with holding thread lock
-IAfTrack* AudioFlinger::PlaybackThread::getTrackById_l(
+IAfTrack* PlaybackThread::getTrackById_l(
audio_port_handle_t trackPortId) {
for (size_t i = 0; i < mTracks.size(); i++) {
if (mTracks[i]->portId() == trackPortId) {
@@ -3596,7 +3599,7 @@
return nullptr;
}
-status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
+status_t PlaybackThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
{
audio_session_t session = chain->sessionId();
sp<EffectBufferHalInterface> halInBuffer, halOutBuffer;
@@ -3732,7 +3735,7 @@
return NO_ERROR;
}
-size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
+size_t PlaybackThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
{
audio_session_t session = chain->sessionId();
@@ -3764,14 +3767,14 @@
return mEffectChains.size();
}
-status_t AudioFlinger::PlaybackThread::attachAuxEffect(
+status_t PlaybackThread::attachAuxEffect(
const sp<IAfTrack>& track, int EffectId)
{
Mutex::Autolock _l(mLock);
return attachAuxEffect_l(track, EffectId);
}
-status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
+status_t PlaybackThread::attachAuxEffect_l(
const sp<IAfTrack>& track, int EffectId)
{
status_t status = NO_ERROR;
@@ -3794,7 +3797,7 @@
return status;
}
-void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
+void PlaybackThread::detachAuxEffect_l(int effectId)
{
for (size_t i = 0; i < mTracks.size(); ++i) {
sp<IAfTrack> track = mTracks[i];
@@ -3804,7 +3807,7 @@
}
}
-bool AudioFlinger::PlaybackThread::threadLoop()
+bool PlaybackThread::threadLoop()
NO_THREAD_SAFETY_ANALYSIS // manual locking of AudioFlinger
{
aflog::setThreadWriter(mNBLogWriter.get());
@@ -3873,11 +3876,12 @@
// Here, we try for the AF lock, but do not block on it as the latency
// is more informational.
if (mAudioFlinger->mLock.tryLock() == NO_ERROR) {
- std::vector<PatchPanel::SoftwarePatch> swPatches;
+ std::vector<SoftwarePatch> swPatches;
double latencyMs = 0.; // not required; initialized for clang-tidy
status_t status = INVALID_OPERATION;
audio_patch_handle_t downstreamPatchHandle = AUDIO_PATCH_HANDLE_NONE;
- if (mAudioFlinger->mPatchPanel.getDownstreamSoftwarePatches(id(), &swPatches) == OK
+ if (mAudioFlinger->mPatchPanel->getDownstreamSoftwarePatches(
+ id(), &swPatches) == OK
&& swPatches.size() > 0) {
status = swPatches[0].getLatencyMs_l(&latencyMs);
downstreamPatchHandle = swPatches[0].getPatchHandle();
@@ -4460,7 +4464,7 @@
return false;
}
-void AudioFlinger::PlaybackThread::collectTimestamps_l()
+void PlaybackThread::collectTimestamps_l()
{
if (mStandby) {
mTimestampVerifier.discontinuity(discontinuityForStandbyOrFlush());
@@ -4596,7 +4600,7 @@
}
// removeTracks_l() must be called with ThreadBase::mLock held
-void AudioFlinger::PlaybackThread::removeTracks_l(const Vector<sp<IAfTrack>>& tracksToRemove)
+void PlaybackThread::removeTracks_l(const Vector<sp<IAfTrack>>& tracksToRemove)
NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
{
for (const auto& track : tracksToRemove) {
@@ -4638,7 +4642,7 @@
}
}
-status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
+status_t PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
{
if (mNormalSink != 0) {
ExtendedTimestamp ets;
@@ -4667,7 +4671,7 @@
// All tracks attached to a mixer with flag VOIP_RX are tied to the same
// stream type STREAM_VOICE_CALL so this will only change the HAL volume once even
// if more than one track are active
-status_t AudioFlinger::PlaybackThread::handleVoipVolume_l(float *volume)
+status_t PlaybackThread::handleVoipVolume_l(float* volume)
{
status_t result = NO_ERROR;
if ((mOutput->flags & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
@@ -4689,7 +4693,7 @@
return result;
}
-status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
+status_t MixerThread::createAudioPatch_l(const struct audio_patch* patch,
audio_patch_handle_t *handle)
{
status_t status;
@@ -4706,7 +4710,7 @@
return status;
}
-status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
+status_t PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
audio_patch_handle_t *handle)
{
status_t status = NO_ERROR;
@@ -4790,7 +4794,7 @@
return status;
}
-status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
+status_t MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
{
status_t status;
if (property_get_bool("af.patch_park", false /* default_value */)) {
@@ -4804,7 +4808,7 @@
return status;
}
-status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
+status_t PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
{
status_t status = NO_ERROR;
@@ -4823,19 +4827,19 @@
return status;
}
-void AudioFlinger::PlaybackThread::addPatchTrack(const sp<IAfPatchTrack>& track)
+void PlaybackThread::addPatchTrack(const sp<IAfPatchTrack>& track)
{
Mutex::Autolock _l(mLock);
mTracks.add(track);
}
-void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<IAfPatchTrack>& track)
+void PlaybackThread::deletePatchTrack(const sp<IAfPatchTrack>& track)
{
Mutex::Autolock _l(mLock);
destroyTrack_l(track);
}
-void AudioFlinger::PlaybackThread::toAudioPortConfig(struct audio_port_config *config)
+void PlaybackThread::toAudioPortConfig(struct audio_port_config* config)
{
ThreadBase::toAudioPortConfig(config);
config->role = AUDIO_PORT_ROLE_SOURCE;
@@ -4849,7 +4853,14 @@
// ----------------------------------------------------------------------------
-AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+/* static */
+sp<IAfPlaybackThread> IAfPlaybackThread::createMixerThread(
+ const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
+ audio_io_handle_t id, bool systemReady, type_t type, audio_config_base_t* mixerConfig) {
+ return sp<MixerThread>::make(audioFlinger, output, id, systemReady, type, mixerConfig);
+}
+
+MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady, type_t type, audio_config_base_t *mixerConfig)
: PlaybackThread(audioFlinger, output, id, type, systemReady, mixerConfig),
// mAudioMixer below
@@ -5034,7 +5045,7 @@
}
}
-AudioFlinger::MixerThread::~MixerThread()
+MixerThread::~MixerThread()
{
if (mFastMixer != 0) {
FastMixerStateQueue *sq = mFastMixer->sq();
@@ -5071,7 +5082,7 @@
delete mAudioMixer;
}
-void AudioFlinger::MixerThread::onFirstRef() {
+void MixerThread::onFirstRef() {
PlaybackThread::onFirstRef();
Mutex::Autolock _l(mLock);
@@ -5087,7 +5098,7 @@
}
}
-uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
+uint32_t MixerThread::correctLatency_l(uint32_t latency) const
{
if (mFastMixer != 0) {
MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
@@ -5096,7 +5107,7 @@
return latency;
}
-ssize_t AudioFlinger::MixerThread::threadLoop_write()
+ssize_t MixerThread::threadLoop_write()
{
// FIXME we should only do one push per cycle; confirm this is true
// Start the fast mixer if it's not already running
@@ -5139,7 +5150,7 @@
return PlaybackThread::threadLoop_write();
}
-void AudioFlinger::MixerThread::threadLoop_standby()
+void MixerThread::threadLoop_standby()
{
// Idle the fast mixer if it's currently running
if (mFastMixer != 0) {
@@ -5177,24 +5188,24 @@
PlaybackThread::threadLoop_standby();
}
-bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
+bool PlaybackThread::waitingAsyncCallback_l()
{
return false;
}
-bool AudioFlinger::PlaybackThread::shouldStandby_l()
+bool PlaybackThread::shouldStandby_l()
{
return !mStandby;
}
-bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
+bool PlaybackThread::waitingAsyncCallback()
{
Mutex::Autolock _l(mLock);
return waitingAsyncCallback_l();
}
// shared by MIXER and DIRECT, overridden by DUPLICATING
-void AudioFlinger::PlaybackThread::threadLoop_standby()
+void PlaybackThread::threadLoop_standby()
{
ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
mOutput->standby();
@@ -5210,20 +5221,20 @@
setHalLatencyMode_l();
}
-void AudioFlinger::PlaybackThread::onAddNewTrack_l()
+void PlaybackThread::onAddNewTrack_l()
{
ALOGV("signal playback thread");
broadcast_l();
}
-void AudioFlinger::PlaybackThread::onAsyncError()
+void PlaybackThread::onAsyncError()
{
for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
invalidateTracks((audio_stream_type_t)i);
}
}
-void AudioFlinger::MixerThread::threadLoop_mix()
+void MixerThread::threadLoop_mix()
{
// mix buffers...
mAudioMixer->process();
@@ -5241,7 +5252,7 @@
}
-void AudioFlinger::MixerThread::threadLoop_sleepTime()
+void MixerThread::threadLoop_sleepTime()
{
// If no tracks are ready, sleep once for the duration of an output
// buffer size, then write 0s to the output
@@ -5295,7 +5306,7 @@
}
// prepareTracks_l() must be called with ThreadBase::mLock held
-AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
+PlaybackThread::mixer_state MixerThread::prepareTracks_l(
Vector<sp<IAfTrack>>* tracksToRemove)
{
// clean up deleted track ids in AudioMixer before allocating new tracks
@@ -6091,7 +6102,7 @@
}
// trackCountForUid_l() must be called with ThreadBase::mLock held
-uint32_t AudioFlinger::PlaybackThread::trackCountForUid_l(uid_t uid) const
+uint32_t PlaybackThread::trackCountForUid_l(uid_t uid) const
{
uint32_t trackCount = 0;
for (size_t i = 0; i < mTracks.size() ; i++) {
@@ -6102,7 +6113,7 @@
return trackCount;
}
-bool AudioFlinger::PlaybackThread::IsTimestampAdvancing::check(AudioStreamOut * output)
+bool PlaybackThread::IsTimestampAdvancing::check(AudioStreamOut* output)
{
// Check the timestamp to see if it's advancing once every 150ms. If we check too frequently, we
// could falsely detect that the frame position has stalled due to underrun because we haven't
@@ -6126,7 +6137,7 @@
return mLatchedValue;
}
-void AudioFlinger::PlaybackThread::IsTimestampAdvancing::clear()
+void PlaybackThread::IsTimestampAdvancing::clear()
{
mLatchedValue = true;
mPreviousPosition = 0;
@@ -6134,7 +6145,7 @@
}
// isTrackAllowed_l() must be called with ThreadBase::mLock held
-bool AudioFlinger::MixerThread::isTrackAllowed_l(
+bool MixerThread::isTrackAllowed_l(
audio_channel_mask_t channelMask, audio_format_t format,
audio_session_t sessionId, uid_t uid) const
{
@@ -6154,7 +6165,7 @@
}
// checkForNewParameter_l() must be called with ThreadBase::mLock held
-bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
+bool MixerThread::checkForNewParameter_l(const String8& keyValuePair,
status_t& status)
{
bool reconfig = false;
@@ -6168,7 +6179,7 @@
reconfig = true;
}
if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
- if (!isValidPcmSinkFormat((audio_format_t) value)) {
+ if (!AudioFlinger::isValidPcmSinkFormat(static_cast<audio_format_t>(value))) {
status = BAD_VALUE;
} else {
// no need to save value, since it's constant
@@ -6176,7 +6187,7 @@
}
}
if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
- if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
+ if (!AudioFlinger::isValidPcmSinkChannelMask(static_cast<audio_channel_mask_t>(value))) {
status = BAD_VALUE;
} else {
// no need to save value, since it's constant
@@ -6234,7 +6245,7 @@
}
-void AudioFlinger::MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
+void MixerThread::dumpInternals_l(int fd, const Vector<String16>& args)
{
PlaybackThread::dumpInternals_l(fd, args);
dprintf(fd, " Thread throttle time (msecs): %u\n", mThreadThrottleTimeMs);
@@ -6281,17 +6292,17 @@
dprintf(fd, "Supported latency modes: %s\n", toString(mSupportedLatencyModes).c_str());
}
-uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
+uint32_t MixerThread::idleSleepTimeUs() const
{
return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
}
-uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
+uint32_t MixerThread::suspendSleepTimeUs() const
{
return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
}
-void AudioFlinger::MixerThread::cacheParameters_l()
+void MixerThread::cacheParameters_l()
{
PlaybackThread::cacheParameters_l();
@@ -6302,11 +6313,11 @@
maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
}
-void AudioFlinger::MixerThread::onHalLatencyModesChanged_l() {
+void MixerThread::onHalLatencyModesChanged_l() {
mAudioFlinger->onSupportedLatencyModesChanged(mId, mSupportedLatencyModes);
}
-void AudioFlinger::MixerThread::setHalLatencyMode_l() {
+void MixerThread::setHalLatencyMode_l() {
// Only handle latency mode if:
// - mBluetoothLatencyModesEnabled is true
// - the HAL supports latency modes
@@ -6348,7 +6359,7 @@
}
}
-void AudioFlinger::MixerThread::updateHalSupportedLatencyModes_l() {
+void MixerThread::updateHalSupportedLatencyModes_l() {
if (mOutput == nullptr || mOutput->stream == nullptr) {
return;
@@ -6366,7 +6377,7 @@
}
}
-status_t AudioFlinger::MixerThread::getSupportedLatencyModes(
+status_t MixerThread::getSupportedLatencyModes(
std::vector<audio_latency_mode_t>* modes) {
if (modes == nullptr) {
return BAD_VALUE;
@@ -6376,7 +6387,7 @@
return NO_ERROR;
}
-void AudioFlinger::MixerThread::onRecommendedLatencyModeChanged(
+void MixerThread::onRecommendedLatencyModeChanged(
std::vector<audio_latency_mode_t> modes) {
Mutex::Autolock _l(mLock);
if (modes != mSupportedLatencyModes) {
@@ -6387,7 +6398,7 @@
}
}
-status_t AudioFlinger::MixerThread::setBluetoothVariableLatencyEnabled(bool enabled) {
+status_t MixerThread::setBluetoothVariableLatencyEnabled(bool enabled) {
if (mOutput == nullptr || mOutput->audioHwDev == nullptr
|| !mOutput->audioHwDev->supportsBluetoothVariableLatency()) {
return INVALID_OPERATION;
@@ -6398,7 +6409,16 @@
// ----------------------------------------------------------------------------
-AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
+/* static */
+sp<IAfPlaybackThread> IAfPlaybackThread::createDirectOutputThread(
+ const sp<AudioFlinger>& audioFlinger,
+ AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
+ const audio_offload_info_t& offloadInfo) {
+ return sp<DirectOutputThread>::make(
+ audioFlinger, output, id, systemReady, offloadInfo);
+}
+
+DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamOut* output, audio_io_handle_t id, ThreadBase::type_t type, bool systemReady,
const audio_offload_info_t& offloadInfo)
: PlaybackThread(audioFlinger, output, id, type, systemReady)
@@ -6407,18 +6427,18 @@
setMasterBalance(audioFlinger->getMasterBalance_l());
}
-AudioFlinger::DirectOutputThread::~DirectOutputThread()
+DirectOutputThread::~DirectOutputThread()
{
}
-void AudioFlinger::DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
+void DirectOutputThread::dumpInternals_l(int fd, const Vector<String16>& args)
{
PlaybackThread::dumpInternals_l(fd, args);
dprintf(fd, " Master balance: %f Left: %f Right: %f\n",
mMasterBalance.load(), mMasterBalanceLeft, mMasterBalanceRight);
}
-void AudioFlinger::DirectOutputThread::setMasterBalance(float balance)
+void DirectOutputThread::setMasterBalance(float balance)
{
Mutex::Autolock _l(mLock);
if (mMasterBalance != balance) {
@@ -6428,7 +6448,7 @@
}
}
-void AudioFlinger::DirectOutputThread::processVolume_l(IAfTrack *track, bool lastTrack)
+void DirectOutputThread::processVolume_l(IAfTrack* track, bool lastTrack)
{
float left, right;
@@ -6507,7 +6527,7 @@
}
}
-void AudioFlinger::DirectOutputThread::onAddNewTrack_l()
+void DirectOutputThread::onAddNewTrack_l()
{
sp<IAfTrack> previousTrack = mPreviousTrack.promote();
sp<IAfTrack> latestTrack = mActiveTracks.getLatest();
@@ -6532,7 +6552,7 @@
PlaybackThread::onAddNewTrack_l();
}
-AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
+PlaybackThread::mixer_state DirectOutputThread::prepareTracks_l(
Vector<sp<IAfTrack>>* tracksToRemove
)
{
@@ -6755,7 +6775,7 @@
return mixerStatus;
}
-void AudioFlinger::DirectOutputThread::threadLoop_mix()
+void DirectOutputThread::threadLoop_mix()
{
size_t frameCount = mFrameCount;
int8_t *curBuf = (int8_t *)mSinkBuffer;
@@ -6782,7 +6802,7 @@
mActiveTrack.clear();
}
-void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
+void DirectOutputThread::threadLoop_sleepTime()
{
// do not write to HAL when paused
if (mHwPaused || (usesHwAvSync() && mStandby)) {
@@ -6798,7 +6818,7 @@
// linear or proportional PCM direct tracks in underrun.
}
-void AudioFlinger::DirectOutputThread::threadLoop_exit()
+void DirectOutputThread::threadLoop_exit()
{
{
Mutex::Autolock _l(mLock);
@@ -6816,7 +6836,7 @@
}
// must be called with thread mutex locked
-bool AudioFlinger::DirectOutputThread::shouldStandby_l()
+bool DirectOutputThread::shouldStandby_l()
{
bool trackPaused = false;
bool trackStopped = false;
@@ -6833,7 +6853,7 @@
}
// checkForNewParameter_l() must be called with ThreadBase::mLock held
-bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
+bool DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
status_t& status)
{
bool reconfig = false;
@@ -6875,7 +6895,7 @@
return reconfig;
}
-uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
+uint32_t DirectOutputThread::activeSleepTimeUs() const
{
uint32_t time;
if (audio_has_proportional_frames(mFormat)) {
@@ -6886,7 +6906,7 @@
return time;
}
-uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
+uint32_t DirectOutputThread::idleSleepTimeUs() const
{
uint32_t time;
if (audio_has_proportional_frames(mFormat)) {
@@ -6897,7 +6917,7 @@
return time;
}
-uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
+uint32_t DirectOutputThread::suspendSleepTimeUs() const
{
uint32_t time;
if (audio_has_proportional_frames(mFormat)) {
@@ -6908,7 +6928,7 @@
return time;
}
-void AudioFlinger::DirectOutputThread::cacheParameters_l()
+void DirectOutputThread::cacheParameters_l()
{
PlaybackThread::cacheParameters_l();
@@ -6924,7 +6944,7 @@
}
}
-void AudioFlinger::DirectOutputThread::flushHw_l()
+void DirectOutputThread::flushHw_l()
{
PlaybackThread::flushHw_l();
mOutput->flush();
@@ -6935,7 +6955,7 @@
mMonotonicFrameCounter.onFlush();
}
-int64_t AudioFlinger::DirectOutputThread::computeWaitTimeNs_l() const {
+int64_t DirectOutputThread::computeWaitTimeNs_l() const {
// If a VolumeShaper is active, we must wake up periodically to update volume.
const int64_t NS_PER_MS = 1000000;
return mVolumeShaperActive ?
@@ -6944,8 +6964,8 @@
// ----------------------------------------------------------------------------
-AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
- const wp<AudioFlinger::PlaybackThread>& playbackThread)
+AsyncCallbackThread::AsyncCallbackThread(
+ const wp<PlaybackThread>& playbackThread)
: Thread(false /*canCallJava*/),
mPlaybackThread(playbackThread),
mWriteAckSequence(0),
@@ -6954,16 +6974,12 @@
{
}
-AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
-{
-}
-
-void AudioFlinger::AsyncCallbackThread::onFirstRef()
+void AsyncCallbackThread::onFirstRef()
{
run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
}
-bool AudioFlinger::AsyncCallbackThread::threadLoop()
+bool AsyncCallbackThread::threadLoop()
{
while (!exitPending()) {
uint32_t writeAckSequence;
@@ -6992,7 +7008,7 @@
mAsyncError = false;
}
{
- sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
+ const sp<PlaybackThread> playbackThread = mPlaybackThread.promote();
if (playbackThread != 0) {
if (writeAckSequence & 1) {
playbackThread->resetWriteBlocked(writeAckSequence >> 1);
@@ -7009,7 +7025,7 @@
return false;
}
-void AudioFlinger::AsyncCallbackThread::exit()
+void AsyncCallbackThread::exit()
{
ALOGV("AsyncCallbackThread::exit");
Mutex::Autolock _l(mLock);
@@ -7017,14 +7033,14 @@
mWaitWorkCV.broadcast();
}
-void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
+void AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
{
Mutex::Autolock _l(mLock);
// bit 0 is cleared
mWriteAckSequence = sequence << 1;
}
-void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
+void AsyncCallbackThread::resetWriteBlocked()
{
Mutex::Autolock _l(mLock);
// ignore unexpected callbacks
@@ -7034,14 +7050,14 @@
}
}
-void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
+void AsyncCallbackThread::setDraining(uint32_t sequence)
{
Mutex::Autolock _l(mLock);
// bit 0 is cleared
mDrainSequence = sequence << 1;
}
-void AudioFlinger::AsyncCallbackThread::resetDraining()
+void AsyncCallbackThread::resetDraining()
{
Mutex::Autolock _l(mLock);
// ignore unexpected callbacks
@@ -7051,7 +7067,7 @@
}
}
-void AudioFlinger::AsyncCallbackThread::setAsyncError()
+void AsyncCallbackThread::setAsyncError()
{
Mutex::Autolock _l(mLock);
mAsyncError = true;
@@ -7060,7 +7076,16 @@
// ----------------------------------------------------------------------------
-AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
+
+/* static */
+sp<IAfPlaybackThread> IAfPlaybackThread::createOffloadThread(
+ const sp<AudioFlinger>& audioFlinger,
+ AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
+ const audio_offload_info_t& offloadInfo) {
+ return sp<OffloadThread>::make(audioFlinger, output, id, systemReady, offloadInfo);
+}
+
+OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamOut* output, audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo)
: DirectOutputThread(audioFlinger, output, id, OFFLOAD, systemReady, offloadInfo),
@@ -7071,7 +7096,7 @@
mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
}
-void AudioFlinger::OffloadThread::threadLoop_exit()
+void OffloadThread::threadLoop_exit()
{
if (mFlushPending || mHwPaused) {
// If a flush is pending or track was paused, just discard buffered data
@@ -7087,7 +7112,7 @@
PlaybackThread::threadLoop_exit();
}
-AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
+PlaybackThread::mixer_state OffloadThread::prepareTracks_l(
Vector<sp<IAfTrack>>* tracksToRemove
)
{
@@ -7330,7 +7355,7 @@
}
// must be called with thread mutex locked
-bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
+bool OffloadThread::waitingAsyncCallback_l()
{
ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
mWriteAckSequence, mDrainSequence);
@@ -7340,13 +7365,13 @@
return false;
}
-bool AudioFlinger::OffloadThread::waitingAsyncCallback()
+bool OffloadThread::waitingAsyncCallback()
{
Mutex::Autolock _l(mLock);
return waitingAsyncCallback_l();
}
-void AudioFlinger::OffloadThread::flushHw_l()
+void OffloadThread::flushHw_l()
{
DirectOutputThread::flushHw_l();
// Flush anything still waiting in the mixbuffer
@@ -7367,7 +7392,7 @@
}
}
-void AudioFlinger::OffloadThread::invalidateTracks(audio_stream_type_t streamType)
+void OffloadThread::invalidateTracks(audio_stream_type_t streamType)
{
Mutex::Autolock _l(mLock);
if (PlaybackThread::invalidateTracks_l(streamType)) {
@@ -7375,7 +7400,7 @@
}
}
-void AudioFlinger::OffloadThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
+void OffloadThread::invalidateTracks(std::set<audio_port_handle_t>& portIds) {
Mutex::Autolock _l(mLock);
if (PlaybackThread::invalidateTracks_l(portIds)) {
mFlushPending = true;
@@ -7384,8 +7409,15 @@
// ----------------------------------------------------------------------------
-AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
- AudioFlinger::MixerThread* mainThread, audio_io_handle_t id, bool systemReady)
+/* static */
+sp<IAfDuplicatingThread> IAfDuplicatingThread::create(
+ const sp<AudioFlinger>& audioFlinger,
+ IAfPlaybackThread* mainThread, audio_io_handle_t id, bool systemReady) {
+ return sp<DuplicatingThread>::make(audioFlinger, mainThread, id, systemReady);
+}
+
+DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
+ IAfPlaybackThread* mainThread, audio_io_handle_t id, bool systemReady)
: MixerThread(audioFlinger, mainThread->getOutput(), id,
systemReady, DUPLICATING),
mWaitTimeMs(UINT_MAX)
@@ -7393,14 +7425,14 @@
addOutputTrack(mainThread);
}
-AudioFlinger::DuplicatingThread::~DuplicatingThread()
+DuplicatingThread::~DuplicatingThread()
{
for (size_t i = 0; i < mOutputTracks.size(); i++) {
mOutputTracks[i]->destroy();
}
}
-void AudioFlinger::DuplicatingThread::threadLoop_mix()
+void DuplicatingThread::threadLoop_mix()
{
// mix buffers...
if (outputsReady()) {
@@ -7418,7 +7450,7 @@
mStandbyTimeNs = systemTime() + mStandbyDelayNs;
}
-void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
+void DuplicatingThread::threadLoop_sleepTime()
{
if (mSleepTimeUs == 0) {
if (mMixerStatus == MIXER_TRACKS_ENABLED) {
@@ -7438,7 +7470,7 @@
}
}
-ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
+ssize_t DuplicatingThread::threadLoop_write()
{
for (size_t i = 0; i < outputTracks.size(); i++) {
const ssize_t actualWritten = outputTracks[i]->write(mSinkBuffer, writeFrames);
@@ -7466,7 +7498,7 @@
return (ssize_t)mSinkBufferSize;
}
-void AudioFlinger::DuplicatingThread::threadLoop_standby()
+void DuplicatingThread::threadLoop_standby()
{
// DuplicatingThread implements standby by stopping all tracks
for (size_t i = 0; i < outputTracks.size(); i++) {
@@ -7474,7 +7506,7 @@
}
}
-void AudioFlinger::DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args)
+void DuplicatingThread::dumpInternals_l(int fd, const Vector<String16>& args)
{
MixerThread::dumpInternals_l(fd, args);
@@ -7484,8 +7516,7 @@
if (numTracks > 0) {
ss << ":";
for (const auto &track : mOutputTracks) {
- // TODO(b/288339104) type
- const auto thread = sp<ThreadBase>::cast(track->thread().promote());
+ const auto thread = track->thread().promote();
ss << " (" << track->id() << " : ";
if (thread.get() != nullptr) {
ss << thread.get() << ", " << thread->id();
@@ -7500,17 +7531,17 @@
write(fd, result.c_str(), result.size());
}
-void AudioFlinger::DuplicatingThread::saveOutputTracks()
+void DuplicatingThread::saveOutputTracks()
{
outputTracks = mOutputTracks;
}
-void AudioFlinger::DuplicatingThread::clearOutputTracks()
+void DuplicatingThread::clearOutputTracks()
{
outputTracks.clear();
}
-void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
+void DuplicatingThread::addOutputTrack(IAfPlaybackThread* thread)
{
Mutex::Autolock _l(mLock);
// The downstream MixerThread consumes thread->frameCount() amount of frames per mix pass.
@@ -7547,7 +7578,7 @@
updateWaitTime_l();
}
-void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
+void DuplicatingThread::removeOutputTrack(IAfPlaybackThread* thread)
{
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mOutputTracks.size(); i++) {
@@ -7565,12 +7596,11 @@
}
// caller must hold mLock
-void AudioFlinger::DuplicatingThread::updateWaitTime_l()
+void DuplicatingThread::updateWaitTime_l()
{
mWaitTimeMs = UINT_MAX;
for (size_t i = 0; i < mOutputTracks.size(); i++) {
- // TODO(b/288339104) type
- const auto strong = sp<ThreadBase>::cast(mOutputTracks[i]->thread().promote());
+ const auto strong = mOutputTracks[i]->thread().promote();
if (strong != 0) {
uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
if (waitTimeMs < mWaitTimeMs) {
@@ -7580,19 +7610,18 @@
}
}
-bool AudioFlinger::DuplicatingThread::outputsReady()
+bool DuplicatingThread::outputsReady()
{
for (size_t i = 0; i < outputTracks.size(); i++) {
- // TODO(b/288339104) type
- const auto thread = sp<ThreadBase>::cast(outputTracks[i]->thread().promote());
+ const auto thread = outputTracks[i]->thread().promote();
if (thread == 0) {
ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
outputTracks[i].get());
return false;
}
- PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
+ IAfPlaybackThread* const playbackThread = thread->asIAfPlaybackThread().get();
// see note at standby() declaration
- if (playbackThread->standby() && !playbackThread->isSuspended()) {
+ if (playbackThread->inStandby() && !playbackThread->isSuspended()) {
ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
thread.get());
return false;
@@ -7601,7 +7630,7 @@
return true;
}
-void AudioFlinger::DuplicatingThread::sendMetadataToBackend_l(
+void DuplicatingThread::sendMetadataToBackend_l(
const StreamOutHalInterface::SourceMetadata& metadata)
{
for (auto& outputTrack : outputTracks) { // not mOutputTracks
@@ -7609,12 +7638,12 @@
}
}
-uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
+uint32_t DuplicatingThread::activeSleepTimeUs() const
{
return (mWaitTimeMs * 1000) / 2;
}
-void AudioFlinger::DuplicatingThread::cacheParameters_l()
+void DuplicatingThread::cacheParameters_l()
{
// updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
updateWaitTime_l();
@@ -7624,7 +7653,17 @@
// ----------------------------------------------------------------------------
-AudioFlinger::SpatializerThread::SpatializerThread(const sp<AudioFlinger>& audioFlinger,
+/* static */
+sp<IAfPlaybackThread> IAfPlaybackThread::createSpatializerThread(
+ const sp<AudioFlinger>& audioFlinger,
+ AudioStreamOut* output,
+ audio_io_handle_t id,
+ bool systemReady,
+ audio_config_base_t* mixerConfig) {
+ return sp<SpatializerThread>::make(audioFlinger, output, id, systemReady, mixerConfig);
+}
+
+SpatializerThread::SpatializerThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamOut* output,
audio_io_handle_t id,
bool systemReady,
@@ -7633,7 +7672,7 @@
{
}
-void AudioFlinger::SpatializerThread::onFirstRef() {
+void SpatializerThread::onFirstRef() {
MixerThread::onFirstRef();
const pid_t tid = getTid();
@@ -7648,7 +7687,7 @@
}
}
-void AudioFlinger::SpatializerThread::setHalLatencyMode_l() {
+void SpatializerThread::setHalLatencyMode_l() {
// if mSupportedLatencyModes is empty, the HAL stream does not support
// latency mode control and we can exit.
if (mSupportedLatencyModes.empty()) {
@@ -7686,7 +7725,7 @@
}
}
-status_t AudioFlinger::SpatializerThread::setRequestedLatencyMode(audio_latency_mode_t mode) {
+status_t SpatializerThread::setRequestedLatencyMode(audio_latency_mode_t mode) {
if (mode != AUDIO_LATENCY_MODE_LOW && mode != AUDIO_LATENCY_MODE_FREE) {
return BAD_VALUE;
}
@@ -7695,7 +7734,7 @@
return NO_ERROR;
}
-void AudioFlinger::SpatializerThread::checkOutputStageEffects()
+void SpatializerThread::checkOutputStageEffects()
{
bool hasVirtualizer = false;
bool hasDownMixer = false;
@@ -7751,7 +7790,14 @@
// Record
// ----------------------------------------------------------------------------
-AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
+sp<IAfRecordThread> IAfRecordThread::create(const sp<AudioFlinger>& audioFlinger,
+ AudioStreamIn* input,
+ audio_io_handle_t id,
+ bool systemReady) {
+ return sp<RecordThread>::make(audioFlinger, input, id, systemReady);
+}
+
+RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamIn *input,
audio_io_handle_t id,
bool systemReady
@@ -7910,7 +7956,7 @@
// FIXME mNormalSource
}
-AudioFlinger::RecordThread::~RecordThread()
+RecordThread::~RecordThread()
{
if (mFastCapture != 0) {
FastCaptureStateQueue *sq = mFastCapture->sq();
@@ -7932,12 +7978,12 @@
free(mRsmpInBuffer);
}
-void AudioFlinger::RecordThread::onFirstRef()
+void RecordThread::onFirstRef()
{
run(mThreadName, PRIORITY_URGENT_AUDIO);
}
-void AudioFlinger::RecordThread::preExit()
+void RecordThread::preExit()
{
ALOGV(" preExit()");
Mutex::Autolock _l(mLock);
@@ -7949,7 +7995,7 @@
mStartStopCond.broadcast();
}
-bool AudioFlinger::RecordThread::threadLoop()
+bool RecordThread::threadLoop()
{
nsecs_t lastWarning = 0;
@@ -8514,7 +8560,7 @@
return false;
}
-void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
+void RecordThread::standbyIfNotAlreadyInStandby()
{
if (!mStandby) {
inputStandBy();
@@ -8524,7 +8570,7 @@
}
}
-void AudioFlinger::RecordThread::inputStandBy()
+void RecordThread::inputStandBy()
{
// Idle the fast capture if it's currently running
if (mFastCapture != 0) {
@@ -8565,7 +8611,7 @@
}
// RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
-sp<IAfRecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
+sp<IAfRecordTrack> RecordThread::createRecordTrack_l(
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t *pSampleRate,
@@ -8763,7 +8809,7 @@
return track;
}
-status_t AudioFlinger::RecordThread::start(IAfRecordTrack* recordTrack,
+status_t RecordThread::start(IAfRecordTrack* recordTrack,
AudioSystem::sync_event_t event,
audio_session_t triggerSession)
{
@@ -8859,21 +8905,21 @@
}
}
-void AudioFlinger::RecordThread::syncStartEventCallback(const wp<audioflinger::SyncEvent>& event)
+void RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
{
- sp<audioflinger::SyncEvent> strongEvent = event.promote();
+ const sp<SyncEvent> strongEvent = event.promote();
if (strongEvent != 0) {
sp<IAfTrackBase> ptr =
std::any_cast<const wp<IAfTrackBase>>(strongEvent->cookie()).promote();
if (ptr != nullptr) {
- // TODO(b/288339104) handleSyncStartEvent is in IAfTrackBase not IAfRecordTrack.
+ // TODO(b/291317898) handleSyncStartEvent is in IAfTrackBase not IAfRecordTrack.
ptr->handleSyncStartEvent(strongEvent);
}
}
}
-bool AudioFlinger::RecordThread::stop(IAfRecordTrack* recordTrack) {
+bool RecordThread::stop(IAfRecordTrack* recordTrack) {
ALOGV("RecordThread::stop");
AutoMutex _l(mLock);
// if we're invalid, we can't be on the ActiveTracks.
@@ -8901,14 +8947,12 @@
return false;
}
-bool AudioFlinger::RecordThread::isValidSyncEvent(
- const sp<audioflinger::SyncEvent>& /* event */) const
+bool RecordThread::isValidSyncEvent(const sp<SyncEvent>& /* event */) const
{
return false;
}
-status_t AudioFlinger::RecordThread::setSyncEvent(
- const sp<audioflinger::SyncEvent>& event __unused)
+status_t RecordThread::setSyncEvent(const sp<SyncEvent>& /* event */)
{
#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
if (!isValidSyncEvent(event)) {
@@ -8933,8 +8977,8 @@
#endif
}
-status_t AudioFlinger::RecordThread::getActiveMicrophones(
- std::vector<media::MicrophoneInfoFw>* activeMicrophones)
+status_t RecordThread::getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) const
{
ALOGV("RecordThread::getActiveMicrophones");
AutoMutex _l(mLock);
@@ -8945,7 +8989,7 @@
return status;
}
-status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
+status_t RecordThread::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction)
{
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
@@ -8956,7 +9000,7 @@
return mInput->stream->setPreferredMicrophoneDirection(direction);
}
-status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
+status_t RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
{
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
AutoMutex _l(mLock);
@@ -8966,14 +9010,14 @@
return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
}
-status_t AudioFlinger::RecordThread::shareAudioHistory(
+status_t RecordThread::shareAudioHistory(
const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
int64_t sharedAudioStartMs) {
AutoMutex _l(mLock);
return shareAudioHistory_l(sharedAudioPackageName, sharedSessionId, sharedAudioStartMs);
}
-status_t AudioFlinger::RecordThread::shareAudioHistory_l(
+status_t RecordThread::shareAudioHistory_l(
const std::string& sharedAudioPackageName, audio_session_t sharedSessionId,
int64_t sharedAudioStartMs) {
@@ -9013,13 +9057,13 @@
return NO_ERROR;
}
-void AudioFlinger::RecordThread::resetAudioHistory_l() {
+void RecordThread::resetAudioHistory_l() {
mSharedAudioSessionId = AUDIO_SESSION_NONE;
mSharedAudioStartFrames = -1;
mSharedAudioPackageName = "";
}
-AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::RecordThread::updateMetadata_l()
+ThreadBase::MetadataUpdate RecordThread::updateMetadata_l()
{
if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
return {}; // nothing to do
@@ -9036,7 +9080,7 @@
}
// destroyTrack_l() must be called with ThreadBase::mLock held
-void AudioFlinger::RecordThread::destroyTrack_l(const sp<IAfRecordTrack>& track)
+void RecordThread::destroyTrack_l(const sp<IAfRecordTrack>& track)
{
track->terminate();
track->setState(IAfTrackBase::STOPPED);
@@ -9047,7 +9091,7 @@
}
}
-void AudioFlinger::RecordThread::removeTrack_l(const sp<IAfRecordTrack>& track)
+void RecordThread::removeTrack_l(const sp<IAfRecordTrack>& track)
{
String8 result;
track->appendDump(result, false /* active */);
@@ -9061,7 +9105,7 @@
}
}
-void AudioFlinger::RecordThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
+void RecordThread::dumpInternals_l(int fd, const Vector<String16>& /* args */)
{
AudioStreamIn *input = mInput;
audio_input_flags_t flags = input != NULL ? input->flags : AUDIO_INPUT_FLAG_NONE;
@@ -9089,7 +9133,7 @@
copy->dump(fd);
}
-void AudioFlinger::RecordThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
+void RecordThread::dumpTracks_l(int fd, const Vector<String16>& /* args */)
{
String8 result;
size_t numtracks = mTracks.size();
@@ -9133,7 +9177,7 @@
write(fd, result.string(), result.size());
}
-void AudioFlinger::RecordThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
+void RecordThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
{
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mTracks.size() ; i++) {
@@ -9146,8 +9190,8 @@
void ResamplerBufferProvider::reset()
{
- const auto threadBase = sp<AudioFlinger::ThreadBase>::cast(mRecordTrack->thread().promote());
- auto* const recordThread = static_cast<AudioFlinger::RecordThread *>(threadBase.get());
+ const auto threadBase = mRecordTrack->thread().promote();
+ auto* const recordThread = static_cast<RecordThread *>(threadBase->asIAfRecordThread().get());
mRsmpInUnrel = 0;
const int32_t rear = recordThread->mRsmpInRear;
ssize_t deltaFrames = 0;
@@ -9170,8 +9214,8 @@
void ResamplerBufferProvider::sync(
size_t *framesAvailable, bool *hasOverrun)
{
- const auto threadBase = sp<AudioFlinger::ThreadBase>::cast(mRecordTrack->thread().promote());
- auto* const recordThread = static_cast<AudioFlinger::RecordThread *>(threadBase.get());
+ const auto threadBase = mRecordTrack->thread().promote();
+ auto* const recordThread = static_cast<RecordThread *>(threadBase->asIAfRecordThread().get());
const int32_t rear = recordThread->mRsmpInRear;
const int32_t front = mRsmpInFront;
const ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
@@ -9204,13 +9248,13 @@
status_t ResamplerBufferProvider::getNextBuffer(
AudioBufferProvider::Buffer* buffer)
{
- const auto threadBase = sp<AudioFlinger::ThreadBase>::cast(mRecordTrack->thread().promote());
+ const auto threadBase = mRecordTrack->thread().promote();
if (threadBase == 0) {
buffer->frameCount = 0;
buffer->raw = NULL;
return NOT_ENOUGH_DATA;
}
- auto* const recordThread = static_cast<AudioFlinger::RecordThread *>(threadBase.get());
+ auto* const recordThread = static_cast<RecordThread *>(threadBase->asIAfRecordThread().get());
int32_t rear = recordThread->mRsmpInRear;
int32_t front = mRsmpInFront;
ssize_t filled = audio_utils::safe_sub_overflow(rear, front);
@@ -9258,13 +9302,13 @@
buffer->frameCount = 0;
}
-void AudioFlinger::RecordThread::checkBtNrec()
+void RecordThread::checkBtNrec()
{
Mutex::Autolock _l(mLock);
checkBtNrec_l();
}
-void AudioFlinger::RecordThread::checkBtNrec_l()
+void RecordThread::checkBtNrec_l()
{
// disable AEC and NS if the device is a BT SCO headset supporting those
// pre processings
@@ -9279,7 +9323,7 @@
}
-bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
+bool RecordThread::checkForNewParameter_l(const String8& keyValuePair,
status_t& status)
{
bool reconfig = false;
@@ -9367,7 +9411,7 @@
return reconfig;
}
-String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
+String8 RecordThread::getParameters(const String8& keys)
{
Mutex::Autolock _l(mLock);
if (initCheck() == NO_ERROR) {
@@ -9379,7 +9423,7 @@
return {};
}
-void AudioFlinger::RecordThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
+void RecordThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
audio_port_handle_t portId) {
sp<AudioIoDescriptor> desc;
switch (event) {
@@ -9400,7 +9444,7 @@
mAudioFlinger->ioConfigChanged(event, desc, pid);
}
-void AudioFlinger::RecordThread::readInputParameters_l()
+void RecordThread::readInputParameters_l()
{
status_t result = mInput->stream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
@@ -9443,7 +9487,7 @@
.record();
}
-uint32_t AudioFlinger::RecordThread::getInputFramesLost()
+uint32_t RecordThread::getInputFramesLost() const
{
Mutex::Autolock _l(mLock);
uint32_t result;
@@ -9453,7 +9497,7 @@
return 0;
}
-KeyedVector<audio_session_t, bool> AudioFlinger::RecordThread::sessionIds() const
+KeyedVector<audio_session_t, bool> RecordThread::sessionIds() const
{
KeyedVector<audio_session_t, bool> ids;
Mutex::Autolock _l(mLock);
@@ -9467,7 +9511,7 @@
return ids;
}
-AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
+AudioStreamIn* RecordThread::clearInput()
{
Mutex::Autolock _l(mLock);
AudioStreamIn *input = mInput;
@@ -9476,7 +9520,7 @@
}
// this method must always be called either with ThreadBase mLock held or inside the thread loop
-sp<StreamHalInterface> AudioFlinger::RecordThread::stream() const
+sp<StreamHalInterface> RecordThread::stream() const
{
if (mInput == NULL) {
return NULL;
@@ -9484,7 +9528,7 @@
return mInput->stream;
}
-status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
+status_t RecordThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
{
ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
chain->setThread(this);
@@ -9502,7 +9546,7 @@
return NO_ERROR;
}
-size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
+size_t RecordThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
{
ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
@@ -9515,7 +9559,7 @@
return mEffectChains.size();
}
-status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
+status_t RecordThread::createAudioPatch_l(const struct audio_patch* patch,
audio_patch_handle_t *handle)
{
status_t status = NO_ERROR;
@@ -9572,7 +9616,7 @@
return status;
}
-status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
+status_t RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
{
status_t status = NO_ERROR;
@@ -9591,7 +9635,7 @@
return status;
}
-void AudioFlinger::RecordThread::updateOutDevices(const DeviceDescriptorBaseVector& outDevices)
+void RecordThread::updateOutDevices(const DeviceDescriptorBaseVector& outDevices)
{
Mutex::Autolock _l(mLock);
mOutDevices = outDevices;
@@ -9601,7 +9645,7 @@
}
}
-int32_t AudioFlinger::RecordThread::getOldestFront_l()
+int32_t RecordThread::getOldestFront_l()
{
if (mTracks.size() == 0) {
return mRsmpInRear;
@@ -9623,7 +9667,7 @@
return oldestFront;
}
-void AudioFlinger::RecordThread::updateFronts_l(int32_t offset)
+void RecordThread::updateFronts_l(int32_t offset)
{
if (offset == 0) {
return;
@@ -9635,7 +9679,7 @@
}
}
-void AudioFlinger::RecordThread::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs)
+void RecordThread::resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs)
{
// This is the formula for calculating the temporary buffer size.
// With 7 HAL buffers, we can guarantee ability to down-sample the input by ratio of 6:1 to
@@ -9659,7 +9703,7 @@
mRsmpInRear = 0;
ALOG_ASSERT(maxSharedAudioHistoryMs >= 0
- && maxSharedAudioHistoryMs <= AudioFlinger::kMaxSharedAudioHistoryMs,
+ && maxSharedAudioHistoryMs <= kMaxSharedAudioHistoryMs,
"resizeInputBuffer_l() called with invalid max shared history %d",
maxSharedAudioHistoryMs);
if (maxSharedAudioHistoryMs != 0) {
@@ -9728,7 +9772,7 @@
mRsmpInBuffer = rsmpInBuffer;
}
-void AudioFlinger::RecordThread::addPatchTrack(const sp<IAfPatchRecord>& record)
+void RecordThread::addPatchTrack(const sp<IAfPatchRecord>& record)
{
Mutex::Autolock _l(mLock);
mTracks.add(record);
@@ -9737,7 +9781,7 @@
}
}
-void AudioFlinger::RecordThread::deletePatchTrack(const sp<IAfPatchRecord>& record)
+void RecordThread::deletePatchTrack(const sp<IAfPatchRecord>& record)
{
Mutex::Autolock _l(mLock);
if (mSource == record->getSource()) {
@@ -9746,7 +9790,7 @@
destroyTrack_l(record);
}
-void AudioFlinger::RecordThread::toAudioPortConfig(struct audio_port_config *config)
+void RecordThread::toAudioPortConfig(struct audio_port_config* config)
{
ThreadBase::toAudioPortConfig(config);
config->role = AUDIO_PORT_ROLE_SINK;
@@ -9762,56 +9806,85 @@
// Mmap
// ----------------------------------------------------------------------------
-AudioFlinger::MmapThreadHandle::MmapThreadHandle(const sp<MmapThread>& thread)
+// Mmap stream control interface implementation. Each MmapThreadHandle controls one
+// MmapPlaybackThread or MmapCaptureThread instance.
+class MmapThreadHandle : public MmapStreamInterface {
+public:
+ explicit MmapThreadHandle(const sp<IAfMmapThread>& thread);
+ ~MmapThreadHandle() override;
+
+ // MmapStreamInterface virtuals
+ status_t createMmapBuffer(int32_t minSizeFrames,
+ struct audio_mmap_buffer_info* info) final;
+ status_t getMmapPosition(struct audio_mmap_position* position) final;
+ status_t getExternalPosition(uint64_t* position, int64_t* timeNanos) final;
+ status_t start(const AudioClient& client,
+ const audio_attributes_t* attr, audio_port_handle_t* handle) final;
+ status_t stop(audio_port_handle_t handle) final;
+ status_t standby() final;
+ status_t reportData(const void* buffer, size_t frameCount) final;
+private:
+ const sp<IAfMmapThread> mThread;
+};
+
+/* static */
+sp<MmapStreamInterface> IAfMmapThread::createMmapStreamInterfaceAdapter(
+ const sp<IAfMmapThread>& mmapThread) {
+ return sp<MmapThreadHandle>::make(mmapThread);
+}
+
+MmapThreadHandle::MmapThreadHandle(const sp<IAfMmapThread>& thread)
: mThread(thread)
{
assert(thread != 0); // thread must start non-null and stay non-null
}
-AudioFlinger::MmapThreadHandle::~MmapThreadHandle()
+// MmapStreamInterface could be directly implemented by MmapThread excepting this
+// special handling on adapter dtor.
+MmapThreadHandle::~MmapThreadHandle()
{
mThread->disconnect();
}
-status_t AudioFlinger::MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
+status_t MmapThreadHandle::createMmapBuffer(int32_t minSizeFrames,
struct audio_mmap_buffer_info *info)
{
return mThread->createMmapBuffer(minSizeFrames, info);
}
-status_t AudioFlinger::MmapThreadHandle::getMmapPosition(struct audio_mmap_position *position)
+status_t MmapThreadHandle::getMmapPosition(struct audio_mmap_position* position)
{
return mThread->getMmapPosition(position);
}
-status_t AudioFlinger::MmapThreadHandle::getExternalPosition(uint64_t *position,
+status_t MmapThreadHandle::getExternalPosition(uint64_t* position,
int64_t *timeNanos) {
return mThread->getExternalPosition(position, timeNanos);
}
-status_t AudioFlinger::MmapThreadHandle::start(const AudioClient& client,
+status_t MmapThreadHandle::start(const AudioClient& client,
const audio_attributes_t *attr, audio_port_handle_t *handle)
-
{
return mThread->start(client, attr, handle);
}
-status_t AudioFlinger::MmapThreadHandle::stop(audio_port_handle_t handle)
+status_t MmapThreadHandle::stop(audio_port_handle_t handle)
{
return mThread->stop(handle);
}
-status_t AudioFlinger::MmapThreadHandle::standby()
+status_t MmapThreadHandle::standby()
{
return mThread->standby();
}
-status_t AudioFlinger::MmapThreadHandle::reportData(const void* buffer, size_t frameCount) {
+status_t MmapThreadHandle::reportData(const void* buffer, size_t frameCount)
+{
return mThread->reportData(buffer, frameCount);
}
-AudioFlinger::MmapThread::MmapThread(
+MmapThread::MmapThread(
const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady, bool isOut)
: ThreadBase(audioFlinger, id, (isOut ? MMAP_PLAYBACK : MMAP_CAPTURE), systemReady, isOut),
@@ -9826,16 +9899,12 @@
readHalParameters_l();
}
-AudioFlinger::MmapThread::~MmapThread()
-{
-}
-
-void AudioFlinger::MmapThread::onFirstRef()
+void MmapThread::onFirstRef()
{
run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
}
-void AudioFlinger::MmapThread::disconnect()
+void MmapThread::disconnect()
{
ActiveTracks<IAfMmapTrack> activeTracks;
{
@@ -9856,7 +9925,7 @@
}
-void AudioFlinger::MmapThread::configure(const audio_attributes_t *attr,
+void MmapThread::configure(const audio_attributes_t* attr,
audio_stream_type_t streamType __unused,
audio_session_t sessionId,
const sp<MmapStreamCallback>& callback,
@@ -9870,7 +9939,7 @@
mPortId = portId;
}
-status_t AudioFlinger::MmapThread::createMmapBuffer(int32_t minSizeFrames,
+status_t MmapThread::createMmapBuffer(int32_t minSizeFrames,
struct audio_mmap_buffer_info *info)
{
if (mHalStream == 0) {
@@ -9880,7 +9949,7 @@
return mHalStream->createMmapBuffer(minSizeFrames, info);
}
-status_t AudioFlinger::MmapThread::getMmapPosition(struct audio_mmap_position *position)
+status_t MmapThread::getMmapPosition(struct audio_mmap_position* position) const
{
if (mHalStream == 0) {
return NO_INIT;
@@ -9888,7 +9957,7 @@
return mHalStream->getMmapPosition(position);
}
-status_t AudioFlinger::MmapThread::exitStandby_l()
+status_t MmapThread::exitStandby_l()
{
// The HAL must receive track metadata before starting the stream
updateMetadata_l();
@@ -9905,7 +9974,7 @@
return NO_ERROR;
}
-status_t AudioFlinger::MmapThread::start(const AudioClient& client,
+status_t MmapThread::start(const AudioClient& client,
const audio_attributes_t *attr,
audio_port_handle_t *handle)
{
@@ -10052,7 +10121,7 @@
return ret;
}
-status_t AudioFlinger::MmapThread::stop(audio_port_handle_t handle)
+status_t MmapThread::stop(audio_port_handle_t handle)
{
ALOGV("%s handle %d", __FUNCTION__, handle);
@@ -10106,7 +10175,7 @@
return NO_ERROR;
}
-status_t AudioFlinger::MmapThread::standby()
+status_t MmapThread::standby()
{
ALOGV("%s", __FUNCTION__);
@@ -10126,12 +10195,12 @@
return NO_ERROR;
}
-status_t AudioFlinger::MmapThread::reportData(const void* /*buffer*/, size_t /*frameCount*/) {
+status_t MmapThread::reportData(const void* /*buffer*/, size_t /*frameCount*/) {
// This is a stub implementation. The MmapPlaybackThread overrides this function.
return INVALID_OPERATION;
}
-void AudioFlinger::MmapThread::readHalParameters_l()
+void MmapThread::readHalParameters_l()
{
status_t result = mHalStream->getAudioProperties(&mSampleRate, &mChannelMask, &mHALFormat);
LOG_ALWAYS_FATAL_IF(result != OK, "Error retrieving audio properties from HAL: %d", result);
@@ -10167,7 +10236,7 @@
.record();
}
-bool AudioFlinger::MmapThread::threadLoop()
+bool MmapThread::threadLoop()
{
checkSilentMode_l();
@@ -10238,7 +10307,7 @@
}
// checkForNewParameter_l() must be called with ThreadBase::mLock held
-bool AudioFlinger::MmapThread::checkForNewParameter_l(const String8& keyValuePair,
+bool MmapThread::checkForNewParameter_l(const String8& keyValuePair,
status_t& status)
{
AudioParameter param = AudioParameter(keyValuePair);
@@ -10256,7 +10325,7 @@
return false;
}
-String8 AudioFlinger::MmapThread::getParameters(const String8& keys)
+String8 MmapThread::getParameters(const String8& keys)
{
Mutex::Autolock _l(mLock);
String8 out_s8;
@@ -10266,7 +10335,7 @@
return {};
}
-void AudioFlinger::MmapThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
+void MmapThread::ioConfigChanged(audio_io_config_event_t event, pid_t pid,
audio_port_handle_t portId __unused) {
sp<AudioIoDescriptor> desc;
bool isInput = false;
@@ -10291,7 +10360,7 @@
mAudioFlinger->ioConfigChanged(event, desc, pid);
}
-status_t AudioFlinger::MmapThread::createAudioPatch_l(const struct audio_patch *patch,
+status_t MmapThread::createAudioPatch_l(const struct audio_patch* patch,
audio_patch_handle_t *handle)
NO_THREAD_SAFETY_ANALYSIS // elease and re-acquire mLock
{
@@ -10382,7 +10451,7 @@
return status;
}
-status_t AudioFlinger::MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
+status_t MmapThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
{
status_t status = NO_ERROR;
@@ -10404,7 +10473,7 @@
return status;
}
-void AudioFlinger::MmapThread::toAudioPortConfig(struct audio_port_config *config)
+void MmapThread::toAudioPortConfig(struct audio_port_config* config)
{
ThreadBase::toAudioPortConfig(config);
if (isOutput()) {
@@ -10418,7 +10487,7 @@
}
}
-status_t AudioFlinger::MmapThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
+status_t MmapThread::addEffectChain_l(const sp<IAfEffectChain>& chain)
{
audio_session_t session = chain->sessionId();
@@ -10442,7 +10511,7 @@
return NO_ERROR;
}
-size_t AudioFlinger::MmapThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
+size_t MmapThread::removeEffectChain_l(const sp<IAfEffectChain>& chain)
{
audio_session_t session = chain->sessionId();
@@ -10465,29 +10534,29 @@
return mEffectChains.size();
}
-void AudioFlinger::MmapThread::threadLoop_standby()
+void MmapThread::threadLoop_standby()
{
mHalStream->standby();
}
-void AudioFlinger::MmapThread::threadLoop_exit()
+void MmapThread::threadLoop_exit()
{
// Do not call callback->onTearDown() because it is redundant for thread exit
// and because it can cause a recursive mutex lock on stop().
}
-status_t AudioFlinger::MmapThread::setSyncEvent(const sp<audioflinger::SyncEvent>& /* event */)
+status_t MmapThread::setSyncEvent(const sp<SyncEvent>& /* event */)
{
return BAD_VALUE;
}
-bool AudioFlinger::MmapThread::isValidSyncEvent(
- const sp<audioflinger::SyncEvent>& /* event */) const
+bool MmapThread::isValidSyncEvent(
+ const sp<SyncEvent>& /* event */) const
{
return false;
}
-status_t AudioFlinger::MmapThread::checkEffectCompatibility_l(
+status_t MmapThread::checkEffectCompatibility_l(
const effect_descriptor_t *desc, audio_session_t sessionId)
{
// No global effect sessions on mmap threads
@@ -10521,7 +10590,7 @@
return NO_ERROR;
}
-void AudioFlinger::MmapThread::checkInvalidTracks_l()
+void MmapThread::checkInvalidTracks_l()
NO_THREAD_SAFETY_ANALYSIS // release and re-acquire mLock
{
sp<MmapStreamCallback> callback;
@@ -10542,7 +10611,7 @@
}
}
-void AudioFlinger::MmapThread::dumpInternals_l(int fd, const Vector<String16>& args __unused)
+void MmapThread::dumpInternals_l(int fd, const Vector<String16>& /* args */)
{
dprintf(fd, " Attributes: content type %d usage %d source %d\n",
mAttr.content_type, mAttr.usage, mAttr.source);
@@ -10552,7 +10621,7 @@
}
}
-void AudioFlinger::MmapThread::dumpTracks_l(int fd, const Vector<String16>& args __unused)
+void MmapThread::dumpTracks_l(int fd, const Vector<String16>& /* args */)
{
String8 result;
size_t numtracks = mActiveTracks.size();
@@ -10572,7 +10641,14 @@
write(fd, result.string(), result.size());
}
-AudioFlinger::MmapPlaybackThread::MmapPlaybackThread(
+/* static */
+sp<IAfMmapPlaybackThread> IAfMmapPlaybackThread::create(
+ const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ AudioHwDevice* hwDev, AudioStreamOut* output, bool systemReady) {
+ return sp<MmapPlaybackThread>::make(audioFlinger, id, hwDev, output, systemReady);
+}
+
+MmapPlaybackThread::MmapPlaybackThread(
const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady)
: MmapThread(audioFlinger, id, hwDev, output->stream, systemReady, true /* isOut */),
@@ -10606,7 +10682,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::configure(const audio_attributes_t *attr,
+void MmapPlaybackThread::configure(const audio_attributes_t* attr,
audio_stream_type_t streamType,
audio_session_t sessionId,
const sp<MmapStreamCallback>& callback,
@@ -10617,7 +10693,7 @@
mStreamType = streamType;
}
-AudioStreamOut* AudioFlinger::MmapPlaybackThread::clearOutput()
+AudioStreamOut* MmapPlaybackThread::clearOutput()
{
Mutex::Autolock _l(mLock);
AudioStreamOut *output = mOutput;
@@ -10625,7 +10701,7 @@
return output;
}
-void AudioFlinger::MmapPlaybackThread::setMasterVolume(float value)
+void MmapPlaybackThread::setMasterVolume(float value)
{
Mutex::Autolock _l(mLock);
// Don't apply master volume in SW if our HAL can do it for us.
@@ -10637,7 +10713,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::setMasterMute(bool muted)
+void MmapPlaybackThread::setMasterMute(bool muted)
{
Mutex::Autolock _l(mLock);
// Don't apply master mute in SW if our HAL can do it for us.
@@ -10648,7 +10724,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
+void MmapPlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
{
Mutex::Autolock _l(mLock);
mStreamTypes[stream].volume = value;
@@ -10657,13 +10733,13 @@
}
}
-float AudioFlinger::MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
+float MmapPlaybackThread::streamVolume(audio_stream_type_t stream) const
{
Mutex::Autolock _l(mLock);
return mStreamTypes[stream].volume;
}
-void AudioFlinger::MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
+void MmapPlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
{
Mutex::Autolock _l(mLock);
mStreamTypes[stream].mute = muted;
@@ -10672,7 +10748,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
+void MmapPlaybackThread::invalidateTracks(audio_stream_type_t streamType)
{
Mutex::Autolock _l(mLock);
if (streamType == mStreamType) {
@@ -10683,7 +10759,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds)
+void MmapPlaybackThread::invalidateTracks(std::set<audio_port_handle_t>& portIds)
{
Mutex::Autolock _l(mLock);
bool trackMatch = false;
@@ -10702,7 +10778,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::processVolume_l()
+void MmapPlaybackThread::processVolume_l()
NO_THREAD_SAFETY_ANALYSIS // access of track->processMuteEvent_l
{
float volume;
@@ -10757,7 +10833,7 @@
}
}
-AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::MmapPlaybackThread::updateMetadata_l()
+ThreadBase::MetadataUpdate MmapPlaybackThread::updateMetadata_l()
{
if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
return {}; // nothing to do
@@ -10782,7 +10858,7 @@
return change;
};
-void AudioFlinger::MmapPlaybackThread::checkSilentMode_l()
+void MmapPlaybackThread::checkSilentMode_l()
{
if (!mMasterMute) {
char value[PROPERTY_VALUE_MAX];
@@ -10799,7 +10875,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::toAudioPortConfig(struct audio_port_config *config)
+void MmapPlaybackThread::toAudioPortConfig(struct audio_port_config* config)
{
MmapThread::toAudioPortConfig(config);
if (mOutput && mOutput->flags != AUDIO_OUTPUT_FLAG_NONE) {
@@ -10808,8 +10884,8 @@
}
}
-status_t AudioFlinger::MmapPlaybackThread::getExternalPosition(uint64_t *position,
- int64_t *timeNanos)
+status_t MmapPlaybackThread::getExternalPosition(uint64_t* position,
+ int64_t* timeNanos) const
{
if (mOutput == nullptr) {
return NO_INIT;
@@ -10822,7 +10898,7 @@
return status;
}
-status_t AudioFlinger::MmapPlaybackThread::reportData(const void* buffer, size_t frameCount) {
+status_t MmapPlaybackThread::reportData(const void* buffer, size_t frameCount) {
// Send to MelProcessor for sound dose measurement.
auto processor = mMelProcessor.load();
if (processor) {
@@ -10833,7 +10909,7 @@
}
// startMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::MmapPlaybackThread::startMelComputation_l(
+void MmapPlaybackThread::startMelComputation_l(
const sp<audio_utils::MelProcessor>& processor)
{
ALOGV("%s: starting mel processor for thread %d", __func__, id());
@@ -10847,7 +10923,7 @@
}
// stopMelComputation_l() must be called with AudioFlinger::mLock held
-void AudioFlinger::MmapPlaybackThread::stopMelComputation_l()
+void MmapPlaybackThread::stopMelComputation_l()
{
ALOGV("%s: pausing mel processor for thread %d", __func__, id());
auto melProcessor = mMelProcessor.load();
@@ -10856,7 +10932,7 @@
}
}
-void AudioFlinger::MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
+void MmapPlaybackThread::dumpInternals_l(int fd, const Vector<String16>& args)
{
MmapThread::dumpInternals_l(fd, args);
@@ -10865,7 +10941,14 @@
dprintf(fd, " Master volume: %f Master mute %d\n", mMasterVolume, mMasterMute);
}
-AudioFlinger::MmapCaptureThread::MmapCaptureThread(
+/* static */
+sp<IAfMmapCaptureThread> IAfMmapCaptureThread::create(
+ const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
+ AudioHwDevice* hwDev, AudioStreamIn* input, bool systemReady) {
+ return sp<MmapCaptureThread>::make(audioFlinger, id, hwDev, input, systemReady);
+}
+
+MmapCaptureThread::MmapCaptureThread(
const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady)
: MmapThread(audioFlinger, id, hwDev, input->stream, systemReady, false /* isOut */),
@@ -10875,7 +10958,7 @@
mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
}
-status_t AudioFlinger::MmapCaptureThread::exitStandby_l()
+status_t MmapCaptureThread::exitStandby_l()
{
{
// mInput might have been cleared by clearInput()
@@ -10886,7 +10969,7 @@
return MmapThread::exitStandby_l();
}
-AudioFlinger::AudioStreamIn* AudioFlinger::MmapCaptureThread::clearInput()
+AudioStreamIn* MmapCaptureThread::clearInput()
{
Mutex::Autolock _l(mLock);
AudioStreamIn *input = mInput;
@@ -10894,8 +10977,7 @@
return input;
}
-
-void AudioFlinger::MmapCaptureThread::processVolume_l()
+void MmapCaptureThread::processVolume_l()
{
bool changed = false;
bool silenced = false;
@@ -10922,7 +11004,7 @@
}
}
-AudioFlinger::ThreadBase::MetadataUpdate AudioFlinger::MmapCaptureThread::updateMetadata_l()
+ThreadBase::MetadataUpdate MmapCaptureThread::updateMetadata_l()
{
if (!isStreamInitialized() || !mActiveTracks.readAndClearHasChanged()) {
return {}; // nothing to do
@@ -10945,7 +11027,7 @@
return change;
}
-void AudioFlinger::MmapCaptureThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
+void MmapCaptureThread::setRecordSilenced(audio_port_handle_t portId, bool silenced)
{
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mActiveTracks.size() ; i++) {
@@ -10957,7 +11039,7 @@
setClientSilencedIfExists_l(portId, silenced);
}
-void AudioFlinger::MmapCaptureThread::toAudioPortConfig(struct audio_port_config *config)
+void MmapCaptureThread::toAudioPortConfig(struct audio_port_config* config)
{
MmapThread::toAudioPortConfig(config);
if (mInput && mInput->flags != AUDIO_INPUT_FLAG_NONE) {
@@ -10966,8 +11048,8 @@
}
}
-status_t AudioFlinger::MmapCaptureThread::getExternalPosition(
- uint64_t *position, int64_t *timeNanos)
+status_t MmapCaptureThread::getExternalPosition(
+ uint64_t* position, int64_t* timeNanos) const
{
if (mInput == nullptr) {
return NO_INIT;
@@ -10977,11 +11059,18 @@
// ----------------------------------------------------------------------------
-AudioFlinger::BitPerfectThread::BitPerfectThread(const sp<AudioFlinger> &audioflinger,
+/* static */
+sp<IAfPlaybackThread> IAfPlaybackThread::createBitPerfectThread(
+ const sp<AudioFlinger>& audioflinger,
+ AudioStreamOut* output, audio_io_handle_t id, bool systemReady) {
+ return sp<BitPerfectThread>::make(audioflinger, output, id, systemReady);
+}
+
+BitPerfectThread::BitPerfectThread(const sp<AudioFlinger> &audioflinger,
AudioStreamOut *output, audio_io_handle_t id, bool systemReady)
: MixerThread(audioflinger, output, id, systemReady, BIT_PERFECT) {}
-AudioFlinger::PlaybackThread::mixer_state AudioFlinger::BitPerfectThread::prepareTracks_l(
+PlaybackThread::mixer_state BitPerfectThread::prepareTracks_l(
Vector<sp<IAfTrack>>* tracksToRemove) {
mixer_state result = MixerThread::prepareTracks_l(tracksToRemove);
// If there is only one active track and it is bit-perfect, enable tee buffer.
@@ -11014,7 +11103,7 @@
return result;
}
-void AudioFlinger::BitPerfectThread::threadLoop_mix() {
+void BitPerfectThread::threadLoop_mix() {
MixerThread::threadLoop_mix();
mHasDataCopiedToSinkBuffer = mIsBitPerfect;
}
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index bd0cb68..a8847d7 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -15,39 +15,24 @@
** limitations under the License.
*/
-#ifndef INCLUDING_FROM_AUDIOFLINGER_H
- #error This header file should only be included from AudioFlinger.h
-#endif
+#pragma once
-public: // TODO(b/288339104) extract out of AudioFlinger class
-class ThreadBase : public Thread {
- // TODO(b/288339104) remove friends
- friend class RecordTrack;
- friend class Track;
- friend class TrackBase;
+namespace android {
+
+class AsyncCallbackThread;
+
+class ThreadBase : public virtual IAfThreadBase, public Thread {
public:
- enum type_t {
- MIXER, // Thread class is MixerThread
- DIRECT, // Thread class is DirectOutputThread
- DUPLICATING, // Thread class is DuplicatingThread
- RECORD, // Thread class is RecordThread
- OFFLOAD, // Thread class is OffloadThread
- MMAP_PLAYBACK, // Thread class for MMAP playback stream
- MMAP_CAPTURE, // Thread class for MMAP capture stream
- SPATIALIZER, //
- BIT_PERFECT, // Thread class for BitPerfectThread
- // If you add any values here, also update ThreadBase::threadTypeToString()
- };
-
static const char *threadTypeToString(type_t type);
+ AudioFlinger* audioFlinger() const final { return mAudioFlinger.get(); }
+
ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
type_t type, bool systemReady, bool isOut);
- virtual ~ThreadBase();
+ ~ThreadBase() override;
- virtual status_t readyToRun();
-
- void clearPowerManager();
+ status_t readyToRun() final;
+ void clearPowerManager() final;
// base for record and playback
enum {
@@ -91,8 +76,6 @@
class ConfigEvent: public RefBase {
public:
- virtual ~ConfigEvent() {}
-
void dump(char *buffer, size_t size) {
snprintf(buffer, size, "Event type: %d\n", mType);
if (mData != nullptr) {
@@ -136,7 +119,6 @@
ConfigEvent(CFG_EVENT_IO) {
mData = new IoConfigEventData(event, pid, portId);
}
- virtual ~IoConfigEvent() {}
};
class PrioConfigEventData : public ConfigEventData {
@@ -161,7 +143,6 @@
ConfigEvent(CFG_EVENT_PRIO, true) {
mData = new PrioConfigEventData(pid, tid, prio, forApp);
}
- virtual ~PrioConfigEvent() {}
};
class SetParameterConfigEventData : public ConfigEventData {
@@ -183,7 +164,6 @@
mData = new SetParameterConfigEventData(keyValuePairs);
mWaitStatus = true;
}
- virtual ~SetParameterConfigEvent() {}
};
class CreateAudioPatchConfigEventData : public ConfigEventData {
@@ -208,7 +188,6 @@
mData = new CreateAudioPatchConfigEventData(patch, handle);
mWaitStatus = true;
}
- virtual ~CreateAudioPatchConfigEvent() {}
};
class ReleaseAudioPatchConfigEventData : public ConfigEventData {
@@ -230,7 +209,6 @@
mData = new ReleaseAudioPatchConfigEventData(handle);
mWaitStatus = true;
}
- virtual ~ReleaseAudioPatchConfigEvent() {}
};
class UpdateOutDevicesConfigEventData : public ConfigEventData {
@@ -251,8 +229,6 @@
ConfigEvent(CFG_EVENT_UPDATE_OUT_DEVICE) {
mData = new UpdateOutDevicesConfigEventData(outDevices);
}
-
- virtual ~UpdateOutDevicesConfigEvent();
};
class ResizeBufferConfigEventData : public ConfigEventData {
@@ -273,8 +249,6 @@
ConfigEvent(CFG_EVENT_RESIZE_BUFFER) {
mData = new ResizeBufferConfigEventData(maxSharedAudioHistoryMs);
}
-
- virtual ~ResizeBufferConfigEvent() {}
};
class CheckOutputStageEffectsEvent : public ConfigEvent {
@@ -282,8 +256,6 @@
CheckOutputStageEffectsEvent() :
ConfigEvent(CFG_EVENT_CHECK_OUTPUT_STAGE_EFFECTS) {
}
-
- virtual ~CheckOutputStageEffectsEvent() {}
};
class HalLatencyModesChangedEvent : public ConfigEvent {
@@ -291,8 +263,6 @@
HalLatencyModesChangedEvent() :
ConfigEvent(CFG_EVENT_HAL_LATENCY_MODES_CHANGED) {
}
-
- virtual ~HalLatencyModesChangedEvent() {}
};
@@ -310,108 +280,87 @@
wp<ThreadBase> mThread;
};
- virtual status_t initCheck() const = 0;
+ type_t type() const final { return mType; }
+ bool isDuplicating() const final { return (mType == DUPLICATING); }
+ audio_io_handle_t id() const final { return mId;}
- // static externally-visible
- type_t type() const { return mType; }
- bool isDuplicating() const { return (mType == DUPLICATING); }
-
- audio_io_handle_t id() const { return mId;}
-
- // dynamic externally-visible
- uint32_t sampleRate() const { return mSampleRate; }
- audio_channel_mask_t channelMask() const { return mChannelMask; }
- virtual audio_channel_mask_t mixerChannelMask() const { return mChannelMask; }
-
- audio_format_t format() const { return mHALFormat; }
- uint32_t channelCount() const { return mChannelCount; }
-
- // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
- // and returns the [normal mix] buffer's frame count.
- virtual size_t frameCount() const = 0;
- virtual audio_channel_mask_t hapticChannelMask() const { return AUDIO_CHANNEL_NONE; }
- virtual uint32_t latency_l() const { return 0; }
- virtual void setVolumeForOutput_l(float left __unused, float right __unused) const {}
+ uint32_t sampleRate() const final { return mSampleRate; }
+ audio_channel_mask_t channelMask() const final { return mChannelMask; }
+ audio_channel_mask_t mixerChannelMask() const override { return mChannelMask; }
+ audio_format_t format() const final { return mHALFormat; }
+ uint32_t channelCount() const final { return mChannelCount; }
+ audio_channel_mask_t hapticChannelMask() const override { return AUDIO_CHANNEL_NONE; }
+ uint32_t hapticChannelCount() const override { return 0; }
+ uint32_t latency_l() const override { return 0; }
+ void setVolumeForOutput_l(float /* left */, float /* right */) const override {}
// Return's the HAL's frame count i.e. fast mixer buffer size.
- size_t frameCountHAL() const { return mFrameCount; }
-
- size_t frameSize() const { return mFrameSize; }
+ size_t frameCountHAL() const final { return mFrameCount; }
+ size_t frameSize() const final { return mFrameSize; }
// Should be "virtual status_t requestExitAndWait()" and override same
// method in Thread, but Thread::requestExitAndWait() is not yet virtual.
- void exit();
- virtual bool checkForNewParameter_l(const String8& keyValuePair,
- status_t& status) = 0;
- virtual status_t setParameters(const String8& keyValuePairs);
- virtual String8 getParameters(const String8& keys) = 0;
- virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) = 0;
+ void exit() final;
+ status_t setParameters(const String8& keyValuePairs) final;
+
// sendConfigEvent_l() must be called with ThreadBase::mLock held
// Can temporarily release the lock if waiting for a reply from
// processConfigEvents_l().
- status_t sendConfigEvent_l(sp<ConfigEvent>& event);
- void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
- void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
- void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp);
- void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp);
- status_t sendSetParameterConfigEvent_l(const String8& keyValuePair);
- status_t sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
- status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
- status_t sendUpdateOutDeviceConfigEvent(
- const DeviceDescriptorBaseVector& outDevices);
- void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs);
- void sendCheckOutputStageEffectsEvent();
- void sendCheckOutputStageEffectsEvent_l();
- void sendHalLatencyModesChangedEvent_l();
+ status_t sendConfigEvent_l(sp<ConfigEvent>& event);
+ void sendIoConfigEvent(audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) final;
+ void sendIoConfigEvent_l(audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) final;
+ void sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio, bool forApp) final;
+ void sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio, bool forApp) final;
+ status_t sendSetParameterConfigEvent_l(const String8& keyValuePair) final;
+ status_t sendCreateAudioPatchConfigEvent(const struct audio_patch* patch,
+ audio_patch_handle_t* handle) final;
+ status_t sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle) final;
+ status_t sendUpdateOutDeviceConfigEvent(
+ const DeviceDescriptorBaseVector& outDevices) final;
+ void sendResizeBufferConfigEvent_l(int32_t maxSharedAudioHistoryMs) final;
+ void sendCheckOutputStageEffectsEvent() final;
+ void sendCheckOutputStageEffectsEvent_l() final;
+ void sendHalLatencyModesChangedEvent_l() final;
- void processConfigEvents_l();
- virtual void setCheckOutputStageEffects() {}
- virtual void cacheParameters_l() = 0;
- virtual status_t createAudioPatch_l(const struct audio_patch *patch,
- audio_patch_handle_t *handle) = 0;
- virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
- virtual void updateOutDevices(const DeviceDescriptorBaseVector& outDevices);
- virtual void toAudioPortConfig(struct audio_port_config *config) = 0;
+ void processConfigEvents_l() final;
+ void setCheckOutputStageEffects() override {}
+ void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
+ void toAudioPortConfig(struct audio_port_config* config) override;
+ void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
- virtual void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs);
+ // see note at declaration of mStandby, mOutDevice and mInDevice
+ bool inStandby() const override { return mStandby; }
+ const DeviceTypeSet outDeviceTypes() const final {
+ return getAudioDeviceTypes(mOutDeviceTypeAddrs);
+ }
+ audio_devices_t inDeviceType() const final { return mInDeviceTypeAddr.mType; }
+ DeviceTypeSet getDeviceTypes() const final {
+ return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
+ }
- // see note at declaration of mStandby, mOutDevice and mInDevice
- bool standby() const { return mStandby; }
- const DeviceTypeSet outDeviceTypes() const {
- return getAudioDeviceTypes(mOutDeviceTypeAddrs);
- }
- audio_devices_t inDeviceType() const { return mInDeviceTypeAddr.mType; }
- DeviceTypeSet getDeviceTypes() const {
- return isOutput() ? outDeviceTypes() : DeviceTypeSet({inDeviceType()});
- }
+ const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const final {
+ return mOutDeviceTypeAddrs;
+ }
+ const AudioDeviceTypeAddr& inDeviceTypeAddr() const final {
+ return mInDeviceTypeAddr;
+ }
- const AudioDeviceTypeAddrVector& outDeviceTypeAddrs() const {
- return mOutDeviceTypeAddrs;
- }
- const AudioDeviceTypeAddr& inDeviceTypeAddr() const {
- return mInDeviceTypeAddr;
- }
+ bool isOutput() const final { return mIsOut; }
- bool isOutput() const { return mIsOut; }
+ bool isOffloadOrMmap() const final {
+ switch (mType) {
+ case OFFLOAD:
+ case MMAP_PLAYBACK:
+ case MMAP_CAPTURE:
+ return true;
+ default:
+ return false;
+ }
+ }
- bool isOffloadOrMmap() const {
- switch (mType) {
- case OFFLOAD:
- case MMAP_PLAYBACK:
- case MMAP_CAPTURE:
- return true;
- default:
- return false;
- }
- }
-
- virtual sp<StreamHalInterface> stream() const = 0;
-
- sp<IAfEffectHandle> createEffect_l(
+ sp<IAfEffectHandle> createEffect_l(
const sp<Client>& client,
const sp<media::IEffectClient>& effectClient,
int32_t priority,
@@ -421,7 +370,7 @@
status_t *status /*non-NULL*/,
bool pinned,
bool probe,
- bool notifyFramesProcessed);
+ bool notifyFramesProcessed) final;
// return values for hasAudioSession (bit field)
enum effect_state {
@@ -437,47 +386,40 @@
// bit-perfect track
};
- // get effect chain corresponding to session Id.
- sp<IAfEffectChain> getEffectChain(audio_session_t sessionId);
- // same as getEffectChain() but must be called with ThreadBase mutex locked
- sp<IAfEffectChain> getEffectChain_l(audio_session_t sessionId) const;
- std::vector<int> getEffectIds_l(audio_session_t sessionId);
- // add an effect chain to the chain list (mEffectChains)
- virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
- // remove an effect chain from the chain list (mEffectChains)
- virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) = 0;
+ // get effect chain corresponding to session Id.
+ sp<IAfEffectChain> getEffectChain(audio_session_t sessionId) const final;
+ // same as getEffectChain() but must be called with ThreadBase mutex locked
+ sp<IAfEffectChain> getEffectChain_l(audio_session_t sessionId) const final;
+ std::vector<int> getEffectIds_l(audio_session_t sessionId) const final;
+
// lock all effect chains Mutexes. Must be called before releasing the
// ThreadBase mutex before processing the mixer and effects. This guarantees the
// integrity of the chains during the process.
// Also sets the parameter 'effectChains' to current value of mEffectChains.
- void lockEffectChains_l(Vector<sp<IAfEffectChain>>& effectChains);
+ void lockEffectChains_l(Vector<sp<IAfEffectChain>>& effectChains) final;
// unlock effect chains after process
- void unlockEffectChains(const Vector<sp<IAfEffectChain>>& effectChains);
+ void unlockEffectChains(const Vector<sp<IAfEffectChain>>& effectChains) final;
// get a copy of mEffectChains vector
- Vector<sp<IAfEffectChain>> getEffectChains_l() const { return mEffectChains; };
+ Vector<sp<IAfEffectChain>> getEffectChains_l() const final { return mEffectChains; };
// set audio mode to all effect chains
- void setMode(audio_mode_t mode);
+ void setMode(audio_mode_t mode) final;
// get effect module with corresponding ID on specified audio session
- sp<IAfEffectModule> getEffect(audio_session_t sessionId, int effectId);
- sp<IAfEffectModule> getEffect_l(audio_session_t sessionId, int effectId);
+ sp<IAfEffectModule> getEffect(audio_session_t sessionId, int effectId) const final;
+ sp<IAfEffectModule> getEffect_l(audio_session_t sessionId, int effectId) const final;
// add and effect module. Also creates the effect chain is none exists for
// the effects audio session. Only called in a context of moving an effect
// from one thread to another
- status_t addEffect_l(const sp<IAfEffectModule>& effect);
+ status_t addEffect_l(const sp<IAfEffectModule>& effect) final;
// remove and effect module. Also removes the effect chain is this was the last
// effect
- void removeEffect_l(const sp<IAfEffectModule>& effect, bool release = false);
+ void removeEffect_l(const sp<IAfEffectModule>& effect, bool release = false) final;
// disconnect an effect handle from module and destroy module if last handle
- void disconnectEffectHandle(IAfEffectHandle *handle, bool unpinIfLast);
+ void disconnectEffectHandle(IAfEffectHandle* handle, bool unpinIfLast) final;
// detach all tracks connected to an auxiliary effect
- virtual void detachAuxEffect_l(int effectId __unused) {}
- // returns a combination of:
- // - EFFECT_SESSION if effects on this audio session exist in one chain
- // - TRACK_SESSION if tracks on this audio session exist
- // - FAST_SESSION if fast tracks on this audio session exist
- // - SPATIALIZED_SESSION if spatialized tracks on this audio session exist
- virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
- uint32_t hasAudioSession(audio_session_t sessionId) const {
+ void detachAuxEffect_l(int /* effectId */) override {}
+ // TODO(b/291317898) - remove hasAudioSession_l below.
+ uint32_t hasAudioSession_l(audio_session_t sessionId) const override = 0;
+ uint32_t hasAudioSession(audio_session_t sessionId) const final {
Mutex::Autolock _l(mLock);
return hasAudioSession_l(sessionId);
}
@@ -511,19 +453,17 @@
// the value returned by default implementation is not important as the
// strategy is only meaningful for PlaybackThread which implements this method
- virtual product_strategy_t getStrategyForSession_l(
- audio_session_t sessionId __unused) {
+ product_strategy_t getStrategyForSession_l(
+ audio_session_t /* sessionId */) const override {
return static_cast<product_strategy_t>(0);
}
// check if some effects must be suspended/restored when an effect is enabled
// or disabled
- void checkSuspendOnEffectEnabled(bool enabled,
+ void checkSuspendOnEffectEnabled(bool enabled,
audio_session_t sessionId,
- bool threadLocked);
+ bool threadLocked) final;
- virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) = 0;
- virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const = 0;
// Return a reference to a per-thread heap which can be used to allocate IMemory
// objects that will be read-only to client processes, read/write to mediaserver,
@@ -531,36 +471,35 @@
// The heap is per-thread rather than common across all threads, because
// clients can't be trusted not to modify the offset of the IMemory they receive.
// If a thread does not have such a heap, this method returns 0.
- virtual sp<MemoryDealer> readOnlyHeap() const { return 0; }
+ sp<MemoryDealer> readOnlyHeap() const override { return nullptr; }
- virtual sp<IMemory> pipeMemory() const { return 0; }
+ sp<IMemory> pipeMemory() const override { return nullptr; }
- void systemReady();
+ void systemReady() final;
- // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
- virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
- audio_session_t sessionId) = 0;
+ void broadcast_l() final;
- void broadcast_l();
+ bool isTimestampCorrectionEnabled() const override { return false; }
- virtual bool isTimestampCorrectionEnabled() const { return false; }
+ bool isMsdDevice() const final { return mIsMsdDevice; }
- bool isMsdDevice() const { return mIsMsdDevice; }
-
- void dump(int fd, const Vector<String16>& args);
+ void dump(int fd, const Vector<String16>& args) override;
// deliver stats to mediametrics.
- void sendStatistics(bool force);
+ void sendStatistics(bool force) final;
+ Mutex& mutex() const final {
+ return mLock;
+ }
mutable Mutex mLock;
- void onEffectEnable(const sp<IAfEffectModule>& effect);
- void onEffectDisable();
+ void onEffectEnable(const sp<IAfEffectModule>& effect) final;
+ void onEffectDisable() final;
// invalidateTracksForAudioSession_l must be called with holding mLock.
- virtual void invalidateTracksForAudioSession_l(audio_session_t sessionId __unused) const { }
+ void invalidateTracksForAudioSession_l(audio_session_t /* sessionId */) const override {}
// Invalidate all the tracks with the given audio session.
- void invalidateTracksForAudioSession(audio_session_t sessionId) const {
+ void invalidateTracksForAudioSession(audio_session_t sessionId) const final {
Mutex::Autolock _l(mLock);
invalidateTracksForAudioSession_l(sessionId);
}
@@ -576,10 +515,8 @@
}
}
- virtual bool isStreamInitialized() = 0;
-
- virtual void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor);
- virtual void stopMelComputation_l();
+ void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
+ void stopMelComputation_l() override;
protected:
@@ -603,7 +540,7 @@
// occurs when all suspend requests are cancelled.
void setEffectSuspended_l(const effect_uuid_t *type,
bool suspend,
- audio_session_t sessionId);
+ audio_session_t sessionId) final;
// updated mSuspendedSessions when an effect is suspended or restored
void updateSuspendedSessions_l(const effect_uuid_t *type,
bool suspend,
@@ -630,7 +567,7 @@
return INVALID_OPERATION;
}
public:
-// TODO(b/288339104) organize with publics
+// TODO(b/291317898) organize with publics
product_strategy_t getStrategyForStream(audio_stream_type_t stream) const;
protected:
@@ -640,9 +577,6 @@
{ }
virtual void dumpTracks_l(int fd __unused, const Vector<String16>& args __unused) { }
-
- friend class AudioFlinger; // for mEffectChains and mAudioManager
-
const type_t mType;
// Used by parameters, config events, addTrack_l, exit
@@ -785,7 +719,7 @@
bool isEmpty() const {
return mActiveTracks.isEmpty();
}
- ssize_t indexOf(const sp<T>& item) {
+ ssize_t indexOf(const sp<T>& item) const {
return mActiveTracks.indexOf(item);
}
sp<T> operator[](size_t index) const {
@@ -846,36 +780,14 @@
void dumpEffectChains_l(int fd, const Vector<String16>& args);
};
-class VolumeInterface {
- public:
-
- virtual ~VolumeInterface() {}
-
- virtual void setMasterVolume(float value) = 0;
- virtual void setMasterMute(bool muted) = 0;
- virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
- virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
- virtual float streamVolume(audio_stream_type_t stream) const = 0;
-
-};
-
// --- PlaybackThread ---
-class PlaybackThread : public ThreadBase, public StreamOutHalInterfaceCallback,
- public VolumeInterface, public StreamOutHalInterfaceEventCallback {
- // TODO(b/288339104) remove friends
- friend class OutputTrack;
- friend class Track;
+class PlaybackThread : public ThreadBase, public virtual IAfPlaybackThread,
+ public StreamOutHalInterfaceCallback,
+ public virtual VolumeInterface, public StreamOutHalInterfaceEventCallback {
public:
-
- enum mixer_state {
- MIXER_IDLE, // no active tracks
- MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready
- MIXER_TRACKS_READY, // at least one active track, and at least one track has data
- MIXER_DRAIN_TRACK, // drain currently playing track
- MIXER_DRAIN_ALL, // fully drain the hardware
- // standby mode does not have an enum value
- // suspend by audio policy manager is orthogonal to mixer state
- };
+ sp<IAfPlaybackThread> asIAfPlaybackThread() final {
+ return sp<IAfPlaybackThread>::fromExisting(this);
+ }
// retry count before removing active track in case of underrun on offloaded thread:
// we need to make sure that AudioTrack client has enough time to send large buffers
@@ -883,7 +795,6 @@
// handled for offloaded tracks
static const int8_t kMaxTrackRetriesOffload = 20;
static const int8_t kMaxTrackStartupRetriesOffload = 100;
- static const int8_t kMaxTrackStopRetriesOffload = 2;
static constexpr uint32_t kMaxTracksPerUid = 40;
static constexpr size_t kMaxTracks = 256;
@@ -896,16 +807,20 @@
PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
audio_io_handle_t id, type_t type, bool systemReady,
audio_config_base_t *mixerConfig = nullptr);
- virtual ~PlaybackThread();
+ ~PlaybackThread() override;
// Thread virtuals
- virtual bool threadLoop();
+ bool threadLoop() final;
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() override;
- virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
- audio_session_t sessionId);
+ status_t checkEffectCompatibility_l(
+ const effect_descriptor_t* desc, audio_session_t sessionId) final;
+
+ void addOutputTrack_l(const sp<IAfTrack>& track) final {
+ mTracks.add(track);
+ }
protected:
// Code snippets that were lifted up out of threadLoop()
@@ -930,18 +845,21 @@
virtual void onDrainReady();
virtual void onError();
+public: // AsyncCallbackThread
void resetWriteBlocked(uint32_t sequence);
void resetDraining(uint32_t sequence);
+protected:
virtual bool waitingAsyncCallback();
virtual bool waitingAsyncCallback_l();
virtual bool shouldStandby_l();
virtual void onAddNewTrack_l();
+public: // AsyncCallbackThread
void onAsyncError(); // error reported by AsyncCallbackThread
-
+protected:
// StreamHalInterfaceCodecFormatCallback implementation
void onCodecFormatChanged(
- const std::basic_string<uint8_t>& metadataBs) override;
+ const std::basic_string<uint8_t>& metadataBs) final;
// ThreadBase virtuals
virtual void preExit();
@@ -956,29 +874,28 @@
virtual void setHalLatencyMode_l() {}
- void dumpInternals_l(int fd, const Vector<String16>& args) override;
- void dumpTracks_l(int fd, const Vector<String16>& args) override;
+ void dumpInternals_l(int fd, const Vector<String16>& args) override;
+ void dumpTracks_l(int fd, const Vector<String16>& args) final;
public:
- virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
+ status_t initCheck() const final { return mOutput == nullptr ? NO_INIT : NO_ERROR; }
// return estimated latency in milliseconds, as reported by HAL
- uint32_t latency() const;
+ uint32_t latency() const final;
// same, but lock must already be held
- uint32_t latency_l() const override;
+ uint32_t latency_l() const final;
// VolumeInterface
- virtual void setMasterVolume(float value);
- virtual void setMasterBalance(float balance);
- virtual void setMasterMute(bool muted);
- virtual void setStreamVolume(audio_stream_type_t stream, float value);
- virtual void setStreamMute(audio_stream_type_t stream, bool muted);
- virtual float streamVolume(audio_stream_type_t stream) const;
+ void setMasterVolume(float value) final;
+ void setMasterBalance(float balance) override;
+ void setMasterMute(bool muted) final;
+ void setStreamVolume(audio_stream_type_t stream, float value) final;
+ void setStreamMute(audio_stream_type_t stream, bool muted) final;
+ float streamVolume(audio_stream_type_t stream) const final;
+ void setVolumeForOutput_l(float left, float right) const final;
- void setVolumeForOutput_l(float left, float right) const override;
-
- sp<IAfTrack> createTrack_l(
+ sp<IAfTrack> createTrack_l(
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -999,15 +916,20 @@
audio_port_handle_t portId,
const sp<media::IAudioTrackCallback>& callback,
bool isSpatialized,
- bool isBitPerfect);
+ bool isBitPerfect) final;
- AudioStreamOut* getOutput() const;
- AudioStreamOut* clearOutput();
- virtual sp<StreamHalInterface> stream() const;
+ bool isTrackActive(const sp<IAfTrack>& track) const final {
+ return mActiveTracks.indexOf(track) >= 0;
+ }
+
+ AudioStreamOut* getOutput_l() const final { return mOutput; }
+ AudioStreamOut* getOutput() const final;
+ AudioStreamOut* clearOutput() final;
+ sp<StreamHalInterface> stream() const final;
// a very large number of suspend() will eventually wraparound, but unlikely
- void suspend() { (void) android_atomic_inc(&mSuspended); }
- void restore()
+ void suspend() final { (void) android_atomic_inc(&mSuspended); }
+ void restore() final
{
// if restore() is done without suspend(), get back into
// range so that the next suspend() will operate correctly
@@ -1015,123 +937,127 @@
android_atomic_release_store(0, &mSuspended);
}
}
- bool isSuspended() const
+ bool isSuspended() const final
{ return android_atomic_acquire_load(&mSuspended) > 0; }
- virtual String8 getParameters(const String8& keys);
- virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
- status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
+ String8 getParameters(const String8& keys);
+ void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) final;
+ status_t getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames) const final;
// Consider also removing and passing an explicit mMainBuffer initialization
// parameter to AF::IAfTrack::Track().
- float *sinkBuffer() const {
+ float* sinkBuffer() const final {
return reinterpret_cast<float *>(mSinkBuffer); };
- virtual void detachAuxEffect_l(int effectId);
- status_t attachAuxEffect(const sp<IAfTrack>& track,
- int EffectId);
- status_t attachAuxEffect_l(const sp<IAfTrack>& track,
- int EffectId);
+ void detachAuxEffect_l(int effectId) final;
- virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
- virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
- uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
+ status_t attachAuxEffect(const sp<IAfTrack>& track, int EffectId) final;
+ status_t attachAuxEffect_l(const sp<IAfTrack>& track, int EffectId) final;
+
+ status_t addEffectChain_l(const sp<IAfEffectChain>& chain) final;
+ size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) final;
+ uint32_t hasAudioSession_l(audio_session_t sessionId) const final {
return ThreadBase::hasAudioSession_l(sessionId, mTracks);
}
- virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
+ product_strategy_t getStrategyForSession_l(audio_session_t sessionId) const final;
- status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) override;
- bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const override;
+ status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final;
+ bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const final;
// called with AudioFlinger lock held
- bool invalidateTracks_l(audio_stream_type_t streamType);
- bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds);
- virtual void invalidateTracks(audio_stream_type_t streamType);
+ bool invalidateTracks_l(audio_stream_type_t streamType) final;
+ bool invalidateTracks_l(std::set<audio_port_handle_t>& portIds) final;
+ void invalidateTracks(audio_stream_type_t streamType) override;
// Invalidate tracks by a set of port ids. The port id will be removed from
// the given set if the corresponding track is found and invalidated.
- virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds);
+ void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
- virtual size_t frameCount() const { return mNormalFrameCount; }
+ size_t frameCount() const final { return mNormalFrameCount; }
- audio_channel_mask_t mixerChannelMask() const override {
+ audio_channel_mask_t mixerChannelMask() const final {
return mMixerChannelMask;
}
- status_t getTimestamp_l(AudioTimestamp& timestamp);
+ status_t getTimestamp_l(AudioTimestamp& timestamp) final;
- void addPatchTrack(const sp<IAfPatchTrack>& track);
- void deletePatchTrack(const sp<IAfPatchTrack>& track);
+ void addPatchTrack(const sp<IAfPatchTrack>& track) final;
+ void deletePatchTrack(const sp<IAfPatchTrack>& track) final;
- virtual void toAudioPortConfig(struct audio_port_config *config);
+ void toAudioPortConfig(struct audio_port_config* config) final;
// Return the asynchronous signal wait time.
- virtual int64_t computeWaitTimeNs_l() const { return INT64_MAX; }
+ int64_t computeWaitTimeNs_l() const override { return INT64_MAX; }
// returns true if the track is allowed to be added to the thread.
- virtual bool isTrackAllowed_l(
+ bool isTrackAllowed_l(
audio_channel_mask_t channelMask __unused,
audio_format_t format __unused,
audio_session_t sessionId __unused,
- uid_t uid) const {
+ uid_t uid) const override {
return trackCountForUid_l(uid) < PlaybackThread::kMaxTracksPerUid
&& mTracks.size() < PlaybackThread::kMaxTracks;
}
- bool isTimestampCorrectionEnabled() const override {
+ bool isTimestampCorrectionEnabled() const final {
return audio_is_output_devices(mTimestampCorrectedDevice)
&& outDeviceTypes().count(mTimestampCorrectedDevice) != 0;
}
- virtual bool isStreamInitialized() {
+ bool isStreamInitialized() const final {
return !(mOutput == nullptr || mOutput->stream == nullptr);
}
- audio_channel_mask_t hapticChannelMask() const override {
+ audio_channel_mask_t hapticChannelMask() const final {
return mHapticChannelMask;
}
- bool supportsHapticPlayback() const {
+
+ uint32_t hapticChannelCount() const final {
+ return mHapticChannelCount;
+ }
+
+ bool supportsHapticPlayback() const final {
return (mHapticChannelMask & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE;
}
- void setDownStreamPatch(const struct audio_patch *patch) {
+ void setDownStreamPatch(const struct audio_patch* patch) final {
Mutex::Autolock _l(mLock);
mDownStreamPatch = *patch;
}
- IAfTrack* getTrackById_l(audio_port_handle_t trackId);
+ IAfTrack* getTrackById_l(audio_port_handle_t trackId) final;
- bool hasMixer() const {
+ bool hasMixer() const final {
return mType == MIXER || mType == DUPLICATING || mType == SPATIALIZER;
}
- virtual status_t setRequestedLatencyMode(
- audio_latency_mode_t mode __unused) { return INVALID_OPERATION; }
+ status_t setRequestedLatencyMode(
+ audio_latency_mode_t /* mode */) override { return INVALID_OPERATION; }
- virtual status_t getSupportedLatencyModes(
- std::vector<audio_latency_mode_t>* modes __unused) {
+ status_t getSupportedLatencyModes(
+ std::vector<audio_latency_mode_t>* /* modes */) override {
return INVALID_OPERATION;
}
- virtual status_t setBluetoothVariableLatencyEnabled(bool enabled __unused) {
+ status_t setBluetoothVariableLatencyEnabled(bool /* enabled */) override{
return INVALID_OPERATION;
}
- void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
- void stopMelComputation_l() override;
+ void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
+ void stopMelComputation_l() override;
- void setStandby() {
+ void setStandby() final {
Mutex::Autolock _l(mLock);
setStandby_l();
}
- void setStandby_l() {
+ void setStandby_l() final {
mStandby = true;
mHalStarted = false;
mKernelPositionOnStandby =
mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
}
- bool waitForHalStart() {
+ bool waitForHalStart() final {
Mutex::Autolock _l(mLock);
static const nsecs_t kWaitHalTimeoutNs = seconds(2);
nsecs_t endWaitTimetNs = systemTime() + kWaitHalTimeoutNs;
@@ -1246,7 +1172,6 @@
audio_channel_mask_t mMixerChannelMask = AUDIO_CHANNEL_NONE;
-private:
// mMasterMute is in both PlaybackThread and in AudioFlinger. When a
// PlaybackThread needs to find out if master-muted, it checks it's local
// copy rather than the one in AudioFlinger. This optimization saves a lock.
@@ -1260,7 +1185,6 @@
: mTimestampVerifier.DISCONTINUITY_MODE_CONTINUOUS;
}
-protected:
ActiveTracks<IAfTrack> mActiveTracks;
// Time to sleep between cycles when:
@@ -1271,7 +1195,7 @@
// No sleep in standby mode; waits on a condition
// Code snippets that are temporarily lifted up out of threadLoop() until the merge
- void checkSilentMode_l();
+ virtual void checkSilentMode_l() final; // consider unification with MMapThread
// Non-trivial for DUPLICATING only
virtual void saveOutputTracks() { }
@@ -1289,25 +1213,22 @@
audio_patch_handle_t *handle);
virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
- bool usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
+ bool usesHwAvSync() const final { return mType == DIRECT && mOutput != nullptr
&& mHwSupportsPause
&& (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
uint32_t trackCountForUid_l(uid_t uid) const;
void invalidateTracksForAudioSession_l(
- audio_session_t sessionId) const override {
+ audio_session_t sessionId) const override {
ThreadBase::invalidateTracksForAudioSession_l(sessionId, mTracks);
}
-private:
-
- friend class AudioFlinger; // for numerous
-
DISALLOW_COPY_AND_ASSIGN(PlaybackThread);
- status_t addTrack_l(const sp<IAfTrack>& track);
- bool destroyTrack_l(const sp<IAfTrack>& track);
+ status_t addTrack_l(const sp<IAfTrack>& track) final;
+ bool destroyTrack_l(const sp<IAfTrack>& track) final;
+
void removeTrack_l(const sp<IAfTrack>& track);
void readOutputParameters_l();
@@ -1369,6 +1290,7 @@
Tracks<IAfTrack> mTracks;
stream_type_t mStreamTypes[AUDIO_STREAM_CNT];
+
AudioStreamOut *mOutput;
float mMasterVolume;
@@ -1423,19 +1345,20 @@
// Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
// callbacks are ignored.
uint32_t mDrainSequence;
+
sp<AsyncCallbackThread> mCallbackThread;
Mutex mAudioTrackCbLock;
// Record of IAudioTrackCallback
std::map<sp<IAfTrack>, sp<media::IAudioTrackCallback>> mAudioTrackCallbacks;
-private:
// The HAL output sink is treated as non-blocking, but current implementation is blocking
sp<NBAIO_Sink> mOutputSink;
// If a fast mixer is present, the blocking pipe sink, otherwise clear
sp<NBAIO_Sink> mPipeSink;
// The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
sp<NBAIO_Sink> mNormalSink;
+
uint32_t mScreenState; // cached copy of gScreenState
// TODO: add comment and adjust size as needed
static const size_t kFastMixerLogSize = 8 * 1024;
@@ -1453,14 +1376,14 @@
int64_t mKernelPositionOnStandby = 0;
public:
- virtual bool hasFastMixer() const = 0;
- virtual FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
- { FastTrackUnderruns dummy; return dummy; }
- const std::atomic<int64_t>& framesWritten() const { return mFramesWritten; }
+ FastTrackUnderruns getFastTrackUnderruns(size_t /* fastIndex */) const override
+ { return {}; }
+ const std::atomic<int64_t>& framesWritten() const final { return mFramesWritten; }
protected:
// accessed by both binder threads and within threadLoop(), lock on mutex needed
- unsigned mFastTrackAvailMask; // bit i set if fast track [i] is available
+ uint32_t& fastTrackAvailMask_l() final { return mFastTrackAvailMask; }
+ uint32_t mFastTrackAvailMask; // bit i set if fast track [i] is available
bool mHwSupportsPause;
bool mHwPaused;
bool mFlushPending;
@@ -1517,30 +1440,29 @@
bool systemReady,
type_t type = MIXER,
audio_config_base_t *mixerConfig = nullptr);
- virtual ~MixerThread();
+ ~MixerThread() override;
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() override;
// StreamOutHalInterfaceLatencyModeCallback
void onRecommendedLatencyModeChanged(
- std::vector<audio_latency_mode_t> modes) override;
+ std::vector<audio_latency_mode_t> modes) final;
// Thread virtuals
- virtual bool checkForNewParameter_l(const String8& keyValuePair,
- status_t& status);
+ bool checkForNewParameter_l(const String8& keyValuePair, status_t& status) final;
- virtual bool isTrackAllowed_l(
+ bool isTrackAllowed_l(
audio_channel_mask_t channelMask, audio_format_t format,
- audio_session_t sessionId, uid_t uid) const override;
+ audio_session_t sessionId, uid_t uid) const final;
protected:
- virtual mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove);
- virtual uint32_t idleSleepTimeUs() const;
- virtual uint32_t suspendSleepTimeUs() const;
- virtual void cacheParameters_l();
+ mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove) override;
+ uint32_t idleSleepTimeUs() const final;
+ uint32_t suspendSleepTimeUs() const final;
+ void cacheParameters_l() override;
- virtual void acquireWakeLock_l() {
+ void acquireWakeLock_l() final {
PlaybackThread::acquireWakeLock_l();
if (hasFastMixer()) {
mFastMixer->setBoottimeOffset(
@@ -1551,15 +1473,15 @@
void dumpInternals_l(int fd, const Vector<String16>& args) override;
// threadLoop snippets
- virtual ssize_t threadLoop_write();
- virtual void threadLoop_standby();
- virtual void threadLoop_mix();
- virtual void threadLoop_sleepTime();
- virtual uint32_t correctLatency_l(uint32_t latency) const;
+ ssize_t threadLoop_write() override;
+ void threadLoop_standby() override;
+ void threadLoop_mix() override;
+ void threadLoop_sleepTime() override;
+ uint32_t correctLatency_l(uint32_t latency) const final;
- virtual status_t createAudioPatch_l(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
- virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
+ status_t createAudioPatch_l(
+ const struct audio_patch* patch, audio_patch_handle_t* handle) final;
+ status_t releaseAudioPatch_l(const audio_patch_handle_t handle) final;
AudioMixer* mAudioMixer; // normal mixer
@@ -1635,9 +1557,13 @@
void setHalLatencyMode_l() override;
};
-class DirectOutputThread : public PlaybackThread {
+class DirectOutputThread : public PlaybackThread, public virtual IAfDirectOutputThread {
public:
+ sp<IAfDirectOutputThread> asIAfDirectOutputThread() final {
+ return sp<IAfDirectOutputThread>::fromExisting(this);
+ }
+
DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
audio_io_handle_t id, bool systemReady,
const audio_offload_info_t& offloadInfo)
@@ -1645,7 +1571,7 @@
virtual ~DirectOutputThread();
- status_t selectPresentation(int presentationId, int programId);
+ status_t selectPresentation(int presentationId, int programId) final;
// Thread virtuals
@@ -1745,11 +1671,8 @@
class AsyncCallbackThread : public Thread {
public:
-
explicit AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
- virtual ~AsyncCallbackThread();
-
// Thread virtuals
virtual bool threadLoop();
@@ -1778,16 +1701,20 @@
bool mAsyncError;
};
-class DuplicatingThread : public MixerThread {
+class DuplicatingThread : public MixerThread, public IAfDuplicatingThread {
public:
- DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
+ DuplicatingThread(const sp<AudioFlinger>& audioFlinger, IAfPlaybackThread* mainThread,
audio_io_handle_t id, bool systemReady);
- virtual ~DuplicatingThread();
+ ~DuplicatingThread() override;
+
+ sp<IAfDuplicatingThread> asIAfDuplicatingThread() final {
+ return sp<IAfDuplicatingThread>::fromExisting(this);
+ }
// Thread virtuals
- void addOutputTrack(MixerThread* thread);
- void removeOutputTrack(MixerThread* thread);
- uint32_t waitTimeMs() const { return mWaitTimeMs; }
+ void addOutputTrack(IAfPlaybackThread* thread) final;
+ void removeOutputTrack(IAfPlaybackThread* thread) final;
+ uint32_t waitTimeMs() const final { return mWaitTimeMs; }
void sendMetadataToBackend_l(
const StreamOutHalInterface::SourceMetadata& metadata) override;
@@ -1843,18 +1770,17 @@
audio_io_handle_t id,
bool systemReady,
audio_config_base_t *mixerConfig);
- ~SpatializerThread() override {}
- bool hasFastMixer() const override { return false; }
+ bool hasFastMixer() const final { return false; }
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() final;
- status_t setRequestedLatencyMode(audio_latency_mode_t mode) override;
+ status_t setRequestedLatencyMode(audio_latency_mode_t mode) final;
protected:
- void checkOutputStageEffects() override;
- void setHalLatencyMode_l() override;
+ void checkOutputStageEffects() final;
+ void setHalLatencyMode_l() final;
private:
// Do not request a specific mode by default
@@ -1864,40 +1790,39 @@
};
// record thread
-class RecordThread : public ThreadBase
+class RecordThread : public IAfRecordThread, public ThreadBase
{
- // TODO(b/288339104) remove friends
- friend class PassthruPatchRecord;
- friend class RecordTrack;
friend class ResamplerBufferProvider;
public:
-
+ sp<IAfRecordThread> asIAfRecordThread() final {
+ return sp<IAfRecordThread>::fromExisting(this);
+ }
RecordThread(const sp<AudioFlinger>& audioFlinger,
AudioStreamIn *input,
audio_io_handle_t id,
bool systemReady
);
- virtual ~RecordThread();
+ ~RecordThread() override;
// no addTrack_l ?
- void destroyTrack_l(const sp<IAfRecordTrack>& track);
- void removeTrack_l(const sp<IAfRecordTrack>& track);
+ void destroyTrack_l(const sp<IAfRecordTrack>& track) final;
+ void removeTrack_l(const sp<IAfRecordTrack>& track) final;
// Thread virtuals
- virtual bool threadLoop();
- virtual void preExit();
+ bool threadLoop() final;
+ void preExit() final;
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() final;
- virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
+ status_t initCheck() const final { return mInput == nullptr ? NO_INIT : NO_ERROR; }
- virtual sp<MemoryDealer> readOnlyHeap() const { return mReadOnlyHeap; }
+ sp<MemoryDealer> readOnlyHeap() const final { return mReadOnlyHeap; }
- virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
+ sp<IMemory> pipeMemory() const final { return mPipeMemory; }
- sp<IAfRecordTrack> createRecordTrack_l(
+ sp<IAfRecordTrack> createRecordTrack_l(
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t *pSampleRate,
@@ -1912,17 +1837,19 @@
pid_t tid,
status_t *status /*non-NULL*/,
audio_port_handle_t portId,
- int32_t maxSharedAudioHistoryMs);
+ int32_t maxSharedAudioHistoryMs) final;
status_t start(IAfRecordTrack* recordTrack,
AudioSystem::sync_event_t event,
- audio_session_t triggerSession);
+ audio_session_t triggerSession) final;
// ask the thread to stop the specified track, and
// return true if the caller should then do it's part of the stopping process
- bool stop(IAfRecordTrack* recordTrack);
+ bool stop(IAfRecordTrack* recordTrack) final;
+ AudioStreamIn* getInput() const final { return mInput; }
+ AudioStreamIn* clearInput() final;
- AudioStreamIn* clearInput();
+ // TODO(b/291317898) Unify with IAfThreadBase
virtual sp<StreamHalInterface> stream() const;
@@ -1930,19 +1857,19 @@
status_t& status);
virtual void cacheParameters_l() {}
virtual String8 getParameters(const String8& keys);
- virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
+ void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) final;
virtual status_t createAudioPatch_l(const struct audio_patch *patch,
audio_patch_handle_t *handle);
virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
void updateOutDevices(const DeviceDescriptorBaseVector& outDevices) override;
void resizeInputBuffer_l(int32_t maxSharedAudioHistoryMs) override;
- void addPatchTrack(const sp<IAfPatchRecord>& record);
- void deletePatchTrack(const sp<IAfPatchRecord>& record);
+ void addPatchTrack(const sp<IAfPatchRecord>& record) final;
+ void deletePatchTrack(const sp<IAfPatchRecord>& record) final;
void readInputParameters_l();
- virtual uint32_t getInputFramesLost();
+ uint32_t getInputFramesLost() const final;
virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
@@ -1961,7 +1888,7 @@
static void syncStartEventCallback(const wp<audioflinger::SyncEvent>& event);
virtual size_t frameCount() const { return mFrameCount; }
- bool hasFastCapture() const { return mFastCapture != 0; }
+ bool hasFastCapture() const final { return mFastCapture != 0; }
virtual void toAudioPortConfig(struct audio_port_config *config);
virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
@@ -1972,20 +1899,20 @@
mActiveTracks.updatePowerState(this, true /* force */);
}
- void checkBtNrec();
+ void checkBtNrec() final;
// Sets the UID records silence
- void setRecordSilenced(audio_port_handle_t portId, bool silenced);
+ void setRecordSilenced(audio_port_handle_t portId, bool silenced) final;
- status_t getActiveMicrophones(
- std::vector<media::MicrophoneInfoFw>* activeMicrophones);
-
- status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
- status_t setPreferredMicrophoneFieldDimension(float zoom);
+ status_t getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) const final;
+ status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) final;
+ status_t setPreferredMicrophoneFieldDimension(float zoom) final;
MetadataUpdate updateMetadata_l() override;
- bool fastTrackAvailable() const { return mFastTrackAvail; }
+ bool fastTrackAvailable() const final { return mFastTrackAvail; }
+ void setFastTrackAvailable(bool available) final { mFastTrackAvail = available; }
bool isTimestampCorrectionEnabled() const override {
// checks popcount for exactly one device.
@@ -1995,15 +1922,15 @@
&& inDeviceType() == mTimestampCorrectedDevice;
}
- status_t shareAudioHistory(const std::string& sharedAudioPackageName,
+ status_t shareAudioHistory(const std::string& sharedAudioPackageName,
audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
- int64_t sharedAudioStartMs = -1);
+ int64_t sharedAudioStartMs = -1) final;
status_t shareAudioHistory_l(const std::string& sharedAudioPackageName,
audio_session_t sharedSessionId = AUDIO_SESSION_NONE,
int64_t sharedAudioStartMs = -1);
- void resetAudioHistory_l();
+ void resetAudioHistory_l() final;
- virtual bool isStreamInitialized() {
+ bool isStreamInitialized() const final {
return !(mInput == nullptr || mInput->stream == nullptr);
}
@@ -2095,87 +2022,85 @@
audio_session_t mSharedAudioSessionId = AUDIO_SESSION_NONE;
};
-class MmapThread : public ThreadBase
+class MmapThread : public ThreadBase, public virtual IAfMmapThread
{
public:
MmapThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, const sp<StreamHalInterface>& stream, bool systemReady,
bool isOut);
- virtual ~MmapThread();
- virtual void configure(const audio_attributes_t *attr,
+ void configure(const audio_attributes_t* attr,
audio_stream_type_t streamType,
audio_session_t sessionId,
const sp<MmapStreamCallback>& callback,
audio_port_handle_t deviceId,
- audio_port_handle_t portId);
+ audio_port_handle_t portId) override;
- void disconnect();
+ void disconnect() final;
- // MmapStreamInterface
- status_t createMmapBuffer(int32_t minSizeFrames,
- struct audio_mmap_buffer_info *info);
- status_t getMmapPosition(struct audio_mmap_position *position);
+ // MmapStreamInterface for adapter.
+ status_t createMmapBuffer(int32_t minSizeFrames, struct audio_mmap_buffer_info* info) final;
+ status_t getMmapPosition(struct audio_mmap_position* position) const override;
status_t start(const AudioClient& client,
const audio_attributes_t *attr,
- audio_port_handle_t *handle);
- status_t stop(audio_port_handle_t handle);
- status_t standby();
- virtual status_t getExternalPosition(uint64_t *position, int64_t *timeNaos) = 0;
- virtual status_t reportData(const void* buffer, size_t frameCount);
+ audio_port_handle_t* handle) final;
+ status_t stop(audio_port_handle_t handle) final;
+ status_t standby() final;
+ status_t getExternalPosition(uint64_t* position, int64_t* timeNanos) const = 0;
+ status_t reportData(const void* buffer, size_t frameCount) override;
// RefBase
- virtual void onFirstRef();
+ void onFirstRef() final;
// Thread virtuals
- virtual bool threadLoop();
+ bool threadLoop() final;
- virtual void threadLoop_exit();
- virtual void threadLoop_standby();
- virtual bool shouldStandby_l() { return false; }
- virtual status_t exitStandby_l() REQUIRES(mLock);
+ // Not in ThreadBase
+ virtual void threadLoop_exit() final;
+ virtual void threadLoop_standby() final;
+ virtual bool shouldStandby_l() final { return false; }
+ virtual status_t exitStandby_l() REQUIRES(mLock);
- virtual status_t initCheck() const { return (mHalStream == 0) ? NO_INIT : NO_ERROR; }
- virtual size_t frameCount() const { return mFrameCount; }
- virtual bool checkForNewParameter_l(const String8& keyValuePair,
- status_t& status);
- virtual String8 getParameters(const String8& keys);
- virtual void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
+ status_t initCheck() const final { return mHalStream == nullptr ? NO_INIT : NO_ERROR; }
+ size_t frameCount() const final { return mFrameCount; }
+ bool checkForNewParameter_l(const String8& keyValuePair, status_t& status) final;
+ String8 getParameters(const String8& keys) final;
+ void ioConfigChanged(audio_io_config_event_t event, pid_t pid = 0,
+ audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE) final;
void readHalParameters_l();
- virtual void cacheParameters_l() {}
- virtual status_t createAudioPatch_l(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
- virtual status_t releaseAudioPatch_l(const audio_patch_handle_t handle);
- virtual void toAudioPortConfig(struct audio_port_config *config);
+ void cacheParameters_l() final {}
+ status_t createAudioPatch_l(
+ const struct audio_patch* patch, audio_patch_handle_t* handle) final;
+ status_t releaseAudioPatch_l(const audio_patch_handle_t handle) final;
+ void toAudioPortConfig(struct audio_port_config* config) override;
- virtual sp<StreamHalInterface> stream() const { return mHalStream; }
- virtual status_t addEffectChain_l(const sp<IAfEffectChain>& chain);
- virtual size_t removeEffectChain_l(const sp<IAfEffectChain>& chain);
- virtual status_t checkEffectCompatibility_l(const effect_descriptor_t *desc,
- audio_session_t sessionId);
+ sp<StreamHalInterface> stream() const final { return mHalStream; }
+ status_t addEffectChain_l(const sp<IAfEffectChain>& chain) final;
+ size_t removeEffectChain_l(const sp<IAfEffectChain>& chain) final;
+ status_t checkEffectCompatibility_l(
+ const effect_descriptor_t *desc, audio_session_t sessionId) final;
- uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
+ uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
// Note: using mActiveTracks as no mTracks here.
return ThreadBase::hasAudioSession_l(sessionId, mActiveTracks);
}
- virtual status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event);
- virtual bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const;
+ status_t setSyncEvent(const sp<audioflinger::SyncEvent>& event) final;
+ bool isValidSyncEvent(const sp<audioflinger::SyncEvent>& event) const final;
- virtual void checkSilentMode_l() {}
- virtual void processVolume_l() {}
+ virtual void checkSilentMode_l() {} // cannot be const (RecordThread)
+ virtual void processVolume_l() {}
void checkInvalidTracks_l();
- virtual audio_stream_type_t streamType() { return AUDIO_STREAM_DEFAULT; }
-
- virtual void invalidateTracks(audio_stream_type_t streamType __unused) {}
- virtual void invalidateTracks(std::set<audio_port_handle_t>& portIds __unused) {}
+ // Not in ThreadBase
+ virtual audio_stream_type_t streamType() const { return AUDIO_STREAM_DEFAULT; }
+ virtual void invalidateTracks(audio_stream_type_t /* streamType */) {}
+ void invalidateTracks(std::set<audio_port_handle_t>& /* portIds */) override {}
// Sets the UID records silence
- virtual void setRecordSilenced(audio_port_handle_t portId __unused,
- bool silenced __unused) {}
+ void setRecordSilenced(
+ audio_port_handle_t /* portId */, bool /* silenced */) override {}
- virtual bool isStreamInitialized() { return false; }
+ bool isStreamInitialized() const override { return false; }
void setClientSilencedState_l(audio_port_handle_t portId, bool silenced) {
mClientSilencedStates[portId] = silenced;
@@ -2198,8 +2123,8 @@
}
protected:
- void dumpInternals_l(int fd, const Vector<String16>& args) override;
- void dumpTracks_l(int fd, const Vector<String16>& args) override;
+ void dumpInternals_l(int fd, const Vector<String16>& args) override;
+ void dumpTracks_l(int fd, const Vector<String16>& args) final;
/**
* @brief mDeviceId current device port unique identifier
@@ -2222,56 +2147,59 @@
static constexpr int32_t kMaxNoCallbackWarnings = 5;
};
-class MmapPlaybackThread : public MmapThread, public VolumeInterface
-{
-
+class MmapPlaybackThread : public MmapThread, public IAfMmapPlaybackThread,
+ public virtual VolumeInterface {
public:
MmapPlaybackThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamOut *output, bool systemReady);
- virtual ~MmapPlaybackThread() {}
- virtual void configure(const audio_attributes_t *attr,
+ sp<IAfMmapPlaybackThread> asIAfMmapPlaybackThread() final {
+ return sp<IAfMmapPlaybackThread>::fromExisting(this);
+ }
+
+ void configure(const audio_attributes_t* attr,
audio_stream_type_t streamType,
audio_session_t sessionId,
const sp<MmapStreamCallback>& callback,
audio_port_handle_t deviceId,
- audio_port_handle_t portId);
+ audio_port_handle_t portId) final;
- AudioStreamOut* clearOutput();
+ AudioStreamOut* clearOutput() final;
// VolumeInterface
- virtual void setMasterVolume(float value);
- virtual void setMasterMute(bool muted);
- virtual void setStreamVolume(audio_stream_type_t stream, float value);
- virtual void setStreamMute(audio_stream_type_t stream, bool muted);
- virtual float streamVolume(audio_stream_type_t stream) const;
+ void setMasterVolume(float value) final;
+ void setMasterBalance(float /* value */) final {} // Needs implementation?
+ void setMasterMute(bool muted) final;
+ void setStreamVolume(audio_stream_type_t stream, float value) final;
+ void setStreamMute(audio_stream_type_t stream, bool muted) final;
+ float streamVolume(audio_stream_type_t stream) const final;
void setMasterMute_l(bool muted) { mMasterMute = muted; }
- virtual void invalidateTracks(audio_stream_type_t streamType);
- void invalidateTracks(std::set<audio_port_handle_t>& portIds) override;
+ void invalidateTracks(audio_stream_type_t streamType) final;
+ void invalidateTracks(std::set<audio_port_handle_t>& portIds) final;
- virtual audio_stream_type_t streamType() { return mStreamType; }
- virtual void checkSilentMode_l();
- void processVolume_l() override;
+ audio_stream_type_t streamType() const final { return mStreamType; }
+ void checkSilentMode_l() final;
+ void processVolume_l() final;
- MetadataUpdate updateMetadata_l() override;
+ MetadataUpdate updateMetadata_l() final;
- virtual void toAudioPortConfig(struct audio_port_config *config);
+ void toAudioPortConfig(struct audio_port_config* config) final;
- status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
+ status_t getExternalPosition(uint64_t* position, int64_t* timeNanos) const final;
- virtual bool isStreamInitialized() {
+ bool isStreamInitialized() const final {
return !(mOutput == nullptr || mOutput->stream == nullptr);
}
- status_t reportData(const void* buffer, size_t frameCount) override;
+ status_t reportData(const void* buffer, size_t frameCount) final;
- void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) override;
- void stopMelComputation_l() override;
+ void startMelComputation_l(const sp<audio_utils::MelProcessor>& processor) final;
+ void stopMelComputation_l() final;
protected:
- void dumpInternals_l(int fd, const Vector<String16>& args) override;
+ void dumpInternals_l(int fd, const Vector<String16>& args) final;
float streamVolume_l() const {
return mStreamTypes[mStreamType].volume;
}
@@ -2288,28 +2216,29 @@
mediautils::atomic_sp<audio_utils::MelProcessor> mMelProcessor;
};
-class MmapCaptureThread : public MmapThread
+class MmapCaptureThread : public MmapThread, public IAfMmapCaptureThread
{
-
public:
MmapCaptureThread(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
AudioHwDevice *hwDev, AudioStreamIn *input, bool systemReady);
- virtual ~MmapCaptureThread() {}
- AudioStreamIn* clearInput();
+ sp<IAfMmapCaptureThread> asIAfMmapCaptureThread() final {
+ return sp<IAfMmapCaptureThread>::fromExisting(this);
+ }
- status_t exitStandby_l() REQUIRES(mLock) override;
+ AudioStreamIn* clearInput() final;
- MetadataUpdate updateMetadata_l() override;
- void processVolume_l() override;
- void setRecordSilenced(audio_port_handle_t portId,
- bool silenced) override;
+ status_t exitStandby_l() REQUIRES(mLock) final;
- virtual void toAudioPortConfig(struct audio_port_config *config);
+ MetadataUpdate updateMetadata_l() final;
+ void processVolume_l() final;
+ void setRecordSilenced(audio_port_handle_t portId, bool silenced) final;
- status_t getExternalPosition(uint64_t *position, int64_t *timeNanos) override;
+ void toAudioPortConfig(struct audio_port_config* config) final;
- virtual bool isStreamInitialized() {
+ status_t getExternalPosition(uint64_t* position, int64_t* timeNanos) const final;
+
+ bool isStreamInitialized() const final {
return !(mInput == nullptr || mInput->stream == nullptr);
}
@@ -2324,8 +2253,8 @@
audio_io_handle_t id, bool systemReady);
protected:
- mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove) override;
- void threadLoop_mix() override;
+ mixer_state prepareTracks_l(Vector<sp<IAfTrack>>* tracksToRemove) final;
+ void threadLoop_mix() final;
private:
bool mIsBitPerfect;
@@ -2333,4 +2262,4 @@
float mVolumeRight = 0.f;
};
-private:
\ No newline at end of file
+} // namespace android
diff --git a/services/audioflinger/TrackBase.h b/services/audioflinger/TrackBase.h
index 8f31468..194a515 100644
--- a/services/audioflinger/TrackBase.h
+++ b/services/audioflinger/TrackBase.h
@@ -22,7 +22,7 @@
// base for record and playback
class TrackBase : public ExtendedAudioBufferProvider, public virtual IAfTrackBase {
public:
- TrackBase(AudioFlinger::ThreadBase* thread,
+ TrackBase(IAfThreadBase* thread,
const sp<Client>& client,
const audio_attributes_t& mAttr,
uint32_t sampleRate,
@@ -69,8 +69,7 @@
bool isSpatialized() const override { return false; }
bool isBitPerfect() const override { return false; }
- // TODO(b/288339104) type
- wp<Thread> thread() const final { return mThread; }
+ wp<IAfThreadBase> thread() const final { return mThread; }
const sp<ServerProxy>& serverProxy() const final { return mServerProxy; }
@@ -322,7 +321,7 @@
// true for Track, false for RecordTrack,
// this could be a track type if needed later
- const wp<AudioFlinger::ThreadBase> mThread;
+ const wp<IAfThreadBase> mThread;
const alloc_type mAllocType;
/*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const
sp<IMemory> mCblkMemory;
@@ -392,7 +391,7 @@
{
public:
PatchTrackBase(const sp<ClientProxy>& proxy,
- const AudioFlinger::ThreadBase& thread,
+ IAfThreadBase* thread,
const Timeout& timeout);
void setPeerTimeout(std::chrono::nanoseconds timeout) final;
void setPeerProxy(const sp<IAfPatchTrackBase>& proxy, bool holdReference) final {
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 6722dc3..9169783 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -81,7 +81,7 @@
// TrackBase constructor must be called with AudioFlinger::mLock held
TrackBase::TrackBase(
- AudioFlinger::ThreadBase *thread,
+ IAfThreadBase *thread,
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t sampleRate,
@@ -315,15 +315,15 @@
}
PatchTrackBase::PatchTrackBase(const sp<ClientProxy>& proxy,
- const AudioFlinger::ThreadBase& thread, const Timeout& timeout)
+ IAfThreadBase* thread, const Timeout& timeout)
: mProxy(proxy)
{
if (timeout) {
setPeerTimeout(*timeout);
} else {
// Double buffer mixer
- uint64_t mixBufferNs = ((uint64_t)2 * thread.frameCount() * 1000000000) /
- thread.sampleRate();
+ uint64_t mixBufferNs = ((uint64_t)2 * thread->frameCount() * 1000000000) /
+ thread->sampleRate();
setPeerTimeout(std::chrono::nanoseconds{mixBufferNs});
}
}
@@ -388,7 +388,6 @@
: BnAudioTrack(),
mTrack(track)
{
- // TODO(b/288339104) binder thread priority change not needed.
setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
}
@@ -559,11 +558,12 @@
// static
sp<OpPlayAudioMonitor> OpPlayAudioMonitor::createIfNeeded(
+ IAfThreadBase* thread,
const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
audio_stream_type_t streamType)
{
- Vector <String16> packages;
- uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
+ Vector<String16> packages;
+ const uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
getPackagesForUid(uid, packages);
if (isServiceUid(uid)) {
if (packages.isEmpty()) {
@@ -585,15 +585,20 @@
id, attr.flags);
return nullptr;
}
- return new OpPlayAudioMonitor(attributionSource, attr.usage, id);
+ return sp<OpPlayAudioMonitor>::make(thread, attributionSource, attr.usage, id, uid);
}
-OpPlayAudioMonitor::OpPlayAudioMonitor(
- const AttributionSourceState& attributionSource, audio_usage_t usage, int id)
- : mHasOpPlayAudio(true), mAttributionSource(attributionSource), mUsage((int32_t) usage),
- mId(id)
-{
-}
+OpPlayAudioMonitor::OpPlayAudioMonitor(IAfThreadBase* thread,
+ const AttributionSourceState& attributionSource,
+ audio_usage_t usage, int id, uid_t uid)
+ : mThread(wp<IAfThreadBase>::fromExisting(thread)),
+ mHasOpPlayAudio(true),
+ mAttributionSource(attributionSource),
+ mUsage((int32_t)usage),
+ mId(id),
+ mUid(uid),
+ mPackageName(VALUE_OR_FATAL(aidl2legacy_string_view_String16(
+ attributionSource.packageName.value_or("")))) {}
OpPlayAudioMonitor::~OpPlayAudioMonitor()
{
@@ -609,9 +614,7 @@
if (mAttributionSource.packageName.has_value()) {
mOpCallback = new PlayAudioOpCallback(this);
mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
- VALUE_OR_FATAL(aidl2legacy_string_view_String16(
- mAttributionSource.packageName.value_or("")))
- , mOpCallback);
+ mPackageName, mOpCallback);
}
}
@@ -624,16 +627,20 @@
// - not called from PlayAudioOpCallback because the callback is not installed in this case
void OpPlayAudioMonitor::checkPlayAudioForUsage()
{
- if (!mAttributionSource.packageName.has_value()) {
- mHasOpPlayAudio.store(false);
- } else {
- uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAttributionSource.uid));
- String16 packageName = VALUE_OR_FATAL(
- aidl2legacy_string_view_String16(mAttributionSource.packageName.value_or("")));
- bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
- mUsage, uid, packageName) == AppOpsManager::MODE_ALLOWED;
- ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
- mHasOpPlayAudio.store(hasIt);
+ const bool hasAppOps = mAttributionSource.packageName.has_value()
+ && mAppOpsManager.checkAudioOpNoThrow(
+ AppOpsManager::OP_PLAY_AUDIO, mUsage, mUid, mPackageName) ==
+ AppOpsManager::MODE_ALLOWED;
+
+ bool shouldChange = !hasAppOps; // check if we need to update.
+ if (mHasOpPlayAudio.compare_exchange_strong(shouldChange, hasAppOps)) {
+ ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasAppOps ? "not " : "");
+ auto thread = mThread.promote();
+ if (thread != nullptr && thread->type() == IAfThreadBase::OFFLOAD) {
+ // Wake up Thread if offloaded, otherwise it may be several seconds for update.
+ Mutex::Autolock _l(thread->mutex());
+ thread->broadcast_l();
+ }
}
}
@@ -667,8 +674,8 @@
#define LOG_TAG "AF::Track"
/* static */
-sp<IAfTrack> IAfTrack::create( // TODO(b/288339104) void*
- void * /* AudioFlinger::PlaybackThread */ thread,
+sp<IAfTrack> IAfTrack::create(
+ IAfPlaybackThread* thread,
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -691,7 +698,7 @@
float speed,
bool isSpatialized,
bool isBitPerfect) {
- return sp<Track>::make(reinterpret_cast<AudioFlinger::PlaybackThread*>(thread),
+ return sp<Track>::make(thread,
client,
streamType,
attr,
@@ -716,7 +723,7 @@
// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
Track::Track(
- AudioFlinger::PlaybackThread *thread,
+ IAfPlaybackThread* thread,
const sp<Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
@@ -759,7 +766,7 @@
mAuxEffectId(0), mHasVolumeController(false),
mFrameMap(16 /* sink-frame-to-track-frame map memory */),
mVolumeHandler(new media::VolumeHandler(sampleRate)),
- mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(attributionSource, attr, id(),
+ mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(thread, attributionSource, attr, id(),
streamType)),
// mSinkTimestamp
mFastIndex(-1),
@@ -807,15 +814,15 @@
// race with setSyncEvent(). However, if we call it, we cannot properly start
// static fast tracks (SoundPool) immediately after stopping.
//mAudioTrackServerProxy->framesReadyIsCalledByMultipleThreads();
- ALOG_ASSERT(thread->mFastTrackAvailMask != 0);
- int i = __builtin_ctz(thread->mFastTrackAvailMask);
+ ALOG_ASSERT(thread->fastTrackAvailMask_l() != 0);
+ const int i = __builtin_ctz(thread->fastTrackAvailMask_l());
ALOG_ASSERT(0 < i && i < (int)FastMixerState::sMaxFastTracks);
// FIXME This is too eager. We allocate a fast track index before the
// fast track becomes active. Since fast tracks are a scarce resource,
// this means we are potentially denying other more important fast tracks from
// being created. It would be better to allocate the index dynamically.
mFastIndex = i;
- thread->mFastTrackAvailMask &= ~(1 << i);
+ thread->fastTrackAvailMask_l() &= ~(1 << i);
}
mServerLatencySupported = checkServerLatencySupported(format, flags);
@@ -875,10 +882,10 @@
sp<Track> keep(this);
{ // scope for mLock
bool wasActive = false;
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
wasActive = playbackThread->destroyTrack_l(this);
forEachTeePatchTrack_l([](const auto& patchTrack) { patchTrack->destroy(); });
}
@@ -1154,19 +1161,19 @@
ALOGV("%s(%d): calling pid %d session %d",
__func__, mId, IPCThreadState::self()->getCallingPid(), mSessionId);
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
if (isOffloaded()) {
- Mutex::Autolock _laf(thread->mAudioFlinger->mLock);
- Mutex::Autolock _lth(thread->mLock);
+ Mutex::Autolock _laf(thread->audioFlinger()->mLock);
+ Mutex::Autolock _lth(thread->mutex());
sp<IAfEffectChain> ec = thread->getEffectChain_l(mSessionId);
- if (thread->mAudioFlinger->isNonOffloadableGlobalEffectEnabled_l() ||
+ if (thread->audioFlinger()->isNonOffloadableGlobalEffectEnabled_l() ||
(ec != 0 && ec->isNonOffloadableEnabled())) {
invalidate();
return PERMISSION_DENIED;
}
}
- Mutex::Autolock _lth(thread->mLock);
+ Mutex::Autolock _lth(thread->mutex());
track_state state = mState;
// here the track could be either new, or restarted
// in both cases "unstop" the track
@@ -1198,7 +1205,7 @@
__func__, mId, (int)mThreadIoHandle);
}
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
// states to reset position info for pcm tracks
if (audio_is_linear_pcm(mFormat)
@@ -1266,7 +1273,7 @@
}
if (status == NO_ERROR) {
// send format to AudioManager for playback activity monitoring
- sp<IAudioManager> audioManager = thread->mAudioFlinger->getOrCreateAudioManager();
+ const sp<IAudioManager> audioManager = thread->audioFlinger()->getOrCreateAudioManager();
if (audioManager && mPortId != AUDIO_PORT_HANDLE_NONE) {
std::unique_ptr<os::PersistableBundle> bundle =
std::make_unique<os::PersistableBundle>();
@@ -1288,14 +1295,14 @@
void Track::stop()
{
ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
+ Mutex::Autolock _l(thread->mutex());
track_state state = mState;
if (state == RESUMING || state == ACTIVE || state == PAUSING || state == PAUSED) {
// If the track is not active (PAUSED and buffers full), flush buffers
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- if (playbackThread->mActiveTracks.indexOf(this) < 0) {
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
+ if (!playbackThread->isTrackActive(this)) {
reset();
mState = STOPPED;
} else if (!isFastTrack() && !isOffloaded() && !isDirect()) {
@@ -1307,7 +1314,7 @@
// move to STOPPING_2 when drain completes and then STOPPED
mState = STOPPING_1;
if (isOffloaded()) {
- mRetryCount = AudioFlinger::PlaybackThread::kMaxTrackStopRetriesOffload;
+ mRetryCount = IAfPlaybackThread::kMaxTrackStopRetriesOffload;
}
}
playbackThread->broadcast_l();
@@ -1321,10 +1328,10 @@
void Track::pause()
{
ALOGV("%s(%d): calling pid %d", __func__, mId, IPCThreadState::self()->getCallingPid());
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
switch (mState) {
case STOPPING_1:
case STOPPING_2:
@@ -1358,15 +1365,15 @@
void Track::flush()
{
ALOGV("%s(%d)", __func__, mId);
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
// Flush the ring buffer now if the track is not active in the PlaybackThread.
// Otherwise the flush would not be done until the track is resumed.
// Requires FastTrack removal be BLOCK_UNTIL_ACKED
- if (playbackThread->mActiveTracks.indexOf(this) < 0) {
+ if (!playbackThread->isTrackActive(this)) {
(void)mServerProxy->flushBufferIfNeeded();
}
@@ -1405,7 +1412,7 @@
if (isDirect()) {
mFlushHwPending = true;
}
- if (playbackThread->mActiveTracks.indexOf(this) < 0) {
+ if (!playbackThread->isTrackActive(this)) {
reset();
}
}
@@ -1456,12 +1463,12 @@
status_t Track::setParameters(const String8& keyValuePairs)
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread == 0) {
ALOGE("%s(%d): thread is dead", __func__, mId);
return FAILED_TRANSACTION;
- } else if ((thread->type() == AudioFlinger::ThreadBase::DIRECT) ||
- (thread->type() == AudioFlinger::ThreadBase::OFFLOAD)) {
+ } else if (thread->type() == IAfThreadBase::DIRECT
+ || thread->type() == IAfThreadBase::OFFLOAD) {
return thread->setParameters(keyValuePairs);
} else {
return PERMISSION_DENIED;
@@ -1470,13 +1477,13 @@
status_t Track::selectPresentation(int presentationId,
int programId) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread == 0) {
ALOGE("thread is dead");
return FAILED_TRANSACTION;
- } else if ((thread->type() == AudioFlinger::ThreadBase::DIRECT)
- || (thread->type() == AudioFlinger::ThreadBase::OFFLOAD)) {
- auto directOutputThread = static_cast<AudioFlinger::DirectOutputThread*>(thread.get());
+ } else if (thread->type() == IAfThreadBase::DIRECT
+ || thread->type() == IAfThreadBase::OFFLOAD) {
+ auto directOutputThread = thread->asIAfDirectOutputThread().get();
return directOutputThread->selectPresentation(presentationId, programId);
}
return INVALID_OPERATION;
@@ -1490,9 +1497,9 @@
if (isOffloadedOrDirect()) {
// Signal thread to fetch new volume.
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
+ Mutex::Autolock _l(thread->mutex());
thread->broadcast_l();
}
}
@@ -1607,7 +1614,7 @@
}
}
-void Track::setTeePatchesToUpdate_l(AudioFlinger::TeePatches teePatchesToUpdate) {
+void Track::setTeePatchesToUpdate_l(TeePatches teePatchesToUpdate) {
ALOGW_IF(mTeePatchesToUpdate.has_value(),
"%s, existing tee patches to update will be ignored", __func__);
mTeePatchesToUpdate = std::move(teePatchesToUpdate);
@@ -1651,26 +1658,26 @@
if (!isOffloaded() && !isDirect()) {
return INVALID_OPERATION; // normal tracks handled through SSQ
}
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread == 0) {
return INVALID_OPERATION;
}
- Mutex::Autolock _l(thread->mLock);
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
return playbackThread->getTimestamp_l(timestamp);
}
status_t Track::attachAuxEffect(int EffectId)
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread == nullptr) {
return DEAD_OBJECT;
}
- auto dstThread = sp<AudioFlinger::PlaybackThread>::cast(thread);
+ auto dstThread = thread->asIAfPlaybackThread();
// srcThread is initialized by call to moveAuxEffectToIo()
- sp<AudioFlinger::PlaybackThread> srcThread;
+ sp<IAfPlaybackThread> srcThread;
sp<AudioFlinger> af = mClient->audioFlinger();
status_t status = af->moveAuxEffectToIo(EffectId, dstThread, &srcThread);
@@ -1856,10 +1863,10 @@
void Track::signal()
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock _l(t->mLock);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock _l(t->mutex());
t->broadcast_l();
}
}
@@ -1868,11 +1875,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock _l(t->mLock);
- status = t->mOutput->stream->getDualMonoMode(mode);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock _l(t->mutex());
+ status = t->getOutput_l()->stream->getDualMonoMode(mode);
ALOGD_IF((status == NO_ERROR) && (mDualMonoMode != *mode),
"%s: mode %d inconsistent", __func__, mDualMonoMode);
}
@@ -1884,11 +1891,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock lock(t->mLock);
- status = t->mOutput->stream->setDualMonoMode(mode);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock lock(t->mutex());
+ status = t->getOutput_l()->stream->setDualMonoMode(mode);
if (status == NO_ERROR) {
mDualMonoMode = mode;
}
@@ -1901,11 +1908,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock lock(t->mLock);
- status = t->mOutput->stream->getAudioDescriptionMixLevel(leveldB);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock lock(t->mutex());
+ status = t->getOutput_l()->stream->getAudioDescriptionMixLevel(leveldB);
ALOGD_IF((status == NO_ERROR) && (mAudioDescriptionMixLevel != *leveldB),
"%s: level %.3f inconsistent", __func__, mAudioDescriptionMixLevel);
}
@@ -1917,11 +1924,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock lock(t->mLock);
- status = t->mOutput->stream->setAudioDescriptionMixLevel(leveldB);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock lock(t->mutex());
+ status = t->getOutput_l()->stream->setAudioDescriptionMixLevel(leveldB);
if (status == NO_ERROR) {
mAudioDescriptionMixLevel = leveldB;
}
@@ -1935,11 +1942,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock lock(t->mLock);
- status = t->mOutput->stream->getPlaybackRateParameters(playbackRate);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock lock(t->mutex());
+ status = t->getOutput_l()->stream->getPlaybackRateParameters(playbackRate);
ALOGD_IF((status == NO_ERROR) &&
!isAudioPlaybackRateEqual(mPlaybackRateParameters, *playbackRate),
"%s: playbackRate inconsistent", __func__);
@@ -1953,11 +1960,11 @@
{
status_t status = INVALID_OPERATION;
if (isOffloadedOrDirect()) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != nullptr) {
- auto* const t = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
- Mutex::Autolock lock(t->mLock);
- status = t->mOutput->stream->setPlaybackRateParameters(playbackRate);
+ auto* const t = thread->asIAfPlaybackThread().get();
+ Mutex::Autolock lock(t->mutex());
+ status = t->getOutput_l()->stream->setPlaybackRateParameters(playbackRate);
if (status == NO_ERROR) {
mPlaybackRateParameters = playbackRate;
}
@@ -2076,13 +2083,13 @@
}
bool Track::AudioVibrationController::setMute(bool muted) {
- sp<AudioFlinger::ThreadBase> thread = mTrack->mThread.promote();
+ const sp<IAfThreadBase> thread = mTrack->mThread.promote();
if (thread != 0) {
// Lock for updating mHapticPlaybackEnabled.
- Mutex::Autolock _l(thread->mLock);
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
if ((mTrack->channelMask() & AUDIO_CHANNEL_HAPTIC_ALL) != AUDIO_CHANNEL_NONE
- && playbackThread->mHapticChannelCount > 0) {
+ && playbackThread->hapticChannelCount() > 0) {
ALOGD("%s, haptic playback was %s for track %d",
__func__, muted ? "muted" : "unmuted", mTrack->id());
mTrack->setHapticPlaybackEnabled(!muted);
@@ -2109,17 +2116,17 @@
#define LOG_TAG "AF::OutputTrack"
/* static */
-sp<IAfOutputTrack> IAfOutputTrack::create( // TODO(b/288339104) void*
- void* /* AudioFlinger::PlaybackThread */ playbackThread,
- void* /* AudioFlinger::DuplicatingThread */ sourceThread,
+sp<IAfOutputTrack> IAfOutputTrack::create(
+ IAfPlaybackThread* playbackThread,
+ IAfDuplicatingThread* sourceThread,
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
const AttributionSourceState& attributionSource) {
return sp<OutputTrack>::make(
- reinterpret_cast<AudioFlinger::PlaybackThread*>(playbackThread),
- reinterpret_cast<AudioFlinger::DuplicatingThread*>(sourceThread),
+ playbackThread,
+ sourceThread,
sampleRate,
format,
channelMask,
@@ -2128,8 +2135,8 @@
}
OutputTrack::OutputTrack(
- AudioFlinger::PlaybackThread *playbackThread,
- AudioFlinger::DuplicatingThread *sourceThread,
+ IAfPlaybackThread* playbackThread,
+ IAfDuplicatingThread* sourceThread,
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
@@ -2146,7 +2153,7 @@
if (mCblk != NULL) {
mOutBuffer.frameCount = 0;
- playbackThread->mTracks.add(this);
+ playbackThread->addOutputTrack_l(this);
ALOGV("%s(): mCblk %p, mBuffer %p, "
"frameCount %zu, mChannelMask 0x%08x",
__func__, mCblk, mBuffer,
@@ -2194,8 +2201,8 @@
ssize_t OutputTrack::write(void* data, uint32_t frames)
{
if (!mActive && frames != 0) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
- if (thread != nullptr && thread->standby()) {
+ const sp<IAfThreadBase> thread = mThread.promote();
+ if (thread != nullptr && thread->inStandby()) {
// preload one silent buffer to trigger mixer on start()
ClientProxy::Buffer buf { .mFrameCount = mClientProxy->getStartThresholdInFrames() };
status_t status = mClientProxy->obtainBuffer(&buf);
@@ -2213,7 +2220,7 @@
// If another OutputTrack has already started it can underrun but this is OK
// as only silence has been played so far and the retry count is very high on
// OutputTrack.
- auto* const pt = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ auto* const pt = thread->asIAfPlaybackThread().get();
if (!pt->waitForHalStart()) {
ALOGW("%s(%d): timeout waiting for thread to exit standby", __func__, mId);
stop();
@@ -2302,8 +2309,8 @@
// If we could not write all frames, allocate a buffer and queue it for next time.
if (inBuffer.frameCount) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
- if (thread != 0 && !thread->standby()) {
+ const sp<IAfThreadBase> thread = mThread.promote();
+ if (thread != nullptr && !thread->inStandby()) {
queueBuffer(inBuffer);
}
}
@@ -2395,7 +2402,7 @@
/* static */
sp<IAfPatchTrack> IAfPatchTrack::create(
- void* /* PlaybackThread */ playbackThread, // TODO(b/288339104)
+ IAfPlaybackThread* playbackThread,
audio_stream_type_t streamType,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
@@ -2411,7 +2418,7 @@
* even if it might glitch. */)
{
return sp<PatchTrack>::make(
- reinterpret_cast<AudioFlinger::PlaybackThread*>(playbackThread),
+ playbackThread,
streamType,
sampleRate,
channelMask,
@@ -2424,7 +2431,7 @@
frameCountToBeReady);
}
-PatchTrack::PatchTrack(AudioFlinger::PlaybackThread *playbackThread,
+PatchTrack::PatchTrack(IAfPlaybackThread* playbackThread,
audio_stream_type_t streamType,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
@@ -2441,8 +2448,9 @@
buffer, bufferSize, nullptr /* sharedBuffer */,
AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
- PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
- *playbackThread, timeout)
+ PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true)
+ : nullptr,
+ playbackThread, timeout)
{
ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
__func__, mId, sampleRate,
@@ -2541,9 +2549,9 @@
if (mFillingStatus == FS_ACTIVE
&& audio_is_linear_pcm(mFormat)
&& !isOffloadedOrDirect()) {
- if (sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ if (const sp<IAfThreadBase> thread = mThread.promote();
thread != 0) {
- auto* const playbackThread = static_cast<AudioFlinger::PlaybackThread*>(thread.get());
+ auto* const playbackThread = thread->asIAfPlaybackThread().get();
const size_t frameCount = playbackThread->frameCount() * sampleRate()
/ playbackThread->sampleRate();
if (framesReady() < frameCount) {
@@ -2603,7 +2611,6 @@
: BnAudioRecord(),
mRecordTrack(recordTrack)
{
- // TODO(b/288339104) binder thread priority change not needed.
setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
}
@@ -2658,8 +2665,8 @@
#define LOG_TAG "AF::RecordTrack"
-/* static */ // TODO(b/288339104)
-sp<IAfRecordTrack> IAfRecordTrack::create(void* /*AudioFlinger::RecordThread */ thread,
+/* static */
+sp<IAfRecordTrack> IAfRecordTrack::create(IAfRecordThread* thread,
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t sampleRate,
@@ -2677,7 +2684,7 @@
int32_t startFrames)
{
return sp<RecordTrack>::make(
- reinterpret_cast<AudioFlinger::RecordThread*>(thread),
+ thread,
client,
attr,
sampleRate,
@@ -2697,7 +2704,7 @@
// RecordTrack constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
RecordTrack::RecordTrack(
- AudioFlinger::RecordThread* thread,
+ IAfRecordThread* thread,
const sp<Client>& client,
const audio_attributes_t& attr,
uint32_t sampleRate,
@@ -2736,7 +2743,7 @@
if (!isDirect()) {
mRecordBufferConverter = new RecordBufferConverter(
- thread->mChannelMask, thread->mFormat, thread->mSampleRate,
+ thread->channelMask(), thread->format(), thread->sampleRate(),
channelMask, format, sampleRate);
// Check if the RecordBufferConverter construction was successful.
// If not, don't continue with construction.
@@ -2756,8 +2763,8 @@
mResamplerBufferProvider = new ResamplerBufferProvider(this);
if (flags & AUDIO_INPUT_FLAG_FAST) {
- ALOG_ASSERT(thread->mFastTrackAvail);
- thread->mFastTrackAvail = false;
+ ALOG_ASSERT(thread->fastTrackAvailable());
+ thread->setFastTrackAvailable(false);
} else {
// TODO: only Normal Record has timestamps (Fast Record does not).
mServerLatencySupported = checkServerLatencySupported(mFormat, flags);
@@ -2806,9 +2813,9 @@
status_t RecordTrack::start(AudioSystem::sync_event_t event,
audio_session_t triggerSession)
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
return recordThread->start(this, event, triggerSession);
} else {
ALOGW("%s track %d: thread was destroyed", __func__, portId());
@@ -2818,9 +2825,9 @@
void RecordTrack::stop()
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
if (recordThread->stop(this) && isExternalTrack()) {
AudioSystem::stopInput(mPortId);
}
@@ -2833,10 +2840,10 @@
sp<RecordTrack> keep(this);
{
track_state priorState = mState;
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- Mutex::Autolock _l(thread->mLock);
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ Mutex::Autolock _l(thread->mutex());
+ auto* const recordThread = thread->asIAfRecordThread().get();
priorState = mState;
if (!mSharedAudioPackageName.empty()) {
recordThread->resetAudioHistory_l();
@@ -2930,11 +2937,11 @@
const sp<audioflinger::SyncEvent>& event)
{
size_t framesToDrop = 0;
- sp<AudioFlinger::ThreadBase> threadBase = mThread.promote();
+ const sp<IAfThreadBase> threadBase = mThread.promote();
if (threadBase != 0) {
// TODO: use actual buffer filling status instead of 2 buffers when info is available
// from audio HAL
- framesToDrop = threadBase->mFrameCount * 2;
+ framesToDrop = threadBase->frameCount() * 2;
}
mSynchronizedRecordState.onPlaybackFinished(event, framesToDrop);
@@ -2988,9 +2995,9 @@
status_t RecordTrack::getActiveMicrophones(
std::vector<media::MicrophoneInfoFw>* activeMicrophones) const
{
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
return recordThread->getActiveMicrophones(activeMicrophones);
} else {
return BAD_VALUE;
@@ -2999,9 +3006,9 @@
status_t RecordTrack::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
return recordThread->setPreferredMicrophoneDirection(direction);
} else {
return BAD_VALUE;
@@ -3009,9 +3016,9 @@
}
status_t RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
return recordThread->setPreferredMicrophoneFieldDimension(zoom);
} else {
return BAD_VALUE;
@@ -3035,9 +3042,9 @@
return PERMISSION_DENIED;
}
- sp<AudioFlinger::ThreadBase> thread = mThread.promote();
+ const sp<IAfThreadBase> thread = mThread.promote();
if (thread != 0) {
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>(thread.get());
+ auto* const recordThread = thread->asIAfRecordThread().get();
status_t status = recordThread->shareAudioHistory(
sharedAudioPackageName, mSessionId, sharedAudioStartMs);
if (status == NO_ERROR) {
@@ -3075,7 +3082,7 @@
/* static */
sp<IAfPatchRecord> IAfPatchRecord::create(
- void* /* RecordThread */ recordThread, // TODO(b/288339104)
+ IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -3087,7 +3094,7 @@
audio_source_t source)
{
return sp<PatchRecord>::make(
- reinterpret_cast<AudioFlinger::RecordThread*>(recordThread),
+ recordThread,
sampleRate,
channelMask,
format,
@@ -3099,7 +3106,7 @@
source);
}
-PatchRecord::PatchRecord(AudioFlinger::RecordThread *recordThread,
+PatchRecord::PatchRecord(IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -3114,8 +3121,9 @@
sampleRate, format, channelMask, frameCount,
buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
- PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
- *recordThread, timeout)
+ PatchTrackBase(mCblk ? new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true)
+ : nullptr,
+ recordThread, timeout)
{
ALOGV("%s(%d): sampleRate %d mPeerTimeout %d.%03d sec",
__func__, mId, sampleRate,
@@ -3217,7 +3225,7 @@
/* static */
sp<IAfPatchRecord> IAfPatchRecord::createPassThru(
- void* /* RecordThread */ recordThread, // TODO(b/288339104)
+ IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -3226,7 +3234,7 @@
audio_source_t source)
{
return sp<PassthruPatchRecord>::make(
- reinterpret_cast<AudioFlinger::RecordThread*>(recordThread),
+ recordThread,
sampleRate,
channelMask,
format,
@@ -3236,7 +3244,7 @@
}
PassthruPatchRecord::PassthruPatchRecord(
- AudioFlinger::RecordThread* recordThread,
+ IAfRecordThread* recordThread,
uint32_t sampleRate,
audio_channel_mask_t channelMask,
audio_format_t format,
@@ -3253,13 +3261,13 @@
}
sp<StreamInHalInterface> PassthruPatchRecord::obtainStream(
- sp<AudioFlinger::ThreadBase>* thread)
+ sp<IAfThreadBase>* thread)
{
*thread = mThread.promote();
if (!*thread) return nullptr;
- auto* const recordThread = static_cast<AudioFlinger::RecordThread*>((*thread).get());
- Mutex::Autolock _l(recordThread->mLock);
- return recordThread->mInput ? recordThread->mInput->stream : nullptr;
+ auto* const recordThread = (*thread)->asIAfRecordThread().get();
+ Mutex::Autolock _l(recordThread->mutex());
+ return recordThread->getInput() ? recordThread->getInput()->stream : nullptr;
}
// PatchProxyBufferProvider methods are called on DirectOutputThread
@@ -3281,7 +3289,7 @@
const size_t framesToRead = std::min(buffer->mFrameCount, mFrameCount);
buffer->mFrameCount = 0;
buffer->mRaw = nullptr;
- sp<AudioFlinger::ThreadBase> thread;
+ sp<IAfThreadBase> thread;
sp<StreamInHalInterface> stream = obtainStream(&thread);
if (!stream) return NO_INIT; // If there is no stream, RecordThread is not reading.
@@ -3368,7 +3376,7 @@
status_t PassthruPatchRecord::getCapturePosition(
int64_t* frames, int64_t* time)
{
- sp<AudioFlinger::ThreadBase> thread;
+ sp<IAfThreadBase> thread;
sp<StreamInHalInterface> stream = obtainStream(&thread);
return stream ? stream->getCapturePosition(frames, time) : NO_INIT;
}
@@ -3405,7 +3413,7 @@
#define LOG_TAG "AF::MmapTrack"
/* static */
-sp<IAfMmapTrack> IAfMmapTrack::create(void* /* AudioFlinger::ThreadBase */ thread,
+sp<IAfMmapTrack> IAfMmapTrack::create(IAfThreadBase* thread,
const audio_attributes_t& attr,
uint32_t sampleRate,
audio_format_t format,
@@ -3417,7 +3425,7 @@
audio_port_handle_t portId)
{
return sp<MmapTrack>::make(
- reinterpret_cast<AudioFlinger::ThreadBase*>(thread),
+ thread,
attr,
sampleRate,
format,
@@ -3429,7 +3437,7 @@
portId);
}
-MmapTrack::MmapTrack(AudioFlinger::ThreadBase* thread,
+MmapTrack::MmapTrack(IAfThreadBase* thread,
const audio_attributes_t& attr,
uint32_t sampleRate,
audio_format_t format,
diff --git a/services/audioflinger/datapath/AudioStreamIn.h b/services/audioflinger/datapath/AudioStreamIn.h
new file mode 100644
index 0000000..7b3a090
--- /dev/null
+++ b/services/audioflinger/datapath/AudioStreamIn.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2023 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/audiohal/DeviceHalInterface.h>
+#include <media/audiohal/StreamHalInterface.h>
+
+namespace android {
+
+// Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord).
+struct Source {
+ virtual ~Source() = default;
+ // The following methods have the same signatures as in StreamHalInterface.
+ virtual status_t read(void* buffer, size_t bytes, size_t* read) = 0;
+ virtual status_t getCapturePosition(int64_t* frames, int64_t* time) = 0;
+ virtual status_t standby() = 0;
+};
+
+// AudioStreamIn is immutable, so its fields are const.
+// The methods must not be const to match StreamHalInterface signature.
+
+struct AudioStreamIn : public Source {
+ const AudioHwDevice* const audioHwDev;
+ const sp<StreamInHalInterface> stream;
+ const audio_input_flags_t flags;
+
+ AudioStreamIn(
+ const AudioHwDevice* dev, const sp<StreamInHalInterface>& in,
+ audio_input_flags_t flags)
+ : audioHwDev(dev), stream(in), flags(flags) {}
+
+ status_t read(void* buffer, size_t bytes, size_t* read) final {
+ return stream->read(buffer, bytes, read);
+ }
+
+ status_t getCapturePosition(int64_t* frames, int64_t* time) final {
+ return stream->getCapturePosition(frames, time);
+ }
+
+ status_t standby() final { return stream->standby(); }
+
+ sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); }
+};
+
+} // namespace android
diff --git a/services/audioflinger/datapath/VolumeInterface.h b/services/audioflinger/datapath/VolumeInterface.h
new file mode 100644
index 0000000..1564fe1
--- /dev/null
+++ b/services/audioflinger/datapath/VolumeInterface.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2023 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 <system/audio.h>
+
+namespace android {
+
+class VolumeInterface : public virtual RefBase {
+public:
+ virtual void setMasterVolume(float value) = 0;
+ virtual void setMasterBalance(float balance) = 0;
+ virtual void setMasterMute(bool muted) = 0;
+ virtual void setStreamVolume(audio_stream_type_t stream, float value) = 0;
+ virtual void setStreamMute(audio_stream_type_t stream, bool muted) = 0;
+ // TODO(b/290699744) add "get" prefix for getter below.
+ virtual float streamVolume(audio_stream_type_t stream) const = 0;
+};
+
+} // namespace android
diff --git a/services/audioflinger/timing/tests/mediasyncevent_tests.cpp b/services/audioflinger/timing/tests/mediasyncevent_tests.cpp
index 745bb35..ab2d88f 100644
--- a/services/audioflinger/timing/tests/mediasyncevent_tests.cpp
+++ b/services/audioflinger/timing/tests/mediasyncevent_tests.cpp
@@ -25,7 +25,8 @@
using namespace android::audioflinger;
namespace {
-
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wenum-constexpr-conversion"
TEST(MediaSyncEventTests, Basic) {
struct Cookie : public RefBase {};
@@ -66,5 +67,5 @@
syncEvent->cancel();
ASSERT_TRUE(syncEvent->isCancelled());
}
-
+#pragma clang diagnostic pop
} // namespace
diff --git a/services/audioflinger/timing/tests/synchronizedrecordstate_tests.cpp b/services/audioflinger/timing/tests/synchronizedrecordstate_tests.cpp
index 68f154d..82df059 100644
--- a/services/audioflinger/timing/tests/synchronizedrecordstate_tests.cpp
+++ b/services/audioflinger/timing/tests/synchronizedrecordstate_tests.cpp
@@ -26,6 +26,8 @@
namespace {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wenum-constexpr-conversion"
TEST(SynchronizedRecordStateTests, Basic) {
struct Cookie : public RefBase {};
@@ -74,5 +76,5 @@
ASSERT_FALSE(triggered);
ASSERT_TRUE(syncEvent->isCancelled());
}
-
+#pragma clang diagnostic pop
}
diff --git a/services/audiopolicy/engineconfigurable/parameter-framework/examples/Car/Android.bp b/services/audiopolicy/engineconfigurable/parameter-framework/examples/Car/Android.bp
index bc72484..7d2d293 100644
--- a/services/audiopolicy/engineconfigurable/parameter-framework/examples/Car/Android.bp
+++ b/services/audiopolicy/engineconfigurable/parameter-framework/examples/Car/Android.bp
@@ -55,6 +55,7 @@
//
prebuilt_etc {
name: "parameter-framework.policy",
+ enabled: false, // TODO: This module depends on domaingeneratorpolicyrule_gen, which fails to build
filename_from_src: true,
vendor: true,
src: ":domaingeneratorpolicyrule_gen",
@@ -68,6 +69,7 @@
}
genrule {
name: "domaingeneratorpolicyrule_gen",
+ enabled: false, // TODO: This module fails to build
defaults: ["domaingeneratorpolicyrule"],
srcs: [
":audio_policy_pfw_toplevel",
diff --git a/services/audiopolicy/engineconfigurable/parameter-framework/examples/CarEmu/Android.bp b/services/audiopolicy/engineconfigurable/parameter-framework/examples/CarEmu/Android.bp
index 11da8c7..f825e5f 100644
--- a/services/audiopolicy/engineconfigurable/parameter-framework/examples/CarEmu/Android.bp
+++ b/services/audiopolicy/engineconfigurable/parameter-framework/examples/CarEmu/Android.bp
@@ -56,6 +56,7 @@
//
prebuilt_etc {
name: "parameter-framework.policy",
+ enabled: false, // TODO: This module depends on domaingeneratorpolicyrule_gen, which fails to build
filename_from_src: true,
vendor: true,
src: ":domaingeneratorpolicyrule_gen",
@@ -69,6 +70,7 @@
}
genrule {
name: "domaingeneratorpolicyrule_gen",
+ enabled: false, // TODO: This module fails to build
defaults: ["domaingeneratorpolicyrule"],
srcs: [
":audio_policy_pfw_toplevel",
diff --git a/services/audiopolicy/engineconfigurable/parameter-framework/examples/Phone/Android.bp b/services/audiopolicy/engineconfigurable/parameter-framework/examples/Phone/Android.bp
index 91ffeb5..4a83cbc 100644
--- a/services/audiopolicy/engineconfigurable/parameter-framework/examples/Phone/Android.bp
+++ b/services/audiopolicy/engineconfigurable/parameter-framework/examples/Phone/Android.bp
@@ -55,6 +55,7 @@
//
prebuilt_etc {
name: "parameter-framework.policy",
+ enabled: false, // TODO: This module depends on domaingeneratorpolicyrule_gen, which fails to build
filename_from_src: true,
vendor: true,
src: ":domaingeneratorpolicyrule_gen",
@@ -68,6 +69,7 @@
}
genrule {
name: "domaingeneratorpolicyrule_gen",
+ enabled: false, // TODO: This module fails to build
defaults: ["domaingeneratorpolicyrule"],
srcs: [
":audio_policy_pfw_toplevel",
diff --git a/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoInput/Android.bp b/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoInput/Android.bp
index cac63fc..89ab892 100644
--- a/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoInput/Android.bp
+++ b/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoInput/Android.bp
@@ -34,6 +34,7 @@
prebuilt_etc {
name: "parameter-framework.policy",
+ enabled: false, // TODO: This module depends on domaingeneratorpolicyrule_gen, which fails to build
filename_from_src: true,
vendor: true,
src: ":domaingeneratorpolicyrule_gen",
@@ -47,6 +48,7 @@
genrule {
name: "domaingeneratorpolicyrule_gen",
+ enabled: false, // TODO: This module fails to build
defaults: ["domaingeneratorpolicyrule"],
srcs: [
":audio_policy_pfw_toplevel",
diff --git a/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoOutput/Android.bp b/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoOutput/Android.bp
index 337f358..4880547 100644
--- a/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoOutput/Android.bp
+++ b/services/audiopolicy/engineconfigurable/parameter-framework/examples/SettingsNoOutput/Android.bp
@@ -34,6 +34,7 @@
prebuilt_etc {
name: "parameter-framework.policy",
+ enabled: false, // TODO: This module depends on domaingeneratorpolicyrule_gen, which fails to build
filename_from_src: true,
vendor: true,
src: ":domaingeneratorpolicyrule_gen",
@@ -46,6 +47,7 @@
}
genrule {
name: "domaingeneratorpolicyrule_gen",
+ enabled: false, // TODO: This module fails to build
defaults: ["domaingeneratorpolicyrule"],
srcs: [
":audio_policy_pfw_toplevel",
diff --git a/services/audiopolicy/tests/audiopolicymanager_tests.cpp b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
index 15eae14..b56bb16 100644
--- a/services/audiopolicy/tests/audiopolicymanager_tests.cpp
+++ b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
@@ -1905,7 +1905,7 @@
audio_io_handle_t mOutput;
audio_stream_type_t mStream = AUDIO_STREAM_DEFAULT;
audio_port_handle_t mSelectedDeviceId = AUDIO_PORT_HANDLE_NONE;
- audio_port_handle_t mPortId;
+ audio_port_handle_t mPortId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::output_type_t mOutputType;
audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
bool mIsSpatialized;
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index 222f459..4757a42 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -2659,6 +2659,11 @@
}
case ICameraService::EVENT_USB_DEVICE_ATTACHED:
case ICameraService::EVENT_USB_DEVICE_DETACHED: {
+ if (args.size() != 1) {
+ return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT,
+ "USB Device Event requires 1 argument");
+ }
+
// Notify CameraProviderManager for lazy HALs
mCameraProviderManager->notifyUsbDeviceEvent(eventId,
std::to_string(args[0]));
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
index 7185895..f98636b 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.cpp
@@ -487,7 +487,7 @@
bufferDeferred = true;
} else {
nsecs_t presentTime = mSyncToDisplay ?
- syncTimestampToDisplayLocked(captureTime, releaseFence->dup()) : captureTime;
+ syncTimestampToDisplayLocked(captureTime, releaseFence) : captureTime;
setTransform(transform, true/*mayChangeMirror*/);
res = native_window_set_buffers_timestamp(mConsumer.get(), presentTime);
@@ -1412,7 +1412,7 @@
}
}
-nsecs_t Camera3OutputStream::syncTimestampToDisplayLocked(nsecs_t t, int releaseFence) {
+nsecs_t Camera3OutputStream::syncTimestampToDisplayLocked(nsecs_t t, sp<Fence> releaseFence) {
nsecs_t currentTime = systemTime();
if (!mFixedFps) {
mLastCaptureTime = t;
@@ -1460,8 +1460,8 @@
mRefVsyncData = vsyncEventData;
mReferenceCaptureTime = t;
mReferenceArrivalTime = currentTime;
- if (releaseFence != -1) {
- mReferenceFrameFence = new Fence(releaseFence);
+ if (releaseFence->isValid()) {
+ mReferenceFrameFence = new Fence(releaseFence->dup());
} else {
mFenceSignalOffset = 0;
}
diff --git a/services/camera/libcameraservice/device3/Camera3OutputStream.h b/services/camera/libcameraservice/device3/Camera3OutputStream.h
index 0b456c0..65791a9 100644
--- a/services/camera/libcameraservice/device3/Camera3OutputStream.h
+++ b/services/camera/libcameraservice/device3/Camera3OutputStream.h
@@ -446,7 +446,7 @@
static constexpr nsecs_t kTimelineThresholdNs = 1000000LL; // 1 millisecond
static constexpr float kMaxIntervalRatioDeviation = 0.05f;
static constexpr int kMaxTimelines = 2;
- nsecs_t syncTimestampToDisplayLocked(nsecs_t t, int releaseFence);
+ nsecs_t syncTimestampToDisplayLocked(nsecs_t t, sp<Fence> releaseFence);
// In case of fence being used
sp<Fence> mReferenceFrameFence;
diff --git a/services/mediametrics/AudioAnalytics.cpp b/services/mediametrics/AudioAnalytics.cpp
index 59d1ae4..bd4ac38 100644
--- a/services/mediametrics/AudioAnalytics.cpp
+++ b/services/mediametrics/AudioAnalytics.cpp
@@ -242,6 +242,7 @@
"channel_count_hardware",
"sample_rate_hardware",
"uid",
+ "sample_rate_client",
};
static constexpr const char * HeadTrackerDeviceEnabledFields[] {
@@ -1379,6 +1380,10 @@
const auto uid = item->getUid();
+ int32_t sampleRateClient = 0;
+ mAudioAnalytics.mAnalyticsState->timeMachine().get(
+ key, AMEDIAMETRICS_PROP_SAMPLERATECLIENT, &sampleRateClient);
+
LOG(LOG_LEVEL) << "key:" << key
<< " path:" << path
<< " direction:" << direction << "(" << directionStr << ")"
@@ -1402,7 +1407,8 @@
<< " format_hardware:" << formatHardware << "(" << formatHardwareStr << ")"
<< " channel_count_hardware:" << channelCountHardware
<< " sample_rate_hardware: " << sampleRateHardware
- << " uid: " << uid;
+ << " uid: " << uid
+ << " sample_rate_client: " << sampleRateClient;
if (mAudioAnalytics.mDeliverStatistics) {
const stats::media_metrics::BytesField bf_serialized(
@@ -1431,6 +1437,7 @@
, channelCountHardware
, sampleRateHardware
, uid
+ , sampleRateClient
);
std::stringstream ss;
ss << "result:" << result;
@@ -1458,6 +1465,7 @@
, channelCountHardware
, sampleRateHardware
, uid
+ , sampleRateClient
);
ss << " " << fieldsStr;
std::string str = ss.str();