android_media_MediaMetadataRetriever.cpp revision 4342f08faba4ce730d080796b13e9f2b9b06c350 
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 <assert.h>
22#include <utils/Log.h>
23#include <utils/threads.h>
24#include <SkBitmap.h>
25#include <media/IMediaHTTPService.h>
26#include <media/mediametadataretriever.h>
27#include <media/mediascanner.h>
28#include <private/media/VideoFrame.h>
29
30#include "jni.h"
31#include <nativehelper/JNIHelp.h>
32#include "android_runtime/AndroidRuntime.h"
33#include "android_media_MediaDataSource.h"
34#include "android_media_Utils.h"
35#include "android_util_Binder.h"
36
37#include "android/graphics/GraphicsJNI.h"
38
39using namespace android;
40
41struct fields_t {
42    jfieldID context;
43    jclass bitmapClazz;  // Must be a global ref
44    jmethodID createBitmapMethod;
45    jmethodID createScaledBitmapMethod;
46    jclass configClazz;  // Must be a global ref
47    jmethodID createConfigMethod;
48};
49
50static fields_t fields;
51static Mutex sLock;
52static const char* const kClassPathName = "android/media/MediaMetadataRetriever";
53
54static void process_media_retriever_call(JNIEnv *env, status_t opStatus, const char* exception, const char *message)
55{
56    if (opStatus == (status_t) INVALID_OPERATION) {
57        jniThrowException(env, "java/lang/IllegalStateException", NULL);
58    } else if (opStatus != (status_t) OK) {
59        if (strlen(message) > 230) {
60            // If the message is too long, don't bother displaying the status code.
61            jniThrowException( env, exception, message);
62        } else {
63            char msg[256];
64            // Append the status code to the message.
65            sprintf(msg, "%s: status = 0x%X", message, opStatus);
66            jniThrowException( env, exception, msg);
67        }
68    }
69}
70
71static MediaMetadataRetriever* getRetriever(JNIEnv* env, jobject thiz)
72{
73    // No lock is needed, since it is called internally by other methods that are protected
74    MediaMetadataRetriever* retriever = (MediaMetadataRetriever*) env->GetLongField(thiz, fields.context);
75    return retriever;
76}
77
78static void setRetriever(JNIEnv* env, jobject thiz, MediaMetadataRetriever* retriever)
79{
80    // No lock is needed, since it is called internally by other methods that are protected
81    env->SetLongField(thiz, fields.context, (jlong) retriever);
82}
83
84static void
85android_media_MediaMetadataRetriever_setDataSourceAndHeaders(
86        JNIEnv *env, jobject thiz, jobject httpServiceBinderObj, jstring path,
87        jobjectArray keys, jobjectArray values) {
88
89    ALOGV("setDataSource");
90    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
91    if (retriever == 0) {
92        jniThrowException(
93                env,
94                "java/lang/IllegalStateException", "No retriever available");
95
96        return;
97    }
98
99    if (!path) {
100        jniThrowException(
101                env, "java/lang/IllegalArgumentException", "Null pointer");
102
103        return;
104    }
105
106    const char *tmp = env->GetStringUTFChars(path, NULL);
107    if (!tmp) {  // OutOfMemoryError exception already thrown
108        return;
109    }
110
111    String8 pathStr(tmp);
112    env->ReleaseStringUTFChars(path, tmp);
113    tmp = NULL;
114
115    // Don't let somebody trick us in to reading some random block of memory
116    if (strncmp("mem://", pathStr.string(), 6) == 0) {
117        jniThrowException(
118                env, "java/lang/IllegalArgumentException", "Invalid pathname");
119        return;
120    }
121
122    // We build a similar KeyedVector out of it.
123    KeyedVector<String8, String8> headersVector;
124    if (!ConvertKeyValueArraysToKeyedVector(
125            env, keys, values, &headersVector)) {
126        return;
127    }
128
129    sp<IMediaHTTPService> httpService;
130    if (httpServiceBinderObj != NULL) {
131        sp<IBinder> binder = ibinderForJavaObject(env, httpServiceBinderObj);
132        httpService = interface_cast<IMediaHTTPService>(binder);
133    }
134
135    process_media_retriever_call(
136            env,
137            retriever->setDataSource(
138                httpService,
139                pathStr.string(),
140                headersVector.size() > 0 ? &headersVector : NULL),
141
142            "java/lang/RuntimeException",
143            "setDataSource failed");
144}
145
146static void android_media_MediaMetadataRetriever_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
147{
148    ALOGV("setDataSource");
149    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
150    if (retriever == 0) {
151        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
152        return;
153    }
154    if (!fileDescriptor) {
155        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
156        return;
157    }
158    int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
159    if (offset < 0 || length < 0 || fd < 0) {
160        if (offset < 0) {
161            ALOGE("negative offset (%lld)", (long long)offset);
162        }
163        if (length < 0) {
164            ALOGE("negative length (%lld)", (long long)length);
165        }
166        if (fd < 0) {
167            ALOGE("invalid file descriptor");
168        }
169        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
170        return;
171    }
172    process_media_retriever_call(env, retriever->setDataSource(fd, offset, length), "java/lang/RuntimeException", "setDataSource failed");
173}
174
175static void android_media_MediaMetadataRetriever_setDataSourceCallback(JNIEnv *env, jobject thiz, jobject dataSource)
176{
177    ALOGV("setDataSourceCallback");
178    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
179    if (retriever == 0) {
180        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
181        return;
182    }
183    if (dataSource == NULL) {
184        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
185        return;
186    }
187
188    sp<IDataSource> callbackDataSource = new JMediaDataSource(env, dataSource);
189    process_media_retriever_call(env, retriever->setDataSource(callbackDataSource), "java/lang/RuntimeException", "setDataSourceCallback failed");
190}
191
192template<typename T>
193static void rotate0(T* dst, const T* src, size_t width, size_t height)
194{
195    memcpy(dst, src, width * height * sizeof(T));
196}
197
198template<typename T>
199static void rotate90(T* dst, const T* src, size_t width, size_t height)
200{
201    for (size_t i = 0; i < height; ++i) {
202        for (size_t j = 0; j < width; ++j) {
203            dst[j * height + height - 1 - i] = src[i * width + j];
204        }
205    }
206}
207
208template<typename T>
209static void rotate180(T* dst, const T* src, size_t width, size_t height)
210{
211    for (size_t i = 0; i < height; ++i) {
212        for (size_t j = 0; j < width; ++j) {
213            dst[(height - 1 - i) * width + width - 1 - j] = src[i * width + j];
214        }
215    }
216}
217
218template<typename T>
219static void rotate270(T* dst, const T* src, size_t width, size_t height)
220{
221    for (size_t i = 0; i < height; ++i) {
222        for (size_t j = 0; j < width; ++j) {
223            dst[(width - 1 - j) * height + i] = src[i * width + j];
224        }
225    }
226}
227
228template<typename T>
229static void rotate(T *dst, const T *src, size_t width, size_t height, int angle)
230{
231    switch (angle) {
232        case 0:
233            rotate0(dst, src, width, height);
234            break;
235        case 90:
236            rotate90(dst, src, width, height);
237            break;
238        case 180:
239            rotate180(dst, src, width, height);
240            break;
241        case 270:
242            rotate270(dst, src, width, height);
243            break;
244    }
245}
246
247static jobject getBitmapFromVideoFrame(
248        JNIEnv *env, VideoFrame *videoFrame, jint dst_width, jint dst_height) {
249    ALOGV("getBitmapFromVideoFrame: dimension = %dx%d and bytes = %d",
250            videoFrame->mDisplayWidth,
251            videoFrame->mDisplayHeight,
252            videoFrame->mSize);
253
254    jobject config = env->CallStaticObjectMethod(
255                        fields.configClazz,
256                        fields.createConfigMethod,
257                        GraphicsJNI::colorTypeToLegacyBitmapConfig(kRGB_565_SkColorType));
258
259    uint32_t width, height, displayWidth, displayHeight;
260    bool swapWidthAndHeight = false;
261    if (videoFrame->mRotationAngle == 90 || videoFrame->mRotationAngle == 270) {
262        width = videoFrame->mHeight;
263        height = videoFrame->mWidth;
264        swapWidthAndHeight = true;
265        displayWidth = videoFrame->mDisplayHeight;
266        displayHeight = videoFrame->mDisplayWidth;
267    } else {
268        width = videoFrame->mWidth;
269        height = videoFrame->mHeight;
270        displayWidth = videoFrame->mDisplayWidth;
271        displayHeight = videoFrame->mDisplayHeight;
272    }
273
274    jobject jBitmap = env->CallStaticObjectMethod(
275                            fields.bitmapClazz,
276                            fields.createBitmapMethod,
277                            width,
278                            height,
279                            config);
280    if (jBitmap == NULL) {
281        if (env->ExceptionCheck()) {
282            env->ExceptionClear();
283        }
284        ALOGE("getBitmapFromVideoFrame: create Bitmap failed!");
285        return NULL;
286    }
287
288    SkBitmap bitmap;
289    GraphicsJNI::getSkBitmap(env, jBitmap, &bitmap);
290
291    rotate((uint16_t*)bitmap.getPixels(),
292           (uint16_t*)((char*)videoFrame + sizeof(VideoFrame)),
293           videoFrame->mWidth,
294           videoFrame->mHeight,
295           videoFrame->mRotationAngle);
296
297    if (dst_width <= 0 || dst_height <= 0) {
298        dst_width = displayWidth;
299        dst_height = displayHeight;
300    } else {
301        float factor = std::min((float)dst_width / (float)displayWidth,
302                (float)dst_height / (float)displayHeight);
303        dst_width = std::round(displayWidth * factor);
304        dst_height = std::round(displayHeight * factor);
305    }
306
307    if ((uint32_t)dst_width != videoFrame->mWidth ||
308        (uint32_t)dst_height != videoFrame->mHeight) {
309        ALOGV("Bitmap dimension is scaled from %dx%d to %dx%d",
310                width, height, dst_width, dst_height);
311        jobject scaledBitmap = env->CallStaticObjectMethod(fields.bitmapClazz,
312                                fields.createScaledBitmapMethod,
313                                jBitmap,
314                                dst_width,
315                                dst_height,
316                                true);
317        return scaledBitmap;
318    }
319
320    return jBitmap;
321}
322
323static jobject android_media_MediaMetadataRetriever_getFrameAtTime(
324        JNIEnv *env, jobject thiz, jlong timeUs, jint option, jint dst_width, jint dst_height)
325{
326    ALOGV("getFrameAtTime: %lld us option: %d dst width: %d heigh: %d",
327            (long long)timeUs, option, dst_width, dst_height);
328    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
329    if (retriever == 0) {
330        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
331        return NULL;
332    }
333
334    // Call native method to retrieve a video frame
335    VideoFrame *videoFrame = NULL;
336    sp<IMemory> frameMemory = retriever->getFrameAtTime(timeUs, option);
337    if (frameMemory != 0) {  // cast the shared structure to a VideoFrame object
338        videoFrame = static_cast<VideoFrame *>(frameMemory->pointer());
339    }
340    if (videoFrame == NULL) {
341        ALOGE("getFrameAtTime: videoFrame is a NULL pointer");
342        return NULL;
343    }
344
345    return getBitmapFromVideoFrame(env, videoFrame, dst_width, dst_height);
346}
347
348static jobject android_media_MediaMetadataRetriever_getImageAtIndex(
349        JNIEnv *env, jobject thiz, jint index)
350{
351    ALOGV("getImageAtIndex: index %d", index);
352    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
353    if (retriever == 0) {
354        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
355        return NULL;
356    }
357
358    // Call native method to retrieve an image
359    VideoFrame *videoFrame = NULL;
360    sp<IMemory> frameMemory = retriever->getImageAtIndex(index);
361    if (frameMemory != 0) {  // cast the shared structure to a VideoFrame object
362        videoFrame = static_cast<VideoFrame *>(frameMemory->pointer());
363    }
364    if (videoFrame == NULL) {
365        ALOGE("getImageAtIndex: videoFrame is a NULL pointer");
366        return NULL;
367    }
368
369    return getBitmapFromVideoFrame(env, videoFrame, -1, -1);
370}
371
372static jobjectArray android_media_MediaMetadataRetriever_getFrameAtIndex(
373        JNIEnv *env, jobject thiz, jint frameIndex, jint numFrames)
374{
375    ALOGV("getFrameAtIndex: frameIndex %d, numFrames %d", frameIndex, numFrames);
376    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
377    if (retriever == 0) {
378        jniThrowException(env,
379                "java/lang/IllegalStateException", "No retriever available");
380        return NULL;
381    }
382
383    std::vector<sp<IMemory> > frames;
384    status_t err = retriever->getFrameAtIndex(&frames, frameIndex, numFrames);
385    if (err != OK || frames.size() == 0) {
386        ALOGE("failed to get frames from retriever, err=%d, size=%zu",
387                err, frames.size());
388        return NULL;
389    }
390
391    jobjectArray bitmapArrayObj = env->NewObjectArray(
392            frames.size(), fields.bitmapClazz, NULL);
393    if (bitmapArrayObj == NULL) {
394        ALOGE("can't create bitmap array object");
395        return NULL;
396    }
397
398    for (size_t i = 0; i < frames.size(); i++) {
399        if (frames[i] == NULL || frames[i]->pointer() == NULL) {
400            ALOGE("video frame at index %zu is a NULL pointer", frameIndex + i);
401            continue;
402        }
403        VideoFrame *videoFrame = static_cast<VideoFrame *>(frames[i]->pointer());
404        jobject bitmapObj = getBitmapFromVideoFrame(env, videoFrame, -1, -1);
405        env->SetObjectArrayElement(bitmapArrayObj, i, bitmapObj);
406    }
407    return bitmapArrayObj;
408}
409
410static jbyteArray android_media_MediaMetadataRetriever_getEmbeddedPicture(
411        JNIEnv *env, jobject thiz, jint pictureType)
412{
413    ALOGV("getEmbeddedPicture: %d", pictureType);
414    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
415    if (retriever == 0) {
416        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
417        return NULL;
418    }
419    MediaAlbumArt* mediaAlbumArt = NULL;
420
421    // FIXME:
422    // Use pictureType to retrieve the intended embedded picture and also change
423    // the method name to getEmbeddedPicture().
424    sp<IMemory> albumArtMemory = retriever->extractAlbumArt();
425    if (albumArtMemory != 0) {  // cast the shared structure to a MediaAlbumArt object
426        mediaAlbumArt = static_cast<MediaAlbumArt *>(albumArtMemory->pointer());
427    }
428    if (mediaAlbumArt == NULL) {
429        ALOGE("getEmbeddedPicture: Call to getEmbeddedPicture failed.");
430        return NULL;
431    }
432
433    jbyteArray array = env->NewByteArray(mediaAlbumArt->size());
434    if (!array) {  // OutOfMemoryError exception has already been thrown.
435        ALOGE("getEmbeddedPicture: OutOfMemoryError is thrown.");
436    } else {
437        const jbyte* data =
438                reinterpret_cast<const jbyte*>(mediaAlbumArt->data());
439        env->SetByteArrayRegion(array, 0, mediaAlbumArt->size(), data);
440    }
441
442    // No need to delete mediaAlbumArt here
443    return array;
444}
445
446static jobject android_media_MediaMetadataRetriever_extractMetadata(JNIEnv *env, jobject thiz, jint keyCode)
447{
448    ALOGV("extractMetadata");
449    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
450    if (retriever == 0) {
451        jniThrowException(env, "java/lang/IllegalStateException", "No retriever available");
452        return NULL;
453    }
454    const char* value = retriever->extractMetadata(keyCode);
455    if (!value) {
456        ALOGV("extractMetadata: Metadata is not found");
457        return NULL;
458    }
459    ALOGV("extractMetadata: value (%s) for keyCode(%d)", value, keyCode);
460    return env->NewStringUTF(value);
461}
462
463static void android_media_MediaMetadataRetriever_release(JNIEnv *env, jobject thiz)
464{
465    ALOGV("release");
466    Mutex::Autolock lock(sLock);
467    MediaMetadataRetriever* retriever = getRetriever(env, thiz);
468    delete retriever;
469    setRetriever(env, thiz, (MediaMetadataRetriever*) 0);
470}
471
472static void android_media_MediaMetadataRetriever_native_finalize(JNIEnv *env, jobject thiz)
473{
474    ALOGV("native_finalize");
475    // No lock is needed, since android_media_MediaMetadataRetriever_release() is protected
476    android_media_MediaMetadataRetriever_release(env, thiz);
477}
478
479// This function gets a field ID, which in turn causes class initialization.
480// It is called from a static block in MediaMetadataRetriever, which won't run until the
481// first time an instance of this class is used.
482static void android_media_MediaMetadataRetriever_native_init(JNIEnv *env)
483{
484    jclass clazz = env->FindClass(kClassPathName);
485    if (clazz == NULL) {
486        return;
487    }
488
489    fields.context = env->GetFieldID(clazz, "mNativeContext", "J");
490    if (fields.context == NULL) {
491        return;
492    }
493
494    jclass bitmapClazz = env->FindClass("android/graphics/Bitmap");
495    if (bitmapClazz == NULL) {
496        return;
497    }
498    fields.bitmapClazz = (jclass) env->NewGlobalRef(bitmapClazz);
499    if (fields.bitmapClazz == NULL) {
500        return;
501    }
502    fields.createBitmapMethod =
503            env->GetStaticMethodID(fields.bitmapClazz, "createBitmap",
504                    "(IILandroid/graphics/Bitmap$Config;)"
505                    "Landroid/graphics/Bitmap;");
506    if (fields.createBitmapMethod == NULL) {
507        return;
508    }
509    fields.createScaledBitmapMethod =
510            env->GetStaticMethodID(fields.bitmapClazz, "createScaledBitmap",
511                    "(Landroid/graphics/Bitmap;IIZ)"
512                    "Landroid/graphics/Bitmap;");
513    if (fields.createScaledBitmapMethod == NULL) {
514        return;
515    }
516
517    jclass configClazz = env->FindClass("android/graphics/Bitmap$Config");
518    if (configClazz == NULL) {
519        return;
520    }
521    fields.configClazz = (jclass) env->NewGlobalRef(configClazz);
522    if (fields.configClazz == NULL) {
523        return;
524    }
525    fields.createConfigMethod =
526            env->GetStaticMethodID(fields.configClazz, "nativeToConfig",
527                    "(I)Landroid/graphics/Bitmap$Config;");
528    if (fields.createConfigMethod == NULL) {
529        return;
530    }
531}
532
533static void android_media_MediaMetadataRetriever_native_setup(JNIEnv *env, jobject thiz)
534{
535    ALOGV("native_setup");
536    MediaMetadataRetriever* retriever = new MediaMetadataRetriever();
537    if (retriever == 0) {
538        jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
539        return;
540    }
541    setRetriever(env, thiz, retriever);
542}
543
544// JNI mapping between Java methods and native methods
545static const JNINativeMethod nativeMethods[] = {
546        {
547            "_setDataSource",
548            "(Landroid/os/IBinder;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V",
549            (void *)android_media_MediaMetadataRetriever_setDataSourceAndHeaders
550        },
551
552        {"setDataSource",   "(Ljava/io/FileDescriptor;JJ)V", (void *)android_media_MediaMetadataRetriever_setDataSourceFD},
553        {"_setDataSource",   "(Landroid/media/MediaDataSource;)V", (void *)android_media_MediaMetadataRetriever_setDataSourceCallback},
554        {"_getFrameAtTime", "(JIII)Landroid/graphics/Bitmap;", (void *)android_media_MediaMetadataRetriever_getFrameAtTime},
555        {"_getImageAtIndex", "(I)Landroid/graphics/Bitmap;", (void *)android_media_MediaMetadataRetriever_getImageAtIndex},
556        {"_getFrameAtIndex", "(II)[Landroid/graphics/Bitmap;", (void *)android_media_MediaMetadataRetriever_getFrameAtIndex},
557        {"extractMetadata", "(I)Ljava/lang/String;", (void *)android_media_MediaMetadataRetriever_extractMetadata},
558        {"getEmbeddedPicture", "(I)[B", (void *)android_media_MediaMetadataRetriever_getEmbeddedPicture},
559        {"release",         "()V", (void *)android_media_MediaMetadataRetriever_release},
560        {"native_finalize", "()V", (void *)android_media_MediaMetadataRetriever_native_finalize},
561        {"native_setup",    "()V", (void *)android_media_MediaMetadataRetriever_native_setup},
562        {"native_init",     "()V", (void *)android_media_MediaMetadataRetriever_native_init},
563};
564
565// This function only registers the native methods, and is called from
566// JNI_OnLoad in android_media_MediaPlayer.cpp
567int register_android_media_MediaMetadataRetriever(JNIEnv *env)
568{
569    return AndroidRuntime::registerNativeMethods
570        (env, kClassPathName, nativeMethods, NELEM(nativeMethods));
571}
572