Merge "Preliminary support for HDCP as a binder service for wifi display support." into jb-mr1-dev (2231a6d8) · Commits · e / os / android_frameworks_av

include/media/IHDCP.h

0 → 100644

+78 −0

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

		#include <binder/IInterface.h>
		#include <media/hardware/HDCPAPI.h>
		#include <media/stagefright/foundation/ABase.h>

		namespace android {

		struct IHDCPObserver : public IInterface {
		DECLARE_META_INTERFACE(HDCPObserver);

		virtual void notify(
		int msg, int ext1, int ext2, const Parcel *obj) = 0;

		private:
		DISALLOW_EVIL_CONSTRUCTORS(IHDCPObserver);
		};

		struct IHDCP : public IInterface {
		DECLARE_META_INTERFACE(HDCP);

		// Called to specify the observer that receives asynchronous notifications
		// from the HDCP implementation to signal completion/failure of asynchronous
		// operations (such as initialization) or out of band events.
		virtual status_t setObserver(const sp<IHDCPObserver> &observer) = 0;

		// Request to setup an HDCP session with the specified host listening
		// on the specified port.
		virtual status_t initAsync(const char *host, unsigned port) = 0;

		// Request to shutdown the active HDCP session.
		virtual status_t shutdownAsync() = 0;

		// Encrypt a data according to the HDCP spec. The data is to be
		// encrypted in-place, only size bytes of data should be read/write,
		// even if the size is not a multiple of 128 bit (16 bytes).
		// This operation is to be synchronous, i.e. this call does not return
		// until outData contains size bytes of encrypted data.
		// streamCTR will be assigned by the caller (to 0 for the first PES stream,
		// 1 for the second and so on)
		// inputCTR will be maintained by the callee for each PES stream.
		virtual status_t encrypt(
		const void *inData, size_t size, uint32_t streamCTR,
		uint64_t outInputCTR, void outData) = 0;

		private:
		DISALLOW_EVIL_CONSTRUCTORS(IHDCP);
		};

		struct BnHDCPObserver : public BnInterface<IHDCPObserver> {
		virtual status_t onTransact(
		uint32_t code, const Parcel &data, Parcel *reply,
		uint32_t flags = 0);
		};

		struct BnHDCP : public BnInterface<IHDCP> {
		virtual status_t onTransact(
		uint32_t code, const Parcel &data, Parcel *reply,
		uint32_t flags = 0);
		};

		} // namespace android

media/libmedia/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@ LOCAL_SRC_FILES:= \
		IAudioTrack.cpp \
		IAudioRecord.cpp \
		ICrypto.cpp \
		IHDCP.cpp \
		AudioRecord.cpp \
		AudioSystem.cpp \
		mediaplayer.cpp \

media/libmedia/IHDCP.cpp

0 → 100644

+206 −0

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 "IHDCP"
		#include <utils/Log.h>

		#include <binder/Parcel.h>
		#include <media/IHDCP.h>
		#include <media/stagefright/MediaErrors.h>
		#include <media/stagefright/foundation/ADebug.h>

		namespace android {

		enum {
		OBSERVER_NOTIFY = IBinder::FIRST_CALL_TRANSACTION,
		HDCP_SET_OBSERVER,
		HDCP_INIT_ASYNC,
		HDCP_SHUTDOWN_ASYNC,
		HDCP_ENCRYPT,
		};

		struct BpHDCPObserver : public BpInterface<IHDCPObserver> {
		BpHDCPObserver(const sp<IBinder> &impl)
		: BpInterface<IHDCPObserver>(impl) {
		}

		virtual void notify(
		int msg, int ext1, int ext2, const Parcel *obj) {
		Parcel data, reply;
		data.writeInterfaceToken(IHDCPObserver::getInterfaceDescriptor());
		data.writeInt32(msg);
		data.writeInt32(ext1);
		data.writeInt32(ext2);
		if (obj && obj->dataSize() > 0) {
		data.appendFrom(const_cast<Parcel *>(obj), 0, obj->dataSize());
		}
		remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY);
		}
		};

		IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver");

		struct BpHDCP : public BpInterface<IHDCP> {
		BpHDCP(const sp<IBinder> &impl)
		: BpInterface<IHDCP>(impl) {
		}

		virtual status_t setObserver(const sp<IHDCPObserver> &observer) {
		Parcel data, reply;
		data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
		data.writeStrongBinder(observer->asBinder());
		remote()->transact(HDCP_SET_OBSERVER, data, &reply);
		return reply.readInt32();
		}

		virtual status_t initAsync(const char *host, unsigned port) {
		Parcel data, reply;
		data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
		data.writeCString(host);
		data.writeInt32(port);
		remote()->transact(HDCP_INIT_ASYNC, data, &reply);
		return reply.readInt32();
		}

		virtual status_t shutdownAsync() {
		Parcel data, reply;
		data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
		remote()->transact(HDCP_SHUTDOWN_ASYNC, data, &reply);
		return reply.readInt32();
		}

		virtual status_t encrypt(
		const void *inData, size_t size, uint32_t streamCTR,
		uint64_t outInputCTR, void outData) {
		Parcel data, reply;
		data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
		data.writeInt32(size);
		data.write(inData, size);
		data.writeInt32(streamCTR);
		remote()->transact(HDCP_ENCRYPT, data, &reply);

		status_t err = reply.readInt32();

		if (err != OK) {
		*outInputCTR = 0;

		return err;
		}

		*outInputCTR = reply.readInt64();
		reply.read(outData, size);

		return err;
		}
		};

		IMPLEMENT_META_INTERFACE(HDCP, "android.hardware.IHDCP");

		status_t BnHDCPObserver::onTransact(
		uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
		switch (code) {
		case OBSERVER_NOTIFY:
		{
		CHECK_INTERFACE(IHDCPObserver, data, reply);

		int msg = data.readInt32();
		int ext1 = data.readInt32();
		int ext2 = data.readInt32();

		Parcel obj;
		if (data.dataAvail() > 0) {
		obj.appendFrom(
		const_cast<Parcel *>(&data),
		data.dataPosition(),
		data.dataAvail());
		}

		notify(msg, ext1, ext2, &obj);

		return OK;
		}

		default:
		return BBinder::onTransact(code, data, reply, flags);
		}
		}

		status_t BnHDCP::onTransact(
		uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
		switch (code) {
		case HDCP_SET_OBSERVER:
		{
		CHECK_INTERFACE(IHDCP, data, reply);

		sp<IHDCPObserver> observer =
		interface_cast<IHDCPObserver>(data.readStrongBinder());

		reply->writeInt32(setObserver(observer));
		return OK;
		}

		case HDCP_INIT_ASYNC:
		{
		CHECK_INTERFACE(IHDCP, data, reply);

		const char *host = data.readCString();
		unsigned port = data.readInt32();

		reply->writeInt32(initAsync(host, port));
		return OK;
		}

		case HDCP_SHUTDOWN_ASYNC:
		{
		CHECK_INTERFACE(IHDCP, data, reply);

		reply->writeInt32(shutdownAsync());
		return OK;
		}

		case HDCP_ENCRYPT:
		{
		size_t size = data.readInt32();

		void inData = malloc(2 size);
		void outData = (uint8_t )inData + size;

		data.read(inData, size);

		uint32_t streamCTR = data.readInt32();
		uint64_t inputCTR;
		status_t err = encrypt(inData, size, streamCTR, &inputCTR, outData);

		reply->writeInt32(err);

		if (err == OK) {
		reply->writeInt64(inputCTR);
		reply->write(outData, size);
		}

		free(inData);
		inData = outData = NULL;

		return OK;
		}

		default:
		return BBinder::onTransact(code, data, reply, flags);
		}
		}

		} // namespace android

