1 /*
2  * Copyright (C) 2009 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 "BpMediaExtractor"
19 #include <utils/Log.h>
20 
21 #include <stdint.h>
22 #include <time.h>
23 #include <sys/types.h>
24 
25 #include <binder/IPCThreadState.h>
26 #include <binder/Parcel.h>
27 #include <binder/PermissionCache.h>
28 #include <android/IMediaExtractor.h>
29 #include <media/stagefright/MetaData.h>
30 
31 namespace android {
32 
33 enum {
34     COUNTTRACKS = IBinder::FIRST_CALL_TRANSACTION,
35     GETTRACK,
36     GETTRACKMETADATA,
37     GETMETADATA,
38     FLAGS,
39     SETMEDIACAS,
40     NAME,
41     GETMETRICS,
42     SETENTRYPOINT,
43     SETLOGSESSIONID
44 };
45 
46 class BpMediaExtractor : public BpInterface<IMediaExtractor> {
47 public:
BpMediaExtractor(const sp<IBinder> & impl)48     explicit BpMediaExtractor(const sp<IBinder>& impl)
49         : BpInterface<IMediaExtractor>(impl)
50     {
51     }
52 
countTracks()53     virtual size_t countTracks() {
54         ALOGV("countTracks");
55         Parcel data, reply;
56         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
57         status_t ret = remote()->transact(COUNTTRACKS, data, &reply);
58         size_t numTracks = 0;
59         if (ret == NO_ERROR) {
60             numTracks = reply.readUint32();
61         }
62         return numTracks;
63     }
getTrack(size_t index)64     virtual sp<IMediaSource> getTrack(size_t index) {
65         ALOGV("getTrack(%zu)", index);
66         Parcel data, reply;
67         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
68         data.writeUint32(index);
69         status_t ret = remote()->transact(GETTRACK, data, &reply);
70         if (ret == NO_ERROR) {
71             return interface_cast<IMediaSource>(reply.readStrongBinder());
72         }
73         return NULL;
74     }
75 
getTrackMetaData(size_t index,uint32_t flags)76     virtual sp<MetaData> getTrackMetaData(
77             size_t index, uint32_t flags) {
78         ALOGV("getTrackMetaData(%zu, %u)", index, flags);
79         Parcel data, reply;
80         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
81         data.writeUint32(index);
82         data.writeUint32(flags);
83         status_t ret = remote()->transact(GETTRACKMETADATA, data, &reply);
84         if (ret == NO_ERROR) {
85             return MetaData::createFromParcel(reply);
86         }
87         return NULL;
88     }
89 
getMetaData()90     virtual sp<MetaData> getMetaData() {
91         ALOGV("getMetaData");
92         Parcel data, reply;
93         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
94         status_t ret = remote()->transact(GETMETADATA, data, &reply);
95         if (ret == NO_ERROR) {
96             return MetaData::createFromParcel(reply);
97         }
98         return NULL;
99     }
100 
getMetrics(Parcel * reply)101     virtual status_t getMetrics(Parcel * reply) {
102         Parcel data;
103         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
104         status_t ret = remote()->transact(GETMETRICS, data, reply);
105         if (ret == NO_ERROR) {
106             return OK;
107         }
108         return UNKNOWN_ERROR;
109     }
110 
flags() const111     virtual uint32_t flags() const {
112         ALOGV("flags");
113         Parcel data, reply;
114         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
115         status_t ret = remote()->transact(FLAGS, data, &reply);
116         int flgs = 0;
117         if (ret == NO_ERROR) {
118             flgs = reply.readUint32();
119         }
120         return flgs;
121     }
122 
setMediaCas(const HInterfaceToken & casToken)123     virtual status_t setMediaCas(const HInterfaceToken &casToken) {
124         ALOGV("setMediaCas");
125 
126         Parcel data, reply;
127         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
128         data.writeByteVector(casToken);
129 
130         status_t err = remote()->transact(SETMEDIACAS, data, &reply);
131         if (err != NO_ERROR) {
132             return err;
133         }
134         return reply.readInt32();
135     }
136 
name()137     virtual String8 name() {
138         Parcel data, reply;
139         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
140         status_t ret = remote()->transact(NAME, data, &reply);
141         String8 nm;
142         if (ret == NO_ERROR) {
143             nm = reply.readString8();
144         }
145         return nm;
146     }
147 
setEntryPoint(EntryPoint entryPoint)148     virtual status_t setEntryPoint(EntryPoint entryPoint) {
149         Parcel data, reply;
150         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
151         data.writeInt32(static_cast<int32_t>(entryPoint));
152         return remote()->transact(SETENTRYPOINT, data, &reply);
153     }
154 
setLogSessionId(const String8 & logSessionId)155     virtual status_t setLogSessionId(const String8& logSessionId) {
156         Parcel data, reply;
157         data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
158         data.writeString8(logSessionId);
159         return remote()->transact(SETLOGSESSIONID, data, &reply);
160     }
161 };
162 
163 IMPLEMENT_META_INTERFACE(MediaExtractor, "android.media.IMediaExtractor");
164 
165 #undef LOG_TAG
166 #define LOG_TAG "BnMediaExtractor"
167 
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)168 status_t BnMediaExtractor::onTransact(
169     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
170 {
171     switch (code) {
172         case COUNTTRACKS: {
173             ALOGV("countTracks");
174             CHECK_INTERFACE(IMediaExtractor, data, reply);
175             size_t numTracks = countTracks();
176             if (numTracks > INT32_MAX) {
177                 numTracks = 0;
178             }
179             reply->writeUint32(uint32_t(numTracks));
180             return NO_ERROR;
181         }
182         case GETTRACK: {
183             ALOGV("getTrack()");
184             CHECK_INTERFACE(IMediaExtractor, data, reply);
185             uint32_t idx;
186             if (data.readUint32(&idx) == NO_ERROR) {
187                 const sp<IMediaSource> track = getTrack(size_t(idx));
188                 registerMediaSource(this, track);
189                 return reply->writeStrongBinder(IInterface::asBinder(track));
190             }
191             return UNKNOWN_ERROR;
192         }
193         case GETTRACKMETADATA: {
194             ALOGV("getTrackMetaData");
195             CHECK_INTERFACE(IMediaExtractor, data, reply);
196             uint32_t idx;
197             uint32_t flags;
198             if (data.readUint32(&idx) == NO_ERROR &&
199                     data.readUint32(&flags) == NO_ERROR) {
200                 sp<MetaData> meta = getTrackMetaData(idx, flags);
201                 if (meta == NULL) {
202                     return UNKNOWN_ERROR;
203                 }
204                 meta->writeToParcel(*reply);
205                 return NO_ERROR;
206             }
207             return UNKNOWN_ERROR;
208         }
209         case GETMETADATA: {
210             ALOGV("getMetaData");
211             CHECK_INTERFACE(IMediaExtractor, data, reply);
212             sp<MetaData> meta = getMetaData();
213             if (meta != NULL) {
214                 meta->writeToParcel(*reply);
215                 return NO_ERROR;
216             }
217             return UNKNOWN_ERROR;
218         }
219         case GETMETRICS: {
220             CHECK_INTERFACE(IMediaExtractor, data, reply);
221             status_t ret = getMetrics(reply);
222             return ret;
223         }
224         case FLAGS: {
225             ALOGV("flags");
226             CHECK_INTERFACE(IMediaExtractor, data, reply);
227             reply->writeUint32(this->flags());
228             return NO_ERROR;
229         }
230         case SETMEDIACAS: {
231             ALOGV("setMediaCas");
232             CHECK_INTERFACE(IMediaExtractor, data, reply);
233 
234             HInterfaceToken casToken;
235             status_t err = data.readByteVector(&casToken);
236             if (err != NO_ERROR) {
237                 ALOGE("Error reading casToken from parcel");
238                 return err;
239             }
240 
241             reply->writeInt32(setMediaCas(casToken));
242             return OK;
243         }
244         case NAME: {
245             ALOGV("name");
246             CHECK_INTERFACE(IMediaExtractor, data, reply);
247             String8 nm = name();
248             reply->writeString8(nm);
249             return NO_ERROR;
250         }
251         case SETENTRYPOINT: {
252             ALOGV("setEntryPoint");
253             CHECK_INTERFACE(IMediaExtractor, data, reply);
254             int32_t entryPoint;
255             status_t err = data.readInt32(&entryPoint);
256             if (err == OK) {
257                 setEntryPoint(EntryPoint(entryPoint));
258             }
259             return err;
260         }
261         case SETLOGSESSIONID: {
262             ALOGV("setLogSessionId");
263             CHECK_INTERFACE(IMediaExtractor, data, reply);
264             String8 logSessionId;
265             status_t status = data.readString8(&logSessionId);
266             if (status == OK) {
267               setLogSessionId(logSessionId);
268             }
269             return status;
270         }
271         default:
272             return BBinder::onTransact(code, data, reply, flags);
273     }
274 }
275 
276 typedef struct {
277     String8 mime;
278     String8 name;
279     String8 sourceDescription;
280     pid_t owner;
281     wp<IMediaExtractor> extractor;
282     Vector<wp<IMediaSource>> tracks;
283     Vector<String8> trackDescriptions;
284     String8 toString() const;
285     time_t when;
286 } ExtractorInstance;
287 
toString() const288 String8 ExtractorInstance::toString() const {
289     String8 str;
290     char timeString[32];
291     strftime(timeString, sizeof(timeString), "%m-%d %T", localtime(&when));
292     str.append(timeString);
293     str.append(": ");
294     str.append(name);
295     str.append(" for mime ");
296     str.append(mime);
297     str.append(", source ");
298     str.append(sourceDescription);
299     str.append(String8::format(", pid %d: ", owner));
300     if (extractor.promote() == NULL) {
301         str.append("deleted\n");
302     } else {
303         str.append("active\n");
304     }
305     for (size_t i = 0; i < tracks.size(); i++) {
306         const String8 desc = trackDescriptions.itemAt(i);
307         str.appendFormat("    track {%s} ", desc.c_str());
308         wp<IMediaSource> wSource = tracks.itemAt(i);
309         if (wSource == NULL) {
310             str.append(": null\n");
311         } else {
312             const sp<IMediaSource> source = wSource.promote();
313             if (source == NULL) {
314                 str.append(": deleted\n");
315             } else {
316                 str.appendFormat(": active\n");
317             }
318         }
319     }
320     return str;
321 }
322 
323 static Vector<ExtractorInstance> sExtractors;
324 static Mutex sExtractorsLock;
325 
registerMediaSource(const sp<IMediaExtractor> & ex,const sp<IMediaSource> & source)326 void registerMediaSource(
327         const sp<IMediaExtractor> &ex,
328         const sp<IMediaSource> &source) {
329     Mutex::Autolock lock(sExtractorsLock);
330     for (size_t i = 0; i < sExtractors.size(); i++) {
331         ExtractorInstance &instance = sExtractors.editItemAt(i);
332         sp<IMediaExtractor> extractor = instance.extractor.promote();
333         if (extractor != NULL && extractor == ex) {
334             if (instance.tracks.size() > 5) {
335                 instance.tracks.resize(5);
336                 instance.trackDescriptions.resize(5);
337             }
338             instance.tracks.push_front(source);
339             if (source != NULL) {
340                 instance.trackDescriptions.push_front(source->getFormat()->toString());
341             } else {
342                 instance.trackDescriptions.push_front(String8());
343             }
344             break;
345         }
346     }
347 }
348 
registerMediaExtractor(const sp<IMediaExtractor> & extractor,const sp<DataSource> & source,const char * mime)349 void registerMediaExtractor(
350         const sp<IMediaExtractor> &extractor,
351         const sp<DataSource> &source,
352         const char *mime) {
353     ExtractorInstance ex;
354     ex.mime = mime == NULL ? "NULL" : mime;
355     ex.name = extractor->name();
356     ex.sourceDescription = source->toString();
357     ex.owner = IPCThreadState::self()->getCallingPid();
358     ex.extractor = extractor;
359     ex.when = time(NULL);
360 
361     {
362         Mutex::Autolock lock(sExtractorsLock);
363         if (sExtractors.size() > 10) {
364             sExtractors.resize(10);
365         }
366         sExtractors.push_front(ex);
367     }
368 }
369 
dumpExtractors(int fd,const Vector<String16> &)370 status_t dumpExtractors(int fd, const Vector<String16>&) {
371     String8 out;
372     const IPCThreadState* ipc = IPCThreadState::self();
373     const int pid = ipc->getCallingPid();
374     const int uid = ipc->getCallingUid();
375     if (!PermissionCache::checkPermission(String16("android.permission.DUMP"), pid, uid)) {
376         out.appendFormat("Permission Denial: "
377                 "can't dump MediaExtractor from pid=%d, uid=%d\n", pid, uid);
378     } else {
379         out.append("Recent extractors, most recent first:\n");
380         {
381             Mutex::Autolock lock(sExtractorsLock);
382             for (size_t i = 0; i < sExtractors.size(); i++) {
383                 const ExtractorInstance &instance = sExtractors.itemAt(i);
384                 out.append("  ");
385                 out.append(instance.toString());
386             }
387         }
388     }
389     write(fd, out.c_str(), out.size());
390     return OK;
391 }
392 
393 
394 }  // namespace android
395 
396