Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9c6f7908 authored Oct 14, 2019 by Dongwon Kang

Remove libdrmframework.so dependency from libdatasource.so

Name changes:
ClearFileSource -> FileSource
ClearMediaHTTP -> MediaHTTP
FileSource -> PlayerServiceFileSource
MediaHTTP -> PlayerServiceMediaHTTP

PlayerServiceXXX are able to handle OMA(forward-lock) files and now
moved to media/libmediaplayerservice/datasource since they only work
on mediaserver process.

Bug: 142567168
Test: build and DrmTest

Change-Id: I9292dba33d149efe17cf566017dcce1710cc8c88

parent 79b0c24b

media/libdatasource/Android.bp

+0 −3

Original line number	Diff line number	Diff line
		@@ -2,8 +2,6 @@ cc_library {
		name: "libdatasource",

		srcs: [
		"ClearFileSource.cpp",
		"ClearMediaHTTP.cpp",
		"DataSourceFactory.cpp",
		"DataURISource.cpp",
		"FileSource.cpp",
		@@ -31,7 +29,6 @@ cc_library {
		shared_libs: [
		"liblog",
		"libcutils",
		"libdrmframework",
		"libutils",
		"libstagefright_foundation",
		"libdl",

media/libdatasource/ClearFileSource.cpp

deleted100644 → 0

+0 −143

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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "ClearFileSource"
		#include <utils/Log.h>

		#include <datasource/ClearFileSource.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/FoundationUtils.h>
		#include <sys/types.h>
		#include <unistd.h>
		#include <sys/types.h>
		#include <sys/stat.h>
		#include <fcntl.h>

		namespace android {

		ClearFileSource::ClearFileSource(const char *filename)
		: mFd(-1),
		mOffset(0),
		mLength(-1),
		mName("<null>") {

		if (filename) {
		mName = String8::format("FileSource(%s)", filename);
		}
		ALOGV("%s", filename);
		mFd = open(filename, O_LARGEFILE \| O_RDONLY);

		if (mFd >= 0) {
		mLength = lseek64(mFd, 0, SEEK_END);
		} else {
		ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));
		}
		}

		ClearFileSource::ClearFileSource(int fd, int64_t offset, int64_t length)
		: mFd(fd),
		mOffset(offset),
		mLength(length),
		mName("<null>") {
		ALOGV("fd=%d (%s), offset=%lld, length=%lld",
		fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);

		if (mOffset < 0) {
		mOffset = 0;
		}
		if (mLength < 0) {
		mLength = 0;
		}
		if (mLength > INT64_MAX - mOffset) {
		mLength = INT64_MAX - mOffset;
		}
		struct stat s;
		if (fstat(fd, &s) == 0) {
		if (mOffset > s.st_size) {
		mOffset = s.st_size;
		mLength = 0;
		}
		if (mOffset + mLength > s.st_size) {
		mLength = s.st_size - mOffset;
		}
		}
		if (mOffset != offset \|\| mLength != length) {
		ALOGW("offset/length adjusted from %lld/%lld to %lld/%lld",
		(long long) offset, (long long) length,
		(long long) mOffset, (long long) mLength);
		}

		mName = String8::format(
		"FileSource(fd(%s), %lld, %lld)",
		nameForFd(fd).c_str(),
		(long long) mOffset,
		(long long) mLength);

		}

		ClearFileSource::~ClearFileSource() {
		if (mFd >= 0) {
		::close(mFd);
		mFd = -1;
		}
		}

		status_t ClearFileSource::initCheck() const {
		return mFd >= 0 ? OK : NO_INIT;
		}

		ssize_t ClearFileSource::readAt(off64_t offset, void *data, size_t size) {
		if (mFd < 0) {
		return NO_INIT;
		}

		Mutex::Autolock autoLock(mLock);
		if (mLength >= 0) {
		if (offset >= mLength) {
		return 0; // read beyond EOF.
		}
		uint64_t numAvailable = mLength - offset;
		if ((uint64_t)size > numAvailable) {
		size = numAvailable;
		}
		}
		return readAt_l(offset, data, size);
		}

		ssize_t ClearFileSource::readAt_l(off64_t offset, void *data, size_t size) {
		off64_t result = lseek64(mFd, offset + mOffset, SEEK_SET);
		if (result == -1) {
		ALOGE("seek to %lld failed", (long long)(offset + mOffset));
		return UNKNOWN_ERROR;
		}

		return ::read(mFd, data, size);
		}

		status_t ClearFileSource::getSize(off64_t *size) {
		Mutex::Autolock autoLock(mLock);

		if (mFd < 0) {
		return NO_INIT;
		}

		*size = mLength;

		return OK;
		}

		} // namespace android

media/libdatasource/ClearMediaHTTP.cpp

deleted100644 → 0

+0 −184

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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "ClearMediaHTTP"
		#include <utils/Log.h>

		#include <datasource/ClearMediaHTTP.h>

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/ALooper.h>
		#include <media/stagefright/FoundationUtils.h>

		#include <media/MediaHTTPConnection.h>

		namespace android {

		ClearMediaHTTP::ClearMediaHTTP(const sp<MediaHTTPConnection> &conn)
		: mInitCheck((conn != NULL) ? OK : NO_INIT),
		mHTTPConnection(conn),
		mCachedSizeValid(false),
		mCachedSize(0ll) {
		}

		ClearMediaHTTP::~ClearMediaHTTP() {
		}

		status_t ClearMediaHTTP::connect(
		const char *uri,
		const KeyedVector<String8, String8> *headers,
		off64_t /* offset */) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		KeyedVector<String8, String8> extHeaders;
		if (headers != NULL) {
		extHeaders = *headers;
		}

		if (extHeaders.indexOfKey(String8("User-Agent")) < 0) {
		extHeaders.add(String8("User-Agent"), String8(MakeUserAgent().c_str()));
		}

		mLastURI = uri;
		// reconnect() calls with uri == old mLastURI.c_str(), which gets zapped
		// as part of the above assignment. Ensure no accidental later use.
		uri = NULL;

		bool success = mHTTPConnection->connect(mLastURI.c_str(), &extHeaders);

		mLastHeaders = extHeaders;

		mCachedSizeValid = false;

		if (success) {
		AString sanitized = uriDebugString(mLastURI);
		mName = String8::format("ClearMediaHTTP(%s)", sanitized.c_str());
		}

		return success ? OK : UNKNOWN_ERROR;
		}

		void ClearMediaHTTP::close() {
		disconnect();
		}

		void ClearMediaHTTP::disconnect() {
		mName = String8("ClearMediaHTTP(<disconnected>)");
		if (mInitCheck != OK) {
		return;
		}

		mHTTPConnection->disconnect();
		}

		status_t ClearMediaHTTP::initCheck() const {
		return mInitCheck;
		}

		ssize_t ClearMediaHTTP::readAt(off64_t offset, void *data, size_t size) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		int64_t startTimeUs = ALooper::GetNowUs();

		size_t numBytesRead = 0;
		while (numBytesRead < size) {
		size_t copy = size - numBytesRead;

		if (copy > 64 * 1024) {
		// limit the buffer sizes transferred across binder boundaries
		// to avoid spurious transaction failures.
		copy = 64 * 1024;
		}

		ssize_t n = mHTTPConnection->readAt(
		offset + numBytesRead, (uint8_t *)data + numBytesRead, copy);

		if (n < 0) {
		return n;
		} else if (n == 0) {
		break;
		}

		numBytesRead += n;
		}

		int64_t delayUs = ALooper::GetNowUs() - startTimeUs;

		addBandwidthMeasurement(numBytesRead, delayUs);

		return numBytesRead;
		}

		status_t ClearMediaHTTP::getSize(off64_t *size) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		// Caching the returned size so that it stays valid even after a
		// disconnect. NuCachedSource2 relies on this.

		if (!mCachedSizeValid) {
		mCachedSize = mHTTPConnection->getSize();
		mCachedSizeValid = true;
		}

		*size = mCachedSize;

		return size < 0 ? size : static_cast<status_t>(OK);
		}

		uint32_t ClearMediaHTTP::flags() {
		return kWantsPrefetching \| kIsHTTPBasedSource;
		}

		status_t ClearMediaHTTP::reconnectAtOffset(off64_t offset) {
		return connect(mLastURI.c_str(), &mLastHeaders, offset);
		}


		String8 ClearMediaHTTP::getUri() {
		if (mInitCheck != OK) {
		return String8::empty();
		}

		String8 uri;
		if (OK == mHTTPConnection->getUri(&uri)) {
		return uri;
		}
		return String8(mLastURI.c_str());
		}

		String8 ClearMediaHTTP::getMIMEType() const {
		if (mInitCheck != OK) {
		return String8("application/octet-stream");
		}

		String8 mimeType;
		status_t err = mHTTPConnection->getMIMEType(&mimeType);

		if (err != OK) {
		return String8("application/octet-stream");
		}

		return mimeType;
		}

		} // namespace android

