C API for extractor plugins (0b16447f) · Commits · e / os / android_frameworks_av

include/media/MediaExtractorPluginApi.h

0 → 100644

+91 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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_EXTRACTOR_PLUGIN_API_H_
		#define MEDIA_EXTRACTOR_PLUGIN_API_H_

		#include <utils/Errors.h> // for status_t

		namespace android {

		struct MediaTrack;
		class MetaDataBase;
		class DataSourceBase;

		extern "C" {

		struct CMediaExtractor {
		void *data;

		void (free)(void data);
		size_t (countTracks)(void data);
		MediaTrack* (getTrack)(void data, size_t index);
		status_t (*getTrackMetaData)(
		void *data,
		MetaDataBase& meta,
		size_t index, uint32_t flags);

		status_t (getMetaData)(void data, MetaDataBase& meta);
		uint32_t (flags)(void data);
		status_t (setMediaCas)(void data, const uint8_t* casToken, size_t size);
		const char * (name)(void data);
		};

		typedef CMediaExtractor* (CreatorFunc)(DataSourceBase source, void *meta);
		typedef void (FreeMetaFunc)(void meta);

		// The sniffer can optionally fill in an opaque object, "meta", that helps
		// the corresponding extractor initialize its state without duplicating
		// effort already exerted by the sniffer. If "freeMeta" is given, it will be
		// called against the opaque object when it is no longer used.
		typedef CreatorFunc (*SnifferFunc)(
		DataSourceBase source, float confidence,
		void *meta, FreeMetaFunc freeMeta);

		typedef struct {
		const uint8_t b[16];
		} media_uuid_t;

		typedef struct {
		// version number of this structure
		const uint32_t def_version;

		// A unique identifier for this extractor.
		// See below for a convenience macro to create this from a string.
		media_uuid_t extractor_uuid;

		// Version number of this extractor. When two extractors with the same
		// uuid are encountered, the one with the largest version number will
		// be used.
		const uint32_t extractor_version;

		// a human readable name
		const char *extractor_name;

		// the sniffer function
		const SnifferFunc sniff;
		} ExtractorDef;

		const uint32_t EXTRACTORDEF_VERSION = 1;

		// each plugin library exports one function of this type
		typedef ExtractorDef (*GetExtractorDef)();

		} // extern "C"

		} // namespace android

		#endif // MEDIA_EXTRACTOR_PLUGIN_API_H_

include/media/MediaExtractorPluginHelper.h

0 → 100644

