Merge changes I36b6f18f,Ibacdb889 into main (83b7c2eb) · Commits · e / os / android_frameworks_av

media/libstagefright/MediaCodec.cpp

+40 −0

Original line number	Diff line number	Diff line
		@@ -48,7 +48,10 @@
		#include <binder/IMemory.h>
		#include <binder/IServiceManager.h>
		#include <binder/MemoryDealer.h>
		#include <com_android_graphics_libgui_flags.h>
		#include <cutils/properties.h>
		#include <gui/BufferItem.h>
		#include <gui/BufferItemConsumer.h>
		#include <gui/BufferQueue.h>
		#include <gui/Surface.h>
		#include <hidlmemory/FrameworkUtils.h>
		@@ -770,6 +773,42 @@ MediaCodec::BufferInfo::BufferInfo() : mOwnedByClient(false) {}

		////////////////////////////////////////////////////////////////////////////////

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		class MediaCodec::ReleaseSurface {
		public:
		explicit ReleaseSurface(uint64_t usage) {
		std::tie(mConsumer, mSurface) = BufferItemConsumer::create(usage);

		struct FrameAvailableListener : public BufferItemConsumer::FrameAvailableListener {
		FrameAvailableListener(const sp<BufferItemConsumer> &consumer) {
		mConsumer = consumer;
		}
		void onFrameAvailable(const BufferItem&) override {
		BufferItem buffer;
		// consume buffer
		sp<BufferItemConsumer> consumer = mConsumer.promote();
		if (consumer != nullptr && consumer->acquireBuffer(&buffer, 0) == NO_ERROR) {
		consumer->releaseBuffer(buffer.mGraphicBuffer, buffer.mFence);
		}
		}

		wp<BufferItemConsumer> mConsumer;
		};
		mFrameAvailableListener = sp<FrameAvailableListener>::make(mConsumer);
		mConsumer->setFrameAvailableListener(mFrameAvailableListener);
		mConsumer->setName(String8{"MediaCodec.release"});
		}

		const sp<Surface> &getSurface() {
		return mSurface;
		}

		private:
		sp<BufferItemConsumer> mConsumer;
		sp<Surface> mSurface;
		sp<BufferItemConsumer::FrameAvailableListener> mFrameAvailableListener;
		};
		#else
		class MediaCodec::ReleaseSurface {
		public:
		explicit ReleaseSurface(uint64_t usage) {
		@@ -807,6 +846,7 @@ private:
		sp<IGraphicBufferConsumer> mConsumer;
		sp<Surface> mSurface;
		};
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)

		////////////////////////////////////////////////////////////////////////////////

media/libstagefright/MediaSync.cpp

+80 −1