media/libdatasource/FileSource.cpp

+81 −93

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		* 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.
		@@ -20,45 +20,84 @@

		#include <datasource/FileSource.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <private/android_filesystem_config.h>
		#include <media/stagefright/FoundationUtils.h>
		#include <sys/types.h>
		#include <unistd.h>
		#include <sys/types.h>
		#include <sys/stat.h>
		#include <fcntl.h>

		namespace android {

		FileSource::FileSource(const char *filename)
		: ClearFileSource(filename),
		mDecryptHandle(NULL),
		mDrmManagerClient(NULL),
		mDrmBufOffset(0),
		mDrmBufSize(0),
		mDrmBuf(NULL){
		: mFd(-1),
		mOffset(0),
		mLength(-1),
		mName("<null>") {

		if (filename) {
		mName = String8::format("FileSource(%s)", filename);
		}
		ALOGV("%s", filename);
		mFd = open(filename, O_LARGEFILE \| O_RDONLY);

		FileSource::FileSource(int fd, int64_t offset, int64_t length)
		: ClearFileSource(fd, offset, length),
		mDecryptHandle(NULL),
		mDrmManagerClient(NULL),
		mDrmBufOffset(0),
		mDrmBufSize(0),
		mDrmBuf(NULL) {
		if (mFd >= 0) {
		mLength = lseek64(mFd, 0, SEEK_END);
		} else {
		ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));
		}
		}

		FileSource::~FileSource() {
		if (mDrmBuf != NULL) {
		delete[] mDrmBuf;
		mDrmBuf = NULL;
		FileSource::FileSource(int fd, int64_t offset, int64_t length)
		: mFd(fd),
		mOffset(offset),
		mLength(length),
		mName("<null>") {
		ALOGV("fd=%d (%s), offset=%lld, length=%lld",
		fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);

		if (mOffset < 0) {
		mOffset = 0;
		}
		if (mLength < 0) {
		mLength = 0;
		}
		if (mLength > INT64_MAX - mOffset) {
		mLength = INT64_MAX - mOffset;
		}
		struct stat s;
		if (fstat(fd, &s) == 0) {
		if (mOffset > s.st_size) {
		mOffset = s.st_size;
		mLength = 0;
		}
		if (mOffset + mLength > s.st_size) {
		mLength = s.st_size - mOffset;
		}
		}
		if (mOffset != offset \|\| mLength != length) {
		ALOGW("offset/length adjusted from %lld/%lld to %lld/%lld",
		(long long) offset, (long long) length,
		(long long) mOffset, (long long) mLength);
		}

		mName = String8::format(
		"FileSource(fd(%s), %lld, %lld)",
		nameForFd(fd).c_str(),
		(long long) mOffset,
		(long long) mLength);

		if (mDecryptHandle != NULL) {
		// To release mDecryptHandle
		CHECK(mDrmManagerClient);
		mDrmManagerClient->closeDecryptSession(mDecryptHandle);
		mDecryptHandle = NULL;
		}

		if (mDrmManagerClient != NULL) {
		delete mDrmManagerClient;
		mDrmManagerClient = NULL;
		FileSource::~FileSource() {
		if (mFd >= 0) {
		::close(mFd);
		mFd = -1;
		}
		}

		status_t FileSource::initCheck() const {
		return mFd >= 0 ? OK : NO_INIT;
		}

		ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {
		@@ -67,7 +106,6 @@ ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {
		}

		Mutex::Autolock autoLock(mLock);

		if (mLength >= 0) {
		if (offset >= mLength) {
		return 0; // read beyond EOF.
		@@ -77,79 +115,29 @@ ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {
		size = numAvailable;
		}
		}

		if (mDecryptHandle != NULL && DecryptApiType::CONTAINER_BASED
		== mDecryptHandle->decryptApiType) {
		return readAtDRM_l(offset, data, size);
		} else {
		return readAt_l(offset, data, size);
		}
		}

		sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) {
		if (getuid() == AID_MEDIA_EX) return nullptr; // no DRM in media extractor
		if (mDrmManagerClient == NULL) {
		mDrmManagerClient = new DrmManagerClient();
		}

		if (mDrmManagerClient == NULL) {
		return NULL;
		ssize_t FileSource::readAt_l(off64_t offset, void *data, size_t size) {
		off64_t result = lseek64(mFd, offset + mOffset, SEEK_SET);
		if (result == -1) {
		ALOGE("seek to %lld failed", (long long)(offset + mOffset));
		return UNKNOWN_ERROR;
		}

		if (mDecryptHandle == NULL) {
		mDecryptHandle = mDrmManagerClient->openDecryptSession(
		mFd, mOffset, mLength, mime);
		return ::read(mFd, data, size);
		}

		if (mDecryptHandle == NULL) {
		delete mDrmManagerClient;
		mDrmManagerClient = NULL;
		}

		return mDecryptHandle;
		}
		status_t FileSource::getSize(off64_t *size) {
		Mutex::Autolock autoLock(mLock);

		ssize_t FileSource::readAtDRM_l(off64_t offset, void *data, size_t size) {
		size_t DRM_CACHE_SIZE = 1024;
		if (mDrmBuf == NULL) {
		mDrmBuf = new unsigned char[DRM_CACHE_SIZE];
		if (mFd < 0) {
		return NO_INIT;
		}

		if (mDrmBuf != NULL && mDrmBufSize > 0 && (offset + mOffset) >= mDrmBufOffset
		&& (offset + mOffset + size) <= static_cast<size_t>(mDrmBufOffset + mDrmBufSize)) {
		/* Use buffered data */
		memcpy(data, (void*)(mDrmBuf+(offset+mOffset-mDrmBufOffset)), size);
		return size;
		} else if (size <= DRM_CACHE_SIZE) {
		/* Buffer new data */
		mDrmBufOffset = offset + mOffset;
		mDrmBufSize = mDrmManagerClient->pread(mDecryptHandle, mDrmBuf,
		DRM_CACHE_SIZE, offset + mOffset);
		if (mDrmBufSize > 0) {
		int64_t dataRead = 0;
		dataRead = size > static_cast<size_t>(mDrmBufSize) ? mDrmBufSize : size;
		memcpy(data, (void*)mDrmBuf, dataRead);
		return dataRead;
		} else {
		return mDrmBufSize;
		}
		} else {
		/* Too big chunk to cache. Call DRM directly */
		return mDrmManagerClient->pread(mDecryptHandle, data, size, offset + mOffset);
		}
		}
		*size = mLength;

		/* static */
		bool FileSource::requiresDrm(int fd, int64_t offset, int64_t length, const char *mime) {
		std::unique_ptr<DrmManagerClient> drmClient(new DrmManagerClient());
		sp<DecryptHandle> decryptHandle =
		drmClient->openDecryptSession(fd, offset, length, mime);
		bool requiresDrm = false;
		if (decryptHandle != nullptr) {
		requiresDrm = decryptHandle->decryptApiType == DecryptApiType::CONTAINER_BASED;
		drmClient->closeDecryptSession(decryptHandle);
		}
		return requiresDrm;
		return OK;
		}

		} // namespace android

media/libdatasource/MediaHTTP.cpp

+134 −24

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 The Android Open Source Project
		* 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.
		@@ -20,7 +20,6 @@

		#include <datasource/MediaHTTP.h>

		#include <binder/IServiceManager.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/ALooper.h>
		#include <media/stagefright/FoundationUtils.h>
		@@ -30,45 +29,156 @@
		namespace android {

		MediaHTTP::MediaHTTP(const sp<MediaHTTPConnection> &conn)
		: ClearMediaHTTP(conn),
		mDrmManagerClient(NULL) {
		: mInitCheck((conn != NULL) ? OK : NO_INIT),
		mHTTPConnection(conn),
		mCachedSizeValid(false),
		mCachedSize(0ll) {
		}

		MediaHTTP::~MediaHTTP() {
		clearDRMState_l();
		}

		// DRM...
		status_t MediaHTTP::connect(
		const char *uri,
		const KeyedVector<String8, String8> *headers,
		off64_t /* offset */) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		KeyedVector<String8, String8> extHeaders;
		if (headers != NULL) {
		extHeaders = *headers;
		}

		if (extHeaders.indexOfKey(String8("User-Agent")) < 0) {
		extHeaders.add(String8("User-Agent"), String8(MakeUserAgent().c_str()));
		}

		mLastURI = uri;
		// reconnect() calls with uri == old mLastURI.c_str(), which gets zapped
		// as part of the above assignment. Ensure no accidental later use.
		uri = NULL;

		bool success = mHTTPConnection->connect(mLastURI.c_str(), &extHeaders);

		mLastHeaders = extHeaders;

		mCachedSizeValid = false;

		if (success) {
		AString sanitized = uriDebugString(mLastURI);
		mName = String8::format("MediaHTTP(%s)", sanitized.c_str());
		}

		return success ? OK : UNKNOWN_ERROR;
		}

		void MediaHTTP::close() {
		disconnect();
		}

		void MediaHTTP::disconnect() {
		mName = String8("MediaHTTP(<disconnected>)");
		if (mInitCheck != OK) {
		return;
		}

		mHTTPConnection->disconnect();
		}

		status_t MediaHTTP::initCheck() const {
		return mInitCheck;
		}

		ssize_t MediaHTTP::readAt(off64_t offset, void *data, size_t size) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		int64_t startTimeUs = ALooper::GetNowUs();

		sp<DecryptHandle> MediaHTTP::DrmInitialization(const char* mime) {
		if (mDrmManagerClient == NULL) {
		mDrmManagerClient = new DrmManagerClient();
		size_t numBytesRead = 0;
		while (numBytesRead < size) {
		size_t copy = size - numBytesRead;

		if (copy > 64 * 1024) {
		// limit the buffer sizes transferred across binder boundaries
		// to avoid spurious transaction failures.
		copy = 64 * 1024;
		}

		ssize_t n = mHTTPConnection->readAt(
		offset + numBytesRead, (uint8_t *)data + numBytesRead, copy);

		if (n < 0) {
		return n;
		} else if (n == 0) {
		break;
		}

		numBytesRead += n;
		}

		int64_t delayUs = ALooper::GetNowUs() - startTimeUs;

		addBandwidthMeasurement(numBytesRead, delayUs);

		return numBytesRead;
		}

		status_t MediaHTTP::getSize(off64_t *size) {
		if (mInitCheck != OK) {
		return mInitCheck;
		}

		if (mDrmManagerClient == NULL) {
		return NULL;
		// Caching the returned size so that it stays valid even after a
		// disconnect. NuCachedSource2 relies on this.

		if (!mCachedSizeValid) {
		mCachedSize = mHTTPConnection->getSize();
		mCachedSizeValid = true;
		}

		*size = mCachedSize;

		return size < 0 ? size : static_cast<status_t>(OK);
		}

		uint32_t MediaHTTP::flags() {
		return kWantsPrefetching \| kIsHTTPBasedSource;
		}

		if (mDecryptHandle == NULL) {
		mDecryptHandle = mDrmManagerClient->openDecryptSession(
		String8(mLastURI.c_str()), mime);
		status_t MediaHTTP::reconnectAtOffset(off64_t offset) {
		return connect(mLastURI.c_str(), &mLastHeaders, offset);
		}

		if (mDecryptHandle == NULL) {
		delete mDrmManagerClient;
		mDrmManagerClient = NULL;

		String8 MediaHTTP::getUri() {
		if (mInitCheck != OK) {
		return String8::empty();
		}

		String8 uri;
		if (OK == mHTTPConnection->getUri(&uri)) {
		return uri;
		}
		return String8(mLastURI.c_str());
		}

		return mDecryptHandle;
		String8 MediaHTTP::getMIMEType() const {
		if (mInitCheck != OK) {
		return String8("application/octet-stream");
		}

		void MediaHTTP::clearDRMState_l() {
		if (mDecryptHandle != NULL) {
		// To release mDecryptHandle
		CHECK(mDrmManagerClient);
		mDrmManagerClient->closeDecryptSession(mDecryptHandle);
		mDecryptHandle = NULL;
		String8 mimeType;
		status_t err = mHTTPConnection->getMIMEType(&mimeType);

		if (err != OK) {
		return String8("application/octet-stream");
		}

		return mimeType;
		}

		} // namespace android