Snap for 9024801 from 1f0ac9da70d59bb6fcf3480fd47083287513b31b to tm-qpr1-release (e3fdabca) · Commits · e / os / android_frameworks_av

drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -619,6 +619,7 @@ Return<void> DrmPlugin::getSecurityLevel(const hidl_vec<uint8_t>& sessionId,
		return Void();
		}

		Mutex::Autolock lock(mSecurityLevelLock);
		std::map<std::vector<uint8_t>, SecurityLevel>::iterator itr =
		mSecurityLevel.find(sid);
		if (itr == mSecurityLevel.end()) {
		@@ -691,6 +692,7 @@ Return<Status> DrmPlugin::setSecurityLevel(const hidl_vec<uint8_t>& sessionId,
		return Status::ERROR_DRM_SESSION_NOT_OPENED;
		}

		Mutex::Autolock lock(mSecurityLevelLock);
		std::map<std::vector<uint8_t>, SecurityLevel>::iterator itr =
		mSecurityLevel.find(sid);
		if (itr != mSecurityLevel.end()) {

drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h

+3 −1

Original line number	Diff line number	Diff line
		@@ -414,7 +414,8 @@ private:
		std::map<std::string, std::vector<uint8_t> > mByteArrayProperties;
		std::map<std::string, std::vector<uint8_t> > mReleaseKeysMap;
		std::map<std::vector<uint8_t>, std::string> mPlaybackId;
		std::map<std::vector<uint8_t>, SecurityLevel> mSecurityLevel;
		std::map<std::vector<uint8_t>, SecurityLevel> mSecurityLevel
		GUARDED_BY(mSecurityLevelLock);
		sp<IDrmPluginListener> mListener;
		sp<IDrmPluginListener_V1_2> mListenerV1_2;
		SessionLibrary *mSessionLibrary;
		@@ -434,6 +435,7 @@ private:

		DeviceFiles mFileHandle;
		Mutex mSecureStopLock;
		Mutex mSecurityLevelLock;

		CLEARKEY_DISALLOW_COPY_AND_ASSIGN_AND_NEW(DrmPlugin);
		};

media/codec2/hidl/1.0/utils/types.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -1447,6 +1447,10 @@ bool objcpy(C2FrameData* d, const FrameData& s,
		bool objcpy(C2BaseBlock* d, const BaseBlock& s) {
		switch (s.getDiscriminator()) {
		case BaseBlock::hidl_discriminator::nativeBlock: {
		if (s.nativeBlock() == nullptr) {
		LOG(ERROR) << "Null BaseBlock::nativeBlock handle";
		return false;
		}
		native_handle_t* sHandle =
		native_handle_clone(s.nativeBlock());
		if (sHandle == nullptr) {

media/codec2/sfplugin/CCodec.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -2141,7 +2141,8 @@ void CCodec::signalResume() {

		std::map<size_t, sp<MediaCodecBuffer>> clientInputBuffers;
		status_t err = mChannel->prepareInitialInputBuffers(&clientInputBuffers);
		if (err != OK) {
		// FIXME(b/237656746)
		if (err != OK && err != NO_MEMORY) {
		ALOGE("Resume request for Input Buffers failed");
		mCallback->onError(err, ACTION_CODE_FATAL);
		return;

media/libaudiohal/impl/EffectsFactoryHalHidl.cpp

+55 −38

Original line number	Diff line number	Diff line
		@@ -17,6 +17,9 @@
		#define LOG_TAG "EffectsFactoryHalHidl"
		//#define LOG_NDEBUG 0

		#include <optional>
		#include <tuple>

		#include <cutils/native_handle.h>

		#include <UuidUtils.h>
		@@ -38,51 +41,71 @@ namespace effect {
		using namespace ::android::hardware::audio::common::CPP_VERSION;
		using namespace ::android::hardware::audio::effect::CPP_VERSION;

		EffectsFactoryHalHidl::EffectsFactoryHalHidl(sp<IEffectsFactory> effectsFactory)
		: EffectConversionHelperHidl("EffectsFactory") {
		ALOG_ASSERT(effectsFactory != nullptr, "Provided IEffectsFactory service is NULL");
		mEffectsFactory = effectsFactory;
		}
		class EffectDescriptorCache {
		public:
		using QueryResult = std::tuple<Return<void>, Result, hidl_vec<EffectDescriptor>>;
		QueryResult queryAllDescriptors(IEffectsFactory* effectsFactory);
		private:
		std::mutex mLock;
		std::optional<hidl_vec<EffectDescriptor>> mLastDescriptors; // GUARDED_BY(mLock)
		};

		status_t EffectsFactoryHalHidl::queryAllDescriptors() {
		if (mEffectsFactory == 0) return NO_INIT;
		EffectDescriptorCache::QueryResult EffectDescriptorCache::queryAllDescriptors(
		IEffectsFactory* effectsFactory) {
		{
		std::lock_guard l(mLock);
		if (mLastDescriptors.has_value()) {
		return {::android::hardware::Void(), Result::OK, mLastDescriptors.value()};
		}
		}
		Result retval = Result::NOT_INITIALIZED;
		Return<void> ret = mEffectsFactory->getAllDescriptors(
		hidl_vec<EffectDescriptor> descriptors;
		Return<void> ret = effectsFactory->getAllDescriptors(
		[&](Result r, const hidl_vec<EffectDescriptor>& result) {
		retval = r;
		if (retval == Result::OK) {
		mLastDescriptors = result;
		descriptors = result;
		}
		});
		if (ret.isOk()) {
		return retval == Result::OK ? OK : NO_INIT;
		if (ret.isOk() && retval == Result::OK) {
		std::lock_guard l(mLock);
		mLastDescriptors = descriptors;
		}
		mLastDescriptors.resize(0);
		return processReturn(__FUNCTION__, ret);
		return {std::move(ret), retval, std::move(descriptors)};
		}

		EffectsFactoryHalHidl::EffectsFactoryHalHidl(sp<IEffectsFactory> effectsFactory)
		: EffectConversionHelperHidl("EffectsFactory"), mCache(new EffectDescriptorCache) {
		ALOG_ASSERT(effectsFactory != nullptr, "Provided IEffectsFactory service is NULL");
		mEffectsFactory = effectsFactory;
		}

		status_t EffectsFactoryHalHidl::queryNumberEffects(uint32_t *pNumEffects) {
		status_t queryResult = queryAllDescriptors();
		if (queryResult == OK) {
		*pNumEffects = mLastDescriptors.size();
		if (mEffectsFactory == 0) return NO_INIT;
		auto [ret, retval, descriptors] = mCache->queryAllDescriptors(mEffectsFactory.get());
		if (ret.isOk() && retval == Result::OK) {
		*pNumEffects = descriptors.size();
		return OK;
		} else if (ret.isOk()) {
		return NO_INIT;
		}
		return queryResult;
		return processReturn(__FUNCTION__, ret);
		}

		status_t EffectsFactoryHalHidl::getDescriptor(
		uint32_t index, effect_descriptor_t *pDescriptor) {
		// TODO: We need somehow to track the changes on the server side
		// or figure out how to convert everybody to query all the descriptors at once.
		if (pDescriptor == nullptr) {
		return BAD_VALUE;
		}
		if (mLastDescriptors.size() == 0) {
		status_t queryResult = queryAllDescriptors();
		if (queryResult != OK) return queryResult;
		if (mEffectsFactory == 0) return NO_INIT;
		auto [ret, retval, descriptors] = mCache->queryAllDescriptors(mEffectsFactory.get());
		if (ret.isOk() && retval == Result::OK) {
		if (index >= descriptors.size()) return NAME_NOT_FOUND;
		EffectUtils::effectDescriptorToHal(descriptors[index], pDescriptor);
		} else if (ret.isOk()) {
		return NO_INIT;
		}
		if (index >= mLastDescriptors.size()) return NAME_NOT_FOUND;
		EffectUtils::effectDescriptorToHal(mLastDescriptors[index], pDescriptor);
		return OK;
		return processReturn(__FUNCTION__, ret);
		}

		status_t EffectsFactoryHalHidl::getDescriptor(
		@@ -114,21 +137,15 @@ status_t EffectsFactoryHalHidl::getDescriptors(const effect_uuid_t *pEffectType,
		if (pEffectType == nullptr \|\| descriptors == nullptr) {
		return BAD_VALUE;
		}
		if (mEffectsFactory == 0) return NO_INIT;

		uint32_t numEffects = 0;
		status_t status = queryNumberEffects(&numEffects);
		if (status != NO_ERROR) {
		ALOGW("%s error %d from FactoryHal queryNumberEffects", __func__, status);
		return status;
		auto [ret, retval, hidlDescs] = mCache->queryAllDescriptors(mEffectsFactory.get());
		if (!ret.isOk() \|\| retval != Result::OK) {
		return processReturn(__FUNCTION__, ret, retval);
		}

		for (uint32_t i = 0; i < numEffects; i++) {
		for (const auto& hidlDesc : hidlDescs) {
		effect_descriptor_t descriptor;
		status = getDescriptor(i, &descriptor);
		if (status != NO_ERROR) {
		ALOGW("%s error %d from FactoryHal getDescriptor", __func__, status);
		continue;
		}
		EffectUtils::effectDescriptorToHal(hidlDesc, &descriptor);
		if (memcmp(&descriptor.type, pEffectType, sizeof(effect_uuid_t)) == 0) {
		descriptors->push_back(descriptor);
		}