media/libmediaplayerservice/HDCP.cpp

0 → 100644

+101 −0

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 "HDCP"
		#include <utils/Log.h>

		#include "HDCP.h"

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

		#include <dlfcn.h>

		namespace android {

		HDCP::HDCP()
		: mLibHandle(NULL),
		mHDCPModule(NULL) {
		mLibHandle = dlopen("libstagefright_hdcp.so", RTLD_NOW);

		if (mLibHandle == NULL) {
		ALOGE("Unable to locate libstagefright_hdcp.so");
		return;
		}

		typedef HDCPModule (CreateHDCPModuleFunc)();
		CreateHDCPModuleFunc createHDCPModule =
		(CreateHDCPModuleFunc)dlsym(mLibHandle, "createHDCPModule");

		if (createHDCPModule == NULL) {
		ALOGE("Unable to find symbol 'createHDCPModule'.");
		} else if ((mHDCPModule = createHDCPModule()) == NULL) {
		ALOGE("createHDCPModule failed.");
		}
		}

		HDCP::~HDCP() {
		if (mHDCPModule != NULL) {
		delete mHDCPModule;
		mHDCPModule = NULL;
		}

		if (mLibHandle != NULL) {
		dlclose(mLibHandle);
		mLibHandle = NULL;
		}
		}

		status_t HDCP::setObserver(const sp<IHDCPObserver> &observer) {
		if (mHDCPModule == NULL) {
		return NO_INIT;
		}

		mObserver = observer;

		return OK;
		}

		status_t HDCP::initAsync(const char *host, unsigned port) {
		if (mHDCPModule == NULL) {
		return NO_INIT;
		}

		return mHDCPModule->initAsync(host, port);
		}

		status_t HDCP::shutdownAsync() {
		if (mHDCPModule == NULL) {
		return NO_INIT;
		}

		return mHDCPModule->shutdownAsync();
		}

		status_t HDCP::encrypt(
		const void *inData, size_t size, uint32_t streamCTR,
		uint64_t outInputCTR, void outData) {
		if (mHDCPModule == NULL) {
		*outInputCTR = 0;

		return NO_INIT;
		}

		return mHDCPModule->encrypt(inData, size, streamCTR, outInputCTR, outData);
		}

		} // namespace android

media/libmediaplayerservice/HDCP.h

0 → 100644

+48 −0

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

		#ifndef HDCP_H_

		#define HDCP_H_

		#include <media/IHDCP.h>

		namespace android {

		struct HDCP : public BnHDCP {
		HDCP();
		virtual ~HDCP();

		virtual status_t setObserver(const sp<IHDCPObserver> &observer);
		virtual status_t initAsync(const char *host, unsigned port);
		virtual status_t shutdownAsync();

		virtual status_t encrypt(
		const void *inData, size_t size, uint32_t streamCTR,
		uint64_t outInputCTR, void outData);

		private:
		void *mLibHandle;
		HDCPModule *mHDCPModule;
		sp<IHDCPObserver> mObserver;

		DISALLOW_EVIL_CONSTRUCTORS(HDCP);
		};

		} // namespace android

		#endif // HDCP_H_