release-request-ffeef8d5-ea8d-4e3e-9efa-ff171615a565-for-git_oc-dr1-release-39... (96c0b2f9) · Commits · e / os / android_frameworks_av

camera/include/camera/ndk/NdkCameraMetadataTags.h

+5 −1

Original line number	Diff line number	Diff line
		@@ -1542,7 +1542,11 @@ typedef enum acamera_metadata_tag {
		* request A.</p>
		* <p>Note that when enableZsl is <code>true</code>, it is not guaranteed to get output images captured in the
		* past for requests with STILL_CAPTURE capture intent.</p>
		* <p>The value of enableZsl in capture templates is always <code>false</code> if present.</p>
		* <p>For applications targeting SDK versions O and newer, the value of enableZsl in
		* TEMPLATE_STILL_CAPTURE template may be <code>true</code>. The value in other templates is always
		* <code>false</code> if present.</p>
		* <p>For applications targeting SDK versions older than O, the value of enableZsl in all
		* capture templates is always <code>false</code> if present.</p>
		*
		* @see ACAMERA_CONTROL_CAPTURE_INTENT
		* @see ACAMERA_SENSOR_TIMESTAMP

drm/libmediadrm/Android.mk

+2 −12

Original line number	Diff line number	Diff line
		@@ -25,16 +25,9 @@ LOCAL_SRC_FILES += \
		IDrmClient.cpp \
		IMediaDrmService.cpp \
		MediaCasDefs.cpp \
		SharedLibrary.cpp
		ifneq ($(DISABLE_TREBLE_DRM), true)
		LOCAL_SRC_FILES += \
		SharedLibrary.cpp \
		DrmHal.cpp \
		CryptoHal.cpp
		else
		LOCAL_SRC_FILES += \
		Drm.cpp \
		Crypto.cpp
		endif

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		@@ -43,15 +36,12 @@ LOCAL_SHARED_LIBRARIES := \
		liblog \
		libmediautils \
		libstagefright_foundation \
		libutils
		ifneq ($(DISABLE_TREBLE_DRM), true)
		LOCAL_SHARED_LIBRARIES += \
		libutils \
		android.hidl.base@1.0 \
		android.hardware.drm@1.0 \
		libhidlbase \
		libhidlmemory \
		libhidltransport
		endif

		LOCAL_CFLAGS += -Werror -Wno-error=deprecated-declarations -Wall

drm/libmediadrm/Crypto.cpp

deleted100644 → 0

+0 −288

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

		//#define LOG_NDEBUG 0
		#define LOG_TAG "Crypto"
		#include <utils/Log.h>
		#include <dirent.h>
		#include <dlfcn.h>

		#include <binder/IMemory.h>
		#include <media/Crypto.h>
		#include <media/DrmPluginPath.h>
		#include <media/hardware/CryptoAPI.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/AString.h>
		#include <media/stagefright/foundation/hexdump.h>
		#include <media/stagefright/MediaErrors.h>

		namespace android {

		KeyedVector<Vector<uint8_t>, String8> Crypto::mUUIDToLibraryPathMap;
		KeyedVector<String8, wp<SharedLibrary> > Crypto::mLibraryPathToOpenLibraryMap;
		Mutex Crypto::mMapLock;

		static bool operator<(const Vector<uint8_t> &lhs, const Vector<uint8_t> &rhs) {
		if (lhs.size() < rhs.size()) {
		return true;
		} else if (lhs.size() > rhs.size()) {
		return false;
		}

		return memcmp((void )lhs.array(), (void )rhs.array(), rhs.size()) < 0;
		}

		Crypto::Crypto()
		: mInitCheck(NO_INIT),
		mFactory(NULL),
		mPlugin(NULL) {
		}

		Crypto::~Crypto() {
		delete mPlugin;
		mPlugin = NULL;
		closeFactory();
		}

		void Crypto::closeFactory() {
		delete mFactory;
		mFactory = NULL;
		mLibrary.clear();
		}

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

		/*
		* Search the plugins directory for a plugin that supports the scheme
		* specified by uuid
		*
		* If found:
		* mLibrary holds a strong pointer to the dlopen'd library
		* mFactory is set to the library's factory method
		* mInitCheck is set to OK
		*
		* If not found:
		* mLibrary is cleared and mFactory are set to NULL
		* mInitCheck is set to an error (!OK)
		*/
		void Crypto::findFactoryForScheme(const uint8_t uuid[16]) {

		closeFactory();

		// lock static maps
		Mutex::Autolock autoLock(mMapLock);

		// first check cache
		Vector<uint8_t> uuidVector;
		uuidVector.appendArray(uuid, sizeof(uuid[0]) * 16);
		ssize_t index = mUUIDToLibraryPathMap.indexOfKey(uuidVector);
		if (index >= 0) {
		if (loadLibraryForScheme(mUUIDToLibraryPathMap[index], uuid)) {
		mInitCheck = OK;
		return;
		} else {
		ALOGE("Failed to load from cached library path!");
		mInitCheck = ERROR_UNSUPPORTED;
		return;
		}
		}

		// no luck, have to search
		String8 dirPath(getDrmPluginPath());
		String8 pluginPath;

		DIR* pDir = opendir(dirPath.string());
		if (pDir) {
		struct dirent* pEntry;
		while ((pEntry = readdir(pDir))) {

		pluginPath = dirPath + "/" + pEntry->d_name;

		if (pluginPath.getPathExtension() == ".so") {

		if (loadLibraryForScheme(pluginPath, uuid)) {
		mUUIDToLibraryPathMap.add(uuidVector, pluginPath);
		mInitCheck = OK;
		closedir(pDir);
		return;
		}
		}
		}

		closedir(pDir);
		}

		// try the legacy libdrmdecrypt.so
		pluginPath = "libdrmdecrypt.so";
		if (loadLibraryForScheme(pluginPath, uuid)) {
		mUUIDToLibraryPathMap.add(uuidVector, pluginPath);
		mInitCheck = OK;
		return;
		}

		mInitCheck = ERROR_UNSUPPORTED;
		}

		bool Crypto::loadLibraryForScheme(const String8 &path, const uint8_t uuid[16]) {

		// get strong pointer to open shared library
		ssize_t index = mLibraryPathToOpenLibraryMap.indexOfKey(path);
		if (index >= 0) {
		mLibrary = mLibraryPathToOpenLibraryMap[index].promote();
		} else {
		index = mLibraryPathToOpenLibraryMap.add(path, NULL);
		}

		if (!mLibrary.get()) {
		mLibrary = new SharedLibrary(path);
		if (!*mLibrary) {
		ALOGE("loadLibraryForScheme failed:%s", mLibrary->lastError());
		return false;
		}

		mLibraryPathToOpenLibraryMap.replaceValueAt(index, mLibrary);
		}

		typedef CryptoFactory (CreateCryptoFactoryFunc)();

		CreateCryptoFactoryFunc createCryptoFactory =
		(CreateCryptoFactoryFunc)mLibrary->lookup("createCryptoFactory");

		if (createCryptoFactory == NULL \|\|
		(mFactory = createCryptoFactory()) == NULL \|\|
		!mFactory->isCryptoSchemeSupported(uuid)) {
		ALOGE("createCryptoFactory failed:%s", mLibrary->lastError());
		closeFactory();
		return false;
		}
		return true;
		}

		bool Crypto::isCryptoSchemeSupported(const uint8_t uuid[16]) {
		Mutex::Autolock autoLock(mLock);

		if (mFactory && mFactory->isCryptoSchemeSupported(uuid)) {
		return true;
		}

		findFactoryForScheme(uuid);
		return (mInitCheck == OK);
		}

		status_t Crypto::createPlugin(
		const uint8_t uuid[16], const void *data, size_t size) {
		Mutex::Autolock autoLock(mLock);

		if (mPlugin != NULL) {
		return -EINVAL;
		}

		if (!mFactory \|\| !mFactory->isCryptoSchemeSupported(uuid)) {
		findFactoryForScheme(uuid);
		}

		if (mInitCheck != OK) {
		return mInitCheck;
		}

		return mFactory->createPlugin(uuid, data, size, &mPlugin);
		}

		status_t Crypto::destroyPlugin() {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}

		if (mPlugin == NULL) {
		return -EINVAL;
		}

		delete mPlugin;
		mPlugin = NULL;

		return OK;
		}

		bool Crypto::requiresSecureDecoderComponent(const char *mime) const {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}

		if (mPlugin == NULL) {
		return -EINVAL;
		}

		return mPlugin->requiresSecureDecoderComponent(mime);
		}

		ssize_t Crypto::decrypt(const uint8_t key[16], const uint8_t iv[16],
		CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,
		const sp<IMemory> &source, size_t offset,
		const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,
		const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {

		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}

		if (mPlugin == NULL) {
		return -EINVAL;
		}

		const void srcPtr = static_cast<uint8_t >(source->pointer()) + offset;

		void *destPtr;
		bool secure = false;
		if (destination.mType == kDestinationTypeNativeHandle) {
		destPtr = static_cast<void *>(destination.mHandle);
		secure = true;
		} else {
		destPtr = destination.mSharedMemory->pointer();
		}

		ssize_t result = mPlugin->decrypt(secure, key, iv, mode, pattern, srcPtr, subSamples,
		numSubSamples, destPtr, errorDetailMsg);

		return result;
		}

		void Crypto::notifyResolution(uint32_t width, uint32_t height) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck == OK && mPlugin != NULL) {
		mPlugin->notifyResolution(width, height);
		}
		}

		status_t Crypto::setMediaDrmSession(const Vector<uint8_t> &sessionId) {
		Mutex::Autolock autoLock(mLock);

		status_t result = NO_INIT;
		if (mInitCheck == OK && mPlugin != NULL) {
		result = mPlugin->setMediaDrmSession(sessionId);
		}
		return result;
		}

		} // namespace android

drm/libmediadrm/Drm.cpp

deleted100644 → 0

+0 −799

File deleted.

Preview size limit exceeded, changes collapsed.

media/libmediametrics/MediaAnalyticsItem.cpp

+19 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@
		#include <binder/IServiceManager.h>
		#include <media/IMediaAnalyticsService.h>
		#include <media/MediaAnalyticsItem.h>
		#include <private/android_filesystem_config.h>

		namespace android {

		@@ -776,6 +777,24 @@ sp<IMediaAnalyticsService> MediaAnalyticsItem::getInstance() {
		return NULL;
		}

		// completely skip logging from certain UIDs. We do this here
		// to avoid the multi-second timeouts while we learn that
		// sepolicy will not let us find the service.
		// We do this only for a select set of UIDs
		// The sepolicy protection is still in place, we just want a faster
		// response from this specific, small set of uids.
		{
		uid_t uid = getuid();
		switch (uid) {
		case AID_RADIO: // telephony subsystem, RIL
		return NULL;
		break;
		default:
		// let sepolicy deny access if appropriate
		break;
		}
		}

		{
		Mutex::Autolock _l(sInitMutex);
		const char *badness = "";