Merge "Instead of hardcoding OMX component names in our code, support" (faf88b85) · Commits · e / os / android_frameworks_base

include/media/stagefright/ACodec.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -118,6 +118,7 @@ private:
		sp<FlushingState> mFlushingState;

		AString mComponentName;
		uint32_t mQuirks;
		sp<IOMX> mOMX;
		IOMX::node_id mNode;
		sp<MemoryDealer> mDealer[2];

include/media/stagefright/MediaCodecList.h

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2012, 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.
		*/

		#ifndef MEDIA_CODEC_LIST_H_

		#define MEDIA_CODEC_LIST_H_

		#include <media/stagefright/foundation/ABase.h>
		#include <media/stagefright/foundation/AString.h>

		#include <sys/types.h>
		#include <utils/Errors.h>
		#include <utils/KeyedVector.h>
		#include <utils/Vector.h>

		namespace android {

		struct MediaCodecList {
		static const MediaCodecList *getInstance();

		ssize_t findCodecByType(
		const char *type, bool encoder, size_t startIndex = 0) const;

		ssize_t findCodecByName(const char *name) const;

		const char *getCodecName(size_t index) const;
		bool codecHasQuirk(size_t index, const char *quirkName) const;

		private:
		enum Section {
		SECTION_TOPLEVEL,
		SECTION_DECODERS,
		SECTION_DECODER,
		SECTION_ENCODERS,
		SECTION_ENCODER,
		};

		struct CodecInfo {
		AString mName;
		bool mIsEncoder;
		uint32_t mTypes;
		uint32_t mQuirks;
		};

		static MediaCodecList *sCodecList;

		status_t mInitCheck;
		Section mCurrentSection;
		int32_t mDepth;

		Vector<CodecInfo> mCodecInfos;
		KeyedVector<AString, size_t> mCodecQuirks;
		KeyedVector<AString, size_t> mTypes;

		MediaCodecList();
		~MediaCodecList();

		status_t initCheck() const;
		void parseXMLFile(FILE *file);

		static void StartElementHandlerWrapper(
		void me, const char name, const char **attrs);

		static void EndElementHandlerWrapper(void me, const char name);

		void startElementHandler(const char name, const char *attrs);
		void endElementHandler(const char *name);

		status_t addMediaCodecFromAttributes(bool encoder, const char **attrs);
		void addMediaCodec(bool encoder, const char name, const char type = NULL);

		status_t addQuirk(const char **attrs);
		status_t addTypeFromAttributes(const char **attrs);
		void addType(const char *name);

		DISALLOW_EVIL_CONSTRUCTORS(MediaCodecList);
		};

		} // namespace android

		#endif // MEDIA_CODEC_LIST_H_

include/media/stagefright/OMXCodec.h