+184 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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_EXTRACTOR_PLUGIN_HELPER_H_

		#define MEDIA_EXTRACTOR_PLUGIN_HELPER_H_

		#include <stdio.h>
		#include <vector>

		#include <utils/Errors.h>
		#include <utils/Log.h>
		#include <utils/RefBase.h>
		#include <media/MediaExtractorPluginApi.h>

		namespace android {

		class DataSourceBase;
		class MetaDataBase;
		struct MediaTrack;

		// extractor plugins can derive from this class which looks remarkably
		// like MediaExtractor and can be easily wrapped in the required C API
		class MediaExtractorPluginHelper
		{
		public:
		virtual ~MediaExtractorPluginHelper() {}
		virtual size_t countTracks() = 0;
		virtual MediaTrack *getTrack(size_t index) = 0;

		enum GetTrackMetaDataFlags {
		kIncludeExtensiveMetaData = 1
		};
		virtual status_t getTrackMetaData(
		MetaDataBase& meta,
		size_t index, uint32_t flags = 0) = 0;

		// Return container specific meta-data. The default implementation
		// returns an empty metadata object.
		virtual status_t getMetaData(MetaDataBase& meta) = 0;

		enum Flags {
		CAN_SEEK_BACKWARD = 1, // the "seek 10secs back button"
		CAN_SEEK_FORWARD = 2, // the "seek 10secs forward button"
		CAN_PAUSE = 4,
		CAN_SEEK = 8, // the "seek bar"
		};

		// If subclasses do _not_ override this, the default is
		// CAN_SEEK_BACKWARD \| CAN_SEEK_FORWARD \| CAN_SEEK \| CAN_PAUSE
		virtual uint32_t flags() const {
		return CAN_SEEK_BACKWARD \| CAN_SEEK_FORWARD \| CAN_SEEK \| CAN_PAUSE;
		};

		virtual status_t setMediaCas(const uint8_t* /casToken/, size_t /size/) {
		return INVALID_OPERATION;
		}

		virtual const char * name() { return "<unspecified>"; }

		protected:
		MediaExtractorPluginHelper() {}

		private:
		MediaExtractorPluginHelper(const MediaExtractorPluginHelper &);
		MediaExtractorPluginHelper &operator=(const MediaExtractorPluginHelper &);
		};

		inline CMediaExtractor wrap(MediaExtractorPluginHelper extractor) {
		CMediaExtractor wrapper = (CMediaExtractor) malloc(sizeof(CMediaExtractor));
		wrapper->data = extractor;
		wrapper->free = [](void *data) -> void {
		delete (MediaExtractorPluginHelper*)(data);
		};
		wrapper->countTracks = [](void *data) -> size_t {
		return ((MediaExtractorPluginHelper*)data)->countTracks();
		};
		wrapper->getTrack = [](void data, size_t index) -> MediaTrack {
		return ((MediaExtractorPluginHelper*)data)->getTrack(index);
		};
		wrapper->getTrackMetaData = [](
		void *data,
		MetaDataBase& meta,
		size_t index, uint32_t flags) -> status_t {
		return ((MediaExtractorPluginHelper*)data)->getTrackMetaData(meta, index, flags);
		};
		wrapper->getMetaData = [](
		void *data,
		MetaDataBase& meta) -> status_t {
		return ((MediaExtractorPluginHelper*)data)->getMetaData(meta);
		};
		wrapper->flags = [](
		void *data) -> uint32_t {
		return ((MediaExtractorPluginHelper*)data)->flags();
		};
		wrapper->setMediaCas = [](
		void data, const uint8_t casToken, size_t size) -> status_t {
		return ((MediaExtractorPluginHelper*)data)->setMediaCas(casToken, size);
		};
		wrapper->name = [](
		void data) -> const char {
		return ((MediaExtractorPluginHelper*)data)->name();
		};
		return wrapper;
		}

		// helpers to create a media_uuid_t from a string literal

		// purposely not defined anywhere so that this will fail to link if
		// expressions below are not evaluated at compile time
		int invalid_uuid_string(const char *);

		template <typename T, size_t N>
		constexpr uint8_t _digitAt_(const T (&s)[N], const size_t n) {
		return s[n] >= '0' && s[n] <= '9' ? s[n] - '0'
		: s[n] >= 'a' && s[n] <= 'f' ? s[n] - 'a' + 10
		: s[n] >= 'A' && s[n] <= 'F' ? s[n] - 'A' + 10
		: invalid_uuid_string("uuid: bad digits");
		}

		template <typename T, size_t N>
		constexpr uint8_t _hexByteAt_(const T (&s)[N], size_t n) {
		return (_digitAt_(s, n) << 4) + _digitAt_(s, n + 1);
		}

		constexpr bool _assertIsDash_(char c) {
		return c == '-' ? true : invalid_uuid_string("Wrong format");
		}

		template <size_t N>
		constexpr media_uuid_t constUUID(const char (&s) [N]) {
		static_assert(N == 37, "uuid: wrong length");
		return
		_assertIsDash_(s[8]),
		_assertIsDash_(s[13]),
		_assertIsDash_(s[18]),
		_assertIsDash_(s[23]),
		media_uuid_t {{
		_hexByteAt_(s, 0),
		_hexByteAt_(s, 2),
		_hexByteAt_(s, 4),
		_hexByteAt_(s, 6),
		_hexByteAt_(s, 9),
		_hexByteAt_(s, 11),
		_hexByteAt_(s, 14),
		_hexByteAt_(s, 16),
		_hexByteAt_(s, 19),
		_hexByteAt_(s, 21),
		_hexByteAt_(s, 24),
		_hexByteAt_(s, 26),
		_hexByteAt_(s, 28),
		_hexByteAt_(s, 30),
		_hexByteAt_(s, 32),
		_hexByteAt_(s, 34),
		}};
		}
		// Convenience macro to create a media_uuid_t from a string literal, which should
		// be formatted as "12345678-1234-1234-1234-123456789abc", as generated by
		// e.g. https://www.uuidgenerator.net/ or the 'uuidgen' linux command.
		// Hex digits may be upper or lower case.
		//
		// The macro call is otherwise equivalent to specifying the structure directly
		// (e.g. UUID("7d613858-5837-4a38-84c5-332d1cddee27") is the same as
		// {{0x7d, 0x61, 0x38, 0x58, 0x58, 0x37, 0x4a, 0x38,
		// 0x84, 0xc5, 0x33, 0x2d, 0x1c, 0xdd, 0xee, 0x27}})

		#define UUID(str) []{ constexpr media_uuid_t uuid = constUUID(str); return uuid; }()

		} // namespace android

		#endif // MEDIA_EXTRACTOR_PLUGIN_HELPER_H_

