From 1b19c9d120869c3182373a9b06a1ed98898df882 Mon Sep 17 00:00:00 2001 From: Andreas Huber Date: Wed, 29 Aug 2012 11:34:22 -0700 Subject: Preliminary support for HDCP as a binder service for wifi display support. Change-Id: Ie0de1c086c629a668d1c7863992eef56fb94157c --- include/media/IHDCP.h | 78 +++++++++++++ media/libmedia/Android.mk | 1 + media/libmedia/IHDCP.cpp | 206 +++++++++++++++++++++++++++++++++++ media/libmediaplayerservice/HDCP.cpp | 101 +++++++++++++++++ media/libmediaplayerservice/HDCP.h | 48 ++++++++ 5 files changed, 434 insertions(+) create mode 100644 include/media/IHDCP.h create mode 100644 media/libmedia/IHDCP.cpp create mode 100644 media/libmediaplayerservice/HDCP.cpp create mode 100644 media/libmediaplayerservice/HDCP.h diff --git a/include/media/IHDCP.h b/include/media/IHDCP.h new file mode 100644 index 0000000..a0613c7 --- /dev/null +++ b/include/media/IHDCP.h @@ -0,0 +1,78 @@ +/* + * 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 +#include +#include + +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 &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 { + virtual status_t onTransact( + uint32_t code, const Parcel &data, Parcel *reply, + uint32_t flags = 0); +}; + +struct BnHDCP : public BnInterface { + virtual status_t onTransact( + uint32_t code, const Parcel &data, Parcel *reply, + uint32_t flags = 0); +}; + +} // namespace android + + diff --git a/media/libmedia/Android.mk b/media/libmedia/Android.mk index c8e1dc7..bcce063 100644 --- a/media/libmedia/Android.mk +++ b/media/libmedia/Android.mk @@ -18,6 +18,7 @@ LOCAL_SRC_FILES:= \ IAudioTrack.cpp \ IAudioRecord.cpp \ ICrypto.cpp \ + IHDCP.cpp \ AudioRecord.cpp \ AudioSystem.cpp \ mediaplayer.cpp \ diff --git a/media/libmedia/IHDCP.cpp b/media/libmedia/IHDCP.cpp new file mode 100644 index 0000000..493f5a4 --- /dev/null +++ b/media/libmedia/IHDCP.cpp @@ -0,0 +1,206 @@ +/* + * 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 + +#include +#include +#include +#include + +namespace android { + +enum { + OBSERVER_NOTIFY = IBinder::FIRST_CALL_TRANSACTION, + HDCP_SET_OBSERVER, + HDCP_INIT_ASYNC, + HDCP_SHUTDOWN_ASYNC, + HDCP_ENCRYPT, +}; + +struct BpHDCPObserver : public BpInterface { + BpHDCPObserver(const sp &impl) + : BpInterface(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(obj), 0, obj->dataSize()); + } + remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY); + } +}; + +IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver"); + +struct BpHDCP : public BpInterface { + BpHDCP(const sp &impl) + : BpInterface(impl) { + } + + virtual status_t setObserver(const sp &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(&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 observer = + interface_cast(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 diff --git a/media/libmediaplayerservice/HDCP.cpp b/media/libmediaplayerservice/HDCP.cpp new file mode 100644 index 0000000..6f8a465 --- /dev/null +++ b/media/libmediaplayerservice/HDCP.cpp @@ -0,0 +1,101 @@ +/* + * 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 + +#include "HDCP.h" + +#include + +#include + +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 &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 + diff --git a/media/libmediaplayerservice/HDCP.h b/media/libmediaplayerservice/HDCP.h new file mode 100644 index 0000000..2e27689 --- /dev/null +++ b/media/libmediaplayerservice/HDCP.h @@ -0,0 +1,48 @@ +/* + * 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 + +namespace android { + +struct HDCP : public BnHDCP { + HDCP(); + virtual ~HDCP(); + + virtual status_t setObserver(const sp &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 mObserver; + + DISALLOW_EVIL_CONSTRUCTORS(HDCP); +}; + +} // namespace android + +#endif // HDCP_H_ + -- cgit v1.1