IHDCP.cpp revision 279dcd89ab1d2de91dfe95e461412a0f577a6891 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define LOG_NDEBUG 0
18#define LOG_TAG "IHDCP"
19#include <utils/Log.h>
20
21#include <binder/Parcel.h>
22#include <media/IHDCP.h>
23#include <media/stagefright/MediaErrors.h>
24#include <media/stagefright/foundation/ADebug.h>
25
26namespace android {
27
28enum {
29    OBSERVER_NOTIFY = IBinder::FIRST_CALL_TRANSACTION,
30    HDCP_SET_OBSERVER,
31    HDCP_INIT_ASYNC,
32    HDCP_SHUTDOWN_ASYNC,
33    HDCP_ENCRYPT,
34    HDCP_DECRYPT,
35};
36
37struct BpHDCPObserver : public BpInterface<IHDCPObserver> {
38    BpHDCPObserver(const sp<IBinder> &impl)
39        : BpInterface<IHDCPObserver>(impl) {
40    }
41
42    virtual void notify(
43            int msg, int ext1, int ext2, const Parcel *obj) {
44        Parcel data, reply;
45        data.writeInterfaceToken(IHDCPObserver::getInterfaceDescriptor());
46        data.writeInt32(msg);
47        data.writeInt32(ext1);
48        data.writeInt32(ext2);
49        if (obj && obj->dataSize() > 0) {
50            data.appendFrom(const_cast<Parcel *>(obj), 0, obj->dataSize());
51        }
52        remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY);
53    }
54};
55
56IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver");
57
58struct BpHDCP : public BpInterface<IHDCP> {
59    BpHDCP(const sp<IBinder> &impl)
60        : BpInterface<IHDCP>(impl) {
61    }
62
63    virtual status_t setObserver(const sp<IHDCPObserver> &observer) {
64        Parcel data, reply;
65        data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
66        data.writeStrongBinder(observer->asBinder());
67        remote()->transact(HDCP_SET_OBSERVER, data, &reply);
68        return reply.readInt32();
69    }
70
71    virtual status_t initAsync(const char *host, unsigned port) {
72        Parcel data, reply;
73        data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
74        data.writeCString(host);
75        data.writeInt32(port);
76        remote()->transact(HDCP_INIT_ASYNC, data, &reply);
77        return reply.readInt32();
78    }
79
80    virtual status_t shutdownAsync() {
81        Parcel data, reply;
82        data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
83        remote()->transact(HDCP_SHUTDOWN_ASYNC, data, &reply);
84        return reply.readInt32();
85    }
86
87    virtual status_t encrypt(
88            const void *inData, size_t size, uint32_t streamCTR,
89            uint64_t *outInputCTR, void *outData) {
90        Parcel data, reply;
91        data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
92        data.writeInt32(size);
93        data.write(inData, size);
94        data.writeInt32(streamCTR);
95        remote()->transact(HDCP_ENCRYPT, data, &reply);
96
97        status_t err = reply.readInt32();
98
99        if (err != OK) {
100            *outInputCTR = 0;
101
102            return err;
103        }
104
105        *outInputCTR = reply.readInt64();
106        reply.read(outData, size);
107
108        return err;
109    }
110
111    virtual status_t decrypt(
112            const void *inData, size_t size,
113            uint32_t streamCTR, uint64_t inputCTR,
114            void *outData) {
115        Parcel data, reply;
116        data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
117        data.writeInt32(size);
118        data.write(inData, size);
119        data.writeInt32(streamCTR);
120        data.writeInt64(inputCTR);
121        remote()->transact(HDCP_DECRYPT, data, &reply);
122
123        status_t err = reply.readInt32();
124
125        if (err != OK) {
126            return err;
127        }
128
129        reply.read(outData, size);
130
131        return err;
132    }
133};
134
135IMPLEMENT_META_INTERFACE(HDCP, "android.hardware.IHDCP");
136
137status_t BnHDCPObserver::onTransact(
138        uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
139    switch (code) {
140        case OBSERVER_NOTIFY:
141        {
142            CHECK_INTERFACE(IHDCPObserver, data, reply);
143
144            int msg = data.readInt32();
145            int ext1 = data.readInt32();
146            int ext2 = data.readInt32();
147
148            Parcel obj;
149            if (data.dataAvail() > 0) {
150                obj.appendFrom(
151                        const_cast<Parcel *>(&data),
152                        data.dataPosition(),
153                        data.dataAvail());
154            }
155
156            notify(msg, ext1, ext2, &obj);
157
158            return OK;
159        }
160
161        default:
162            return BBinder::onTransact(code, data, reply, flags);
163    }
164}
165
166status_t BnHDCP::onTransact(
167        uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
168    switch (code) {
169        case HDCP_SET_OBSERVER:
170        {
171            CHECK_INTERFACE(IHDCP, data, reply);
172
173            sp<IHDCPObserver> observer =
174                interface_cast<IHDCPObserver>(data.readStrongBinder());
175
176            reply->writeInt32(setObserver(observer));
177            return OK;
178        }
179
180        case HDCP_INIT_ASYNC:
181        {
182            CHECK_INTERFACE(IHDCP, data, reply);
183
184            const char *host = data.readCString();
185            unsigned port = data.readInt32();
186
187            reply->writeInt32(initAsync(host, port));
188            return OK;
189        }
190
191        case HDCP_SHUTDOWN_ASYNC:
192        {
193            CHECK_INTERFACE(IHDCP, data, reply);
194
195            reply->writeInt32(shutdownAsync());
196            return OK;
197        }
198
199        case HDCP_ENCRYPT:
200        {
201            size_t size = data.readInt32();
202
203            void *inData = malloc(2 * size);
204            void *outData = (uint8_t *)inData + size;
205
206            data.read(inData, size);
207
208            uint32_t streamCTR = data.readInt32();
209            uint64_t inputCTR;
210            status_t err = encrypt(inData, size, streamCTR, &inputCTR, outData);
211
212            reply->writeInt32(err);
213
214            if (err == OK) {
215                reply->writeInt64(inputCTR);
216                reply->write(outData, size);
217            }
218
219            free(inData);
220            inData = outData = NULL;
221
222            return OK;
223        }
224
225        case HDCP_DECRYPT:
226        {
227            size_t size = data.readInt32();
228
229            void *inData = malloc(2 * size);
230            void *outData = (uint8_t *)inData + size;
231
232            data.read(inData, size);
233
234            uint32_t streamCTR = data.readInt32();
235            uint64_t inputCTR = data.readInt64();
236            status_t err = decrypt(inData, size, streamCTR, inputCTR, outData);
237
238            reply->writeInt32(err);
239
240            if (err == OK) {
241                reply->write(outData, size);
242            }
243
244            free(inData);
245            inData = outData = NULL;
246
247            return OK;
248        }
249
250        default:
251            return BBinder::onTransact(code, data, reply, flags);
252    }
253}
254
255}  // namespace android
256