Snap for 12559614 from 720d356ee6294fd5d4cc31dcdee434e629ba6a58 to 25Q1-release (c7098feb) · Commits · e / os / android_frameworks_av

drm/drmserver/Android.bp

+0 −4

Original line number	Diff line number	Diff line
		@@ -78,9 +78,6 @@ drmserver_cc_binary {
		"libselinux",
		"libstagefright_foundation",
		],
		whole_static_libs: [
		"libc++fs",
		],

		cflags: [
		"-Wall",
		@@ -127,7 +124,6 @@ cc_fuzz {
		],

		static_libs: [
		"libc++fs",
		"libmediautils",
		"liblog",
		"libdrmframeworkcommon",

drm/libdrmframework/plugins/passthru/Android.bp

+0 −3

Original line number	Diff line number	Diff line
		@@ -45,9 +45,6 @@ cc_library_shared {
		"libdl",
		"libdrmframeworkcommon",
		],
		whole_static_libs: [
		"libc++fs",
		],

		local_include_dirs: ["include"],

media/aconfig/codec_fwk.aconfig

+8 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,14 @@ flag {
		bug: "201479783"
		}

		flag {
		name: "apv_support"
		is_exported: true
		namespace: "codec_fwk"
		description: "Feature flag for Android support for APV Content"
		bug: "375464302"
		}

		flag {
		name: "codec_buffer_state_cleanup"
		namespace: "codec_fwk"

media/audioserver/main_audioserver.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -190,7 +190,7 @@ int main(int argc __unused, char **argv)
		// attempting to call audio flinger on a null pointer could make the process crash
		// and attract attentions.
		std::vector<AudioMMapPolicyInfo> policyInfos;
		status_t status = sp<IAudioFlinger>::cast(af)->getMmapPolicyInfos(
		status_t status = AudioSystem::getMmapPolicyInfos(
		AudioMMapPolicyType::DEFAULT, &policyInfos);
		// Initialize aaudio service when querying mmap policy succeeds and
		// any of the policy supports MMAP.

media/codec2/sfplugin/CCodecBufferChannel.cpp

+110 −2

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@
		#include <android/sysprop/MediaProperties.sysprop.h>
		#include <android-base/parseint.h>
		#include <android-base/properties.h>
		#include <android-base/no_destructor.h>
		#include <android-base/stringprintf.h>
		#include <binder/MemoryBase.h>
		#include <binder/MemoryDealer.h>
		@@ -115,6 +116,109 @@ static uint32_t convertFlags(uint32_t flags, bool toC2) {
		});
		}

		class SurfaceCallbackHandler {
		public:
		enum callback_type_t {
		ON_BUFFER_RELEASED = 0,
		ON_BUFFER_ATTACHED
		};

		void post(callback_type_t callback,
		std::shared_ptr<Codec2Client::Component> component,
		uint32_t generation) {
		if (!component) {
		ALOGW("surface callback psoted for invalid component");
		}
		std::shared_ptr<SurfaceCallbackItem> item =
		std::make_shared<SurfaceCallbackItem>(callback, component, generation);
		std::unique_lock<std::mutex> lock(mMutex);
		mItems.emplace_back(std::move(item));
		mCv.notify_one();
		}

		~SurfaceCallbackHandler() {
		{
		std::unique_lock<std::mutex> lock(mMutex);
		mDone = true;
		mCv.notify_all();
		}
		if (mThread.joinable()) {
		mThread.join();
		}
		}

		static SurfaceCallbackHandler& GetInstance() {
		static base::NoDestructor<SurfaceCallbackHandler> sSurfaceCallbackHandler{};
		return *sSurfaceCallbackHandler;
		}

		private:
		struct SurfaceCallbackItem {
		callback_type_t mCallback;
		std::weak_ptr<Codec2Client::Component> mComp;
		uint32_t mGeneration;

		SurfaceCallbackItem(
		callback_type_t callback,
		std::shared_ptr<Codec2Client::Component> comp,
		uint32_t generation)
		: mCallback(callback), mComp(comp), mGeneration(generation) {}
		};

		SurfaceCallbackHandler() { mThread = std::thread(&SurfaceCallbackHandler::run, this); }

		void run() {
		std::unique_lock<std::mutex> lock(mMutex);
		while (!mDone) {
		while (!mItems.empty()) {
		std::deque<std::shared_ptr<SurfaceCallbackItem>> items = std::move(mItems);
		mItems.clear();
		lock.unlock();
		handle(items);
		lock.lock();
		}
		mCv.wait(lock);
		}
		}

		void handle(std::deque<std::shared_ptr<SurfaceCallbackItem>> &items) {
		while (!items.empty()) {
		std::shared_ptr<SurfaceCallbackItem> item = items.front();
		items.pop_front();
		switch (item->mCallback) {
		case ON_BUFFER_RELEASED: {
		std::shared_ptr<Codec2Client::Component> comp = item->mComp.lock();;
		if (comp) {
		comp->onBufferReleasedFromOutputSurface(item->mGeneration);
		}
		break;
		}
		case ON_BUFFER_ATTACHED: {
		std::shared_ptr<Codec2Client::Component> comp = item->mComp.lock();
		if (comp) {
		comp->onBufferAttachedToOutputSurface(item->mGeneration);
		}
		break;
		}
		default:
		ALOGE("Non defined surface callback message");
		break;
		}
		}
		}

		std::thread mThread;
		bool mDone = false;
		std::deque<std::shared_ptr<SurfaceCallbackItem>> mItems;
		std::mutex mMutex;
		std::condition_variable mCv;


		friend class base::NoDestructor<SurfaceCallbackHandler>;

		DISALLOW_EVIL_CONSTRUCTORS(SurfaceCallbackHandler);
		};

		} // namespace

		CCodecBufferChannel::QueueGuard::QueueGuard(
		@@ -1503,7 +1607,8 @@ void CCodecBufferChannel::onBufferReleasedFromOutputSurface(uint32_t generation)
		// during this interface being executed.
		std::shared_ptr<Codec2Client::Component> comp = mComponent;
		if (comp) {
		comp->onBufferReleasedFromOutputSurface(generation);
		SurfaceCallbackHandler::GetInstance().post(
		SurfaceCallbackHandler::ON_BUFFER_RELEASED, comp, generation);
		}
		}

		@@ -1514,7 +1619,8 @@ void CCodecBufferChannel::onBufferAttachedToOutputSurface(uint32_t generation) {
		// during this interface being executed.
		std::shared_ptr<Codec2Client::Component> comp = mComponent;
		if (comp) {
		comp->onBufferAttachedToOutputSurface(generation);
		SurfaceCallbackHandler::GetInstance().post(
		SurfaceCallbackHandler::ON_BUFFER_ATTACHED, comp, generation);
		}
		}

		@@ -1801,6 +1907,7 @@ status_t CCodecBufferChannel::start(
		outputSurface = output->surface ?
		output->surface->getIGraphicBufferProducer() : nullptr;
		if (outputSurface) {
		(void)SurfaceCallbackHandler::GetInstance();
		output->surface->setMaxDequeuedBufferCount(output->maxDequeueBuffers);
		}
		outputGeneration = output->generation;
		@@ -2727,6 +2834,7 @@ status_t CCodecBufferChannel::setSurface(const sp<Surface> &newSurface,
		oldSurface = outputSurface->surface;
		}
		if (newSurface) {
		(void)SurfaceCallbackHandler::GetInstance();
		newSurface->setScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
		newSurface->setDequeueTimeout(kDequeueTimeoutNs);
		newSurface->setMaxDequeuedBufferCount(maxDequeueCount);