1 /*
2  * Copyright (C) 2014 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 "NdkMediaExtractor"
19 
20 
21 #include <media/NdkMediaError.h>
22 #include <media/NdkMediaExtractor.h>
23 #include "NdkMediaDataSourcePriv.h"
24 #include "NdkMediaFormatPriv.h"
25 
26 
27 #include <inttypes.h>
28 #include <utils/Log.h>
29 #include <utils/StrongPointer.h>
30 #include <media/hardware/CryptoAPI.h>
31 #include <media/stagefright/foundation/ABuffer.h>
32 #include <media/stagefright/foundation/AMessage.h>
33 #include <media/stagefright/MetaData.h>
34 #include <media/stagefright/NuMediaExtractor.h>
35 #include <media/IMediaHTTPService.h>
36 #include <android_runtime/AndroidRuntime.h>
37 #include <android_util_Binder.h>
38 
39 #include <jni.h>
40 
41 using namespace android;
42 
translate_error(status_t err)43 static media_status_t translate_error(status_t err) {
44     if (err == OK) {
45         return AMEDIA_OK;
46     } else if (err == ERROR_END_OF_STREAM) {
47         return AMEDIA_ERROR_END_OF_STREAM;
48     } else if (err == ERROR_IO) {
49         return AMEDIA_ERROR_IO;
50     }
51 
52     ALOGE("sf error code: %d", err);
53     return AMEDIA_ERROR_UNKNOWN;
54 }
55 
56 struct AMediaExtractor {
57     sp<NuMediaExtractor> mImpl;
58     sp<ABuffer> mPsshBuf;
59 };
60 
61 extern "C" {
62 
63 EXPORT
AMediaExtractor_new()64 AMediaExtractor* AMediaExtractor_new() {
65     ALOGV("ctor");
66     AMediaExtractor *mData = new AMediaExtractor();
67     mData->mImpl = new NuMediaExtractor();
68     return mData;
69 }
70 
71 EXPORT
AMediaExtractor_delete(AMediaExtractor * mData)72 media_status_t AMediaExtractor_delete(AMediaExtractor *mData) {
73     ALOGV("dtor");
74     delete mData;
75     return AMEDIA_OK;
76 }
77 
78 EXPORT
AMediaExtractor_setDataSourceFd(AMediaExtractor * mData,int fd,off64_t offset,off64_t length)79 media_status_t AMediaExtractor_setDataSourceFd(AMediaExtractor *mData, int fd, off64_t offset,
80         off64_t length) {
81     ALOGV("setDataSource(%d, %" PRId64 ", %" PRId64 ")", fd, offset, length);
82     return translate_error(mData->mImpl->setDataSource(fd, offset, length));
83 }
84 
85 EXPORT
AMediaExtractor_setDataSource(AMediaExtractor * mData,const char * location)86 media_status_t AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) {
87     ALOGV("setDataSource(%s)", location);
88     // TODO: add header support
89 
90     JNIEnv *env = AndroidRuntime::getJNIEnv();
91     jobject service = NULL;
92     if (env == NULL) {
93         ALOGE("setDataSource(path) must be called from Java thread");
94         return AMEDIA_ERROR_UNSUPPORTED;
95     }
96 
97     jclass mediahttpclass = env->FindClass("android/media/MediaHTTPService");
98     if (mediahttpclass == NULL) {
99         ALOGE("can't find MediaHttpService");
100         env->ExceptionClear();
101         return AMEDIA_ERROR_UNSUPPORTED;
102     }
103 
104     jmethodID mediaHttpCreateMethod = env->GetStaticMethodID(mediahttpclass,
105             "createHttpServiceBinderIfNecessary", "(Ljava/lang/String;)Landroid/os/IBinder;");
106     if (mediaHttpCreateMethod == NULL) {
107         ALOGE("can't find method");
108         env->ExceptionClear();
109         return AMEDIA_ERROR_UNSUPPORTED;
110     }
111 
112     jstring jloc = env->NewStringUTF(location);
113 
114     service = env->CallStaticObjectMethod(mediahttpclass, mediaHttpCreateMethod, jloc);
115     env->DeleteLocalRef(jloc);
116 
117     sp<IMediaHTTPService> httpService;
118     if (service != NULL) {
119         sp<IBinder> binder = ibinderForJavaObject(env, service);
120         httpService = interface_cast<IMediaHTTPService>(binder);
121     }
122 
123     status_t err = mData->mImpl->setDataSource(httpService, location, NULL);
124     env->ExceptionClear();
125     return translate_error(err);
126 }
127 
128 EXPORT
AMediaExtractor_setDataSourceCustom(AMediaExtractor * mData,AMediaDataSource * src)129 media_status_t AMediaExtractor_setDataSourceCustom(AMediaExtractor* mData, AMediaDataSource *src) {
130     return translate_error(mData->mImpl->setDataSource(new NdkDataSource(src)));
131 }
132 
133 EXPORT
AMediaExtractor_getFileFormat(AMediaExtractor * mData)134 AMediaFormat* AMediaExtractor_getFileFormat(AMediaExtractor *mData) {
135     sp<AMessage> format;
136     mData->mImpl->getFileFormat(&format);
137     return AMediaFormat_fromMsg(&format);
138 }
139 
140 EXPORT
AMediaExtractor_getTrackCount(AMediaExtractor * mData)141 size_t AMediaExtractor_getTrackCount(AMediaExtractor *mData) {
142     return mData->mImpl->countTracks();
143 }
144 
145 EXPORT
AMediaExtractor_getTrackFormat(AMediaExtractor * mData,size_t idx)146 AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor *mData, size_t idx) {
147     sp<AMessage> format;
148     mData->mImpl->getTrackFormat(idx, &format);
149     return AMediaFormat_fromMsg(&format);
150 }
151 
152 EXPORT
AMediaExtractor_selectTrack(AMediaExtractor * mData,size_t idx)153 media_status_t AMediaExtractor_selectTrack(AMediaExtractor *mData, size_t idx) {
154     ALOGV("selectTrack(%zu)", idx);
155     return translate_error(mData->mImpl->selectTrack(idx));
156 }
157 
158 EXPORT
AMediaExtractor_unselectTrack(AMediaExtractor * mData,size_t idx)159 media_status_t AMediaExtractor_unselectTrack(AMediaExtractor *mData, size_t idx) {
160     ALOGV("unselectTrack(%zu)", idx);
161     return translate_error(mData->mImpl->unselectTrack(idx));
162 }
163 
164 EXPORT
AMediaExtractor_advance(AMediaExtractor * mData)165 bool AMediaExtractor_advance(AMediaExtractor *mData) {
166     //ALOGV("advance");
167     status_t err = mData->mImpl->advance();
168     if (err == ERROR_END_OF_STREAM) {
169         return false;
170     } else if (err != OK) {
171         ALOGE("sf error code: %d", err);
172         return false;
173     }
174     return true;
175 }
176 
177 EXPORT
AMediaExtractor_seekTo(AMediaExtractor * ex,int64_t seekPosUs,SeekMode mode)178 media_status_t AMediaExtractor_seekTo(AMediaExtractor *ex, int64_t seekPosUs, SeekMode mode) {
179     android::MediaSource::ReadOptions::SeekMode sfmode;
180     if (mode == AMEDIAEXTRACTOR_SEEK_PREVIOUS_SYNC) {
181         sfmode = android::MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC;
182     } else if (mode == AMEDIAEXTRACTOR_SEEK_CLOSEST_SYNC) {
183         sfmode = android::MediaSource::ReadOptions::SEEK_CLOSEST_SYNC;
184     } else {
185         sfmode = android::MediaSource::ReadOptions::SEEK_NEXT_SYNC;
186     }
187 
188     return translate_error(ex->mImpl->seekTo(seekPosUs, sfmode));
189 }
190 
191 EXPORT
AMediaExtractor_readSampleData(AMediaExtractor * mData,uint8_t * buffer,size_t capacity)192 ssize_t AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size_t capacity) {
193     //ALOGV("readSampleData");
194     sp<ABuffer> tmp = new ABuffer(buffer, capacity);
195     if (mData->mImpl->readSampleData(tmp) == OK) {
196         return tmp->size();
197     }
198     return -1;
199 }
200 
201 EXPORT
AMediaExtractor_getSampleSize(AMediaExtractor * mData)202 ssize_t AMediaExtractor_getSampleSize(AMediaExtractor *mData) {
203     size_t sampleSize;
204     status_t err = mData->mImpl->getSampleSize(&sampleSize);
205     if (err != OK) {
206         return -1;
207     }
208     return sampleSize;
209 }
210 
211 EXPORT
AMediaExtractor_getSampleFlags(AMediaExtractor * mData)212 uint32_t AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
213     int sampleFlags = 0;
214     sp<MetaData> meta;
215     status_t err = mData->mImpl->getSampleMeta(&meta);
216     if (err != OK) {
217         return -1;
218     }
219     int32_t val;
220     if (meta->findInt32(kKeyIsSyncFrame, &val) && val != 0) {
221         sampleFlags |= AMEDIAEXTRACTOR_SAMPLE_FLAG_SYNC;
222     }
223 
224     uint32_t type;
225     const void *data;
226     size_t size;
227     if (meta->findData(kKeyEncryptedSizes, &type, &data, &size)) {
228         sampleFlags |= AMEDIAEXTRACTOR_SAMPLE_FLAG_ENCRYPTED;
229     }
230     return sampleFlags;
231 }
232 
233 EXPORT
AMediaExtractor_getSampleTrackIndex(AMediaExtractor * mData)234 int AMediaExtractor_getSampleTrackIndex(AMediaExtractor *mData) {
235     size_t idx;
236     if (mData->mImpl->getSampleTrackIndex(&idx) != OK) {
237         return -1;
238     }
239     return idx;
240 }
241 
242 EXPORT
AMediaExtractor_getSampleTime(AMediaExtractor * mData)243 int64_t AMediaExtractor_getSampleTime(AMediaExtractor *mData) {
244     int64_t time;
245     if (mData->mImpl->getSampleTime(&time) != OK) {
246         return -1;
247     }
248     return time;
249 }
250 
251 EXPORT
AMediaExtractor_getPsshInfo(AMediaExtractor * ex)252 PsshInfo* AMediaExtractor_getPsshInfo(AMediaExtractor *ex) {
253 
254     if (ex->mPsshBuf != NULL) {
255         return (PsshInfo*) ex->mPsshBuf->data();
256     }
257 
258     sp<AMessage> format;
259     ex->mImpl->getFileFormat(&format);
260     sp<ABuffer> buffer;
261     if(!format->findBuffer("pssh", &buffer)) {
262         return NULL;
263     }
264 
265     // the format of the buffer is 1 or more of:
266     //    {
267     //        16 byte uuid
268     //        4 byte data length N
269     //        N bytes of data
270     //    }
271 
272     // Determine the number of entries in the source data.
273     // Since we got the data from stagefright, we trust it is valid and properly formatted.
274     const uint8_t* data = buffer->data();
275     size_t len = buffer->size();
276     size_t numentries = 0;
277     while (len > 0) {
278         numentries++;
279 
280         if (len < 16) {
281             ALOGE("invalid PSSH data");
282             return NULL;
283         }
284         // skip uuid
285         data += 16;
286         len -= 16;
287 
288         // get data length
289         if (len < 4) {
290             ALOGE("invalid PSSH data");
291             return NULL;
292         }
293         uint32_t datalen = *((uint32_t*)data);
294         data += 4;
295         len -= 4;
296 
297         if (len < datalen) {
298             ALOGE("invalid PSSH data");
299             return NULL;
300         }
301         // skip the data
302         data += datalen;
303         len -= datalen;
304     }
305 
306     // there are <numentries> in the source buffer, we need
307     // (source buffer size) - (sizeof(uint32_t) * numentries) + sizeof(size_t)
308     //  + ((sizeof(void*) + sizeof(size_t)) * numentries) bytes for the PsshInfo structure
309     // Or in other words, the data lengths in the source structure are replaced by size_t
310     // (which may be the same size or larger, for 64 bit), and in addition there is an
311     // extra pointer for each entry, and an extra size_t for the entire PsshInfo.
312     size_t newsize = buffer->size() - (sizeof(uint32_t) * numentries) + sizeof(size_t)
313             + ((sizeof(void*) + sizeof(size_t)) * numentries);
314     if (newsize <= buffer->size()) {
315         ALOGE("invalid PSSH data");
316         return NULL;
317     }
318     ex->mPsshBuf = new ABuffer(newsize);
319     ex->mPsshBuf->setRange(0, newsize);
320 
321     // copy data
322     const uint8_t* src = buffer->data();
323     uint8_t* dst = ex->mPsshBuf->data();
324     uint8_t* dstdata = dst + sizeof(size_t) + numentries * sizeof(PsshEntry);
325     *((size_t*)dst) = numentries;
326     dst += sizeof(size_t);
327     for (size_t i = 0; i < numentries; i++) {
328         // copy uuid
329         memcpy(dst, src, 16);
330         src += 16;
331         dst += 16;
332 
333         // get/copy data length
334         uint32_t datalen = *((uint32_t*)src);
335         *((size_t*)dst) = datalen;
336         src += sizeof(uint32_t);
337         dst += sizeof(size_t);
338 
339         // the next entry in the destination is a pointer to the actual data, which we store
340         // after the array of PsshEntry
341         *((void**)dst) = dstdata;
342         dst += sizeof(void*);
343 
344         // copy the actual data
345         memcpy(dstdata, src, datalen);
346         dstdata += datalen;
347         src += datalen;
348     }
349 
350     return (PsshInfo*) ex->mPsshBuf->data();
351 }
352 
353 EXPORT
AMediaExtractor_getSampleCryptoInfo(AMediaExtractor * ex)354 AMediaCodecCryptoInfo *AMediaExtractor_getSampleCryptoInfo(AMediaExtractor *ex) {
355     sp<MetaData> meta;
356     if(ex->mImpl->getSampleMeta(&meta) != 0) {
357         return NULL;
358     }
359 
360     uint32_t type;
361     const void *crypteddata;
362     size_t cryptedsize;
363     if (!meta->findData(kKeyEncryptedSizes, &type, &crypteddata, &cryptedsize)) {
364         return NULL;
365     }
366     size_t numSubSamples = cryptedsize / sizeof(size_t);
367 
368     const void *cleardata;
369     size_t clearsize;
370     if (meta->findData(kKeyPlainSizes, &type, &cleardata, &clearsize)) {
371         if (clearsize != cryptedsize) {
372             // The two must be of the same length.
373             return NULL;
374         }
375     }
376 
377     const void *key;
378     size_t keysize;
379     if (meta->findData(kKeyCryptoKey, &type, &key, &keysize)) {
380         if (keysize != 16) {
381             // Keys must be 16 bytes in length.
382             return NULL;
383         }
384     }
385 
386     const void *iv;
387     size_t ivsize;
388     if (meta->findData(kKeyCryptoIV, &type, &iv, &ivsize)) {
389         if (ivsize != 16) {
390             // IVs must be 16 bytes in length.
391             return NULL;
392         }
393     }
394 
395     int32_t mode;
396     if (!meta->findInt32(kKeyCryptoMode, &mode)) {
397         mode = CryptoPlugin::kMode_AES_CTR;
398     }
399 
400     return AMediaCodecCryptoInfo_new(
401             numSubSamples,
402             (uint8_t*) key,
403             (uint8_t*) iv,
404             (cryptoinfo_mode_t) mode,
405             (size_t*) cleardata,
406             (size_t*) crypteddata);
407 }
408 
409 EXPORT
AMediaExtractor_getCachedDuration(AMediaExtractor * ex)410 int64_t AMediaExtractor_getCachedDuration(AMediaExtractor *ex) {
411     bool eos;
412     int64_t durationUs;
413     if (ex->mImpl->getCachedDuration(&durationUs, &eos)) {
414         return durationUs;
415     }
416     return -1;
417 }
418 
419 EXPORT
AMediaExtractor_getSampleFormat(AMediaExtractor * ex,AMediaFormat * fmt)420 media_status_t AMediaExtractor_getSampleFormat(AMediaExtractor *ex, AMediaFormat *fmt) {
421     if (fmt == NULL) {
422         return AMEDIA_ERROR_INVALID_PARAMETER;
423     }
424 
425     sp<MetaData> sampleMeta;
426     status_t err = ex->mImpl->getSampleMeta(&sampleMeta);
427     if (err != OK) {
428         return translate_error(err);
429     }
430 
431     sp<AMessage> meta;
432     AMediaFormat_getFormat(fmt, &meta);
433     meta->clear();
434 
435     int32_t layerId;
436     if (sampleMeta->findInt32(kKeyTemporalLayerId, &layerId)) {
437         meta->setInt32(AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID, layerId);
438     }
439 
440     size_t trackIndex;
441     err = ex->mImpl->getSampleTrackIndex(&trackIndex);
442     if (err == OK) {
443         meta->setInt32(AMEDIAFORMAT_KEY_TRACK_INDEX, trackIndex);
444         sp<AMessage> trackFormat;
445         AString mime;
446         err = ex->mImpl->getTrackFormat(trackIndex, &trackFormat);
447         if (err == OK
448                 && trackFormat != NULL
449                 && trackFormat->findString(AMEDIAFORMAT_KEY_MIME, &mime)) {
450             meta->setString(AMEDIAFORMAT_KEY_MIME, mime);
451         }
452     }
453 
454     int64_t durationUs;
455     if (sampleMeta->findInt64(kKeyDuration, &durationUs)) {
456         meta->setInt64(AMEDIAFORMAT_KEY_DURATION, durationUs);
457     }
458 
459     uint32_t dataType; // unused
460     const void *seiData;
461     size_t seiLength;
462     if (sampleMeta->findData(kKeySEI, &dataType, &seiData, &seiLength)) {
463         sp<ABuffer> sei = ABuffer::CreateAsCopy(seiData, seiLength);;
464         meta->setBuffer(AMEDIAFORMAT_KEY_SEI, sei);
465     }
466 
467     const void *mpegUserDataPointer;
468     size_t mpegUserDataLength;
469     if (sampleMeta->findData(
470             kKeyMpegUserData, &dataType, &mpegUserDataPointer, &mpegUserDataLength)) {
471         sp<ABuffer> mpegUserData = ABuffer::CreateAsCopy(mpegUserDataPointer, mpegUserDataLength);
472         meta->setBuffer(AMEDIAFORMAT_KEY_MPEG_USER_DATA, mpegUserData);
473     }
474 
475     return AMEDIA_OK;
476 }
477 
478 EXPORT
AMediaExtractor_disconnect(AMediaExtractor * ex)479 media_status_t AMediaExtractor_disconnect(AMediaExtractor * ex) {
480     ex->mImpl->disconnect();
481     return AMEDIA_OK;
482 }
483 
484 } // extern "C"
485 
486