media/extractors/aac/AACExtractor.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -323,16 +323,16 @@ status_t AACSource::read(

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

		static MediaExtractor* CreateExtractor(
		static CMediaExtractor* CreateExtractor(
		DataSourceBase *source,
		void *meta) {
		off64_t offset = static_cast<off64_t>(meta);
		return new AACExtractor(source, offset);
		return wrap(new AACExtractor(source, offset));
		}

		static MediaExtractor::CreatorFunc Sniff(
		static CreatorFunc Sniff(
		DataSourceBase source, float confidence, void **meta,
		MediaExtractor::FreeMetaFunc *freeMeta) {
		FreeMetaFunc *freeMeta) {
		off64_t pos = 0;

		for (;;) {
		@@ -387,9 +387,9 @@ static MediaExtractor::CreatorFunc Sniff(
		extern "C" {
		// This is the only symbol that needs to be exported
		__attribute__ ((visibility ("default")))
		MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
		ExtractorDef GETEXTRACTORDEF() {
		return {
		MediaExtractor::EXTRACTORDEF_VERSION,
		EXTRACTORDEF_VERSION,
		UUID("4fd80eae-03d2-4d72-9eb9-48fa6bb54613"),
		1, // version
		"AAC Extractor",

media/extractors/aac/AACExtractor.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -18,7 +18,8 @@

		#define AAC_EXTRACTOR_H_

		#include <media/MediaExtractor.h>
		#include <media/MediaExtractorPluginApi.h>
		#include <media/MediaExtractorPluginHelper.h>
		#include <media/stagefright/MetaDataBase.h>

		#include <utils/Vector.h>
		@@ -28,7 +29,7 @@ namespace android {
		struct AMessage;
		class String8;

		class AACExtractor : public MediaExtractor {
		class AACExtractor : public MediaExtractorPluginHelper {
		public:
		AACExtractor(DataSourceBase *source, off64_t offset);

media/extractors/amr/AMRExtractor.cpp

+5 −5

Original line number	Diff line number	Diff line
		@@ -365,9 +365,9 @@ status_t AMRSource::read(
		extern "C" {
		// This is the only symbol that needs to be exported
		__attribute__ ((visibility ("default")))
		MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
		ExtractorDef GETEXTRACTORDEF() {
		return {
		MediaExtractor::EXTRACTORDEF_VERSION,
		EXTRACTORDEF_VERSION,
		UUID("c86639c9-2f31-40ac-a715-fa01b4493aaf"),
		1,
		"AMR Extractor",
		@@ -375,12 +375,12 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
		DataSourceBase *source,
		float *confidence,
		void **,
		MediaExtractor::FreeMetaFunc *) -> MediaExtractor::CreatorFunc {
		FreeMetaFunc *) -> CreatorFunc {
		if (SniffAMR(source, nullptr, confidence)) {
		return [](
		DataSourceBase *source,
		void ) -> MediaExtractor {
		return new AMRExtractor(source);};
		void ) -> CMediaExtractor {
		return wrap(new AMRExtractor(source));};
		}
		return NULL;
		}