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
26 namespace android {
27
28 enum {
29 OBSERVER_NOTIFY = IBinder::FIRST_CALL_TRANSACTION,
30 HDCP_SET_OBSERVER,
31 HDCP_INIT_ASYNC,
32 HDCP_SHUTDOWN_ASYNC,
33 HDCP_ENCRYPT,
34 };
35
36 struct BpHDCPObserver : public BpInterface<IHDCPObserver> {
BpHDCPObserverandroid::BpHDCPObserver37 BpHDCPObserver(const sp<IBinder> &impl)
38 : BpInterface<IHDCPObserver>(impl) {
39 }
40
notifyandroid::BpHDCPObserver41 virtual void notify(
42 int msg, int ext1, int ext2, const Parcel *obj) {
43 Parcel data, reply;
44 data.writeInterfaceToken(IHDCPObserver::getInterfaceDescriptor());
45 data.writeInt32(msg);
46 data.writeInt32(ext1);
47 data.writeInt32(ext2);
48 if (obj && obj->dataSize() > 0) {
49 data.appendFrom(const_cast<Parcel *>(obj), 0, obj->dataSize());
50 }
51 remote()->transact(OBSERVER_NOTIFY, data, &reply, IBinder::FLAG_ONEWAY);
52 }
53 };
54
55 IMPLEMENT_META_INTERFACE(HDCPObserver, "android.hardware.IHDCPObserver");
56
57 struct BpHDCP : public BpInterface<IHDCP> {
BpHDCPandroid::BpHDCP58 BpHDCP(const sp<IBinder> &impl)
59 : BpInterface<IHDCP>(impl) {
60 }
61
setObserverandroid::BpHDCP62 virtual status_t setObserver(const sp<IHDCPObserver> &observer) {
63 Parcel data, reply;
64 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
65 data.writeStrongBinder(observer->asBinder());
66 remote()->transact(HDCP_SET_OBSERVER, data, &reply);
67 return reply.readInt32();
68 }
69
initAsyncandroid::BpHDCP70 virtual status_t initAsync(const char *host, unsigned port) {
71 Parcel data, reply;
72 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
73 data.writeCString(host);
74 data.writeInt32(port);
75 remote()->transact(HDCP_INIT_ASYNC, data, &reply);
76 return reply.readInt32();
77 }
78
shutdownAsyncandroid::BpHDCP79 virtual status_t shutdownAsync() {
80 Parcel data, reply;
81 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
82 remote()->transact(HDCP_SHUTDOWN_ASYNC, data, &reply);
83 return reply.readInt32();
84 }
85
encryptandroid::BpHDCP86 virtual status_t encrypt(
87 const void *inData, size_t size, uint32_t streamCTR,
88 uint64_t *outInputCTR, void *outData) {
89 Parcel data, reply;
90 data.writeInterfaceToken(IHDCP::getInterfaceDescriptor());
91 data.writeInt32(size);
92 data.write(inData, size);
93 data.writeInt32(streamCTR);
94 remote()->transact(HDCP_ENCRYPT, data, &reply);
95
96 status_t err = reply.readInt32();
97
98 if (err != OK) {
99 *outInputCTR = 0;
100
101 return err;
102 }
103
104 *outInputCTR = reply.readInt64();
105 reply.read(outData, size);
106
107 return err;
108 }
109 };
110
111 IMPLEMENT_META_INTERFACE(HDCP, "android.hardware.IHDCP");
112
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)113 status_t BnHDCPObserver::onTransact(
114 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
115 switch (code) {
116 case OBSERVER_NOTIFY:
117 {
118 CHECK_INTERFACE(IHDCPObserver, data, reply);
119
120 int msg = data.readInt32();
121 int ext1 = data.readInt32();
122 int ext2 = data.readInt32();
123
124 Parcel obj;
125 if (data.dataAvail() > 0) {
126 obj.appendFrom(
127 const_cast<Parcel *>(&data),
128 data.dataPosition(),
129 data.dataAvail());
130 }
131
132 notify(msg, ext1, ext2, &obj);
133
134 return OK;
135 }
136
137 default:
138 return BBinder::onTransact(code, data, reply, flags);
139 }
140 }
141
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)142 status_t BnHDCP::onTransact(
143 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
144 switch (code) {
145 case HDCP_SET_OBSERVER:
146 {
147 CHECK_INTERFACE(IHDCP, data, reply);
148
149 sp<IHDCPObserver> observer =
150 interface_cast<IHDCPObserver>(data.readStrongBinder());
151
152 reply->writeInt32(setObserver(observer));
153 return OK;
154 }
155
156 case HDCP_INIT_ASYNC:
157 {
158 CHECK_INTERFACE(IHDCP, data, reply);
159
160 const char *host = data.readCString();
161 unsigned port = data.readInt32();
162
163 reply->writeInt32(initAsync(host, port));
164 return OK;
165 }
166
167 case HDCP_SHUTDOWN_ASYNC:
168 {
169 CHECK_INTERFACE(IHDCP, data, reply);
170
171 reply->writeInt32(shutdownAsync());
172 return OK;
173 }
174
175 case HDCP_ENCRYPT:
176 {
177 size_t size = data.readInt32();
178
179 void *inData = malloc(2 * size);
180 void *outData = (uint8_t *)inData + size;
181
182 data.read(inData, size);
183
184 uint32_t streamCTR = data.readInt32();
185 uint64_t inputCTR;
186 status_t err = encrypt(inData, size, streamCTR, &inputCTR, outData);
187
188 reply->writeInt32(err);
189
190 if (err == OK) {
191 reply->writeInt64(inputCTR);
192 reply->write(outData, size);
193 }
194
195 free(inData);
196 inData = outData = NULL;
197
198 return OK;
199 }
200
201 default:
202 return BBinder::onTransact(code, data, reply, flags);
203 }
204 }
205
206 } // namespace android
207