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/JNIHelp.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