Merge "Remove DRMExtractor" (c62b65fd) · Commits · e / os / android_frameworks_av

include/media/stagefright/MediaExtractor.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -72,7 +72,6 @@ protected:
		virtual ~MediaExtractor() {}

		private:
		bool mIsDrm;

		typedef bool (*SnifferFunc)(
		const sp<DataSource> &source, String8 *mimeType,

media/libstagefright/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,6 @@ LOCAL_SRC_FILES:= \
		DataConverter.cpp \
		DataSource.cpp \
		DataURISource.cpp \
		DRMExtractor.cpp \
		ESDS.cpp \
		FileSource.cpp \
		FLACExtractor.cpp \

media/libstagefright/DRMExtractor.cpp

deleted100644 → 0

+0 −305

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

		#include "include/DRMExtractor.h"

		#include <arpa/inet.h>
		#include <utils/String8.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/Utils.h>
		#include <media/stagefright/DataSource.h>
		#include <media/stagefright/MediaSource.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MetaData.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/MediaBuffer.h>

		#include <drm/drm_framework_common.h>
		#include <utils/Errors.h>


		namespace android {

		class DRMSource : public MediaSource {
		public:
		DRMSource(const sp<IMediaSource> &mediaSource,
		const sp<DecryptHandle> &decryptHandle,
		DrmManagerClient *managerClient,
		int32_t trackId, DrmBuffer *ipmpBox);

		virtual status_t start(MetaData *params = NULL);
		virtual status_t stop();
		virtual sp<MetaData> getFormat();
		virtual status_t read(
		MediaBuffer *buffer, const ReadOptions options = NULL);

		protected:
		virtual ~DRMSource();

		private:
		sp<IMediaSource> mOriginalMediaSource;
		sp<DecryptHandle> mDecryptHandle;
		DrmManagerClient* mDrmManagerClient;
		size_t mTrackId;
		mutable Mutex mDRMLock;
		size_t mNALLengthSize;
		bool mWantsNALFragments;

		DRMSource(const DRMSource &);
		DRMSource &operator=(const DRMSource &);
		};

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

		DRMSource::DRMSource(const sp<IMediaSource> &mediaSource,
		const sp<DecryptHandle> &decryptHandle,
		DrmManagerClient *managerClient,
		int32_t trackId, DrmBuffer *ipmpBox)
		: mOriginalMediaSource(mediaSource),
		mDecryptHandle(decryptHandle),
		mDrmManagerClient(managerClient),
		mTrackId(trackId),
		mNALLengthSize(0),
		mWantsNALFragments(false) {
		CHECK(mDrmManagerClient);
		mDrmManagerClient->initializeDecryptUnit(
		mDecryptHandle, trackId, ipmpBox);

		const char *mime;
		bool success = getFormat()->findCString(kKeyMIMEType, &mime);
		CHECK(success);

		if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
		uint32_t type;
		const void *data;
		size_t size;
		CHECK(getFormat()->findData(kKeyAVCC, &type, &data, &size));

		const uint8_t ptr = (const uint8_t )data;

		CHECK(size >= 7);
		CHECK_EQ(ptr[0], 1); // configurationVersion == 1

		// The number of bytes used to encode the length of a NAL unit.
		mNALLengthSize = 1 + (ptr[4] & 3);
		}
		}

		DRMSource::~DRMSource() {
		Mutex::Autolock autoLock(mDRMLock);
		mDrmManagerClient->finalizeDecryptUnit(mDecryptHandle, mTrackId);
		}

		status_t DRMSource::start(MetaData *params) {
		int32_t val;
		if (params && params->findInt32(kKeyWantsNALFragments, &val)
		&& val != 0) {
		mWantsNALFragments = true;
		} else {
		mWantsNALFragments = false;
		}

		return mOriginalMediaSource->start(params);
		}

		status_t DRMSource::stop() {
		return mOriginalMediaSource->stop();
		}

		sp<MetaData> DRMSource::getFormat() {
		return mOriginalMediaSource->getFormat();
		}

		status_t DRMSource::read(MediaBuffer *buffer, const ReadOptions options) {
		Mutex::Autolock autoLock(mDRMLock);
		status_t err;
		if ((err = mOriginalMediaSource->read(buffer, options)) != OK) {
		return err;
		}

		size_t len = (*buffer)->range_length();

		char src = (char )(buffer)->data() + (buffer)->range_offset();

		DrmBuffer encryptedDrmBuffer(src, len);
		DrmBuffer decryptedDrmBuffer;
		decryptedDrmBuffer.length = len;
		decryptedDrmBuffer.data = new char[len];
		DrmBuffer *pDecryptedDrmBuffer = &decryptedDrmBuffer;

		if ((err = mDrmManagerClient->decrypt(mDecryptHandle, mTrackId,
		&encryptedDrmBuffer, &pDecryptedDrmBuffer)) != NO_ERROR) {

		if (decryptedDrmBuffer.data) {
		delete [] decryptedDrmBuffer.data;
		decryptedDrmBuffer.data = NULL;
		}

		return err;
		}
		CHECK(pDecryptedDrmBuffer == &decryptedDrmBuffer);

		const char *mime;
		CHECK(getFormat()->findCString(kKeyMIMEType, &mime));

		if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC) && !mWantsNALFragments) {
		uint8_t dstData = (uint8_t)src;
		size_t srcOffset = 0;
		size_t dstOffset = 0;

		len = decryptedDrmBuffer.length;
		while (srcOffset < len) {
		CHECK(srcOffset + mNALLengthSize <= len);
		size_t nalLength = 0;
		const uint8_t* data = (const uint8_t*)(&decryptedDrmBuffer.data[srcOffset]);

		switch (mNALLengthSize) {
		case 1:
		nalLength = *data;
		break;
		case 2:
		nalLength = U16_AT(data);
		break;
		case 3:
		nalLength = ((size_t)data[0] << 16) \| U16_AT(&data[1]);
		break;
		case 4:
		nalLength = U32_AT(data);
		break;
		default:
		CHECK(!"Should not be here.");
		break;
		}

		srcOffset += mNALLengthSize;

		size_t end = srcOffset + nalLength;
		if (end > len \|\| end < srcOffset) {
		if (decryptedDrmBuffer.data) {
		delete [] decryptedDrmBuffer.data;
		decryptedDrmBuffer.data = NULL;
		}

		return ERROR_MALFORMED;
		}

		if (nalLength == 0) {
		continue;
		}

		if (dstOffset > SIZE_MAX - 4 \|\|
		dstOffset + 4 > SIZE_MAX - nalLength \|\|
		dstOffset + 4 + nalLength > (*buffer)->size()) {
		(*buffer)->release();
		(*buffer) = NULL;
		if (decryptedDrmBuffer.data) {
		delete [] decryptedDrmBuffer.data;
		decryptedDrmBuffer.data = NULL;
		}
		return ERROR_MALFORMED;
		}

		dstData[dstOffset++] = 0;
		dstData[dstOffset++] = 0;
		dstData[dstOffset++] = 0;
		dstData[dstOffset++] = 1;
		memcpy(&dstData[dstOffset], &decryptedDrmBuffer.data[srcOffset], nalLength);
		srcOffset += nalLength;
		dstOffset += nalLength;
		}

		CHECK_EQ(srcOffset, len);
		(buffer)->set_range((buffer)->range_offset(), dstOffset);

		} else {
		memcpy(src, decryptedDrmBuffer.data, decryptedDrmBuffer.length);
		(buffer)->set_range((buffer)->range_offset(), decryptedDrmBuffer.length);
		}

		if (decryptedDrmBuffer.data) {
		delete [] decryptedDrmBuffer.data;
		decryptedDrmBuffer.data = NULL;
		}

		return OK;
		}

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

		DRMExtractor::DRMExtractor(const sp<DataSource> &source, const char* mime)
		: mDataSource(source),
		mDecryptHandle(NULL),
		mDrmManagerClient(NULL) {
		mOriginalExtractor = MediaExtractor::Create(source, mime);
		mOriginalExtractor->getMetaData()->setInt32(kKeyIsDRM, 1);

		source->getDrmInfo(mDecryptHandle, &mDrmManagerClient);
		}

		DRMExtractor::~DRMExtractor() {
		}

		size_t DRMExtractor::countTracks() {
		return mOriginalExtractor->countTracks();
		}

		sp<IMediaSource> DRMExtractor::getTrack(size_t index) {
		sp<IMediaSource> originalMediaSource = mOriginalExtractor->getTrack(index);
		originalMediaSource->getFormat()->setInt32(kKeyIsDRM, 1);

		int32_t trackID;
		CHECK(getTrackMetaData(index, 0)->findInt32(kKeyTrackID, &trackID));

		DrmBuffer ipmpBox;
		ipmpBox.data = mOriginalExtractor->getDrmTrackInfo(trackID, &(ipmpBox.length));
		CHECK(ipmpBox.length > 0);

		return interface_cast<IMediaSource>(
		new DRMSource(originalMediaSource, mDecryptHandle, mDrmManagerClient,
		trackID, &ipmpBox));
		}

		sp<MetaData> DRMExtractor::getTrackMetaData(size_t index, uint32_t flags) {
		return mOriginalExtractor->getTrackMetaData(index, flags);
		}

		sp<MetaData> DRMExtractor::getMetaData() {
		return mOriginalExtractor->getMetaData();
		}

		bool SniffDRM(
		const sp<DataSource> &source, String8 mimeType, float confidence,
		sp<AMessage> *) {
		sp<DecryptHandle> decryptHandle = source->DrmInitialization();

		if (decryptHandle != NULL) {
		if (decryptHandle->decryptApiType == DecryptApiType::CONTAINER_BASED) {
		*mimeType = String8("drm+container_based+") + decryptHandle->mimeType;
		*confidence = 10.0f;
		} else if (decryptHandle->decryptApiType == DecryptApiType::ELEMENTARY_STREAM_BASED) {
		*mimeType = String8("drm+es_based+") + decryptHandle->mimeType;
		*confidence = 10.0f;
		} else {
		return false;
		}

		return true;
		}

		return false;
		}
		} //namespace android

