1 /*
2  * Copyright 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 "MediaExtractor-JNI"
19 #include <utils/Log.h>
20 
21 #include "android_media_AudioPresentation.h"
22 #include "android_media_MediaDataSource.h"
23 #include "android_media_MediaExtractor.h"
24 #include "android_media_MediaMetricsJNI.h"
25 #include "android_media_Streams.h"
26 #include "android_os_HwRemoteBinder.h"
27 #include "android_runtime/AndroidRuntime.h"
28 #include "android_runtime/Log.h"
29 #include "android_util_Binder.h"
30 #include "jni.h"
31 #include <nativehelper/JNIPlatformHelp.h>
32 
33 #include <android/hardware/cas/1.0/BpHwCas.h>
34 #include <android/hardware/cas/1.0/BnHwCas.h>
35 #include <hidl/HybridInterface.h>
36 #include <media/IMediaHTTPService.h>
37 #include <media/hardware/CryptoAPI.h>
38 #include <media/stagefright/foundation/ABuffer.h>
39 #include <media/stagefright/foundation/ADebug.h>
40 #include <media/stagefright/foundation/AMessage.h>
41 #include <media/DataSource.h>
42 #include <media/stagefright/InterfaceUtils.h>
43 #include <media/stagefright/MediaErrors.h>
44 #include <media/stagefright/MetaData.h>
45 #include <media/stagefright/NuMediaExtractor.h>
46 #include <nativehelper/ScopedLocalRef.h>
47 
48 namespace android {
49 
50 using namespace hardware::cas::V1_0;
51 
52 struct fields_t {
53     jfieldID context;
54 
55     jmethodID cryptoInfoSetID;
56     jmethodID cryptoInfoSetPatternID;
57 };
58 
59 static fields_t gFields;
60 static JAudioPresentationInfo::fields_t gAudioPresentationFields;
61 
JMediaExtractor(JNIEnv * env,jobject thiz)62 JMediaExtractor::JMediaExtractor(JNIEnv *env, jobject thiz)
63     : mClass(NULL),
64       mObject(NULL) {
65     jclass clazz = env->GetObjectClass(thiz);
66     CHECK(clazz != NULL);
67 
68     mClass = (jclass)env->NewGlobalRef(clazz);
69     mObject = env->NewWeakGlobalRef(thiz);
70 
71     mImpl = new NuMediaExtractor;
72 }
73 
~JMediaExtractor()74 JMediaExtractor::~JMediaExtractor() {
75     JNIEnv *env = AndroidRuntime::getJNIEnv();
76 
77     env->DeleteWeakGlobalRef(mObject);
78     mObject = NULL;
79     env->DeleteGlobalRef(mClass);
80     mClass = NULL;
81 }
82 
setDataSource(const sp<IMediaHTTPService> & httpService,const char * path,const KeyedVector<String8,String8> * headers)83 status_t JMediaExtractor::setDataSource(
84         const sp<IMediaHTTPService> &httpService,
85         const char *path,
86         const KeyedVector<String8, String8> *headers) {
87     return mImpl->setDataSource(httpService, path, headers);
88 }
89 
setDataSource(int fd,off64_t offset,off64_t size)90 status_t JMediaExtractor::setDataSource(int fd, off64_t offset, off64_t size) {
91     return mImpl->setDataSource(fd, offset, size);
92 }
93 
setDataSource(const sp<DataSource> & datasource)94 status_t JMediaExtractor::setDataSource(const sp<DataSource> &datasource) {
95     return mImpl->setDataSource(datasource);
96 }
97 
setMediaCas(JNIEnv * env,jobject casBinderObj)98 status_t JMediaExtractor::setMediaCas(JNIEnv *env, jobject casBinderObj) {
99     if (casBinderObj == NULL) {
100         return BAD_VALUE;
101     }
102 
103     sp<hardware::IBinder> hwBinder =
104         JHwRemoteBinder::GetNativeContext(env, casBinderObj)->getBinder();
105     if (hwBinder == NULL) {
106         return BAD_VALUE;
107     }
108 
109     sp<ICas> cas = hardware::fromBinder<ICas, BpHwCas, BnHwCas>(hwBinder);
110     if (cas == NULL) {
111         return BAD_VALUE;
112     }
113 
114     HalToken halToken;
115     if (!createHalToken(cas, &halToken)) {
116         return BAD_VALUE;
117     }
118 
119     return mImpl->setMediaCas(halToken);
120 }
121 
countTracks() const122 size_t JMediaExtractor::countTracks() const {
123     return mImpl->countTracks();
124 }
125 
getTrackFormat(size_t index,jobject * format) const126 status_t JMediaExtractor::getTrackFormat(size_t index, jobject *format) const {
127     sp<AMessage> msg;
128     status_t err;
129     if ((err = mImpl->getTrackFormat(index, &msg)) != OK) {
130         return err;
131     }
132 
133     JNIEnv *env = AndroidRuntime::getJNIEnv();
134 
135     return ConvertMessageToMap(env, msg, format);
136 }
137 
getFileFormat(jobject * format) const138 status_t JMediaExtractor::getFileFormat(jobject *format) const {
139     sp<AMessage> msg;
140     status_t err;
141     if ((err = mImpl->getFileFormat(&msg)) != OK) {
142         return err;
143     }
144 
145     JNIEnv *env = AndroidRuntime::getJNIEnv();
146 
147     return ConvertMessageToMap(env, msg, format);
148 }
149 
selectTrack(size_t index)150 status_t JMediaExtractor::selectTrack(size_t index) {
151     return mImpl->selectTrack(index);
152 }
153 
unselectTrack(size_t index)154 status_t JMediaExtractor::unselectTrack(size_t index) {
155     return mImpl->unselectTrack(index);
156 }
157 
seekTo(int64_t timeUs,MediaSource::ReadOptions::SeekMode mode)158 status_t JMediaExtractor::seekTo(
159         int64_t timeUs, MediaSource::ReadOptions::SeekMode mode) {
160     return mImpl->seekTo(timeUs, mode);
161 }
162 
advance()163 status_t JMediaExtractor::advance() {
164     return mImpl->advance();
165 }
166 
readSampleData(jobject byteBuf,size_t offset,size_t * sampleSize)167 status_t JMediaExtractor::readSampleData(
168         jobject byteBuf, size_t offset, size_t *sampleSize) {
169     JNIEnv *env = AndroidRuntime::getJNIEnv();
170 
171     void *dst = env->GetDirectBufferAddress(byteBuf);
172 
173     size_t dstSize;
174     jbyteArray byteArray = NULL;
175 
176     ScopedLocalRef<jclass> byteBufClass(env, env->FindClass("java/nio/ByteBuffer"));
177     CHECK(byteBufClass.get() != NULL);
178 
179     if (dst == NULL) {
180         jmethodID arrayID =
181             env->GetMethodID(byteBufClass.get(), "array", "()[B");
182         CHECK(arrayID != NULL);
183 
184         byteArray =
185             (jbyteArray)env->CallObjectMethod(byteBuf, arrayID);
186 
187         if (byteArray == NULL) {
188             return INVALID_OPERATION;
189         }
190 
191         jboolean isCopy;
192         dst = env->GetByteArrayElements(byteArray, &isCopy);
193 
194         dstSize = (size_t) env->GetArrayLength(byteArray);
195     } else {
196         dstSize = (size_t) env->GetDirectBufferCapacity(byteBuf);
197     }
198 
199     if (dstSize < offset) {
200         if (byteArray != NULL) {
201             env->ReleaseByteArrayElements(byteArray, (jbyte *)dst, 0);
202         }
203 
204         return -ERANGE;
205     }
206 
207     sp<ABuffer> buffer = new ABuffer((char *)dst + offset, dstSize - offset);
208 
209     status_t err = mImpl->readSampleData(buffer);
210 
211     if (byteArray != NULL) {
212         env->ReleaseByteArrayElements(byteArray, (jbyte *)dst, 0);
213     }
214 
215     if (err != OK) {
216         return err;
217     }
218 
219     *sampleSize = buffer->size();
220 
221     jmethodID positionID = env->GetMethodID(
222             byteBufClass.get(), "position", "(I)Ljava/nio/Buffer;");
223 
224     CHECK(positionID != NULL);
225 
226     jmethodID limitID = env->GetMethodID(
227             byteBufClass.get(), "limit", "(I)Ljava/nio/Buffer;");
228 
229     CHECK(limitID != NULL);
230 
231     jobject me = env->CallObjectMethod(
232             byteBuf, limitID, offset + *sampleSize);
233     env->DeleteLocalRef(me);
234     me = env->CallObjectMethod(
235             byteBuf, positionID, offset);
236     env->DeleteLocalRef(me);
237     me = NULL;
238 
239     return OK;
240 }
241 
getSampleTrackIndex(size_t * trackIndex)242 status_t JMediaExtractor::getSampleTrackIndex(size_t *trackIndex) {
243     return mImpl->getSampleTrackIndex(trackIndex);
244 }
245 
getSampleTime(int64_t * sampleTimeUs)246 status_t JMediaExtractor::getSampleTime(int64_t *sampleTimeUs) {
247     return mImpl->getSampleTime(sampleTimeUs);
248 }
249 
getSampleSize(size_t * sampleSize)250 status_t JMediaExtractor::getSampleSize(size_t *sampleSize) {
251     return mImpl->getSampleSize(sampleSize);
252 }
253 
getSampleFlags(uint32_t * sampleFlags)254 status_t JMediaExtractor::getSampleFlags(uint32_t *sampleFlags) {
255     *sampleFlags = 0;
256 
257     sp<MetaData> meta;
258     status_t err = mImpl->getSampleMeta(&meta);
259 
260     if (err != OK) {
261         return err;
262     }
263 
264     int32_t val;
265     if (meta->findInt32(kKeyIsSyncFrame, &val) && val != 0) {
266         (*sampleFlags) |= NuMediaExtractor::SAMPLE_FLAG_SYNC;
267     }
268 
269     uint32_t type;
270     const void *data;
271     size_t size;
272     if (meta->findData(kKeyEncryptedSizes, &type, &data, &size)) {
273         (*sampleFlags) |= NuMediaExtractor::SAMPLE_FLAG_ENCRYPTED;
274     }
275 
276     return OK;
277 }
278 
getMetrics(Parcel * reply) const279 status_t JMediaExtractor::getMetrics(Parcel *reply) const {
280 
281     status_t status = mImpl->getMetrics(reply);
282     return status;
283 }
284 
285 
getSampleMeta(sp<MetaData> * sampleMeta)286 status_t JMediaExtractor::getSampleMeta(sp<MetaData> *sampleMeta) {
287     return mImpl->getSampleMeta(sampleMeta);
288 }
289 
getCachedDuration(int64_t * durationUs,bool * eos) const290 bool JMediaExtractor::getCachedDuration(int64_t *durationUs, bool *eos) const {
291     return mImpl->getCachedDuration(durationUs, eos);
292 }
293 
getAudioPresentations(size_t trackIdx,AudioPresentationCollection * presentations) const294 status_t JMediaExtractor::getAudioPresentations(size_t trackIdx,
295         AudioPresentationCollection *presentations) const {
296     return mImpl->getAudioPresentations(trackIdx, presentations);
297 }
298 }  // namespace android
299 
300 ////////////////////////////////////////////////////////////////////////////////
301 
302 using namespace android;
303 
setMediaExtractor(JNIEnv * env,jobject thiz,const sp<JMediaExtractor> & extractor)304 static sp<JMediaExtractor> setMediaExtractor(
305         JNIEnv *env, jobject thiz, const sp<JMediaExtractor> &extractor) {
306     sp<JMediaExtractor> old =
307         (JMediaExtractor *)env->GetLongField(thiz, gFields.context);
308 
309     if (extractor != NULL) {
310         extractor->incStrong(thiz);
311     }
312     if (old != NULL) {
313         old->decStrong(thiz);
314     }
315     env->SetLongField(thiz, gFields.context, (jlong)extractor.get());
316 
317     return old;
318 }
319 
getMediaExtractor(JNIEnv * env,jobject thiz)320 static sp<JMediaExtractor> getMediaExtractor(JNIEnv *env, jobject thiz) {
321     return (JMediaExtractor *)env->GetLongField(thiz, gFields.context);
322 }
323 
android_media_MediaExtractor_release(JNIEnv * env,jobject thiz)324 static void android_media_MediaExtractor_release(JNIEnv *env, jobject thiz) {
325     setMediaExtractor(env, thiz, NULL);
326 }
327 
android_media_MediaExtractor_getTrackCount(JNIEnv * env,jobject thiz)328 static jint android_media_MediaExtractor_getTrackCount(
329         JNIEnv *env, jobject thiz) {
330     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
331 
332     if (extractor == NULL) {
333         jniThrowException(env, "java/lang/IllegalStateException", NULL);
334         return -1;
335     }
336 
337     return (jint) extractor->countTracks();
338 }
339 
android_media_MediaExtractor_getTrackFormatNative(JNIEnv * env,jobject thiz,jint index)340 static jobject android_media_MediaExtractor_getTrackFormatNative(
341         JNIEnv *env, jobject thiz, jint index) {
342     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
343 
344     if (extractor == NULL) {
345         jniThrowException(env, "java/lang/IllegalStateException", NULL);
346         return NULL;
347     }
348 
349     jobject format;
350     status_t err = extractor->getTrackFormat(index, &format);
351 
352     if (err != OK) {
353         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
354         return NULL;
355     }
356 
357     return format;
358 }
359 
android_media_MediaExtractor_getFileFormatNative(JNIEnv * env,jobject thiz)360 static jobject android_media_MediaExtractor_getFileFormatNative(
361         JNIEnv *env, jobject thiz) {
362     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
363 
364     if (extractor == NULL) {
365         jniThrowException(env, "java/lang/IllegalStateException", NULL);
366         return NULL;
367     }
368 
369     jobject format;
370     status_t err = extractor->getFileFormat(&format);
371 
372     if (err != OK) {
373         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
374         return NULL;
375     }
376 
377     return format;
378 }
379 
android_media_MediaExtractor_selectTrack(JNIEnv * env,jobject thiz,jint index)380 static void android_media_MediaExtractor_selectTrack(
381         JNIEnv *env, jobject thiz, jint index) {
382     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
383 
384     if (extractor == NULL) {
385         jniThrowException(env, "java/lang/IllegalStateException", NULL);
386         return;
387     }
388 
389     status_t err = extractor->selectTrack(index);
390 
391     if (err != OK) {
392         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
393         return;
394     }
395 }
396 
android_media_MediaExtractor_unselectTrack(JNIEnv * env,jobject thiz,jint index)397 static void android_media_MediaExtractor_unselectTrack(
398         JNIEnv *env, jobject thiz, jint index) {
399     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
400 
401     if (extractor == NULL) {
402         jniThrowException(env, "java/lang/IllegalStateException", NULL);
403         return;
404     }
405 
406     status_t err = extractor->unselectTrack(index);
407 
408     if (err != OK) {
409         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
410         return;
411     }
412 }
413 
android_media_MediaExtractor_seekTo(JNIEnv * env,jobject thiz,jlong timeUs,jint mode)414 static void android_media_MediaExtractor_seekTo(
415         JNIEnv *env, jobject thiz, jlong timeUs, jint mode) {
416     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
417 
418     if (extractor == NULL) {
419         jniThrowException(env, "java/lang/IllegalStateException", NULL);
420         return;
421     }
422 
423     if (mode < MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC
424             || mode >= MediaSource::ReadOptions::SEEK_CLOSEST) {
425         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
426         return;
427     }
428 
429     extractor->seekTo(timeUs, (MediaSource::ReadOptions::SeekMode)mode);
430 }
431 
android_media_MediaExtractor_advance(JNIEnv * env,jobject thiz)432 static jboolean android_media_MediaExtractor_advance(
433         JNIEnv *env, jobject thiz) {
434     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
435 
436     if (extractor == NULL) {
437         jniThrowException(env, "java/lang/IllegalStateException", NULL);
438         return JNI_FALSE;
439     }
440 
441     status_t err = extractor->advance();
442 
443     if (err == ERROR_END_OF_STREAM) {
444         return JNI_FALSE;
445     } else if (err != OK) {
446         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
447         return JNI_FALSE;
448     }
449 
450     return JNI_TRUE;
451 }
452 
android_media_MediaExtractor_readSampleData(JNIEnv * env,jobject thiz,jobject byteBuf,jint offset)453 static jint android_media_MediaExtractor_readSampleData(
454         JNIEnv *env, jobject thiz, jobject byteBuf, jint offset) {
455     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
456 
457     if (extractor == NULL) {
458         jniThrowException(env, "java/lang/IllegalStateException", NULL);
459         return -1;
460     }
461 
462     size_t sampleSize;
463     status_t err = extractor->readSampleData(byteBuf, offset, &sampleSize);
464 
465     if (err == ERROR_END_OF_STREAM) {
466         return -1;
467     } else if (err != OK) {
468         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
469         return -1;
470     }
471 
472     return (jint) sampleSize;
473 }
474 
android_media_MediaExtractor_getSampleTrackIndex(JNIEnv * env,jobject thiz)475 static jint android_media_MediaExtractor_getSampleTrackIndex(
476         JNIEnv *env, jobject thiz) {
477     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
478 
479     if (extractor == NULL) {
480         jniThrowException(env, "java/lang/IllegalStateException", NULL);
481         return -1;
482     }
483 
484     size_t trackIndex;
485     status_t err = extractor->getSampleTrackIndex(&trackIndex);
486 
487     if (err == ERROR_END_OF_STREAM) {
488         return -1;
489     } else if (err != OK) {
490         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
491         return -1;
492     }
493 
494     return (jint) trackIndex;
495 }
496 
android_media_MediaExtractor_getSampleTime(JNIEnv * env,jobject thiz)497 static jlong android_media_MediaExtractor_getSampleTime(
498         JNIEnv *env, jobject thiz) {
499     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
500 
501     if (extractor == NULL) {
502         jniThrowException(env, "java/lang/IllegalStateException", NULL);
503         return -1LL;
504     }
505 
506     int64_t sampleTimeUs;
507     status_t err = extractor->getSampleTime(&sampleTimeUs);
508 
509     if (err == ERROR_END_OF_STREAM) {
510         return -1LL;
511     } else if (err != OK) {
512         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
513         return -1LL;
514     }
515 
516     return (jlong) sampleTimeUs;
517 }
518 
android_media_MediaExtractor_getSampleSize(JNIEnv * env,jobject thiz)519 static jlong android_media_MediaExtractor_getSampleSize(
520         JNIEnv *env, jobject thiz) {
521     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
522 
523     if (extractor == NULL) {
524         jniThrowException(env, "java/lang/IllegalStateException", NULL);
525         return -1LL;
526     }
527 
528     size_t sampleSize;
529     status_t err = extractor->getSampleSize(&sampleSize);
530 
531     if (err == ERROR_END_OF_STREAM) {
532         return -1LL;
533     } else if (err != OK) {
534         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
535         return -1LL;
536     }
537 
538     return (jlong) sampleSize;
539 }
540 
android_media_MediaExtractor_getSampleFlags(JNIEnv * env,jobject thiz)541 static jint android_media_MediaExtractor_getSampleFlags(
542         JNIEnv *env, jobject thiz) {
543     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
544 
545     if (extractor == NULL) {
546         jniThrowException(env, "java/lang/IllegalStateException", NULL);
547         return -1;
548     }
549 
550     uint32_t sampleFlags;
551     status_t err = extractor->getSampleFlags(&sampleFlags);
552 
553     if (err == ERROR_END_OF_STREAM) {
554         return -1;
555     } else if (err != OK) {
556         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
557         return -1;
558     }
559 
560     return (jint) sampleFlags;
561 }
562 
android_media_MediaExtractor_getSampleCryptoInfo(JNIEnv * env,jobject thiz,jobject cryptoInfoObj)563 static jboolean android_media_MediaExtractor_getSampleCryptoInfo(
564         JNIEnv *env, jobject thiz, jobject cryptoInfoObj) {
565     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
566 
567     if (extractor == NULL) {
568         jniThrowException(env, "java/lang/IllegalStateException", NULL);
569         return JNI_FALSE;
570     }
571 
572     sp<MetaData> meta;
573     status_t err = extractor->getSampleMeta(&meta);
574 
575     if (err != OK) {
576         return JNI_FALSE;
577     }
578 
579     uint32_t type;
580     const void *data;
581     size_t size;
582     if (!meta->findData(kKeyEncryptedSizes, &type, &data, &size)) {
583         return JNI_FALSE;
584     }
585 
586     size_t numSubSamples = size / sizeof(int32_t);
587 
588     if (numSubSamples == 0) {
589         return JNI_FALSE;
590     }
591 
592     jintArray numBytesOfEncryptedDataObj = env->NewIntArray(numSubSamples);
593     jboolean isCopy;
594     jint *dst = env->GetIntArrayElements(numBytesOfEncryptedDataObj, &isCopy);
595     for (size_t i = 0; i < numSubSamples; ++i) {
596         dst[i] = ((const int32_t *)data)[i];
597     }
598     env->ReleaseIntArrayElements(numBytesOfEncryptedDataObj, dst, 0);
599     dst = NULL;
600 
601     size_t encSize = size;
602     jintArray numBytesOfPlainDataObj = NULL;
603     if (meta->findData(kKeyPlainSizes, &type, &data, &size)) {
604         if (size != encSize) {
605             // The two must be of the same length.
606             return JNI_FALSE;
607         }
608 
609         numBytesOfPlainDataObj = env->NewIntArray(numSubSamples);
610         jboolean isCopy;
611         jint *dst = env->GetIntArrayElements(numBytesOfPlainDataObj, &isCopy);
612         for (size_t i = 0; i < numSubSamples; ++i) {
613             dst[i] = ((const int32_t *)data)[i];
614         }
615         env->ReleaseIntArrayElements(numBytesOfPlainDataObj, dst, 0);
616         dst = NULL;
617     }
618 
619     jbyteArray keyObj = NULL;
620     if (meta->findData(kKeyCryptoKey, &type, &data, &size)) {
621         if (size != 16) {
622             // Keys must be 16 bytes in length.
623             return JNI_FALSE;
624         }
625 
626         keyObj = env->NewByteArray(size);
627         jboolean isCopy;
628         jbyte *dst = env->GetByteArrayElements(keyObj, &isCopy);
629         memcpy(dst, data, size);
630         env->ReleaseByteArrayElements(keyObj, dst, 0);
631         dst = NULL;
632     }
633 
634     jbyteArray ivObj = NULL;
635     if (meta->findData(kKeyCryptoIV, &type, &data, &size)) {
636         if (size != 16) {
637             // IVs must be 16 bytes in length.
638             return JNI_FALSE;
639         }
640 
641         ivObj = env->NewByteArray(size);
642         jboolean isCopy;
643         jbyte *dst = env->GetByteArrayElements(ivObj, &isCopy);
644         memcpy(dst, data, size);
645         env->ReleaseByteArrayElements(ivObj, dst, 0);
646         dst = NULL;
647     }
648 
649     int32_t mode;
650     if (!meta->findInt32(kKeyCryptoMode, &mode)) {
651         mode = CryptoPlugin::kMode_AES_CTR;
652     }
653 
654     env->CallVoidMethod(
655             cryptoInfoObj,
656             gFields.cryptoInfoSetID,
657             (jint)numSubSamples,
658             numBytesOfPlainDataObj,
659             numBytesOfEncryptedDataObj,
660             keyObj,
661             ivObj,
662             mode);
663 
664     int32_t encryptedByteBlock = 0, skipByteBlock = 0;
665     meta->findInt32(kKeyEncryptedByteBlock, &encryptedByteBlock);
666     meta->findInt32(kKeySkipByteBlock, &skipByteBlock);
667 
668     env->CallVoidMethod(
669             cryptoInfoObj,
670             gFields.cryptoInfoSetPatternID,
671             encryptedByteBlock,
672             skipByteBlock);
673 
674     return JNI_TRUE;
675 }
676 
android_media_MediaExtractor_getAudioPresentations(JNIEnv * env,jobject thiz,jint trackIdx)677 static jobject android_media_MediaExtractor_getAudioPresentations(
678         JNIEnv *env, jobject thiz, jint trackIdx) {
679     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
680     jobject presentationsJObj = JAudioPresentationInfo::asJobject(env, gAudioPresentationFields);
681     if (extractor == NULL) {
682         jniThrowException(env, "java/lang/IllegalStateException", NULL);
683         return presentationsJObj;
684     }
685     AudioPresentationCollection presentations;
686     status_t err = extractor->getAudioPresentations(trackIdx, &presentations);
687     if (err == ERROR_END_OF_STREAM || err == ERROR_UNSUPPORTED) {
688         return presentationsJObj;
689     } else if (err != OK) {
690         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
691         return presentationsJObj;
692     }
693 
694     JAudioPresentationInfo::addPresentations(
695             env, gAudioPresentationFields, presentations, presentationsJObj);
696     return presentationsJObj;
697 }
698 
android_media_MediaExtractor_native_init(JNIEnv * env)699 static void android_media_MediaExtractor_native_init(JNIEnv *env) {
700     jclass clazz = env->FindClass("android/media/MediaExtractor");
701     CHECK(clazz != NULL);
702 
703     gFields.context = env->GetFieldID(clazz, "mNativeContext", "J");
704     CHECK(gFields.context != NULL);
705 
706     clazz = env->FindClass("android/media/MediaCodec$CryptoInfo");
707     CHECK(clazz != NULL);
708 
709     gFields.cryptoInfoSetID =
710         env->GetMethodID(clazz, "set", "(I[I[I[B[BI)V");
711 
712     gFields.cryptoInfoSetPatternID =
713         env->GetMethodID(clazz, "setPattern", "(II)V");
714 
715     gAudioPresentationFields.init(env);
716 }
717 
android_media_MediaExtractor_native_setup(JNIEnv * env,jobject thiz)718 static void android_media_MediaExtractor_native_setup(
719         JNIEnv *env, jobject thiz) {
720     sp<JMediaExtractor> extractor = new JMediaExtractor(env, thiz);
721     setMediaExtractor(env,thiz, extractor);
722 }
723 
android_media_MediaExtractor_setDataSource(JNIEnv * env,jobject thiz,jobject httpServiceBinderObj,jstring pathObj,jobjectArray keysArray,jobjectArray valuesArray)724 static void android_media_MediaExtractor_setDataSource(
725         JNIEnv *env, jobject thiz,
726         jobject httpServiceBinderObj,
727         jstring pathObj,
728         jobjectArray keysArray,
729         jobjectArray valuesArray) {
730     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
731 
732     if (extractor == NULL) {
733         jniThrowException(env, "java/lang/IllegalStateException", NULL);
734         return;
735     }
736 
737     if (pathObj == NULL) {
738         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
739         return;
740     }
741 
742     KeyedVector<String8, String8> headers;
743     if (!ConvertKeyValueArraysToKeyedVector(
744                 env, keysArray, valuesArray, &headers)) {
745         return;
746     }
747 
748     const char *path = env->GetStringUTFChars(pathObj, NULL);
749 
750     if (path == NULL) {
751         return;
752     }
753 
754     sp<IMediaHTTPService> httpService;
755     if (httpServiceBinderObj != NULL) {
756         sp<IBinder> binder = ibinderForJavaObject(env, httpServiceBinderObj);
757         httpService = interface_cast<IMediaHTTPService>(binder);
758     }
759 
760     status_t err = extractor->setDataSource(httpService, path, &headers);
761 
762     env->ReleaseStringUTFChars(pathObj, path);
763     path = NULL;
764 
765     if (err != OK) {
766         jniThrowException(
767                 env,
768                 "java/io/IOException",
769                 "Failed to instantiate extractor.");
770         return;
771     }
772 }
773 
android_media_MediaExtractor_setDataSourceFd(JNIEnv * env,jobject thiz,jobject fileDescObj,jlong offset,jlong length)774 static void android_media_MediaExtractor_setDataSourceFd(
775         JNIEnv *env, jobject thiz,
776         jobject fileDescObj, jlong offset, jlong length) {
777     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
778 
779     if (extractor == NULL) {
780         jniThrowException(env, "java/lang/IllegalStateException", NULL);
781         return;
782     }
783 
784     if (fileDescObj == NULL) {
785         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
786         return;
787     }
788 
789     int fd = jniGetFDFromFileDescriptor(env, fileDescObj);
790 
791     status_t err = extractor->setDataSource(fd, offset, length);
792 
793     if (err != OK) {
794         jniThrowException(
795                 env,
796                 "java/io/IOException",
797                 "Failed to instantiate extractor.");
798         return;
799     }
800 }
801 
android_media_MediaExtractor_setDataSourceCallback(JNIEnv * env,jobject thiz,jobject callbackObj)802 static void android_media_MediaExtractor_setDataSourceCallback(
803         JNIEnv *env, jobject thiz,
804         jobject callbackObj) {
805     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
806 
807     if (extractor == NULL) {
808         jniThrowException(env, "java/lang/IllegalStateException", NULL);
809         return;
810     }
811 
812     if (callbackObj == NULL) {
813         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
814         return;
815     }
816 
817     sp<DataSource> bridge =
818         CreateDataSourceFromIDataSource(new JMediaDataSource(env, callbackObj));
819     status_t err = extractor->setDataSource(bridge);
820 
821     if (err != OK) {
822         // Clear bridge so that JMediaDataSource::close() is called _before_
823         // we throw the IOException.
824         // Otherwise close() gets called when we go out of scope, it calls
825         // Java with a pending exception and crashes the process.
826         bridge.clear();
827         jniThrowException(
828                 env,
829                 "java/io/IOException",
830                 "Failed to instantiate extractor.");
831         return;
832     }
833 }
834 
android_media_MediaExtractor_setMediaCas(JNIEnv * env,jobject thiz,jobject casBinderObj)835 static void android_media_MediaExtractor_setMediaCas(
836         JNIEnv *env, jobject thiz, jobject casBinderObj) {
837     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
838 
839     if (extractor == NULL) {
840         jniThrowException(env, "java/lang/IllegalStateException", NULL);
841         return;
842     }
843 
844     status_t err = extractor->setMediaCas(env, casBinderObj);
845 
846     if (err != OK) {
847         extractor.clear();
848         jniThrowException(
849                 env,
850                 "java/lang/IllegalArgumentException",
851                 "Failed to set MediaCas on extractor.");
852     }
853 }
854 
android_media_MediaExtractor_getCachedDurationUs(JNIEnv * env,jobject thiz)855 static jlong android_media_MediaExtractor_getCachedDurationUs(
856         JNIEnv *env, jobject thiz) {
857     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
858 
859     if (extractor == NULL) {
860         jniThrowException(env, "java/lang/IllegalStateException", NULL);
861         return -1LL;
862     }
863 
864     int64_t cachedDurationUs;
865     bool eos;
866     if (!extractor->getCachedDuration(&cachedDurationUs, &eos)) {
867         return -1LL;
868     }
869 
870     return (jlong) cachedDurationUs;
871 }
872 
android_media_MediaExtractor_hasCacheReachedEOS(JNIEnv * env,jobject thiz)873 static jboolean android_media_MediaExtractor_hasCacheReachedEOS(
874         JNIEnv *env, jobject thiz) {
875     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
876 
877     if (extractor == NULL) {
878         jniThrowException(env, "java/lang/IllegalStateException", NULL);
879         return JNI_TRUE;
880     }
881 
882     int64_t cachedDurationUs;
883     bool eos;
884     if (!extractor->getCachedDuration(&cachedDurationUs, &eos)) {
885         return JNI_TRUE;
886     }
887 
888     return eos ? JNI_TRUE : JNI_FALSE;
889 }
890 
android_media_MediaExtractor_native_finalize(JNIEnv * env,jobject thiz)891 static void android_media_MediaExtractor_native_finalize(
892         JNIEnv *env, jobject thiz) {
893     android_media_MediaExtractor_release(env, thiz);
894 }
895 
896 static jobject
android_media_MediaExtractor_native_getMetrics(JNIEnv * env,jobject thiz)897 android_media_MediaExtractor_native_getMetrics(JNIEnv * env, jobject thiz)
898 {
899     ALOGV("android_media_MediaExtractor_native_getMetrics");
900 
901     sp<JMediaExtractor> extractor = getMediaExtractor(env, thiz);
902     if (extractor == NULL ) {
903         jniThrowException(env, "java/lang/IllegalStateException", NULL);
904         return NULL;
905     }
906 
907     // get what we have for the metrics from the codec
908     Parcel reply;
909     status_t err = extractor->getMetrics(&reply);
910     if (err != OK) {
911         ALOGE("getMetrics failed");
912         return (jobject) NULL;
913     }
914 
915     // build and return the Bundle
916     std::unique_ptr<MediaAnalyticsItem> item(MediaAnalyticsItem::create());
917     item->readFromParcel(reply);
918     jobject mybundle = MediaMetricsJNI::writeMetricsToBundle(env, item.get(), NULL);
919 
920     return mybundle;
921 }
922 
923 
924 static const JNINativeMethod gMethods[] = {
925     { "release", "()V", (void *)android_media_MediaExtractor_release },
926 
927     { "getTrackCount", "()I", (void *)android_media_MediaExtractor_getTrackCount },
928 
929     { "getFileFormatNative", "()Ljava/util/Map;",
930         (void *)android_media_MediaExtractor_getFileFormatNative },
931 
932     { "getTrackFormatNative", "(I)Ljava/util/Map;",
933         (void *)android_media_MediaExtractor_getTrackFormatNative },
934 
935     { "selectTrack", "(I)V", (void *)android_media_MediaExtractor_selectTrack },
936 
937     { "unselectTrack", "(I)V",
938         (void *)android_media_MediaExtractor_unselectTrack },
939 
940     { "seekTo", "(JI)V", (void *)android_media_MediaExtractor_seekTo },
941 
942     { "advance", "()Z", (void *)android_media_MediaExtractor_advance },
943 
944     { "readSampleData", "(Ljava/nio/ByteBuffer;I)I",
945         (void *)android_media_MediaExtractor_readSampleData },
946 
947     { "getSampleTrackIndex", "()I",
948         (void *)android_media_MediaExtractor_getSampleTrackIndex },
949 
950     { "getSampleTime", "()J",
951         (void *)android_media_MediaExtractor_getSampleTime },
952 
953     { "getSampleSize", "()J",
954         (void *)android_media_MediaExtractor_getSampleSize },
955 
956     { "getSampleFlags", "()I",
957         (void *)android_media_MediaExtractor_getSampleFlags },
958 
959     { "getSampleCryptoInfo", "(Landroid/media/MediaCodec$CryptoInfo;)Z",
960         (void *)android_media_MediaExtractor_getSampleCryptoInfo },
961 
962     { "native_init", "()V", (void *)android_media_MediaExtractor_native_init },
963 
964     { "native_setup", "()V",
965       (void *)android_media_MediaExtractor_native_setup },
966 
967     { "native_finalize", "()V",
968       (void *)android_media_MediaExtractor_native_finalize },
969 
970     { "nativeSetDataSource",
971         "(Landroid/os/IBinder;Ljava/lang/String;[Ljava/lang/String;"
972         "[Ljava/lang/String;)V",
973       (void *)android_media_MediaExtractor_setDataSource },
974 
975     { "setDataSource", "(Ljava/io/FileDescriptor;JJ)V",
976       (void *)android_media_MediaExtractor_setDataSourceFd },
977 
978     { "setDataSource", "(Landroid/media/MediaDataSource;)V",
979       (void *)android_media_MediaExtractor_setDataSourceCallback },
980 
981     { "nativeSetMediaCas", "(Landroid/os/IHwBinder;)V",
982       (void *)android_media_MediaExtractor_setMediaCas },
983 
984     { "getCachedDuration", "()J",
985       (void *)android_media_MediaExtractor_getCachedDurationUs },
986 
987     { "hasCacheReachedEndOfStream", "()Z",
988       (void *)android_media_MediaExtractor_hasCacheReachedEOS },
989 
990     {"native_getMetrics",          "()Landroid/os/PersistableBundle;",
991       (void *)android_media_MediaExtractor_native_getMetrics},
992 
993     { "native_getAudioPresentations", "(I)Ljava/util/List;",
994       (void *)android_media_MediaExtractor_getAudioPresentations },
995 };
996 
register_android_media_MediaExtractor(JNIEnv * env)997 int register_android_media_MediaExtractor(JNIEnv *env) {
998     return AndroidRuntime::registerNativeMethods(env,
999                 "android/media/MediaExtractor", gMethods, NELEM(gMethods));
1000 }
1001