1 /*
2 **
3 ** Copyright 2008, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 **     http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17 
18 //#define LOG_NDEBUG 0
19 #define LOG_TAG "MediaMetadataRetrieverJNI"
20 
21 #include <cmath>
22 #include <assert.h>
23 #include <utils/Log.h>
24 #include <utils/threads.h>
25 #include <android/graphics/bitmap.h>
26 #include <media/IMediaHTTPService.h>
27 #include <media/mediametadataretriever.h>
28 #include <media/mediascanner.h>
29 #include <nativehelper/ScopedLocalRef.h>
30 #include <private/media/VideoFrame.h>
31 
32 #include "jni.h"
33 #include <nativehelper/JNIPlatformHelp.h>
34 #include "android_runtime/AndroidRuntime.h"
35 #include "android_media_MediaDataSource.h"
36 #include "android_media_Streams.h"
37 #include "android_util_Binder.h"
38 #include <com_android_media_playback_flags.h>
39 
40 namespace playback_flags = com::android::media::playback::flags;
41 using namespace android;
42 
43 struct fields_t {
44     jfieldID context;
45     jclass bitmapClazz;  // Must be a global ref
46     jmethodID createBitmapMethod;
47     jmethodID createScaledBitmapMethod;
48     jclass bitmapParamsClazz; // Must be a global ref
49     jfieldID inPreferredConfig;
50     jfieldID outActualConfig;
51     jclass arrayListClazz; // Must be a global ref
52     jmethodID arrayListInit;
53     jmethodID arrayListAdd;
54 };
55 
56 static fields_t fields;
57 static Mutex sLock;
58 static const char* const kClassPathName = "android/media/MediaMetadataRetriever";
59 
process_media_retriever_call(JNIEnv * env,status_t opStatus,const char * exception,const char * message)60 static void process_media_retriever_call(JNIEnv *env, status_t opStatus, const char* exception, const char *message)
61 {
62     if (opStatus == (status_t) INVALID_OPERATION) {
63         jniThrowException(env, "java/lang/IllegalStateException", NULL);
64     } else if (opStatus != (status_t) OK) {
65         if (strlen(message) > 230) {
66             // If the message is too long, don't bother displaying the status code.
67             jniThrowException( env, exception, message);
68         } else {
69             char msg[256];
70             // Append the status code to the message.
71             sprintf(msg, "%s: status = 0x%X", message, opStatus);
72             jniThrowException( env, exception, msg);
73         }
74     }
75 }
76 
getRetriever(JNIEnv * env,jobject thiz)77 static sp<MediaMetadataRetriever> getRetriever(JNIEnv* env, jobject thiz)
78 {
79     // No lock is needed, since it is called internally by other methods that are protected
80     MediaMetadataRetriever* retriever = (MediaMetadataRetriever*) env->GetLongField(thiz, fields.context);
81     return retriever;
82 }
83 
setRetriever(JNIEnv * env,jobject thiz,const sp<MediaMetadataRetriever> & retriever)84 static void setRetriever(JNIEnv* env, jobject thiz, const sp<MediaMetadataRetriever> &retriever)
85 {
86     // No lock is needed, since it is called internally by other methods that are protected
87 
88     if (retriever != NULL) {
89         retriever->incStrong(thiz);
90     }
91     sp<MediaMetadataRetriever> old = getRetriever(env, thiz);
92     if (old != NULL) {
93         old->decStrong(thiz);
94     }
95 
96     env->SetLongField(thiz, fields.context, (jlong) retriever.get());
97 }
98 
99 static void
android_media_MediaMetadataRetriever_setDataSourceAndHeaders(JNIEnv * env,jobject thiz,jobject httpServiceBinderObj,jstring path,jobjectArray keys,jobjectArray values)100 android_media_MediaMetadataRetriever_setDataSourceAndHeaders(
101         JNIEnv *env, jobject thiz, jobject httpServiceBinderObj, jstring path,
102         jobjectArray keys, jobjectArray values) {
103 
104     ALOGV("setDataSource");
105     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
106     if (retriever == 0) {
107         jniThrowException(
108                 env,
109                 "java/lang/IllegalStateException", "No retriever available");
110 
111         return;
112     }
113 
114     if (!path) {
115         jniThrowException(
116                 env, "java/lang/IllegalArgumentException", "Null pointer");
117 
118         return;
119     }
120 
121     const char *tmp = env->GetStringUTFChars(path, NULL);
122     if (!tmp) {  // OutOfMemoryError exception already thrown
123         return;
124     }
125 
126     String8 pathStr(tmp);
127     env->ReleaseStringUTFChars(path, tmp);
128     tmp = NULL;
129 
130     // Don't let somebody trick us in to reading some random block of memory
131     if (strncmp("mem://", pathStr.c_str(), 6) == 0) {
132         jniThrowException(
133                 env, "java/lang/IllegalArgumentException", "Invalid pathname");
134         return;
135     }
136 
137     // We build a similar KeyedVector out of it.
138     KeyedVector<String8, String8> headersVector;
139     if (!ConvertKeyValueArraysToKeyedVector(
140             env, keys, values, &headersVector)) {
141         return;
142     }
143 
144     sp<IMediaHTTPService> httpService;
145     if (httpServiceBinderObj != NULL) {
146         sp<IBinder> binder = ibinderForJavaObject(env, httpServiceBinderObj);
147         httpService = interface_cast<IMediaHTTPService>(binder);
148     }
149 
150     process_media_retriever_call(
151             env,
152             retriever->setDataSource(
153                 httpService,
154                 pathStr.c_str(),
155                 headersVector.size() > 0 ? &headersVector : NULL),
156 
157             "java/lang/RuntimeException",
158             "setDataSource failed");
159 }
160 
android_media_MediaMetadataRetriever_setDataSourceFD(JNIEnv * env,jobject thiz,jobject fileDescriptor,jlong offset,jlong length)161 static void android_media_MediaMetadataRetriever_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
162 {
163     ALOGV("setDataSource");
164     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
165     if (retriever == 0) {
166         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
167         return;
168     }
169     if (!fileDescriptor) {
170         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
171         return;
172     }
173     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
174     if (offset < 0 || length < 0 || fd < 0) {
175         if (offset < 0) {
176             ALOGE("negative offset (%lld)", (long long)offset);
177         }
178         if (length < 0) {
179             ALOGE("negative length (%lld)", (long long)length);
180         }
181         if (fd < 0) {
182             ALOGE("invalid file descriptor");
183         }
184         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
185         return;
186     }
187     process_media_retriever_call(env, retriever->setDataSource(fd, offset, length), "java/lang/RuntimeException", "setDataSource failed");
188 }
189 
android_media_MediaMetadataRetriever_setDataSourceCallback(JNIEnv * env,jobject thiz,jobject dataSource)190 static void android_media_MediaMetadataRetriever_setDataSourceCallback(JNIEnv *env, jobject thiz, jobject dataSource)
191 {
192     ALOGV("setDataSourceCallback");
193     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
194     if (retriever == 0) {
195         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
196         return;
197     }
198     if (dataSource == NULL) {
199         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
200         return;
201     }
202 
203     sp<IDataSource> callbackDataSource = new JMediaDataSource(env, dataSource);
204     process_media_retriever_call(env, retriever->setDataSource(callbackDataSource), "java/lang/RuntimeException", "setDataSourceCallback failed");
205 }
206 
207 template<typename T>
rotate0(T * dst,const T * src,size_t width,size_t height)208 static void rotate0(T* dst, const T* src, size_t width, size_t height)
209 {
210     memcpy(dst, src, width * height * sizeof(T));
211 }
212 
213 template<typename T>
rotate90(T * dst,const T * src,size_t width,size_t height)214 static void rotate90(T* dst, const T* src, size_t width, size_t height)
215 {
216     for (size_t i = 0; i < height; ++i) {
217         for (size_t j = 0; j < width; ++j) {
218             dst[j * height + height - 1 - i] = src[i * width + j];
219         }
220     }
221 }
222 
223 template<typename T>
rotate180(T * dst,const T * src,size_t width,size_t height)224 static void rotate180(T* dst, const T* src, size_t width, size_t height)
225 {
226     for (size_t i = 0; i < height; ++i) {
227         for (size_t j = 0; j < width; ++j) {
228             dst[(height - 1 - i) * width + width - 1 - j] = src[i * width + j];
229         }
230     }
231 }
232 
233 template<typename T>
rotate270(T * dst,const T * src,size_t width,size_t height)234 static void rotate270(T* dst, const T* src, size_t width, size_t height)
235 {
236     for (size_t i = 0; i < height; ++i) {
237         for (size_t j = 0; j < width; ++j) {
238             dst[(width - 1 - j) * height + i] = src[i * width + j];
239         }
240     }
241 }
242 
243 template<typename T>
rotate(T * dst,const T * src,size_t width,size_t height,int angle)244 static void rotate(T *dst, const T *src, size_t width, size_t height, int angle)
245 {
246     switch (angle) {
247         case 0:
248             rotate0(dst, src, width, height);
249             break;
250         case 90:
251             rotate90(dst, src, width, height);
252             break;
253         case 180:
254             rotate180(dst, src, width, height);
255             break;
256         case 270:
257             rotate270(dst, src, width, height);
258             break;
259     }
260 }
261 
getBitmapFromVideoFrame(JNIEnv * env,VideoFrame * videoFrame,jint dst_width,jint dst_height,AndroidBitmapFormat outColorType)262 static jobject getBitmapFromVideoFrame(
263         JNIEnv *env, VideoFrame *videoFrame, jint dst_width, jint dst_height,
264         AndroidBitmapFormat outColorType) {
265     ALOGV("getBitmapFromVideoFrame: dimension = %dx%d, displaySize = %dx%d, bytes = %d",
266             videoFrame->mWidth,
267             videoFrame->mHeight,
268             videoFrame->mDisplayWidth,
269             videoFrame->mDisplayHeight,
270             videoFrame->mSize);
271 
272     ScopedLocalRef<jobject> config(env, ABitmapConfig_getConfigFromFormat(env, outColorType));
273 
274     uint32_t width, height, displayWidth, displayHeight;
275     bool swapWidthAndHeight = false;
276     if (videoFrame->mRotationAngle == 90 || videoFrame->mRotationAngle == 270) {
277         width = videoFrame->mHeight;
278         height = videoFrame->mWidth;
279         swapWidthAndHeight = true;
280         displayWidth = videoFrame->mDisplayHeight;
281         displayHeight = videoFrame->mDisplayWidth;
282     } else {
283         width = videoFrame->mWidth;
284         height = videoFrame->mHeight;
285         displayWidth = videoFrame->mDisplayWidth;
286         displayHeight = videoFrame->mDisplayHeight;
287     }
288 
289     jobject jBitmap = env->CallStaticObjectMethod(
290                             fields.bitmapClazz,
291                             fields.createBitmapMethod,
292                             width,
293                             height,
294                             config.get());
295     if (jBitmap == NULL) {
296         if (env->ExceptionCheck()) {
297             env->ExceptionClear();
298         }
299         ALOGE("getBitmapFromVideoFrame: create Bitmap failed!");
300         return NULL;
301     }
302 
303     graphics::Bitmap bitmap(env, jBitmap);
304 
305     if (outColorType == ANDROID_BITMAP_FORMAT_RGB_565) {
306         rotate((uint16_t*)bitmap.getPixels(),
307                (uint16_t*)((char*)videoFrame + sizeof(VideoFrame)),
308                videoFrame->mWidth,
309                videoFrame->mHeight,
310                videoFrame->mRotationAngle);
311     } else {
312         rotate((uint32_t*)bitmap.getPixels(),
313                (uint32_t*)((char*)videoFrame + sizeof(VideoFrame)),
314                videoFrame->mWidth,
315                videoFrame->mHeight,
316                videoFrame->mRotationAngle);
317     }
318 
319     if (dst_width <= 0 || dst_height <= 0) {
320         dst_width = displayWidth;
321         dst_height = displayHeight;
322     } else {
323         float factor = std::min((float)dst_width / (float)displayWidth,
324                 (float)dst_height / (float)displayHeight);
325         dst_width = std::round(displayWidth * factor);
326         dst_height = std::round(displayHeight * factor);
327     }
328 
329     if ((uint32_t)dst_width != width || (uint32_t)dst_height != height) {
330         ALOGV("Bitmap dimension is scaled from %dx%d to %dx%d",
331                 width, height, dst_width, dst_height);
332         jobject scaledBitmap = env->CallStaticObjectMethod(fields.bitmapClazz,
333                                 fields.createScaledBitmapMethod,
334                                 jBitmap,
335                                 dst_width,
336                                 dst_height,
337                                 true);
338 
339         env->DeleteLocalRef(jBitmap);
340         return scaledBitmap;
341     }
342 
343     return jBitmap;
344 }
345 
getColorFormat(JNIEnv * env,jobject options,AndroidBitmapFormat defaultPreferred=ANDROID_BITMAP_FORMAT_RGBA_8888)346 static AndroidBitmapFormat getColorFormat(JNIEnv *env, jobject options,
347         AndroidBitmapFormat defaultPreferred = ANDROID_BITMAP_FORMAT_RGBA_8888) {
348     if (options == NULL) {
349         return defaultPreferred;
350     }
351 
352     ScopedLocalRef<jobject> inConfig(env, env->GetObjectField(options, fields.inPreferredConfig));
353     AndroidBitmapFormat format = ABitmapConfig_getFormatFromConfig(env, inConfig.get());
354 
355     if (format == ANDROID_BITMAP_FORMAT_RGB_565) {
356         return ANDROID_BITMAP_FORMAT_RGB_565;
357     }
358     return ANDROID_BITMAP_FORMAT_RGBA_8888;
359 }
360 
setOutConfig(JNIEnv * env,jobject options,AndroidBitmapFormat colorFormat)361 static void setOutConfig(JNIEnv *env, jobject options, AndroidBitmapFormat colorFormat) {
362     if (options != NULL) {
363         ScopedLocalRef<jobject> config(env, ABitmapConfig_getConfigFromFormat(env, colorFormat));
364         env->SetObjectField(options, fields.outActualConfig, config.get());
365     }
366 }
367 
android_media_MediaMetadataRetriever_getFrameAtTime(JNIEnv * env,jobject thiz,jlong timeUs,jint option,jint dst_width,jint dst_height,jobject params)368 static jobject android_media_MediaMetadataRetriever_getFrameAtTime(
369         JNIEnv *env, jobject thiz, jlong timeUs, jint option,
370         jint dst_width, jint dst_height, jobject params)
371 {
372     ALOGV("getFrameAtTime: %lld us option: %d dst width: %d heigh: %d",
373             (long long)timeUs, option, dst_width, dst_height);
374     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
375     if (retriever == 0) {
376         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
377         return NULL;
378     }
379 
380     AndroidBitmapFormat defaultColorFormat =
381             playback_flags::mediametadataretriever_default_rgba8888()
382             ? ANDROID_BITMAP_FORMAT_RGBA_8888
383             : ANDROID_BITMAP_FORMAT_RGB_565;
384     AndroidBitmapFormat colorFormat = getColorFormat(env, params, defaultColorFormat);
385 
386     // Call native method to retrieve a video frame
387     VideoFrame *videoFrame = NULL;
388     sp<IMemory> frameMemory = retriever->getFrameAtTime(timeUs, option, colorFormat);
389     // TODO: Using unsecurePointer() has some associated security pitfalls
390     //       (see declaration for details).
391     //       Either document why it is safe in this case or address the
392     //       issue (e.g. by copying).
393     if (frameMemory != 0) {  // cast the shared structure to a VideoFrame object
394         videoFrame = static_cast<VideoFrame *>(frameMemory->unsecurePointer());
395     }
396     if (videoFrame == NULL) {
397         ALOGE("getFrameAtTime: videoFrame is a NULL pointer");
398         return NULL;
399     }
400 
401     setOutConfig(env, params, colorFormat);
402     return getBitmapFromVideoFrame(env, videoFrame, dst_width, dst_height, colorFormat);
403 }
404 
android_media_MediaMetadataRetriever_getImageAtIndex(JNIEnv * env,jobject thiz,jint index,jobject params)405 static jobject android_media_MediaMetadataRetriever_getImageAtIndex(
406         JNIEnv *env, jobject thiz, jint index, jobject params)
407 {
408     ALOGV("getImageAtIndex: index %d", index);
409     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
410     if (retriever == 0) {
411         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
412         return NULL;
413     }
414 
415     AndroidBitmapFormat colorFormat = getColorFormat(env, params);
416 
417     // Call native method to retrieve an image
418     VideoFrame *videoFrame = NULL;
419     sp<IMemory> frameMemory = retriever->getImageAtIndex(index, colorFormat);
420     if (frameMemory != 0) {  // cast the shared structure to a VideoFrame object
421         // TODO: Using unsecurePointer() has some associated security pitfalls
422         //       (see declaration for details).
423         //       Either document why it is safe in this case or address the
424         //       issue (e.g. by copying).
425         videoFrame = static_cast<VideoFrame *>(frameMemory->unsecurePointer());
426     }
427     if (videoFrame == NULL) {
428         ALOGE("getImageAtIndex: videoFrame is a NULL pointer");
429         return NULL;
430     }
431 
432     setOutConfig(env, params, colorFormat);
433     return getBitmapFromVideoFrame(env, videoFrame, -1, -1, colorFormat);
434 }
435 
android_media_MediaMetadataRetriever_getThumbnailImageAtIndex(JNIEnv * env,jobject thiz,jint index,jobject params,jint targetSize,jint maxPixels)436 static jobject android_media_MediaMetadataRetriever_getThumbnailImageAtIndex(
437         JNIEnv *env, jobject thiz, jint index, jobject params, jint targetSize, jint maxPixels)
438 {
439     ALOGV("getThumbnailImageAtIndex: index %d", index);
440 
441     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
442     if (retriever == 0) {
443         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
444         return NULL;
445     }
446 
447     AndroidBitmapFormat colorFormat = getColorFormat(env, params);
448     jint dst_width = -1, dst_height = -1;
449 
450     // Call native method to retrieve an image
451     VideoFrame *videoFrame = NULL;
452     sp<IMemory> frameMemory = retriever->getImageAtIndex(
453             index, colorFormat, true /*metaOnly*/, true /*thumbnail*/);
454     if (frameMemory != 0) {
455         // TODO: Using unsecurePointer() has some associated security pitfalls
456         //       (see declaration for details).
457         //       Either document why it is safe in this case or address the
458         //       issue (e.g. by copying).
459         videoFrame = static_cast<VideoFrame *>(frameMemory->unsecurePointer());
460         int32_t thumbWidth = videoFrame->mWidth;
461         int32_t thumbHeight = videoFrame->mHeight;
462         videoFrame = NULL;
463         int64_t thumbPixels = thumbWidth * thumbHeight;
464 
465         // Here we try to use the included thumbnail if it's not too shabby.
466         // If this fails ThumbnailUtils would have to decode the full image and
467         // downscale which could take long.
468         if (thumbWidth >= targetSize || thumbHeight >= targetSize
469                 || thumbPixels * 6 >= maxPixels) {
470             frameMemory = retriever->getImageAtIndex(
471                     index, colorFormat, false /*metaOnly*/, true /*thumbnail*/);
472             if (frameMemory != 0) {
473                 // TODO: Using unsecurePointer() has some associated security pitfalls
474                 //       (see declaration for details).
475                 //       Either document why it is safe in this case or address the
476                 //       issue (e.g. by copying).
477                 videoFrame = static_cast<VideoFrame *>(frameMemory->unsecurePointer());
478             }
479 
480             if (thumbPixels > maxPixels) {
481                 int downscale = ceil(sqrt(thumbPixels / (float)maxPixels));
482                 dst_width = thumbWidth / downscale;
483                 dst_height = thumbHeight /downscale;
484             }
485         }
486     }
487     if (videoFrame == NULL) {
488         ALOGV("getThumbnailImageAtIndex: no suitable thumbnails available");
489         return NULL;
490     }
491 
492     // Ignore rotation for thumbnail extraction to be consistent with
493     // thumbnails extracted by BitmapFactory APIs.
494     videoFrame->mRotationAngle = 0;
495 
496     setOutConfig(env, params, colorFormat);
497     return getBitmapFromVideoFrame(env, videoFrame, dst_width, dst_height, colorFormat);
498 }
499 
android_media_MediaMetadataRetriever_getFrameAtIndex(JNIEnv * env,jobject thiz,jint frameIndex,jint numFrames,jobject params)500 static jobject android_media_MediaMetadataRetriever_getFrameAtIndex(
501         JNIEnv *env, jobject thiz, jint frameIndex, jint numFrames, jobject params)
502 {
503     ALOGV("getFrameAtIndex: frameIndex %d, numFrames %d", frameIndex, numFrames);
504     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
505     if (retriever == 0) {
506         jniThrowException(env,
507                 "java/lang/IllegalStateException", "No retriever available");
508         return NULL;
509     }
510 
511 
512     jobject arrayList = env->NewObject(fields.arrayListClazz, fields.arrayListInit);
513     if (arrayList == NULL) {
514         jniThrowException(env,
515                 "java/lang/IllegalStateException", "Can't create bitmap array");
516         return NULL;
517     }
518 
519     AndroidBitmapFormat colorFormat = getColorFormat(env, params);
520     setOutConfig(env, params, colorFormat);
521     size_t i = 0;
522     for (; i < numFrames; i++) {
523         sp<IMemory> frame = retriever->getFrameAtIndex(frameIndex + i, colorFormat);
524         if (frame == NULL || frame->unsecurePointer() == NULL) {
525             ALOGE("video frame at index %zu is a NULL pointer", frameIndex + i);
526             break;
527         }
528         // TODO: Using unsecurePointer() has some associated security pitfalls
529         //       (see declaration for details).
530         //       Either document why it is safe in this case or address the
531         //       issue (e.g. by copying).
532         VideoFrame *videoFrame = static_cast<VideoFrame *>(frame->unsecurePointer());
533         jobject bitmapObj = getBitmapFromVideoFrame(env, videoFrame, -1, -1, colorFormat);
534         env->CallBooleanMethod(arrayList, fields.arrayListAdd, bitmapObj);
535         env->DeleteLocalRef(bitmapObj);
536     }
537 
538     if (i == 0) {
539         env->DeleteLocalRef(arrayList);
540 
541         jniThrowException(env,
542                 "java/lang/IllegalStateException", "No frames from retriever");
543         return NULL;
544     }
545 
546     return arrayList;
547 }
548 
android_media_MediaMetadataRetriever_getEmbeddedPicture(JNIEnv * env,jobject thiz,jint pictureType)549 static jbyteArray android_media_MediaMetadataRetriever_getEmbeddedPicture(
550         JNIEnv *env, jobject thiz, jint pictureType)
551 {
552     ALOGV("getEmbeddedPicture: %d", pictureType);
553     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
554     if (retriever == 0) {
555         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
556         return NULL;
557     }
558     MediaAlbumArt* mediaAlbumArt = NULL;
559 
560     // FIXME:
561     // Use pictureType to retrieve the intended embedded picture and also change
562     // the method name to getEmbeddedPicture().
563     sp<IMemory> albumArtMemory = retriever->extractAlbumArt();
564     if (albumArtMemory != 0) {  // cast the shared structure to a MediaAlbumArt object
565         // TODO: Using unsecurePointer() has some associated security pitfalls
566         //       (see declaration for details).
567         //       Either document why it is safe in this case or address the
568         //       issue (e.g. by copying).
569         mediaAlbumArt = static_cast<MediaAlbumArt *>(albumArtMemory->unsecurePointer());
570     }
571     if (mediaAlbumArt == NULL) {
572         ALOGE("getEmbeddedPicture: Call to getEmbeddedPicture failed.");
573         return NULL;
574     }
575 
576     jbyteArray array = env->NewByteArray(mediaAlbumArt->size());
577     if (!array) {  // OutOfMemoryError exception has already been thrown.
578         ALOGE("getEmbeddedPicture: OutOfMemoryError is thrown.");
579     } else {
580         const jbyte* data =
581                 reinterpret_cast<const jbyte*>(mediaAlbumArt->data());
582         env->SetByteArrayRegion(array, 0, mediaAlbumArt->size(), data);
583     }
584 
585     // No need to delete mediaAlbumArt here
586     return array;
587 }
588 
android_media_MediaMetadataRetriever_extractMetadata(JNIEnv * env,jobject thiz,jint keyCode)589 static jobject android_media_MediaMetadataRetriever_extractMetadata(JNIEnv *env, jobject thiz, jint keyCode)
590 {
591     ALOGV("extractMetadata");
592     sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz);
593     if (retriever == 0) {
594         jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
595         return NULL;
596     }
597     const char* value = retriever->extractMetadata(keyCode);
598     if (!value) {
599         ALOGV("extractMetadata: Metadata is not found");
600         return NULL;
601     }
602     ALOGV("extractMetadata: value (%s) for keyCode(%d)", value, keyCode);
603     return env->NewStringUTF(value);
604 }
605 
android_media_MediaMetadataRetriever_release(JNIEnv * env,jobject thiz)606 static void android_media_MediaMetadataRetriever_release(JNIEnv *env, jobject thiz)
607 {
608     ALOGV("release");
609     Mutex::Autolock lock(sLock);
610     setRetriever(env, thiz, NULL);
611 }
612 
android_media_MediaMetadataRetriever_native_finalize(JNIEnv * env,jobject thiz)613 static void android_media_MediaMetadataRetriever_native_finalize(JNIEnv *env, jobject thiz)
614 {
615     ALOGV("native_finalize");
616     // No lock is needed, since android_media_MediaMetadataRetriever_release() is protected
617     android_media_MediaMetadataRetriever_release(env, thiz);
618 }
619 
620 // This function gets a field ID, which in turn causes class initialization.
621 // It is called from a static block in MediaMetadataRetriever, which won't run until the
622 // first time an instance of this class is used.
android_media_MediaMetadataRetriever_native_init(JNIEnv * env)623 static void android_media_MediaMetadataRetriever_native_init(JNIEnv *env)
624 {
625     ScopedLocalRef<jclass> clazz(env, env->FindClass(kClassPathName));
626     if (clazz.get() == NULL) {
627         return;
628     }
629 
630     fields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J");
631     if (fields.context == NULL) {
632         return;
633     }
634 
635     clazz.reset(env->FindClass("android/graphics/Bitmap"));
636     if (clazz.get() == NULL) {
637         return;
638     }
639     fields.bitmapClazz = (jclass) env->NewGlobalRef(clazz.get());
640     if (fields.bitmapClazz == NULL) {
641         return;
642     }
643     fields.createBitmapMethod =
644             env->GetStaticMethodID(fields.bitmapClazz, "createBitmap",
645                     "(IILandroid/graphics/Bitmap$Config;)"
646                     "Landroid/graphics/Bitmap;");
647     if (fields.createBitmapMethod == NULL) {
648         return;
649     }
650     fields.createScaledBitmapMethod =
651             env->GetStaticMethodID(fields.bitmapClazz, "createScaledBitmap",
652                     "(Landroid/graphics/Bitmap;IIZ)"
653                     "Landroid/graphics/Bitmap;");
654     if (fields.createScaledBitmapMethod == NULL) {
655         return;
656     }
657 
658     clazz.reset(env->FindClass("android/media/MediaMetadataRetriever$BitmapParams"));
659     if (clazz.get() == NULL) {
660         return;
661     }
662     fields.bitmapParamsClazz = (jclass) env->NewGlobalRef(clazz.get());
663     if (fields.bitmapParamsClazz == NULL) {
664         return;
665     }
666     fields.inPreferredConfig = env->GetFieldID(fields.bitmapParamsClazz,
667             "inPreferredConfig", "Landroid/graphics/Bitmap$Config;");
668     if (fields.inPreferredConfig == NULL) {
669         return;
670     }
671     fields.outActualConfig = env->GetFieldID(fields.bitmapParamsClazz,
672             "outActualConfig", "Landroid/graphics/Bitmap$Config;");
673     if (fields.outActualConfig == NULL) {
674         return;
675     }
676 
677     clazz.reset(env->FindClass("java/util/ArrayList"));
678     if (clazz.get() == NULL) {
679         return;
680     }
681     fields.arrayListClazz = (jclass) env->NewGlobalRef(clazz.get());
682     if (fields.arrayListClazz == NULL) {
683         return;
684     }
685     fields.arrayListInit = env->GetMethodID(clazz.get(), "<init>", "()V");
686     if (fields.arrayListInit == NULL) {
687         return;
688     }
689     fields.arrayListAdd = env->GetMethodID(clazz.get(), "add", "(Ljava/lang/Object;)Z");
690     if (fields.arrayListAdd == NULL) {
691         return;
692     }
693 }
694 
android_media_MediaMetadataRetriever_native_setup(JNIEnv * env,jobject thiz)695 static void android_media_MediaMetadataRetriever_native_setup(JNIEnv *env, jobject thiz)
696 {
697     ALOGV("native_setup");
698     sp<MediaMetadataRetriever> retriever = new MediaMetadataRetriever();
699     if (retriever == 0) {
700         jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
701         return;
702     }
703     setRetriever(env, thiz, retriever);
704 }
705 
706 // JNI mapping between Java methods and native methods
707 static const JNINativeMethod nativeMethods[] = {
708         {
709             "_setDataSource",
710             "(Landroid/os/IBinder;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
711             (void *)android_media_MediaMetadataRetriever_setDataSourceAndHeaders
712         },
713 
714         {"_setDataSource",   "(Ljava/io/FileDescriptor;JJ)V",
715                 (void *)android_media_MediaMetadataRetriever_setDataSourceFD},
716         {"_setDataSource",   "(Landroid/media/MediaDataSource;)V",
717                 (void *)android_media_MediaMetadataRetriever_setDataSourceCallback},
718         {"_getFrameAtTime", "(JIIILandroid/media/MediaMetadataRetriever$BitmapParams;)Landroid/graphics/Bitmap;",
719                 (void *)android_media_MediaMetadataRetriever_getFrameAtTime},
720         {
721             "_getImageAtIndex",
722             "(ILandroid/media/MediaMetadataRetriever$BitmapParams;)Landroid/graphics/Bitmap;",
723             (void *)android_media_MediaMetadataRetriever_getImageAtIndex
724         },
725 
726         {
727             "getThumbnailImageAtIndex",
728             "(ILandroid/media/MediaMetadataRetriever$BitmapParams;II)Landroid/graphics/Bitmap;",
729             (void *)android_media_MediaMetadataRetriever_getThumbnailImageAtIndex
730         },
731 
732         {
733             "_getFrameAtIndex",
734             "(IILandroid/media/MediaMetadataRetriever$BitmapParams;)Ljava/util/List;",
735             (void *)android_media_MediaMetadataRetriever_getFrameAtIndex
736         },
737 
738         {"nativeExtractMetadata", "(I)Ljava/lang/String;",
739                 (void *)android_media_MediaMetadataRetriever_extractMetadata},
740         {"getEmbeddedPicture", "(I)[B",
741                 (void *)android_media_MediaMetadataRetriever_getEmbeddedPicture},
742         {"release",         "()V",
743                 (void *)android_media_MediaMetadataRetriever_release},
744         {"native_finalize", "()V",
745                 (void *)android_media_MediaMetadataRetriever_native_finalize},
746         {"native_setup",    "()V",
747                 (void *)android_media_MediaMetadataRetriever_native_setup},
748         {"native_init",     "()V",
749                 (void *)android_media_MediaMetadataRetriever_native_init},
750 };
751 
752 // This function only registers the native methods, and is called from
753 // JNI_OnLoad in android_media_MediaPlayer.cpp
register_android_media_MediaMetadataRetriever(JNIEnv * env)754 int register_android_media_MediaMetadataRetriever(JNIEnv *env)
755 {
756     return AndroidRuntime::registerNativeMethods
757         (env, kClassPathName, nativeMethods, NELEM(nativeMethods));
758 }
759