diff --git a/.gitignore b/.gitignore index d4a0768bad..ef401313af 100644 --- a/.gitignore +++ b/.gitignore @@ -6,4 +6,12 @@ ipch *.sdf *.suo *.opensdf -vs/2010/libs \ No newline at end of file +vs/2010/libs +bin +gen +libs +obj +.classpath +.project +.settings +.libs diff --git a/gst-sdk/tutorials/android-tutorial-1/AndroidManifest.xml b/gst-sdk/tutorials/android-tutorial-1/AndroidManifest.xml new file mode 100755 index 0000000000..6116ace012 --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/AndroidManifest.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + diff --git a/gst-sdk/tutorials/android-tutorial-1/jni/Android.mk b/gst-sdk/tutorials/android-tutorial-1/jni/Android.mk new file mode 100755 index 0000000000..bed77fd797 --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/jni/Android.mk @@ -0,0 +1,34 @@ +# Copyright (C) 2009 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. +# +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := tutorial-1 +LOCAL_SRC_FILES := tutorial-1.c +LOCAL_SHARED_LIBRARIES := gstreamer_android +LOCAL_LDLIBS := -landroid +include $(BUILD_SHARED_LIBRARY) + +ifndef GSTREAMER_SDK_ROOT +ifndef GSTREAMER_SDK_ROOT_ANDROID +$(error GSTREAMER_SDK_ROOT_ANDROID is not defined!) +endif +GSTREAMER_SDK_ROOT := $(GSTREAMER_SDK_ROOT_ANDROID) +endif +GSTREAMER_NDK_BUILD_PATH := $(GSTREAMER_SDK_ROOT)/share/gst-android/ndk-build/ +GSTREAMER_PLUGINS := coreelements ogg theora vorbis ffmpegcolorspace playback audioconvert audiorate audioresample coreindexers gio uridecodebin videorate videoscale typefindfunctions eglglessink soup amc matroska autodetect videofilter videotestsrc opensles volume +G_IO_MODULES := gnutls +include $(GSTREAMER_NDK_BUILD_PATH)/gstreamer.mk diff --git a/gst-sdk/tutorials/android-tutorial-1/jni/tutorial-1.c b/gst-sdk/tutorials/android-tutorial-1/jni/tutorial-1.c new file mode 100755 index 0000000000..df74084563 --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/jni/tutorial-1.c @@ -0,0 +1,465 @@ +#include +#include +#include +#include +#include +#include +#include + +GST_DEBUG_CATEGORY_STATIC (debug_category); +#define GST_CAT_DEFAULT debug_category + +/* + * These macros provide a way to store the native pointer to CustomData, which might be 32 or 64 bits, into + * a jlong, which is always 64 bits, without warnings. + */ +#if GLIB_SIZEOF_VOID_P == 8 +# define GET_CUSTOM_DATA(env, thiz, fieldID) (CustomData *)(*env)->GetLongField (env, thiz, fieldID) +# define SET_CUSTOM_DATA(env, thiz, fieldID, data) (*env)->SetLongField (env, thiz, fieldID, (jlong)data) +#else +# define GET_CUSTOM_DATA(env, thiz, fieldID) (CustomData *)(jint)(*env)->GetLongField (env, thiz, fieldID) +# define SET_CUSTOM_DATA(env, thiz, fieldID, data) (*env)->SetLongField (env, thiz, fieldID, (jlong)(jint)data) +#endif + +typedef struct _CustomData { + jobject app; + GstElement *pipeline; + GMainContext *context; + GMainLoop *main_loop; + ANativeWindow *native_window; + GstState state, target_state; + gint64 position; + gint64 duration; + gint64 desired_position; + GstClockTime last_seek_time; + gboolean initialized; + gboolean is_live; +} CustomData; + +static pthread_t gst_app_thread; +static pthread_key_t current_jni_env; +static JavaVM *java_vm; +static jfieldID custom_data_field_id; +static jmethodID set_message_method_id; +static jmethodID set_current_position_method_id; +static jmethodID set_current_state_method_id; +static jmethodID on_gstreamer_initialized_method_id; + +/* + * Private methods + */ +static JNIEnv *attach_current_thread (void) { + JNIEnv *env; + JavaVMAttachArgs args; + + GST_DEBUG ("Attaching thread %p", g_thread_self ()); + args.version = JNI_VERSION_1_4; + args.name = NULL; + args.group = NULL; + + if ((*java_vm)->AttachCurrentThread (java_vm, &env, &args) < 0) { + GST_ERROR ("Failed to attach current thread"); + return NULL; + } + + return env; +} + +static void detach_current_thread (void *env) { + GST_DEBUG ("Detaching thread %p", g_thread_self ()); + (*java_vm)->DetachCurrentThread (java_vm); +} + +static JNIEnv *get_jni_env (void) { + JNIEnv *env; + + if ((env = pthread_getspecific (current_jni_env)) == NULL) { + env = attach_current_thread (); + pthread_setspecific (current_jni_env, env); + } + + return env; +} + +static void set_ui_message (const gchar *message, CustomData *data) { + JNIEnv *env = get_jni_env (); + GST_DEBUG ("Setting message to: %s", message); + jstring jmessage = (*env)->NewStringUTF(env, message); + (*env)->CallVoidMethod (env, data->app, set_message_method_id, jmessage); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + } + (*env)->DeleteLocalRef (env, jmessage); +} + +static void set_current_ui_position (gint position, gint duration, CustomData *data) { + JNIEnv *env = get_jni_env (); +// GST_DEBUG ("Setting current position/duration to: %d / %d (ms)", position, duration); + (*env)->CallVoidMethod (env, data->app, set_current_position_method_id, position, duration); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + } +} + +static gboolean refresh_ui (CustomData *data) { + GstFormat fmt = GST_FORMAT_TIME; + gint64 current = -1; + + /* We do not want to update anything unless we have a working pipeline in the PAUSED or PLAYING state */ + if (!data || !data->pipeline || data->state < GST_STATE_PAUSED) + return TRUE; + + /* If we didn't know it yet, query the stream duration */ + if (!GST_CLOCK_TIME_IS_VALID (data->duration)) { + if (!gst_element_query_duration (data->pipeline, &fmt, &data->duration)) { + GST_WARNING ("Could not query current duration"); + } + } + + if (gst_element_query_position (data->pipeline, &fmt, &data->position)) { + /* Java expects these values in milliseconds, and Gst provides nanoseconds */ + set_current_ui_position (data->position / GST_MSECOND, data->duration / GST_MSECOND, data); + } + return TRUE; +} + +static void execute_seek (gint64 desired_position, CustomData *data); +static gboolean +delayed_seek_cb (CustomData *data) +{ + GST_DEBUG ("Doing delayed seek %" GST_TIME_FORMAT, GST_TIME_ARGS (data->desired_position)); + data->last_seek_time = GST_CLOCK_TIME_NONE; + execute_seek (data->desired_position, data); + return FALSE; +} + +static void execute_seek (gint64 desired_position, CustomData *data) { + gboolean res; + gint64 diff; + + if (desired_position == GST_CLOCK_TIME_NONE) + return; + + diff = gst_util_get_timestamp () - data->last_seek_time; + + if (GST_CLOCK_TIME_IS_VALID (data->last_seek_time) && diff < 500 * GST_MSECOND) { + GSource *timeout_source; + + if (!GST_CLOCK_TIME_IS_VALID (data->desired_position)) { + timeout_source = g_timeout_source_new (diff / GST_MSECOND); + g_source_attach (timeout_source, data->context); + g_source_set_callback (timeout_source, (GSourceFunc)delayed_seek_cb, data, NULL); + g_source_unref (timeout_source); + } + data->desired_position = desired_position; + GST_DEBUG ("Throttling seek to %" GST_TIME_FORMAT ", will be in %" GST_TIME_FORMAT, + GST_TIME_ARGS (desired_position), GST_TIME_ARGS (500 * GST_MSECOND - diff)); + } else { + GST_DEBUG ("Setting position to %lld milliseconds", desired_position / GST_MSECOND); + res = gst_element_seek_simple (data->pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT, desired_position); + data->last_seek_time = gst_util_get_timestamp (); + data->desired_position = GST_CLOCK_TIME_NONE; + GST_DEBUG ("Seek returned %d", res); + } +} + +static void error_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + GError *err; + gchar *debug_info; + gchar *message_string; + + gst_message_parse_error (msg, &err, &debug_info); + message_string = g_strdup_printf ("Error received from element %s: %s", GST_OBJECT_NAME (msg->src), err->message); + g_clear_error (&err); + g_free (debug_info); + set_ui_message (message_string, data); + g_free (message_string); + data->target_state = GST_STATE_NULL; + gst_element_set_state (data->pipeline, GST_STATE_NULL); +} + +static void eos_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + set_ui_message (GST_MESSAGE_TYPE_NAME (msg), data); + refresh_ui (data); + data->target_state = GST_STATE_PAUSED; + data->is_live = (gst_element_set_state (data->pipeline, GST_STATE_PAUSED) == GST_STATE_CHANGE_NO_PREROLL); + execute_seek (0, data); +} + +static void duration_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + data->duration = GST_CLOCK_TIME_NONE; +} + +static void buffering_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + gint percent; + + if (data->is_live) + return; + + gst_message_parse_buffering (msg, &percent); + if (percent < 100 && data->target_state >= GST_STATE_PAUSED) { + gchar * message_string = g_strdup_printf ("Buffering %d %%", percent); + gst_element_set_state (data->pipeline, GST_STATE_PAUSED); + set_ui_message (message_string, data); + g_free (message_string); + } else if (data->target_state >= GST_STATE_PLAYING) { + gst_element_set_state (data->pipeline, GST_STATE_PLAYING); + set_ui_message ("PLAYING", data); + } else if (data->target_state >= GST_STATE_PAUSED) { + set_ui_message ("PAUSED", data); + } +} + +static void clock_lost_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + if (data->target_state >= GST_STATE_PLAYING) { + gst_element_set_state (data->pipeline, GST_STATE_PAUSED); + gst_element_set_state (data->pipeline, GST_STATE_PLAYING); + } +} + +static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) { + JNIEnv *env = get_jni_env (); + GstState old_state, new_state, pending_state; + gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state); + /* Only pay attention to messages coming from the pipeline, not its children */ + if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->pipeline)) { + data->state = new_state; + if (data->state >= GST_STATE_PAUSED && GST_CLOCK_TIME_IS_VALID (data->desired_position)) + execute_seek (data->desired_position, data); + GST_DEBUG ("State changed to %s, notifying application", gst_element_state_get_name(new_state)); + (*env)->CallVoidMethod (env, data->app, set_current_state_method_id, new_state); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + } + } +} + +static void check_initialization_complete (CustomData *data) { + JNIEnv *env = get_jni_env (); + /* Check if all conditions are met to report GStreamer as initialized. + * These conditions will change depending on the application */ + if (!data->initialized && data->native_window && data->main_loop) { + GST_DEBUG ("Initialization complete, notifying application. native_window:%p main_loop:%p", data->native_window,data->main_loop); + (*env)->CallVoidMethod (env, data->app, on_gstreamer_initialized_method_id); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + } + data->initialized = TRUE; + } +} + +static void *app_function (void *userdata) { + JavaVMAttachArgs args; + GstBus *bus; + GstMessage *msg; + CustomData *data = (CustomData *)userdata; + GSource *timeout_source; + GSource *bus_source; + + GST_DEBUG ("Creating pipeline in CustomData at %p", data); + + /* create our own GLib Main Context, so we do not interfere with other libraries using GLib */ + data->context = g_main_context_new (); + + data->pipeline = gst_element_factory_make ("playbin2", NULL); + + if (data->native_window) { + GST_DEBUG ("Native window already received, notifying the pipeline about it."); + gst_x_overlay_set_window_handle (GST_X_OVERLAY (data->pipeline), (guintptr)data->native_window); + } + + /* Instruct the bus to emit signals for each received message, and connect to the interesting signals */ + bus = gst_element_get_bus (data->pipeline); + bus_source = gst_bus_create_watch (bus); + g_source_set_callback (bus_source, (GSourceFunc) gst_bus_async_signal_func, NULL, NULL); + g_source_attach (bus_source, data->context); + g_source_unref (bus_source); + g_signal_connect (G_OBJECT (bus), "message::error", (GCallback)error_cb, data); + g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback)eos_cb, data); + g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback)state_changed_cb, data); + g_signal_connect (G_OBJECT (bus), "message::duration", (GCallback)duration_cb, data); + g_signal_connect (G_OBJECT (bus), "message::buffering", (GCallback)buffering_cb, data); + g_signal_connect (G_OBJECT (bus), "message::clock-lost", (GCallback)clock_lost_cb, data); + gst_object_unref (bus); + + /* Register a function that GLib will call 4 times per second */ + timeout_source = g_timeout_source_new (250); + g_source_attach (timeout_source, data->context); + g_source_set_callback (timeout_source, (GSourceFunc)refresh_ui, data, NULL); + g_source_unref (timeout_source); + + /* Create a GLib Main Loop and set it to run */ + GST_DEBUG ("Entering main loop... (CustomData:%p)", data); + data->main_loop = g_main_loop_new (data->context, FALSE); + check_initialization_complete (data); + g_main_loop_run (data->main_loop); + GST_DEBUG ("Exited main loop"); + g_main_loop_unref (data->main_loop); + data->main_loop = NULL; + + /* Free resources */ + g_main_context_unref (data->context); + data->target_state = GST_STATE_NULL; + gst_element_set_state (data->pipeline, GST_STATE_NULL); + gst_object_unref (data->pipeline); + + return NULL; +} + +/* + * Java Bindings + */ +void gst_native_init (JNIEnv* env, jobject thiz) { + CustomData *data = g_new0 (CustomData, 1); + data->duration = GST_CLOCK_TIME_NONE; + data->desired_position = GST_CLOCK_TIME_NONE; + data->last_seek_time = GST_CLOCK_TIME_NONE; + SET_CUSTOM_DATA (env, thiz, custom_data_field_id, data); + GST_DEBUG ("Created CustomData at %p", data); + data->app = (*env)->NewGlobalRef (env, thiz); + GST_DEBUG ("Created GlobalRef for app object at %p", data->app); + pthread_create (&gst_app_thread, NULL, &app_function, data); +} + +void gst_native_finalize (JNIEnv* env, jobject thiz) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + GST_DEBUG ("Quitting main loop..."); + g_main_loop_quit (data->main_loop); + GST_DEBUG ("Waiting for thread to finish..."); + pthread_join (gst_app_thread, NULL); + GST_DEBUG ("Deleting GlobalRef for app object at %p", data->app); + (*env)->DeleteGlobalRef (env, data->app); + GST_DEBUG ("Freeing CustomData at %p", data); + g_free (data); + SET_CUSTOM_DATA (env, thiz, custom_data_field_id, NULL); + GST_DEBUG ("Done finalizing"); +} + +void gst_native_set_uri (JNIEnv* env, jobject thiz, jstring uri) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + const jbyte *char_uri = (*env)->GetStringUTFChars (env, uri, NULL); + GST_DEBUG ("Setting URI to %s", char_uri); + g_object_set(data->pipeline, "uri", char_uri); + (*env)->ReleaseStringUTFChars (env, uri, char_uri); +} + +void gst_native_play (JNIEnv* env, jobject thiz) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + GST_DEBUG ("Setting state to PLAYING"); + data->target_state = GST_STATE_PLAYING; + data->is_live = (gst_element_set_state (data->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_NO_PREROLL); +} + +void gst_native_pause (JNIEnv* env, jobject thiz) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + GST_DEBUG ("Setting state to PAUSED"); + data->target_state = GST_STATE_PAUSED; + data->is_live = (gst_element_set_state (data->pipeline, GST_STATE_PAUSED) == GST_STATE_CHANGE_NO_PREROLL); +} + +void gst_native_set_position (JNIEnv* env, jobject thiz, int milliseconds) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + gint64 desired_position = (gint64)(milliseconds * GST_MSECOND); + if (data->state == GST_STATE_PLAYING || data->state == GST_STATE_PAUSED) { + execute_seek(desired_position, data); + } else { + GST_DEBUG ("Scheduling seek to %d milliseconds for later", milliseconds); + data->desired_position = desired_position; + } +} + +jboolean gst_class_init (JNIEnv* env, jclass klass) { + custom_data_field_id = (*env)->GetFieldID (env, klass, "native_custom_data", "J"); + GST_DEBUG ("The FieldID for the native_custom_data field is %p", custom_data_field_id); + set_message_method_id = (*env)->GetMethodID (env, klass, "setMessage", "(Ljava/lang/String;)V"); + GST_DEBUG ("The MethodID for the setMessage method is %p", set_message_method_id); + set_current_position_method_id = (*env)->GetMethodID (env, klass, "setCurrentPosition", "(II)V"); + GST_DEBUG ("The MethodID for the setCurrentPosition method is %p", set_current_position_method_id); + on_gstreamer_initialized_method_id = (*env)->GetMethodID (env, klass, "onGStreamerInitialized", "()V"); + GST_DEBUG ("The MethodID for the onGStreamerInitialized method is %p", on_gstreamer_initialized_method_id); + set_current_state_method_id = (*env)->GetMethodID (env, klass, "setCurrentState", "(I)V"); + GST_DEBUG ("The MethodID for the setCurrentState method is %p", set_current_state_method_id); + + if (!custom_data_field_id || !set_message_method_id || !set_current_position_method_id || + !on_gstreamer_initialized_method_id || !set_current_state_method_id) { + GST_ERROR ("The calling class does not implement all necessary interface methods"); + return JNI_FALSE; + } + return JNI_TRUE; +} + +void gst_native_surface_init (JNIEnv *env, jobject thiz, jobject surface) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) return; + GST_DEBUG ("Received surface %p", surface); + if (data->native_window) { + GST_DEBUG ("Releasing previous native window %p", data->native_window); + ANativeWindow_release (data->native_window); + } + data->native_window = ANativeWindow_fromSurface(env, surface); + GST_DEBUG ("Got Native Window %p", data->native_window); + + if (data->pipeline) { + GST_DEBUG ("Pipeline already created, notifying the it about the native window."); + gst_x_overlay_set_window_handle (GST_X_OVERLAY (data->pipeline), (guintptr)data->native_window); + } else { + GST_DEBUG ("Pipeline not created yet, it will later be notified about the native window."); + } + + check_initialization_complete (data); +} + +void gst_native_surface_finalize (JNIEnv *env, jobject thiz) { + CustomData *data = GET_CUSTOM_DATA (env, thiz, custom_data_field_id); + if (!data) { + GST_WARNING ("Received surface finalize but there is no CustomData. Ignoring."); + return; + } + GST_DEBUG ("Releasing Native Window %p", data->native_window); + ANativeWindow_release (data->native_window); + data->native_window = NULL; + + if (data->pipeline) { + gst_x_overlay_set_window_handle (GST_X_OVERLAY (data->pipeline), (guintptr)NULL); + } +} + +static JNINativeMethod native_methods[] = { + { "nativeInit", "()V", (void *) gst_native_init}, + { "nativeFinalize", "()V", (void *) gst_native_finalize}, + { "nativeSetUri", "(Ljava/lang/String;)V", (void *) gst_native_set_uri}, + { "nativePlay", "()V", (void *) gst_native_play}, + { "nativePause", "()V", (void *) gst_native_pause}, + { "nativeSetPosition", "(I)V", (void*) gst_native_set_position}, + { "classInit", "()Z", (void *) gst_class_init}, + { "nativeSurfaceInit", "(Ljava/lang/Object;)V", (void *) gst_native_surface_init}, + { "nativeSurfaceFinalize", "()V", (void *) gst_native_surface_finalize} +}; + +jint JNI_OnLoad(JavaVM *vm, void *reserved) { + JNIEnv *env = NULL; + + GST_DEBUG_CATEGORY_INIT (debug_category, "tutorial-1", 0, "Android tutorial 1"); + + java_vm = vm; + + if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) { + GST_ERROR ("Could not retrieve JNIEnv"); + return 0; + } + jclass klass = (*env)->FindClass (env, "com/gst_sdk_tutorials/tutorial_1/Tutorial1"); + (*env)->RegisterNatives (env, klass, native_methods, G_N_ELEMENTS(native_methods)); + + pthread_key_create (¤t_jni_env, detach_current_thread); + + return JNI_VERSION_1_4; +} diff --git a/gst-sdk/tutorials/android-tutorial-1/res/drawable-ldpi/gst_sdk_icon.png b/gst-sdk/tutorials/android-tutorial-1/res/drawable-ldpi/gst_sdk_icon.png new file mode 100755 index 0000000000..98f66e7a42 Binary files /dev/null and b/gst-sdk/tutorials/android-tutorial-1/res/drawable-ldpi/gst_sdk_icon.png differ diff --git a/gst-sdk/tutorials/android-tutorial-1/res/drawable-xhdpi/gst_sdk_icon.png b/gst-sdk/tutorials/android-tutorial-1/res/drawable-xhdpi/gst_sdk_icon.png new file mode 100755 index 0000000000..534ffbf4dc Binary files /dev/null and b/gst-sdk/tutorials/android-tutorial-1/res/drawable-xhdpi/gst_sdk_icon.png differ diff --git a/gst-sdk/tutorials/android-tutorial-1/res/layout/main.xml b/gst-sdk/tutorials/android-tutorial-1/res/layout/main.xml new file mode 100755 index 0000000000..4c3e1000c2 --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/res/layout/main.xml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/gst-sdk/tutorials/android-tutorial-1/res/values/strings.xml b/gst-sdk/tutorials/android-tutorial-1/res/values/strings.xml new file mode 100755 index 0000000000..60c84d95a7 --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/res/values/strings.xml @@ -0,0 +1,6 @@ + + + Android tutorial 1 + Play + Stop + diff --git a/gst-sdk/tutorials/android-tutorial-1/src/com/gst_sdk_tutorials/tutorial_1/Tutorial1.java b/gst-sdk/tutorials/android-tutorial-1/src/com/gst_sdk_tutorials/tutorial_1/Tutorial1.java new file mode 100755 index 0000000000..666a77dcaf --- /dev/null +++ b/gst-sdk/tutorials/android-tutorial-1/src/com/gst_sdk_tutorials/tutorial_1/Tutorial1.java @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2009 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. + */ +package com.gst_sdk_tutorials.tutorial_1; + +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.TimeZone; + +import com.gst_sdk.GStreamer; + +import android.app.Activity; +import android.util.Log; +import android.os.Bundle; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.View; +import android.view.View.OnClickListener; +import android.widget.ImageButton; +import android.widget.SeekBar; +import android.widget.SeekBar.OnSeekBarChangeListener; +import android.widget.TextView; +import android.widget.Toast; + +public class Tutorial1 extends Activity implements SurfaceHolder.Callback, OnSeekBarChangeListener { + private native void nativeInit(); + private native void nativeFinalize(); + private native void nativeSetUri(String uri); + private native void nativePlay(); + private native void nativePause(); + private native void nativeSetPosition(int milliseconds); + private static native boolean classInit(); + private native void nativeSurfaceInit(Object surface); + private native void nativeSurfaceFinalize(); + private long native_custom_data; + + private boolean is_playing_desired; + private int position; + private int duration; + private boolean is_local_media; + private int desired_position; + + private Bundle initialization_data; + + private final String mediaUri = "http://docs.gstreamer.com/media/sintel_trailer-480p.ogv"; + + /* Called when the activity is first created. + @Override */ + public void onCreate(Bundle savedInstanceState) + { + super.onCreate(savedInstanceState); + + try { + GStreamer.init(this); + } catch (Exception e) { + Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show(); + finish(); + return; + } + + setContentView(R.layout.main); + + ImageButton play = (ImageButton) this.findViewById(R.id.button_play); + play.setOnClickListener(new OnClickListener() { + public void onClick(View v) { + is_playing_desired = true; + nativePlay(); + } + }); + + ImageButton pause = (ImageButton) this.findViewById(R.id.button_stop); + pause.setOnClickListener(new OnClickListener() { + public void onClick(View v) { + is_playing_desired = false; + nativePause(); + } + }); + + SurfaceView sv = (SurfaceView) this.findViewById(R.id.surface_video); + SurfaceHolder sh = sv.getHolder(); + sh.addCallback(this); + + SeekBar sb = (SeekBar) this.findViewById(R.id.seek_bar); + sb.setOnSeekBarChangeListener(this); + + initialization_data = savedInstanceState; + + is_local_media = false; + is_playing_desired = false; + + nativeInit(); + } + + protected void onSaveInstanceState (Bundle outState) { + Log.d ("GStreamer", "Saving state, playing:" + is_playing_desired + " position:" + position); + outState.putBoolean("playing", is_playing_desired); + outState.putInt("position", position); + outState.putInt("duration", duration); + } + + protected void onDestroy() { + nativeFinalize(); + super.onDestroy(); + } + + /* Called from native code */ + private void setMessage(final String message) { + final TextView tv = (TextView) this.findViewById(R.id.textview_message); + runOnUiThread (new Runnable() { + public void run() { + tv.setText(message); + } + }); + } + + /* Called from native code */ + private void onGStreamerInitialized () { + nativeSetUri (mediaUri); + if (mediaUri.startsWith("file://")) is_local_media = true; + + if (initialization_data != null) { + is_playing_desired = initialization_data.getBoolean("playing"); + int milliseconds = initialization_data.getInt("position"); + Log.i ("GStreamer", "Restoring state, playing:" + is_playing_desired + " position:" + milliseconds + " ms."); + /* Actually, move to one millisecond in the future. Otherwise, due to rounding errors between the + * milliseconds used here and the nanoseconds used by GStreamer, we would be jumping a bit behind + * where we were before. This, combined with seeking to keyframe positions, would skip one keyframe + * backwards on each iteration. + */ + nativeSetPosition(milliseconds + 1); + if (is_playing_desired) { + nativePlay(); + } else { + nativePause(); + } + } else { + nativePause(); + } + } + + /* The text widget acts as an slave for the seek bar, so it reflects what the seek bar shows, whether + * it is an actual pipeline position or the position the user is currently dragging to. + */ + private void updateTimeWidget () { + final TextView tv = (TextView) this.findViewById(R.id.textview_time); + final SeekBar sb = (SeekBar) this.findViewById(R.id.seek_bar); + final int pos = sb.getProgress(); + + SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss"); + df.setTimeZone(TimeZone.getTimeZone("UTC")); + final String message = df.format(new Date (pos)) + " / " + df.format(new Date (duration)); + tv.setText(message); + } + + /* Called from native code */ + private void setCurrentPosition(final int position, final int duration) { + final SeekBar sb = (SeekBar) this.findViewById(R.id.seek_bar); + + /* Ignore position messages from the pipeline if the seek bar is being dragged */ + if (sb.isPressed()) return; + + runOnUiThread (new Runnable() { + public void run() { + sb.setMax(duration); + sb.setProgress(position); + updateTimeWidget(); + } + }); + this.position = position; + this.duration = duration; + } + + /* Called from native code */ + private void setCurrentState (int state) { + Log.d ("GStreamer", "State has changed to " + state); + switch (state) { + case 1: + setMessage ("NULL"); + break; + case 2: + setMessage ("READY"); + break; + case 3: + setMessage ("PAUSED"); + break; + case 4: + setMessage ("PLAYING"); + break; + } + } + + static { + System.loadLibrary("gstreamer_android"); + System.loadLibrary("tutorial-1"); + classInit(); + } + + public void surfaceChanged(SurfaceHolder holder, int format, int width, + int height) { + Log.d("GStreamer", "Surface changed to format " + format + " width " + + width + " height " + height); + nativeSurfaceInit (holder.getSurface()); + } + + public void surfaceCreated(SurfaceHolder holder) { + Log.d("GStreamer", "Surface created: " + holder.getSurface()); + } + + public void surfaceDestroyed(SurfaceHolder holder) { + Log.d("GStreamer", "Surface destroyed"); + nativeSurfaceFinalize (); + } + + public void onProgressChanged(SeekBar sb, int progress, boolean fromUser) { + if (fromUser == false) return; + desired_position = progress; + /* If this is a local file, allow scrub seeking, this is, seek soon as the slider + * is moved. + */ + if (is_local_media) nativeSetPosition(desired_position); + updateTimeWidget(); + } + + public void onStartTrackingTouch(SeekBar sb) { + nativePause(); + } + + public void onStopTrackingTouch(SeekBar sb) { + /* If this is a remote file, scrub seeking is probably not going to work smoothly enough. + * Therefore, perform only the seek when the slider is released. + */ + if (!is_local_media) nativeSetPosition(desired_position); + if (is_playing_desired) nativePlay(); + } +}