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