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, displaySize = %dx%d, bytes = %d", 267 videoFrame->mWidth, 268 videoFrame->mHeight, 269 videoFrame->mDisplayWidth, 270 videoFrame->mDisplayHeight, 271 videoFrame->mSize); 272 273 ScopedLocalRef<jobject> config(env, 274 env->CallStaticObjectMethod( 275 fields.configClazz, 276 fields.createConfigMethod, 277 GraphicsJNI::colorTypeToLegacyBitmapConfig(outColorType))); 278 279 uint32_t width, height, displayWidth, displayHeight; 280 bool swapWidthAndHeight = false; 281 if (videoFrame->mRotationAngle == 90 || videoFrame->mRotationAngle == 270) { 282 width = videoFrame->mHeight; 283 height = videoFrame->mWidth; 284 swapWidthAndHeight = true; 285 displayWidth = videoFrame->mDisplayHeight; 286 displayHeight = videoFrame->mDisplayWidth; 287 } else { 288 width = videoFrame->mWidth; 289 height = videoFrame->mHeight; 290 displayWidth = videoFrame->mDisplayWidth; 291 displayHeight = videoFrame->mDisplayHeight; 292 } 293 294 jobject jBitmap = env->CallStaticObjectMethod( 295 fields.bitmapClazz, 296 fields.createBitmapMethod, 297 width, 298 height, 299 config.get()); 300 if (jBitmap == NULL) { 301 if (env->ExceptionCheck()) { 302 env->ExceptionClear(); 303 } 304 ALOGE("getBitmapFromVideoFrame: create Bitmap failed!"); 305 return NULL; 306 } 307 308 SkBitmap bitmap; 309 GraphicsJNI::getSkBitmap(env, jBitmap, &bitmap); 310 311 if (outColorType == kRGB_565_SkColorType) { 312 rotate((uint16_t*)bitmap.getPixels(), 313 (uint16_t*)((char*)videoFrame + sizeof(VideoFrame)), 314 videoFrame->mWidth, 315 videoFrame->mHeight, 316 videoFrame->mRotationAngle); 317 } else { 318 rotate((uint32_t*)bitmap.getPixels(), 319 (uint32_t*)((char*)videoFrame + sizeof(VideoFrame)), 320 videoFrame->mWidth, 321 videoFrame->mHeight, 322 videoFrame->mRotationAngle); 323 } 324 325 if (dst_width <= 0 || dst_height <= 0) { 326 dst_width = displayWidth; 327 dst_height = displayHeight; 328 } else { 329 float factor = std::min((float)dst_width / (float)displayWidth, 330 (float)dst_height / (float)displayHeight); 331 dst_width = std::round(displayWidth * factor); 332 dst_height = std::round(displayHeight * factor); 333 } 334 335 if ((uint32_t)dst_width != width || (uint32_t)dst_height != height) { 336 ALOGV("Bitmap dimension is scaled from %dx%d to %dx%d", 337 width, height, dst_width, dst_height); 338 jobject scaledBitmap = env->CallStaticObjectMethod(fields.bitmapClazz, 339 fields.createScaledBitmapMethod, 340 jBitmap, 341 dst_width, 342 dst_height, 343 true); 344 345 env->DeleteLocalRef(jBitmap); 346 return scaledBitmap; 347 } 348 349 return jBitmap; 350} 351 352static int getColorFormat(JNIEnv *env, jobject options) { 353 if (options == NULL) { 354 return HAL_PIXEL_FORMAT_RGBA_8888; 355 } 356 357 ScopedLocalRef<jobject> inConfig(env, env->GetObjectField(options, fields.inPreferredConfig)); 358 SkColorType prefColorType = GraphicsJNI::getNativeBitmapColorType(env, inConfig.get()); 359 360 if (prefColorType == kRGB_565_SkColorType) { 361 return HAL_PIXEL_FORMAT_RGB_565; 362 } 363 return HAL_PIXEL_FORMAT_RGBA_8888; 364} 365 366static SkColorType setOutColorType(JNIEnv *env, int colorFormat, jobject options) { 367 SkColorType outColorType = kN32_SkColorType; 368 if (colorFormat == HAL_PIXEL_FORMAT_RGB_565) { 369 outColorType = kRGB_565_SkColorType; 370 } 371 372 if (options != NULL) { 373 ScopedLocalRef<jobject> config(env, 374 env->CallStaticObjectMethod( 375 fields.configClazz, 376 fields.createConfigMethod, 377 GraphicsJNI::colorTypeToLegacyBitmapConfig(outColorType))); 378 379 env->SetObjectField(options, fields.outActualConfig, config.get()); 380 } 381 return outColorType; 382} 383 384static jobject android_media_MediaMetadataRetriever_getFrameAtTime( 385 JNIEnv *env, jobject thiz, jlong timeUs, jint option, jint dst_width, jint dst_height) 386{ 387 ALOGV("getFrameAtTime: %lld us option: %d dst width: %d heigh: %d", 388 (long long)timeUs, option, dst_width, dst_height); 389 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 390 if (retriever == 0) { 391 jniThrowException(env, "java/lang/IllegalStateException", "No retriever available"); 392 return NULL; 393 } 394 395 // Call native method to retrieve a video frame 396 VideoFrame *videoFrame = NULL; 397 sp<IMemory> frameMemory = retriever->getFrameAtTime(timeUs, option); 398 if (frameMemory != 0) { // cast the shared structure to a VideoFrame object 399 videoFrame = static_cast<VideoFrame *>(frameMemory->pointer()); 400 } 401 if (videoFrame == NULL) { 402 ALOGE("getFrameAtTime: videoFrame is a NULL pointer"); 403 return NULL; 404 } 405 406 return getBitmapFromVideoFrame(env, videoFrame, dst_width, dst_height, kRGB_565_SkColorType); 407} 408 409static jobject android_media_MediaMetadataRetriever_getImageAtIndex( 410 JNIEnv *env, jobject thiz, jint index, jobject params) 411{ 412 ALOGV("getImageAtIndex: index %d", index); 413 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 414 if (retriever == 0) { 415 jniThrowException(env, "java/lang/IllegalStateException", "No retriever available"); 416 return NULL; 417 } 418 419 int colorFormat = getColorFormat(env, params); 420 421 // Call native method to retrieve an image 422 VideoFrame *videoFrame = NULL; 423 sp<IMemory> frameMemory = retriever->getImageAtIndex(index, colorFormat); 424 if (frameMemory != 0) { // cast the shared structure to a VideoFrame object 425 videoFrame = static_cast<VideoFrame *>(frameMemory->pointer()); 426 } 427 if (videoFrame == NULL) { 428 ALOGE("getImageAtIndex: videoFrame is a NULL pointer"); 429 return NULL; 430 } 431 432 SkColorType outColorType = setOutColorType(env, colorFormat, params); 433 434 return getBitmapFromVideoFrame(env, videoFrame, -1, -1, outColorType); 435} 436 437static jobject android_media_MediaMetadataRetriever_getThumbnailImageAtIndex( 438 JNIEnv *env, jobject thiz, jint index, jobject params, jint targetSize, jint maxPixels) 439{ 440 ALOGV("getThumbnailImageAtIndex: index %d", index); 441 442 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 443 if (retriever == 0) { 444 jniThrowException(env, "java/lang/IllegalStateException", "No retriever available"); 445 return NULL; 446 } 447 448 int colorFormat = getColorFormat(env, params); 449 jint dst_width = -1, dst_height = -1; 450 451 // Call native method to retrieve an image 452 VideoFrame *videoFrame = NULL; 453 sp<IMemory> frameMemory = retriever->getImageAtIndex( 454 index, colorFormat, true /*metaOnly*/, true /*thumbnail*/); 455 if (frameMemory != 0) { 456 videoFrame = static_cast<VideoFrame *>(frameMemory->pointer()); 457 int32_t thumbWidth = videoFrame->mWidth; 458 int32_t thumbHeight = videoFrame->mHeight; 459 videoFrame = NULL; 460 int64_t thumbPixels = thumbWidth * thumbHeight; 461 462 // Here we try to use the included thumbnail if it's not too shabby. 463 // If this fails ThumbnailUtils would have to decode the full image and 464 // downscale which could take long. 465 if (thumbWidth >= targetSize || thumbHeight >= targetSize 466 || thumbPixels * 6 >= maxPixels) { 467 frameMemory = retriever->getImageAtIndex( 468 index, colorFormat, false /*metaOnly*/, true /*thumbnail*/); 469 videoFrame = static_cast<VideoFrame *>(frameMemory->pointer()); 470 471 if (thumbPixels > maxPixels) { 472 int downscale = ceil(sqrt(thumbPixels / (float)maxPixels)); 473 dst_width = thumbWidth / downscale; 474 dst_height = thumbHeight /downscale; 475 } 476 } 477 } 478 if (videoFrame == NULL) { 479 ALOGV("getThumbnailImageAtIndex: no suitable thumbnails available"); 480 return NULL; 481 } 482 483 // Ignore rotation for thumbnail extraction to be consistent with 484 // thumbnails extracted by BitmapFactory APIs. 485 videoFrame->mRotationAngle = 0; 486 487 SkColorType outColorType = setOutColorType(env, colorFormat, params); 488 489 return getBitmapFromVideoFrame(env, videoFrame, dst_width, dst_height, outColorType); 490} 491 492static jobject android_media_MediaMetadataRetriever_getFrameAtIndex( 493 JNIEnv *env, jobject thiz, jint frameIndex, jint numFrames, jobject params) 494{ 495 ALOGV("getFrameAtIndex: frameIndex %d, numFrames %d", frameIndex, numFrames); 496 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 497 if (retriever == 0) { 498 jniThrowException(env, 499 "java/lang/IllegalStateException", "No retriever available"); 500 return NULL; 501 } 502 503 int colorFormat = getColorFormat(env, params); 504 505 std::vector<sp<IMemory> > frames; 506 status_t err = retriever->getFrameAtIndex(&frames, frameIndex, numFrames, colorFormat); 507 if (err != OK || frames.size() == 0) { 508 jniThrowException(env, 509 "java/lang/IllegalStateException", "No frames from retriever"); 510 return NULL; 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 SkColorType outColorType = setOutColorType(env, colorFormat, params); 520 521 for (size_t i = 0; i < frames.size(); i++) { 522 if (frames[i] == NULL || frames[i]->pointer() == NULL) { 523 ALOGE("video frame at index %zu is a NULL pointer", frameIndex + i); 524 continue; 525 } 526 VideoFrame *videoFrame = static_cast<VideoFrame *>(frames[i]->pointer()); 527 jobject bitmapObj = getBitmapFromVideoFrame(env, videoFrame, -1, -1, outColorType); 528 env->CallBooleanMethod(arrayList, fields.arrayListAdd, bitmapObj); 529 env->DeleteLocalRef(bitmapObj); 530 } 531 return arrayList; 532} 533 534static jbyteArray android_media_MediaMetadataRetriever_getEmbeddedPicture( 535 JNIEnv *env, jobject thiz, jint pictureType) 536{ 537 ALOGV("getEmbeddedPicture: %d", pictureType); 538 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 539 if (retriever == 0) { 540 jniThrowException(env, "java/lang/IllegalStateException", "No retriever available"); 541 return NULL; 542 } 543 MediaAlbumArt* mediaAlbumArt = NULL; 544 545 // FIXME: 546 // Use pictureType to retrieve the intended embedded picture and also change 547 // the method name to getEmbeddedPicture(). 548 sp<IMemory> albumArtMemory = retriever->extractAlbumArt(); 549 if (albumArtMemory != 0) { // cast the shared structure to a MediaAlbumArt object 550 mediaAlbumArt = static_cast<MediaAlbumArt *>(albumArtMemory->pointer()); 551 } 552 if (mediaAlbumArt == NULL) { 553 ALOGE("getEmbeddedPicture: Call to getEmbeddedPicture failed."); 554 return NULL; 555 } 556 557 jbyteArray array = env->NewByteArray(mediaAlbumArt->size()); 558 if (!array) { // OutOfMemoryError exception has already been thrown. 559 ALOGE("getEmbeddedPicture: OutOfMemoryError is thrown."); 560 } else { 561 const jbyte* data = 562 reinterpret_cast<const jbyte*>(mediaAlbumArt->data()); 563 env->SetByteArrayRegion(array, 0, mediaAlbumArt->size(), data); 564 } 565 566 // No need to delete mediaAlbumArt here 567 return array; 568} 569 570static jobject android_media_MediaMetadataRetriever_extractMetadata(JNIEnv *env, jobject thiz, jint keyCode) 571{ 572 ALOGV("extractMetadata"); 573 sp<MediaMetadataRetriever> retriever = getRetriever(env, thiz); 574 if (retriever == 0) { 575 jniThrowException(env, "java/lang/IllegalStateException", "No retriever available"); 576 return NULL; 577 } 578 const char* value = retriever->extractMetadata(keyCode); 579 if (!value) { 580 ALOGV("extractMetadata: Metadata is not found"); 581 return NULL; 582 } 583 ALOGV("extractMetadata: value (%s) for keyCode(%d)", value, keyCode); 584 return env->NewStringUTF(value); 585} 586 587static void android_media_MediaMetadataRetriever_release(JNIEnv *env, jobject thiz) 588{ 589 ALOGV("release"); 590 Mutex::Autolock lock(sLock); 591 setRetriever(env, thiz, NULL); 592} 593 594static void android_media_MediaMetadataRetriever_native_finalize(JNIEnv *env, jobject thiz) 595{ 596 ALOGV("native_finalize"); 597 // No lock is needed, since android_media_MediaMetadataRetriever_release() is protected 598 android_media_MediaMetadataRetriever_release(env, thiz); 599} 600 601// This function gets a field ID, which in turn causes class initialization. 602// It is called from a static block in MediaMetadataRetriever, which won't run until the 603// first time an instance of this class is used. 604static void android_media_MediaMetadataRetriever_native_init(JNIEnv *env) 605{ 606 ScopedLocalRef<jclass> clazz(env, env->FindClass(kClassPathName)); 607 if (clazz.get() == NULL) { 608 return; 609 } 610 611 fields.context = env->GetFieldID(clazz.get(), "mNativeContext", "J"); 612 if (fields.context == NULL) { 613 return; 614 } 615 616 clazz.reset(env->FindClass("android/graphics/Bitmap")); 617 if (clazz.get() == NULL) { 618 return; 619 } 620 fields.bitmapClazz = (jclass) env->NewGlobalRef(clazz.get()); 621 if (fields.bitmapClazz == NULL) { 622 return; 623 } 624 fields.createBitmapMethod = 625 env->GetStaticMethodID(fields.bitmapClazz, "createBitmap", 626 "(IILandroid/graphics/Bitmap$Config;)" 627 "Landroid/graphics/Bitmap;"); 628 if (fields.createBitmapMethod == NULL) { 629 return; 630 } 631 fields.createScaledBitmapMethod = 632 env->GetStaticMethodID(fields.bitmapClazz, "createScaledBitmap", 633 "(Landroid/graphics/Bitmap;IIZ)" 634 "Landroid/graphics/Bitmap;"); 635 if (fields.createScaledBitmapMethod == NULL) { 636 return; 637 } 638 639 clazz.reset(env->FindClass("android/graphics/Bitmap$Config")); 640 if (clazz.get() == NULL) { 641 return; 642 } 643 fields.configClazz = (jclass) env->NewGlobalRef(clazz.get()); 644 if (fields.configClazz == NULL) { 645 return; 646 } 647 fields.createConfigMethod = 648 env->GetStaticMethodID(fields.configClazz, "nativeToConfig", 649 "(I)Landroid/graphics/Bitmap$Config;"); 650 if (fields.createConfigMethod == NULL) { 651 return; 652 } 653 654 clazz.reset(env->FindClass("android/media/MediaMetadataRetriever$BitmapParams")); 655 if (clazz.get() == NULL) { 656 return; 657 } 658 fields.bitmapParamsClazz = (jclass) env->NewGlobalRef(clazz.get()); 659 if (fields.bitmapParamsClazz == NULL) { 660 return; 661 } 662 fields.inPreferredConfig = env->GetFieldID(fields.bitmapParamsClazz, 663 "inPreferredConfig", "Landroid/graphics/Bitmap$Config;"); 664 if (fields.inPreferredConfig == NULL) { 665 return; 666 } 667 fields.outActualConfig = env->GetFieldID(fields.bitmapParamsClazz, 668 "outActualConfig", "Landroid/graphics/Bitmap$Config;"); 669 if (fields.outActualConfig == NULL) { 670 return; 671 } 672 673 clazz.reset(env->FindClass("java/util/ArrayList")); 674 if (clazz.get() == NULL) { 675 return; 676 } 677 fields.arrayListClazz = (jclass) env->NewGlobalRef(clazz.get()); 678 if (fields.arrayListClazz == NULL) { 679 return; 680 } 681 fields.arrayListInit = env->GetMethodID(clazz.get(), "<init>", "()V"); 682 if (fields.arrayListInit == NULL) { 683 return; 684 } 685 fields.arrayListAdd = env->GetMethodID(clazz.get(), "add", "(Ljava/lang/Object;)Z"); 686 if (fields.arrayListAdd == NULL) { 687 return; 688 } 689} 690 691static void android_media_MediaMetadataRetriever_native_setup(JNIEnv *env, jobject thiz) 692{ 693 ALOGV("native_setup"); 694 sp<MediaMetadataRetriever> retriever = new MediaMetadataRetriever(); 695 if (retriever == 0) { 696 jniThrowException(env, "java/lang/RuntimeException", "Out of memory"); 697 return; 698 } 699 setRetriever(env, thiz, retriever); 700} 701 702// JNI mapping between Java methods and native methods 703static const JNINativeMethod nativeMethods[] = { 704 { 705 "_setDataSource", 706 "(Landroid/os/IBinder;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)V", 707 (void *)android_media_MediaMetadataRetriever_setDataSourceAndHeaders 708 }, 709 710 {"setDataSource", "(Ljava/io/FileDescriptor;JJ)V", 711 (void *)android_media_MediaMetadataRetriever_setDataSourceFD}, 712 {"_setDataSource", "(Landroid/media/MediaDataSource;)V", 713 (void *)android_media_MediaMetadataRetriever_setDataSourceCallback}, 714 {"_getFrameAtTime", "(JIII)Landroid/graphics/Bitmap;", 715 (void *)android_media_MediaMetadataRetriever_getFrameAtTime}, 716 { 717 "_getImageAtIndex", 718 "(ILandroid/media/MediaMetadataRetriever$BitmapParams;)Landroid/graphics/Bitmap;", 719 (void *)android_media_MediaMetadataRetriever_getImageAtIndex 720 }, 721 722 { 723 "getThumbnailImageAtIndex", 724 "(ILandroid/media/MediaMetadataRetriever$BitmapParams;II)Landroid/graphics/Bitmap;", 725 (void *)android_media_MediaMetadataRetriever_getThumbnailImageAtIndex 726 }, 727 728 { 729 "_getFrameAtIndex", 730 "(IILandroid/media/MediaMetadataRetriever$BitmapParams;)Ljava/util/List;", 731 (void *)android_media_MediaMetadataRetriever_getFrameAtIndex 732 }, 733 734 {"extractMetadata", "(I)Ljava/lang/String;", 735 (void *)android_media_MediaMetadataRetriever_extractMetadata}, 736 {"getEmbeddedPicture", "(I)[B", 737 (void *)android_media_MediaMetadataRetriever_getEmbeddedPicture}, 738 {"release", "()V", 739 (void *)android_media_MediaMetadataRetriever_release}, 740 {"native_finalize", "()V", 741 (void *)android_media_MediaMetadataRetriever_native_finalize}, 742 {"native_setup", "()V", 743 (void *)android_media_MediaMetadataRetriever_native_setup}, 744 {"native_init", "()V", 745 (void *)android_media_MediaMetadataRetriever_native_init}, 746}; 747 748// This function only registers the native methods, and is called from 749// JNI_OnLoad in android_media_MediaPlayer.cpp 750int register_android_media_MediaMetadataRetriever(JNIEnv *env) 751{ 752 return AndroidRuntime::registerNativeMethods 753 (env, kClassPathName, nativeMethods, NELEM(nativeMethods)); 754} 755