596 lines
20 KiB
C++
596 lines
20 KiB
C++
/* //device/libs/android_runtime/android_media_MediaPlayer.cpp
|
|
**
|
|
** Copyright 2007, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "MediaPlayer-JNI"
|
|
#include "utils/Log.h"
|
|
|
|
#include <media/mediaplayer.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <utils/threads.h>
|
|
#include "jni.h"
|
|
#include "JNIHelp.h"
|
|
#include "android_runtime/AndroidRuntime.h"
|
|
#include "utils/Errors.h" // for status_t
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct fields_t {
|
|
jfieldID context;
|
|
jfieldID surface;
|
|
/* actually in android.view.Surface XXX */
|
|
jfieldID surface_native;
|
|
|
|
jmethodID post_event;
|
|
};
|
|
static fields_t fields;
|
|
|
|
static Mutex sLock;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ref-counted object for callbacks
|
|
class JNIMediaPlayerListener: public MediaPlayerListener
|
|
{
|
|
public:
|
|
JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
|
|
~JNIMediaPlayerListener();
|
|
void notify(int msg, int ext1, int ext2);
|
|
private:
|
|
JNIMediaPlayerListener();
|
|
jclass mClass; // Reference to MediaPlayer class
|
|
jobject mObject; // Weak ref to MediaPlayer Java object to call on
|
|
};
|
|
|
|
JNIMediaPlayerListener::JNIMediaPlayerListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
|
|
{
|
|
|
|
// Hold onto the MediaPlayer class for use in calling the static method
|
|
// that posts events to the application thread.
|
|
jclass clazz = env->GetObjectClass(thiz);
|
|
if (clazz == NULL) {
|
|
LOGE("Can't find android/media/MediaPlayer");
|
|
jniThrowException(env, "java/lang/Exception", NULL);
|
|
return;
|
|
}
|
|
mClass = (jclass)env->NewGlobalRef(clazz);
|
|
|
|
// We use a weak reference so the MediaPlayer object can be garbage collected.
|
|
// The reference is only used as a proxy for callbacks.
|
|
mObject = env->NewGlobalRef(weak_thiz);
|
|
}
|
|
|
|
JNIMediaPlayerListener::~JNIMediaPlayerListener()
|
|
{
|
|
// remove global references
|
|
JNIEnv *env = AndroidRuntime::getJNIEnv();
|
|
env->DeleteGlobalRef(mObject);
|
|
env->DeleteGlobalRef(mClass);
|
|
}
|
|
|
|
void JNIMediaPlayerListener::notify(int msg, int ext1, int ext2)
|
|
{
|
|
JNIEnv *env = AndroidRuntime::getJNIEnv();
|
|
env->CallStaticVoidMethod(mClass, fields.post_event, mObject, msg, ext1, ext2, 0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static sp<Surface> get_surface(JNIEnv* env, jobject clazz)
|
|
{
|
|
Surface* const p = (Surface*)env->GetIntField(clazz, fields.surface_native);
|
|
return sp<Surface>(p);
|
|
}
|
|
|
|
static sp<MediaPlayer> getMediaPlayer(JNIEnv* env, jobject thiz)
|
|
{
|
|
Mutex::Autolock l(sLock);
|
|
MediaPlayer* const p = (MediaPlayer*)env->GetIntField(thiz, fields.context);
|
|
return sp<MediaPlayer>(p);
|
|
}
|
|
|
|
static sp<MediaPlayer> setMediaPlayer(JNIEnv* env, jobject thiz, const sp<MediaPlayer>& player)
|
|
{
|
|
Mutex::Autolock l(sLock);
|
|
sp<MediaPlayer> old = (MediaPlayer*)env->GetIntField(thiz, fields.context);
|
|
if (player.get()) {
|
|
player->incStrong(thiz);
|
|
}
|
|
if (old != 0) {
|
|
old->decStrong(thiz);
|
|
}
|
|
env->SetIntField(thiz, fields.context, (int)player.get());
|
|
return old;
|
|
}
|
|
|
|
// If exception is NULL and opStatus is not OK, this method sends an error
|
|
// event to the client application; otherwise, if exception is not NULL and
|
|
// opStatus is not OK, this method throws the given exception to the client
|
|
// application.
|
|
static void process_media_player_call(JNIEnv *env, jobject thiz, status_t opStatus, const char* exception, const char *message)
|
|
{
|
|
if (exception == NULL) { // Don't throw exception. Instead, send an event.
|
|
if (opStatus != (status_t) OK) {
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp != 0) mp->notify(MEDIA_ERROR, opStatus, 0);
|
|
}
|
|
} else { // Throw exception!
|
|
if ( opStatus == (status_t) INVALID_OPERATION ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
} else if ( opStatus != (status_t) OK ) {
|
|
if (strlen(message) > 230) {
|
|
// if the message is too long, don't bother displaying the status code
|
|
jniThrowException( env, exception, message);
|
|
} else {
|
|
char msg[256];
|
|
// append the status code to the message
|
|
sprintf(msg, "%s: status=0x%X", message, opStatus);
|
|
jniThrowException( env, exception, msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setDataSource(JNIEnv *env, jobject thiz, jstring path)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
|
|
if (path == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
|
|
const char *pathStr = env->GetStringUTFChars(path, NULL);
|
|
if (pathStr == NULL) { // Out of memory
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
LOGV("setDataSource: path %s", pathStr);
|
|
status_t opStatus = mp->setDataSource(pathStr);
|
|
|
|
// Make sure that local ref is released before a potential exception
|
|
env->ReleaseStringUTFChars(path, pathStr);
|
|
process_media_player_call( env, thiz, opStatus, "java/io/IOException", "setDataSource failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
|
|
if (fileDescriptor == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
int fd = getParcelFileDescriptorFD(env, fileDescriptor);
|
|
LOGV("setDataSourceFD: fd %d", fd);
|
|
process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." );
|
|
}
|
|
|
|
|
|
static void
|
|
android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
jobject surface = env->GetObjectField(thiz, fields.surface);
|
|
if (surface != NULL) {
|
|
const sp<Surface>& native_surface = get_surface(env, surface);
|
|
LOGV("prepare: surface=%p (id=%d)",
|
|
native_surface.get(), native_surface->ID());
|
|
mp->setVideoSurface(native_surface);
|
|
}
|
|
process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
jobject surface = env->GetObjectField(thiz, fields.surface);
|
|
if (surface != NULL) {
|
|
const sp<Surface>& native_surface = get_surface(env, surface);
|
|
LOGV("prepareAsync: surface=%p (id=%d)",
|
|
native_surface.get(), native_surface->ID());
|
|
mp->setVideoSurface(native_surface);
|
|
}
|
|
process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_start(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("start");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->start(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_stop(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("stop");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->stop(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_pause(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("pause");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->pause(), NULL, NULL );
|
|
}
|
|
|
|
static jboolean
|
|
android_media_MediaPlayer_isPlaying(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return false;
|
|
}
|
|
const jboolean is_playing = mp->isPlaying();
|
|
|
|
LOGV("isPlaying: %d", is_playing);
|
|
return is_playing;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_seekTo(JNIEnv *env, jobject thiz, int msec)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
LOGV("seekTo: %d(msec)", msec);
|
|
process_media_player_call( env, thiz, mp->seekTo(msec), NULL, NULL );
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getVideoWidth(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int w;
|
|
if (0 != mp->getVideoWidth(&w)) {
|
|
LOGE("getVideoWidth failed");
|
|
w = 0;
|
|
}
|
|
LOGV("getVideoWidth: %d", w);
|
|
return w;
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getVideoHeight(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int h;
|
|
if (0 != mp->getVideoHeight(&h)) {
|
|
LOGE("getVideoHeight failed");
|
|
h = 0;
|
|
}
|
|
LOGV("getVideoHeight: %d", h);
|
|
return h;
|
|
}
|
|
|
|
|
|
static int
|
|
android_media_MediaPlayer_getCurrentPosition(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int msec;
|
|
process_media_player_call( env, thiz, mp->getCurrentPosition(&msec), NULL, NULL );
|
|
LOGV("getCurrentPosition: %d (msec)", msec);
|
|
return msec;
|
|
}
|
|
|
|
static int
|
|
android_media_MediaPlayer_getDuration(JNIEnv *env, jobject thiz)
|
|
{
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return 0;
|
|
}
|
|
int msec;
|
|
process_media_player_call( env, thiz, mp->getDuration(&msec), NULL, NULL );
|
|
LOGV("getDuration: %d (msec)", msec);
|
|
return msec;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_reset(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("reset");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->reset(), NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setAudioStreamType(JNIEnv *env, jobject thiz, int streamtype)
|
|
{
|
|
LOGV("setAudioStreamType: %d", streamtype);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setAudioStreamType(streamtype) , NULL, NULL );
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setLooping(JNIEnv *env, jobject thiz, jboolean looping)
|
|
{
|
|
LOGV("setLooping: %d", looping);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setLooping(looping), NULL, NULL );
|
|
}
|
|
|
|
static jboolean
|
|
android_media_MediaPlayer_isLooping(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("isLooping");
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return false;
|
|
}
|
|
return mp->isLooping();
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_setVolume(JNIEnv *env, jobject thiz, float leftVolume, float rightVolume)
|
|
{
|
|
LOGV("setVolume: left %f right %f", leftVolume, rightVolume);
|
|
sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
|
|
if (mp == NULL ) {
|
|
jniThrowException(env, "java/lang/IllegalStateException", NULL);
|
|
return;
|
|
}
|
|
process_media_player_call( env, thiz, mp->setVolume(leftVolume, rightVolume), NULL, NULL );
|
|
}
|
|
|
|
// FIXME: deprecated
|
|
static jobject
|
|
android_media_MediaPlayer_getFrameAt(JNIEnv *env, jobject thiz, jint msec)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
|
|
{
|
|
LOGV("native_setup");
|
|
sp<MediaPlayer> mp = new MediaPlayer();
|
|
if (mp == NULL) {
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
|
|
// create new listener and give it to MediaPlayer
|
|
sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
|
|
mp->setListener(listener);
|
|
|
|
// Stow our new C++ MediaPlayer in an opaque field in the Java object.
|
|
setMediaPlayer(env, thiz, mp);
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_release(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("release");
|
|
sp<MediaPlayer> mp = setMediaPlayer(env, thiz, 0);
|
|
if (mp != NULL) {
|
|
// this prevents native callbacks after the object is released
|
|
mp->setListener(0);
|
|
mp->disconnect();
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaPlayer_native_finalize(JNIEnv *env, jobject thiz)
|
|
{
|
|
LOGV("native_finalize");
|
|
android_media_MediaPlayer_release(env, thiz);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static JNINativeMethod gMethods[] = {
|
|
{"setDataSource", "(Ljava/lang/String;)V", (void *)android_media_MediaPlayer_setDataSource},
|
|
{"setDataSource", "(Ljava/io/FileDescriptor;JJ)V", (void *)android_media_MediaPlayer_setDataSourceFD},
|
|
{"prepare", "()V", (void *)android_media_MediaPlayer_prepare},
|
|
{"prepareAsync", "()V", (void *)android_media_MediaPlayer_prepareAsync},
|
|
{"_start", "()V", (void *)android_media_MediaPlayer_start},
|
|
{"_stop", "()V", (void *)android_media_MediaPlayer_stop},
|
|
{"getVideoWidth", "()I", (void *)android_media_MediaPlayer_getVideoWidth},
|
|
{"getVideoHeight", "()I", (void *)android_media_MediaPlayer_getVideoHeight},
|
|
{"seekTo", "(I)V", (void *)android_media_MediaPlayer_seekTo},
|
|
{"_pause", "()V", (void *)android_media_MediaPlayer_pause},
|
|
{"isPlaying", "()Z", (void *)android_media_MediaPlayer_isPlaying},
|
|
{"getCurrentPosition", "()I", (void *)android_media_MediaPlayer_getCurrentPosition},
|
|
{"getDuration", "()I", (void *)android_media_MediaPlayer_getDuration},
|
|
{"_release", "()V", (void *)android_media_MediaPlayer_release},
|
|
{"_reset", "()V", (void *)android_media_MediaPlayer_reset},
|
|
{"setAudioStreamType", "(I)V", (void *)android_media_MediaPlayer_setAudioStreamType},
|
|
{"setLooping", "(Z)V", (void *)android_media_MediaPlayer_setLooping},
|
|
{"isLooping", "()Z", (void *)android_media_MediaPlayer_isLooping},
|
|
{"setVolume", "(FF)V", (void *)android_media_MediaPlayer_setVolume},
|
|
{"getFrameAt", "(I)Landroid/graphics/Bitmap;", (void *)android_media_MediaPlayer_getFrameAt},
|
|
{"native_setup", "(Ljava/lang/Object;)V", (void *)android_media_MediaPlayer_native_setup},
|
|
{"native_finalize", "()V", (void *)android_media_MediaPlayer_native_finalize},
|
|
};
|
|
|
|
static const char* const kClassPathName = "android/media/MediaPlayer";
|
|
|
|
static int register_android_media_MediaPlayer(JNIEnv *env)
|
|
{
|
|
jclass clazz;
|
|
|
|
clazz = env->FindClass("android/media/MediaPlayer");
|
|
if (clazz == NULL) {
|
|
LOGE("Can't find android/media/MediaPlayer");
|
|
return -1;
|
|
}
|
|
|
|
fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
|
|
if (fields.context == NULL) {
|
|
LOGE("Can't find MediaPlayer.mNativeContext");
|
|
return -1;
|
|
}
|
|
|
|
fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
|
|
"(Ljava/lang/Object;IIILjava/lang/Object;)V");
|
|
if (fields.post_event == NULL) {
|
|
LOGE("Can't find MediaPlayer.postEventFromNative");
|
|
return -1;
|
|
}
|
|
|
|
fields.surface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");
|
|
if (fields.surface == NULL) {
|
|
LOGE("Can't find MediaPlayer.mSurface");
|
|
return -1;
|
|
}
|
|
|
|
jclass surface = env->FindClass("android/view/Surface");
|
|
if (surface == NULL) {
|
|
LOGE("Can't find android/view/Surface");
|
|
return -1;
|
|
}
|
|
|
|
fields.surface_native = env->GetFieldID(surface, "mSurface", "I");
|
|
if (fields.surface_native == NULL) {
|
|
LOGE("Can't find Surface fields");
|
|
return -1;
|
|
}
|
|
|
|
return AndroidRuntime::registerNativeMethods(env,
|
|
"android/media/MediaPlayer", gMethods, NELEM(gMethods));
|
|
}
|
|
|
|
extern int register_android_media_MediaRecorder(JNIEnv *env);
|
|
extern int register_android_media_MediaScanner(JNIEnv *env);
|
|
extern int register_android_media_MediaMetadataRetriever(JNIEnv *env);
|
|
extern int register_android_media_AmrInputStream(JNIEnv *env);
|
|
extern int register_android_media_ResampleInputStream(JNIEnv *env);
|
|
|
|
jint JNI_OnLoad(JavaVM* vm, void* reserved)
|
|
{
|
|
JNIEnv* env = NULL;
|
|
jint result = -1;
|
|
|
|
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
|
|
LOGE("ERROR: GetEnv failed\n");
|
|
goto bail;
|
|
}
|
|
assert(env != NULL);
|
|
|
|
if (register_android_media_MediaPlayer(env) < 0) {
|
|
LOGE("ERROR: MediaPlayer native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaRecorder(env) < 0) {
|
|
LOGE("ERROR: MediaRecorder native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaScanner(env) < 0) {
|
|
LOGE("ERROR: MediaScanner native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_MediaMetadataRetriever(env) < 0) {
|
|
LOGE("ERROR: MediaMetadataRetriever native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_AmrInputStream(env) < 0) {
|
|
LOGE("ERROR: AmrInputStream native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
if (register_android_media_ResampleInputStream(env) < 0) {
|
|
LOGE("ERROR: ResampleInputStream native registration failed\n");
|
|
goto bail;
|
|
}
|
|
|
|
/* success -- return valid version number */
|
|
result = JNI_VERSION_1_4;
|
|
|
|
bail:
|
|
return result;
|
|
}
|
|
|
|
// KTHXBYE
|