+25 −21

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@

		namespace android {

		struct MediaCodecList;
		class MemoryDealer;
		struct OMXCodecObserver;
		struct CodecProfileLevel;
		@@ -82,12 +83,35 @@ struct OMXCodec : public MediaSource,
		// from MediaBufferObserver
		virtual void signalBufferReturned(MediaBuffer *buffer);

		enum Quirks {
		kNeedsFlushBeforeDisable = 1,
		kWantsNALFragments = 2,
		kRequiresLoadedToIdleAfterAllocation = 4,
		kRequiresAllocateBufferOnInputPorts = 8,
		kRequiresFlushCompleteEmulation = 16,
		kRequiresAllocateBufferOnOutputPorts = 32,
		kRequiresFlushBeforeShutdown = 64,
		kDefersOutputBufferAllocation = 128,
		kDecoderLiesAboutNumberOfChannels = 256,
		kInputBufferSizesAreBogus = 512,
		kSupportsMultipleFramesPerInputBuffer = 1024,
		kAvoidMemcopyInputRecordingFrames = 2048,
		kRequiresLargerEncoderOutputBuffer = 4096,
		kOutputBuffersAreUnreadable = 8192,
		};

		// for use by ACodec
		static void findMatchingCodecs(
		const char *mime,
		bool createEncoder, const char *matchComponentName,
		uint32_t flags,
		Vector<String8> *matchingCodecs);
		Vector<String8> *matchingCodecs,
		Vector<uint32_t> *matchingCodecQuirks = NULL);

		static uint32_t getComponentQuirks(
		const MediaCodecList *list, size_t index);

		static bool findCodecQuirks(const char componentName, uint32_t quirks);

		protected:
		virtual ~OMXCodec();
		@@ -125,23 +149,6 @@ private:
		SHUTTING_DOWN,
		};

		enum Quirks {
		kNeedsFlushBeforeDisable = 1,
		kWantsNALFragments = 2,
		kRequiresLoadedToIdleAfterAllocation = 4,
		kRequiresAllocateBufferOnInputPorts = 8,
		kRequiresFlushCompleteEmulation = 16,
		kRequiresAllocateBufferOnOutputPorts = 32,
		kRequiresFlushBeforeShutdown = 64,
		kDefersOutputBufferAllocation = 128,
		kDecoderLiesAboutNumberOfChannels = 256,
		kInputBufferSizesAreBogus = 512,
		kSupportsMultipleFramesPerInputBuffer = 1024,
		kAvoidMemcopyInputRecordingFrames = 2048,
		kRequiresLargerEncoderOutputBuffer = 4096,
		kOutputBuffersAreUnreadable = 8192,
		};

		enum BufferStatus {
		OWNED_BY_US,
		OWNED_BY_COMPONENT,
		@@ -327,9 +334,6 @@ private:

		status_t configureCodec(const sp<MetaData> &meta);

		static uint32_t getComponentQuirks(
		const char *componentName, bool isEncoder);

		void restorePatchedDataPointer(BufferInfo *info);

		status_t applyRotation();

include/utils/Vector.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -186,8 +186,8 @@ public:
		inline const_iterator end() const { return array() + size(); }
		inline void reserve(size_t n) { setCapacity(n); }
		inline bool empty() const{ return isEmpty(); }
		inline void push_back(const TYPE& item) { insertAt(item, size()); }
		inline void push_front(const TYPE& item) { insertAt(item, 0); }
		inline void push_back(const TYPE& item) { insertAt(item, size(), 1); }
		inline void push_front(const TYPE& item) { insertAt(item, 0, 1); }
		inline iterator erase(iterator pos) {
		return begin() + removeItemsAt(pos-array());
		}

media/libstagefright/ACodec.cpp

+20 −11

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/AMessage.h>

		#include <media/stagefright/MediaCodecList.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/NativeWindowWrapper.h>
		#include <media/stagefright/OMXClient.h>
		@@ -328,7 +329,8 @@ private:
		////////////////////////////////////////////////////////////////////////////////

		ACodec::ACodec()
		: mNode(NULL),
		: mQuirks(0),
		mNode(NULL),
		mSentFormat(false),
		mIsEncoder(false),
		mShutdownInProgress(false) {
		@@ -427,16 +429,12 @@ status_t ACodec::allocateBuffersOnPort(OMX_U32 portIndex) {

		IOMX::buffer_id buffer;

		if (!strncasecmp(
		mComponentName.c_str(), "OMX.TI.DUCATI1.VIDEO.", 21)) {
		if (portIndex == kPortIndexInput && i == 0) {
		// Only log this warning once per allocation round.

		ALOGW("OMX.TI.DUCATI1.VIDEO.* require the use of "
		"OMX_AllocateBuffer instead of the preferred "
		"OMX_UseBuffer. Vendor must fix this.");
		}
		uint32_t requiresAllocateBufferBit =
		(portIndex == kPortIndexInput)
		? OMXCodec::kRequiresAllocateBufferOnInputPorts
		: OMXCodec::kRequiresAllocateBufferOnOutputPorts;

		if (mQuirks & requiresAllocateBufferBit) {
		err = mOMX->allocateBufferWithBackup(
		mNode, portIndex, mem, &buffer);
		} else {
		@@ -2588,12 +2586,19 @@ bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) {
		sp<IOMX> omx = client.interface();

		Vector<String8> matchingCodecs;
		Vector<uint32_t> matchingCodecQuirks;

		AString mime;

		AString componentName;
		uint32_t quirks;
		if (msg->findString("componentName", &componentName)) {
		matchingCodecs.push_back(String8(componentName.c_str()));

		if (!OMXCodec::findCodecQuirks(componentName.c_str(), &quirks)) {
		quirks = 0;
		}
		matchingCodecQuirks.push_back(quirks);
		} else {
		CHECK(msg->findString("mime", &mime));

		@@ -2607,7 +2612,8 @@ bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) {
		encoder, // createEncoder
		NULL, // matchComponentName
		0, // flags
		&matchingCodecs);
		&matchingCodecs,
		&matchingCodecQuirks);
		}

		sp<CodecObserver> observer = new CodecObserver;
		@@ -2616,6 +2622,7 @@ bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) {
		for (size_t matchIndex = 0; matchIndex < matchingCodecs.size();
		++matchIndex) {
		componentName = matchingCodecs.itemAt(matchIndex).string();
		quirks = matchingCodecQuirks.itemAt(matchIndex);

		pid_t tid = androidGetTid();
		int prevPriority = androidGetThreadPriority(tid);
		@@ -2646,6 +2653,7 @@ bool ACodec::UninitializedState::onAllocateComponent(const sp<AMessage> &msg) {
		observer->setNotificationMessage(notify);

		mCodec->mComponentName = componentName;
		mCodec->mQuirks = quirks;
		mCodec->mOMX = omx;
		mCodec->mNode = node;

		@@ -2692,6 +2700,7 @@ void ACodec::LoadedState::onShutdown(bool keepComponentAllocated) {
		mCodec->mNativeWindow.clear();
		mCodec->mNode = NULL;
		mCodec->mOMX.clear();
		mCodec->mQuirks = 0;
		mCodec->mComponentName.clear();

		mCodec->changeState(mCodec->mUninitializedState);