Merge "MediaPlayer2: Remove libdrmframework.so dependency." (edf39fae) · Commits · e / os / android_frameworks_av

media/libmediaplayer2/nuplayer2/GenericSource2.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -34,7 +34,7 @@
		#include <media/stagefright/foundation/ABuffer.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/AMessage.h>
		#include <media/stagefright/DataSourceFactory.h>
		#include <media/stagefright/ClearDataSourceFactory.h>
		#include <media/stagefright/InterfaceUtils.h>
		#include <media/stagefright/MediaBuffer.h>
		#include <media/stagefright/MediaClock.h>
		@@ -368,7 +368,7 @@ void NuPlayer2::GenericSource2::onPrepareAsync() {
		String8 contentType;

		if (!strncasecmp("http://", uri, 7) \|\| !strncasecmp("https://", uri, 8)) {
		mHttpSource = DataSourceFactory::CreateMediaHTTP(mHTTPService);
		mHttpSource = ClearDataSourceFactory::CreateMediaHTTP(mHTTPService);
		if (mHttpSource == NULL) {
		ALOGE("Failed to create http source!");
		notifyPreparedAndCleanup(UNKNOWN_ERROR);
		@@ -378,7 +378,7 @@ void NuPlayer2::GenericSource2::onPrepareAsync() {

		mLock.unlock();
		// This might take long time if connection has some issue.
		sp<DataSource> dataSource = DataSourceFactory::CreateFromURI(
		sp<DataSource> dataSource = ClearDataSourceFactory::CreateFromURI(
		mHTTPService, uri, &mUriHeaders, &contentType,
		static_cast<HTTPBase *>(mHttpSource.get()));
		mLock.lock();

media/libstagefright/Android.bp

+5 −4

Original line number	Diff line number	Diff line
		@@ -105,6 +105,7 @@ cc_library_shared {
		"DataConverter.cpp",
		"DataSourceFactory.cpp",
		"DataURISource.cpp",
		"ClearFileSource.cpp",
		"FileSource.cpp",
		"FrameDecoder.cpp",
		"HTTPBase.cpp",
		@@ -121,6 +122,7 @@ cc_library_shared {
		"MediaCodecSource.cpp",
		"MediaExtractorFactory.cpp",
		"MediaSync.cpp",
		"http/ClearMediaHTTP.cpp",
		"http/MediaHTTP.cpp",
		"MediaMuxer.cpp",
		"NuCachedSource2.cpp",
		@@ -232,9 +234,9 @@ cc_library {
		srcs: [
		"CallbackDataSource.cpp",
		"CallbackMediaSource.cpp",
		"DataSourceFactory.cpp",
		"ClearDataSourceFactory.cpp",
		"ClearFileSource.cpp",
		"DataURISource.cpp",
		"FileSource.cpp",
		"HTTPBase.cpp",
		"HevcUtils.cpp",
		"InterfaceUtils.cpp",
		@@ -246,13 +248,12 @@ cc_library {
		"RemoteMediaSource.cpp",
		"Utils.cpp",
		"VideoFrameScheduler.cpp",
		"http/MediaHTTP.cpp",
		"http/ClearMediaHTTP.cpp",
		],

		shared_libs: [
		"libbinder",
		"libcutils",
		"libdrmframework",
		"libgui",
		"liblog",
		"libmedia_player2_util",

media/libstagefright/ClearDataSourceFactory.cpp

0 → 100644

+117 −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.
		*/
		//#define LOG_NDEBUG 0
		#define LOG_TAG "ClearDataSourceFactory"

		#include "include/HTTPBase.h"
		#include "include/NuCachedSource2.h"

		#include <media/MediaHTTPConnection.h>
		#include <media/MediaHTTPService.h>
		#include <media/stagefright/ClearFileSource.h>
		#include <media/stagefright/ClearMediaHTTP.h>
		#include <media/stagefright/ClearDataSourceFactory.h>
		#include <media/stagefright/DataURISource.h>
		#include <utils/String8.h>

		namespace android {

		// static
		sp<DataSource> ClearDataSourceFactory::CreateFromURI(
		const sp<MediaHTTPService> &httpService,
		const char *uri,
		const KeyedVector<String8, String8> *headers,
		String8 *contentType,
		HTTPBase *httpSource) {
		if (contentType != NULL) {
		*contentType = "";
		}

		sp<DataSource> source;
		if (!strncasecmp("file://", uri, 7)) {
		source = new ClearFileSource(uri + 7);
		} else if (!strncasecmp("http://", uri, 7) \|\| !strncasecmp("https://", uri, 8)) {
		if (httpService == NULL) {
		ALOGE("Invalid http service!");
		return NULL;
		}

		if (httpSource == NULL) {
		sp<MediaHTTPConnection> conn = httpService->makeHTTPConnection();
		if (conn == NULL) {
		ALOGE("Failed to make http connection from http service!");
		return NULL;
		}
		httpSource = new ClearMediaHTTP(conn);
		}

		String8 cacheConfig;
		bool disconnectAtHighwatermark = false;
		KeyedVector<String8, String8> nonCacheSpecificHeaders;
		if (headers != NULL) {
		nonCacheSpecificHeaders = *headers;
		NuCachedSource2::RemoveCacheSpecificHeaders(
		&nonCacheSpecificHeaders,
		&cacheConfig,
		&disconnectAtHighwatermark);
		}

		if (httpSource->connect(uri, &nonCacheSpecificHeaders) != OK) {
		ALOGE("Failed to connect http source!");
		return NULL;
		}

		if (contentType != NULL) {
		*contentType = httpSource->getMIMEType();
		}

		source = NuCachedSource2::Create(
		httpSource,
		cacheConfig.isEmpty() ? NULL : cacheConfig.string(),
		disconnectAtHighwatermark);
		} else if (!strncasecmp("data:", uri, 5)) {
		source = DataURISource::Create(uri);
		} else {
		// Assume it's a filename.
		source = new ClearFileSource(uri);
		}

		if (source == NULL \|\| source->initCheck() != OK) {
		return NULL;
		}

		return source;
		}

		sp<DataSource> ClearDataSourceFactory::CreateFromFd(int fd, int64_t offset, int64_t length) {
		sp<ClearFileSource> source = new ClearFileSource(fd, offset, length);
		return source->initCheck() != OK ? nullptr : source;
		}

		sp<DataSource> ClearDataSourceFactory::CreateMediaHTTP(const sp<MediaHTTPService> &httpService) {
		if (httpService == NULL) {
		return NULL;
		}

		sp<MediaHTTPConnection> conn = httpService->makeHTTPConnection();
		if (conn == NULL) {
		return NULL;
		} else {
		return new ClearMediaHTTP(conn);
		}
		}

		} // namespace android

media/libstagefright/ClearFileSource.cpp

0 → 100644

+143 −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.
		*/

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

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/ClearFileSource.h>
		#include <media/stagefright/Utils.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/libstagefright/FileSource.cpp

+5 −89

Original line number	Diff line number	Diff line
		@@ -22,90 +22,28 @@
		#include <media/stagefright/FileSource.h>
		#include <media/stagefright/Utils.h>
		#include <private/android_filesystem_config.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)
		: mFd(-1),
		mOffset(0),
		mLength(-1),
		mName("<null>"),
		: ClearFileSource(filename),
		mDecryptHandle(NULL),
		mDrmManagerClient(NULL),
		mDrmBufOffset(0),
		mDrmBufSize(0),
		mDrmBuf(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));
		}
		}

		FileSource::FileSource(int fd, int64_t offset, int64_t length)
		: mFd(fd),
		mOffset(offset),
		mLength(length),
		mName("<null>"),
		: ClearFileSource(fd, offset, length),
		mDecryptHandle(NULL),
		mDrmManagerClient(NULL),
		mDrmBufOffset(0),
		mDrmBufSize(0),
		mDrmBuf(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);

		}

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

		if (mDrmBuf != NULL) {
		delete[] mDrmBuf;
		mDrmBuf = NULL;
		@@ -124,10 +62,6 @@ FileSource::~FileSource() {
		}
		}

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

		ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {
		if (mFd < 0) {
		return NO_INIT;
		@@ -147,28 +81,10 @@ ssize_t FileSource::readAt(off64_t offset, void *data, size_t size) {

		if (mDecryptHandle != NULL && DecryptApiType::CONTAINER_BASED
		== mDecryptHandle->decryptApiType) {
		return readAtDRM(offset, data, size);
		return readAtDRM_l(offset, data, size);
		} else {
		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 readAt_l(offset, data, size);
		}

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

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

		if (mFd < 0) {
		return NO_INIT;
		}

		*size = mLength;

		return OK;
		}

		sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) {
		@@ -194,7 +110,7 @@ sp<DecryptHandle> FileSource::DrmInitialization(const char *mime) {
		return mDecryptHandle;
		}

		ssize_t FileSource::readAtDRM(off64_t offset, void *data, size_t size) {
		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];