Original line number	Diff line number	Diff line
		@@ -18,8 +18,15 @@
		#define LOG_TAG "MediaSync"
		#include <inttypes.h>

		#include <gui/BufferQueue.h>
		#include <com_android_graphics_libgui_flags.h>

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		#include <gui/BufferItemConsumer.h>
		#include <gui/Surface.h>
		#else
		#include <gui/IGraphicBufferConsumer.h>
		#endif
		#include <gui/BufferQueue.h>
		#include <gui/IGraphicBufferProducer.h>

		#include <media/AudioTrack.h>
		@@ -74,7 +81,11 @@ MediaSync::MediaSync()

		MediaSync::~MediaSync() {
		if (mInput != NULL) {
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		mInput->abandon();
		#else
		mInput->consumerDisconnect();
		#endif
		}
		if (mOutput != NULL) {
		mOutput->disconnect(NATIVE_WINDOW_API_MEDIA);
		@@ -204,6 +215,39 @@ status_t MediaSync::createInputSurface(
		return INVALID_OPERATION;
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		int usageFlags = 0;
		mOutput->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &usageFlags);

		auto [newInput, surface] = BufferItemConsumer::create(usageFlags);

		sp<InputListener> listener(new InputListener(this));
		newInput->setFrameAvailableListener(listener);
		newInput->setName(String8("MediaSync"));
		// propagate usage bits from output surface
		status_t status = newInput->setConsumerUsageBits(usageFlags);
		if (status != OK) {
		ALOGE("%s: Unable to set usage bits to %d", __FUNCTION__, usageFlags);
		return status;
		}

		// set undequeued buffer count
		int minUndequeuedBuffers;
		mOutput->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBuffers);
		status = newInput->setMaxAcquiredBufferCount(minUndequeuedBuffers);
		if (status != OK) {
		ALOGE("%s: Unable to set setMaxAcquiredBufferCount to %d", __FUNCTION__,
		minUndequeuedBuffers);
		return status;
		}

		mMaxAcquiredBufferCount = minUndequeuedBuffers;
		mUsageFlagsFromOutput = usageFlags;
		mInput = newInput;
		mListener = listener;
		*outBufferProducer = surface->getIGraphicBufferProducer();
		return OK;
		#else
		sp<IGraphicBufferProducer> bufferProducer;
		sp<IGraphicBufferConsumer> bufferConsumer;
		BufferQueue::createBufferQueue(&bufferProducer, &bufferConsumer);
		@@ -227,6 +271,7 @@ status_t MediaSync::createInputSurface(
		bufferConsumer->setMaxAcquiredBufferCount(mMaxAcquiredBufferCount);
		}
		return status;
		#endif
		}

		void MediaSync::resync_l() {
		@@ -339,7 +384,15 @@ status_t MediaSync::updateQueuedAudioData(

		void MediaSync::setName(const AString &name) {
		Mutex::Autolock lock(mMutex);
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		if (mInput) {
		mInput->setName(String8(name.c_str()));
		} else {
		ALOGE("%s with name %s called without an mInput set", __FUNCTION__, name.c_str());
		}
		#else
		mInput->setConsumerName(String8(name.c_str()));
		#endif
		}

		void MediaSync::flush() {
		@@ -621,7 +674,11 @@ void MediaSync::onFrameAvailableFromInput() {

		ALOGV("acquired buffer %#llx from input", (long long)bufferItem.mGraphicBuffer->getId());

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		status = mInput->detachBuffer(bufferItem.mGraphicBuffer);
		#else
		status = mInput->detachBuffer(bufferItem.mSlot);
		#endif
		if (status != NO_ERROR) {
		ALOGE("detaching buffer from input failed (%d)", status);
		if (status == NO_INIT) {
		@@ -634,7 +691,11 @@ void MediaSync::onFrameAvailableFromInput() {
		if (mBuffersFromInput.indexOfKey(bufferItem.mGraphicBuffer->getId()) >= 0) {
		// Something is wrong since this buffer should be at our hands, bail.
		ALOGE("received buffer multiple times from input");
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		mInput->abandon();
		#else
		mInput->consumerDisconnect();
		#endif
		onAbandoned_l(true /* isInput */);
		return;
		}
		@@ -687,7 +748,11 @@ void MediaSync::renderOneBufferItem_l(const BufferItem &bufferItem) {

		if (mBuffersSentToOutput.indexOfKey(bufferItem.mGraphicBuffer->getId()) >= 0) {
		// Something is wrong since this buffer should be held by output now, bail.
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		mInput->abandon();
		#else
		mInput->consumerDisconnect();
		#endif
		onAbandoned_l(true /* isInput */);
		return;
		}
		@@ -748,10 +813,18 @@ void MediaSync::returnBufferToInput_l(

		// Attach and release the buffer back to the input.
		int consumerSlot;
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		status_t status = mInput->attachBuffer(oldBuffer);
		#else
		status_t status = mInput->attachBuffer(&consumerSlot, oldBuffer);
		#endif
		ALOGE_IF(status != NO_ERROR, "attaching buffer to input failed (%d)", status);
		if (status == NO_ERROR) {
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		mInput->releaseBuffer(oldBuffer, fence);
		#else
		status = mInput->releaseBuffer(consumerSlot, 0 /* frameNumber */, fence);
		#endif
		ALOGE_IF(status != NO_ERROR, "releasing buffer to input failed (%d)", status);
		}

		@@ -770,7 +843,11 @@ void MediaSync::onAbandoned_l(bool isInput) {
		if (isInput) {
		mOutput->disconnect(NATIVE_WINDOW_API_MEDIA);
		} else {
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		mInput->abandon();
		#else
		mInput->consumerDisconnect();
		#endif
		}
		mIsAbandoned = true;
		}
		@@ -815,6 +892,7 @@ void MediaSync::InputListener::onFrameAvailable(const BufferItem &/* item */) {
		mSync->onFrameAvailableFromInput();
		}

		#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		// We don't care about sideband streams, since we won't relay them.
		void MediaSync::InputListener::onSidebandStreamChanged() {
		ALOGE("onSidebandStreamChanged: got sideband stream unexpectedly.");
		@@ -825,6 +903,7 @@ void MediaSync::InputListener::binderDied(const wp<IBinder> &/* who */) {
		Mutex::Autolock lock(mSync->mMutex);
		mSync->onAbandoned_l(true /* isInput */);
		}
		#endif

		MediaSync::OutputListener::OutputListener(const sp<MediaSync> &sync,
		const sp<IGraphicBufferProducer> &output)

media/libstagefright/include/media/stagefright/MediaSync.h

+23 −3

Original line number	Diff line number	Diff line
		@@ -17,7 +17,13 @@
		#ifndef MEDIA_SYNC_H
		#define MEDIA_SYNC_H

		#include <com_android_graphics_libgui_flags.h>

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		#include <gui/BufferItemConsumer.h>
		#else
		#include <gui/IConsumerListener.h>
		#endif
		#include <gui/IProducerListener.h>

		#include <media/AudioResamplerPublic.h>
		@@ -34,7 +40,9 @@ class AudioTrack;
		class BufferItem;
		class Fence;
		class GraphicBuffer;
		#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		class IGraphicBufferConsumer;
		#endif
		class IGraphicBufferProducer;
		struct MediaClock;
		struct VideoFrameScheduler;
		@@ -140,13 +148,19 @@ private:

		// This is a thin wrapper class that lets us listen to
		// IConsumerListener::onFrameAvailable from mInput.
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		class InputListener : public BufferItemConsumer::FrameAvailableListener {
		#else
		class InputListener : public IConsumerListener, public IBinder::DeathRecipient {
		#endif
		public:
		InputListener(const sp<MediaSync> &sync);
		virtual ~InputListener();

		// From IConsumerListener
		virtual void onFrameAvailable(const BufferItem &item);
		// From FrameAvailableListener
		virtual void onFrameAvailable(const BufferItem&) override;

		#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)

		// From IConsumerListener
		// We don't care about released buffers because we detach each buffer as
		@@ -160,6 +174,7 @@ private:

		// From IBinder::DeathRecipient
		virtual void binderDied(const wp<IBinder> &who);
		#endif

		private:
		sp<MediaSync> mSync;
		@@ -192,7 +207,12 @@ private:
		mutable Mutex mMutex;
		Condition mReleaseCondition;
		size_t mNumOutstandingBuffers;
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_MEDIA_MIGRATION)
		sp<BufferItemConsumer> mInput;
		sp<InputListener> mListener; // listener for mInput, so the reference isn't dropped.
		#else
		sp<IGraphicBufferConsumer> mInput;
		#endif
		sp<IGraphicBufferProducer> mOutput;
		int mUsageFlagsFromOutput;
		uint32_t mMaxAcquiredBufferCount; // max acquired buffer count