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