media/libstagefright/MediaExtractor.cpp

+4 −23

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@
		#include "include/OggExtractor.h"
		#include "include/MPEG2PSExtractor.h"
		#include "include/MPEG2TSExtractor.h"
		#include "include/DRMExtractor.h"
		#include "include/FLACExtractor.h"
		#include "include/AACExtractor.h"
		#include "include/MidiExtractor.h"
		@@ -51,8 +50,7 @@

		namespace android {

		MediaExtractor::MediaExtractor():
		mIsDrm(false) {
		MediaExtractor::MediaExtractor() {
		if (!LOG_NDEBUG) {
		uid_t uid = getuid();
		struct passwd *pw = getpwuid(uid);
		@@ -148,23 +146,6 @@ sp<IMediaExtractor> MediaExtractor::Create(
		ALOGW("creating media extractor in calling process");
		return CreateFromService(source, mime);
		} else {
		String8 mime8;
		float confidence;
		sp<AMessage> meta;

		// Check if it's es-based DRM, since DRMExtractor needs to be created in the media server
		// process, not the extractor process.
		if (SniffDRM(source, &mime8, &confidence, &meta)) {
		const char *drmMime = mime8.string();
		ALOGV("Detected media content as '%s' with confidence %.2f", drmMime, confidence);
		if (!strncmp(drmMime, "drm+es_based+", 13)) {
		// DRMExtractor sets container metadata kKeyIsDRM to 1
		return new DRMExtractor(source, drmMime + 14);
		} else {
		mime = drmMime + 20; // get real mimetype after "drm+container_based+" prefix
		}
		}

		// remote extractor
		ALOGV("get service manager");
		sp<IBinder> binder = defaultServiceManager()->getService(String16("media.extractor"));
		@@ -187,6 +168,9 @@ sp<MediaExtractor> MediaExtractor::CreateFromService(
		ALOGV("MediaExtractor::CreateFromService %s", mime);
		RegisterDefaultSniffers();

		// initialize source decryption if needed
		source->DrmInitialization();

		sp<AMessage> meta;

		String8 tmp;
		@@ -299,9 +283,6 @@ void MediaExtractor::RegisterDefaultSniffers() {
		RegisterSniffer_l(SniffMPEG2PS);
		RegisterSniffer_l(SniffMidi);

		if (property_get_bool("drm.service.enabled", false)) {
		RegisterSniffer_l(SniffDRM);
		}
		gSniffersRegistered = true;
		}

media/libstagefright/include/DRMExtractor.h

deleted100644 → 0

+0 −64

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

		#define DRM_EXTRACTOR_H_

		#include <media/IMediaSource.h>
		#include <media/stagefright/MediaExtractor.h>
		#include <drm/DrmManagerClient.h>

		namespace android {

		struct AMessage;
		class DataSource;
		class SampleTable;
		class String8;
		class DecryptHandle;

		class DRMExtractor : public MediaExtractor {
		public:
		DRMExtractor(const sp<DataSource> &source, const char *mime);

		virtual size_t countTracks();
		virtual sp<IMediaSource> getTrack(size_t index);
		virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
		virtual sp<MetaData> getMetaData();
		virtual const char * name() { return "DRMExtractor"; }

		protected:
		virtual ~DRMExtractor();

		private:
		sp<DataSource> mDataSource;

		sp<IMediaExtractor> mOriginalExtractor;
		sp<DecryptHandle> mDecryptHandle;
		DrmManagerClient* mDrmManagerClient;

		DRMExtractor(const DRMExtractor &);
		DRMExtractor &operator=(const DRMExtractor &);
		};

		bool SniffDRM(
		const sp<DataSource> &source, String8 mimeType, float confidence,
		sp<AMessage> *);

		} // namespace android

		#endif // DRM_EXTRACTOR_H_